pil21/COPYING0000644000000000000000000000206611430515775007742 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/README0000644000000000000000000001014613745535417007573 0ustar # 26oct20 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/INSTALL0000644000000000000000000000624313756141525007742 0ustar # 21nov20 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 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 and some examples: # 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 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 tutorials ("doc/tut.html", "doc/native.html", "doc/select.html" and "doc/httpGate.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.l0000644000000000000000000003460114150120625007616 0ustar # 26nov21 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") ) (de msg (X . @) (out 2 (print X) (pass prinl) ) X ) (de script (File . @) (load File) ) (de once "Prg" (unless (idx '*Once (file) T) (run "Prg" 1) ) ) (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 (push '*Bye '(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 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 () (symbols (cons (intern (opt)) (symbols))) ) (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) (sort (conc (let (L (split (chop S) "~") N NIL S) (while (cdr L) (setq N (intern (pack (car L)) N) S (pack S (++ L) "~") ) ) (let P (pack (car L)) (extract '((X) (and (pre? P X) (pack S X))) (all N) ) ) ) (let P (rot (split (chop S) "/")) (setq S (pack (car P)) P (and (cdr P) (pack (glue "/" @) "/")) ) (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") ) ### 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 Z (++ X) (prtty2 Z NIL Z) ) (prin ")") ) (T (nlPrt N) (prin "(") (let 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 Z X (printsp (++ X)) (prtty2 X NIL Z) ) (prin ")") ) ) ((memq (car X) '(=: use later recur 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 Z X (print (++ X)) (run "Prg") ) (prin " )") ) (de prtty0 (X N) (prin "(") (let Z X (pretty (++ X) (- -3 N)) (prtty1 X N Z) ) (prin " )") ) (de prtty1 (X N Z) (loop (NIL X) (T (== Z X) (prin " .")) (T (atom X) (prin " . ") (print X)) (nlPrt1 (++ X) N) ) ) (de prtty2 (X N Z) (loop (print (++ X)) (NIL X) (T (== Z X) (prin " .")) (T (atom X) (prin " . ") (print X)) (if N (prtty? (++ X) N) (space) (print (++ X)) ) (NIL X) (T (== Z X) (prin " .")) (T (atom X) (prin " . ") (print X)) (if N (nlPrt N) (space 2) ) ) ) (de prtty3 (X N) (prin "(") (let 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 (if (or C (pair "X")) (cons 'dm "X" (if (pair "X") (method (car "X") (cdr "X")) (method "X" C) ) ) (cons 'de "X" (val "X")) ) ) (prinl) "X" ) ) (de show ("X" . @) (let *Dbg NIL (setq "X" (pass get "X")) (when (sym? "X") (print "X" (val "X")) (prinl) (maps '((X) (space 3) (if (atom X) (println X) (println (cdr X) (car X)) ) ) "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 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 '*)) (println '|) (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 'pretty 'Z) (noLint '_pretty 'Z) 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/ChangeLog0000644000000000000000000004245414162303640011222 0ustar ####### 21.12 ####### 22dec21 OpenBSD patch (Frithjof Schulze) src/httpGate.c 20dec21 Don't put single "." into readline history 14dec21 Avoid 'resolveActivity' in 'startActivityForResult' lib/android.l 13dec21 Splice also atomic results in "~" read macros and 'fill' src/io.l src/subr.l test/src/subr.l doc/refF.html 12dec21 Bug in 'format' (llvm~fmtNum) src/big.l Overflow float/double to bignum src/main.l src/dec.l src/pico.h src/lib.c 10dec21 'native' and 'struct' not limited to C functions doc/refN.html doc/refS.html 'Str' not used in 'getWord' lib/vip.l 08dec21 Add 'adr' to "see also" of 'native' doc/refN.html 05dec21 Global '*Keys' ":map" command lib/vip.l 04dec21 Lock, sync and commit external symbols lib/vip.l 30nov21 'R' may be modified in 'evCmd' lib/vip.l 29nov21 Extend 'command' with *CmdMap Continue direct editing only with "K" ("^]" always goes to source) lib/vip.l 28nov21 Remove '*Complete' filter lib/vip.l 26nov21 'all*' function lib.l doc/refA.html Refactor TAB-completion lib/vip.l 25nov21 Search namespaces in TAB-completion lib/vip.l 22nov21 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 21nov21 Simplify style manipulations lib/form.l lib/form.js 18nov21 Bug in 'bagBag' lib/form.l 17nov21 Minor cosmetics lib/form.l Inherit 'Dbf' in 'forall' from superclasses lib/db.l 16nov21 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 15nov21 Use 'fName' in 'vf' lib/vip.l 12nov21 '+ObjVar' prefix class lib/form.l 11nov21 Missing semicolon (Mia) lib/form.js 09nov21 Increase escape delay from 80 to 120 lib/vip.l 31oct21 Mention Ctrl-D to terminate 'bt', 'query' and '?' doc/ref.html doc/refB.html doc/refM.html doc/refQ.html doc/ref_.html 30oct21 Generalize cut in 'prove' src/subr.l 29oct21 rl_initialize() not necessary src/lib.c 28oct21 Display namespace in 'status' lib/vip.l Minor optimization in '*Prompt' lib/debug.l 27oct21 'vf' (vi/find) function lib/vip.l Default '*Tab' to 1 lib/xhtml.l 25oct21 '*KeyMap', '*KeyMap-g' and '*KeyMap-q' globals (Erik Gustafson) More transients lib/vip.l 18oct21 Refactor 'gui>' for '+User' lib/adm.l lib/user.l 15oct21 Mention Ctrl-D to terminate 'more' doc/refM.html 11oct21 "CSV" -> "Export CSV" in 'csv' lib/xhtml.l 09oct21 'pico~cells' function lib/vip/draw.l Minor cosmetics lib/vip.l Fix 'arrow' for small distances lib/vip/draw.l 02oct21 Remove '+JsField' lib/form.l doc/app.html doc/form/refJ.html Import 'permute' from 'pico' namespace lib/simul.l 29sep21 '+hintObj' prefix class for '+Obj' and '+ObjVal' lib/form.l 25sep21 'rand' argument checks src/big.l doc/refR.html 24sep21 Ignore SIGINT in 'ctty' parent process src/main.l Forward "^D" bin/pty 23sep21 Clear '*Err' bin/pty 20sep21 Initial '$StkBrk' and '$StkLimit' src/glob.l src/main.l 19sep21 ulimStk() system call src/dec.l src/pico.h src/lib.c 17sep21 Clear 'history' after argument evaluation src/main.l 16sep21 Insert "^M" before "^J" in 'mail' body lib/misc.l 'refObj' function lib/too.l 13sep21 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 10sep21 "gg" uses *Count lib/vip.l 03sep21 'mis>' method for '+Swap' lib/db.l 01sep21 select() system calls are now poll() doc/refK.html doc/refL.html doc/refR.html doc/refS.html doc/refW.html 30aug21 Typo doc/refR.html 28aug21 Add note about 'native' doc/faq.html 'rid' function test/src/sym.l 27aug21 'rid' function src/sym.l src/glob.l test/src/sym.l doc/ref.html doc/refC.html doc/refD.html doc/refF.html doc/refQ.html doc/refR.html 26aug21 Bug in 'place' src/subr.l test/src/subr.l 25aug21 Division by zero did not throw an error src/big.l Private declarations lib/xhtml.l 22aug21 Default alert text color black lib.css 20aug21 Wrong 'tty' checks for stdin/stdout src/main.l src/flow.l 19aug21 LLC and LINK variables src/Makefile 18aug21 Strip binaries src/Makefile 'rasoq' function src/subr.l src/glob.l test/src/subr.l doc/ref.html doc/refA.html doc/refR.html 16aug21 Add 'packJson' lib/json.l 14aug21 Sort TAB-completion lib/vip.l Host option bin/pty 13aug21 Check (sys "SHELL") for default shell lib/vip.l 12aug21 Some Pilog variables private again lib/pilog.l 11aug21 Default shell "bash" -> "sh" lib/vip.l Shell prefix "$ " -> "!" in 'repl' lib/form.l 09aug21 'go', 'up', 'down', 'left' and 'right functions 'block' function lib/vip/draw.l Preset terminal attributes in setRaw() src/lib.c 08aug21 Add files lib/term.l bin/pty 07aug21 Clean up terminal handling lib/vip.l 06aug21 Add TIOCSWINSZ src/sysdefs.c Set standard I/O to a PTY with (ctty) src/Makefile src/main.l src/dec.l doc/refC.html 03aug21 'tty' flag also in 'inFile' src/main.l src/dec.l src/io.l src/flow.l 27jul21 Direct 'run' in auto-load with "# VIP (...)" lib/vip.l 26jul21 Bug in reading non-ASCII characters in internal symbols src/io.l 25jul21 'cnt' argument to 'unify' src/subr.l lib/pilog.l doc/refU.html 24jul21 Signal handler in 'prove' src/subr.l 23jul21 Pilog variables not private lib/pilog.l Revisit Pilog variables in Lisp expressions src/subr.l 22jul21 Revisit private symbols in properties lib/vip.l 21jul21 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 18jul21 Minor cosmetics src/subr.l 16jul21 em120 and em150 styles lib.css 13jul21 'buf' function doc/ref.html doc/refB.html 10jul21 Revisit 'put>' for '+Swap' lib/db.l test/lib/db.l 05jul21 Fix 'clone>' for '+Swap' in '+Bag' lib/db.l 04jul21 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 03jul21 Support methods as ":ta msg> +Cls" lib/vip.l Make 'bagBag' non-destructive lib/form.l 02jul21 'forall' function doc/ref.html Add file doc/rc.sample 01jul21 'forall' function lib/db.l doc/refF.html ####### 21.6 ####### 30jun21 '+Swp' prefix class lib/form.l Lazy external symbol creation in '+Swap' lib/db.l 'has>' check in 'rel>' for '+Joint' lib/db.l Keep application namespaces for background tasks in '*Ns' lib/vip.l 29jun21 Keep application namespaces for background tasks in '*Ns' lib/vip.l bin/vip 24jun21 Minor addition doc/microTemplates 23jun21 Micro-templates for '' and '' doc/microTemplates 22jun21 Micro-templates for '
' and '' lib/xhtml.l lib/xhtml/table lib/xhtml/grid Add and lib/xhtml/tab 21jun21 Minor fix in reference for 'all' doc/refA.html 20jun21 Micro-templates 2.0 lib/xhtml.l lib/xhtml/ doc/microTemplates 19jun21 Wrong 'Attr' output in 'html' lib/xhtml.l 'pack' not needed lib/vip.l General argument to 'any' src/io.l doc/refA.html 18jun21 Also 'flip'ped sort in 'sortButton' lib/form.l 17jun21 'sortButton' function lib/form.l 16jun21 Vip running in coroutine Suspend with "qz", resume with (v) lib/vip.l doc/refV.html 15jun21 Fix terminal after 'pipe', 'in' and 'out' src/io.l 14jun21 Minor fix indentation src/flow.l Restore private declarations lib/xhtml.l Missing '+Remote' methods lib/db.l 13jun21 Add '\e' to escape markups src/io.l doc/ref.html 11jun21 Optional 'put' and 'get' function arguments for '+Joint' lib/db.l 09jun21 Revert confirm row deletion (01may21) lib/form.l 04jun21 'ctty' NIL argument is obsolete src/main.l doc/refC.html Minor renaming src/flow.l 02jun21 Push tag stack in "gf" command lib/vip.l Add A3 page sizes lib/svg.l Intern some globals for reload lib/form.l 01jun21 'class' clears old method and var definitions 'var' uses 'def' instead of 'put' lib.l test/lib.l 29may21 Set cooked terminal mode in 'repl' src/io.l 27may21 Revisit TAB-completion lib/vip.l Use 'val' for '+Swap' relations in 'set>' lib/db.l 25may21 Revisit TAB-completion from 'history' lib/vip.l Unary '+' is obsolete in '*Run' setup lib.l 24may21 Nesting bug in 'cells' lib/vip/draw.l 23may21 Maintain 'symbols' per buffer lib/vip.l 21may21 TAB-complete from 'history' on ": " ":v" command lib/vip.l 20may21 setCooked() only if necessary src/lib.c 19may21 Add file lib/clang.l 18may21 Fix 'struct' example doc/refS.html 14may21 vertical-aligns to top lib.css Optional submenu CSS class index lib/xhtml.l lib/xhtml/menu 12may21 Add file doc/microTemplates Needs '*XhtmlField' in '' lib/xhtml.l 11may21 Don't set IPV6_V6ONLY for OpenBSD lib/net.l 10may21 64-bit check not needed lib/adm.l 06may21 Missing '+Remote' methods lib/db.l Missing 'mail' handshake (Mike Pechkin) lib/misc.l 05may21 Fix catch/throw between coroutines src/main.l src/dec.l src/flow.l doc/structures doc/ref.html 04may21 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 03may21 (co) returns tag of current coroutine src/flow.l doc/refC.html 'shift' function src/sym.l src/glob.l doc/ref.html doc/refS.html doc/refP.html test/src/sym.l 01may21 Confirm row deletion also if repeated lib/form.l 30apr21 Add file doc/app.html 29apr21 Call 'loadCoEnv' in 'unwind' src/main.l src/flow.l Remove coroutines from catch/throw environment src/glob.l 22apr21 Show thousands-separator in total counts in search dialogs lib/form.l 21apr21 File in first column of directory listings lib/vip.l 20apr21 Bug in 'till' reading UTF-8 src/io.l 19apr21 Align SUBRs to 8 bytes src/lib/llvm.l 18apr21 's-expr' function, evaluate with "^E" lib/vip.l 17apr21 '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 16apr21 Independent size of main stack segment src/main.l src/glob.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 15apr21 Infinite timeout for values greater than 24 days in '*Run', 'wait' and 'key' (only on systems with sizeof(int) == 4) src/lib.c 14apr21 Skip remote replication if 'key' is empty src/ssl.c 13apr21 Bug in '
': Header text not evaluated lib/xhtml.l ContextCompat 'permit' function lib/android.l 'Str' in 'repl' private lib/form.l 10apr21 Minor fix indentation lib/vip.l 09apr21 Extensions to NIL punning doc/ref.html 08apr21 Support '-fun' command line arguments bin/vip 07apr21 'enum?' function src/sym.l src/glob.l doc/ref.html doc/refE.html doc/refL.html test/src/sym.l 04apr21 Wrong external declaration src/ht.l 03apr21 Bug in 'stem' (for -O2 or -O3) src/subr.l 01apr21 '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 31mar21 '+Remote' entity class lib/db.l lib/too.l 30mar21 Exit '*', '/*', '/' and '%' upon zero src/big.l 29mar21 Note about the default browser for 'doc' calls man/man1/picolisp.1 doc/man.html 26mar21 'enum' with single argument returns association list src/sym.l doc/refE.html test/src/sym.l 25mar21 Return NIL from 'enum' if key <= 0 src/sym.l Unit tests for 'enum' test/src/sym.l '*Term' signal handling (Constantine Bitensky) src/main.l src/glob.l doc/ref.html doc/refT.html doc/refA.html doc/refH.html doc/refS.html doc/refW.html 24mar21 'enum' function src/sym.l 23mar21 'enum' function src/sym.l src/glob.l doc/ref.html doc/refE.html doc/refH.html doc/refI.html 'rev' function bit count argument src/big.l doc/refR.html 21mar21 'rev' function src/big.l src/glob.l doc/ref.html doc/refR.html doc/refH.html doc/refI.html doc/ref_.html 17mar21 Still missing @lib/xm.l Ukrainian and russian localization (Constantine Bitensky) loc/RU.l loc/uk loc/ru 10mar21 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 08mar21 Missing file @lib/xm.l 07mar21 Ukrainian localization (Constantine Bitensky) loc/UK.l loc/uk 05mar21 Subdirectory recursion buffer-local Recurse when no trailing "/" lib/vip.l 02mar21 '*Bye' cleared in children src/io.l lib.l lib/adm.l lib/app.l doc/diff 28feb21 Missing check for NIL lib/vip.l 26feb21 Remove Access-Control-Allow-Origin header lib/http.l 20feb21 Prefix "@" with "./" in directory listings Recurse into subdirectories with ":E" lib/vip.l 16feb21 Case insensitive search with "~" prefix Increase escape delay to 80 ms lib/vip.l 12feb21 Rename file to "area", add "field" lib/xhtml.l lib/xhtml/area lib/xhtml/field 11feb21 Elaborate '' lib/xhtml.l lib/xhtml/textarea 09feb21 Ignore SIGHUP for non-config calls src/httpGate.c 08feb21 Start task in first 'heartbeat' call lib/heartbeat.l Touch events not needed lib/xhtml/tab 07feb21 Variable titles in menu Layout template line format lib/xhtml.l lib/xhtml/menu lib/xhtml/layout 05feb21 'plio' must preserve $Ptr and $End src/io.l Load @lib/too.l always in 'psh' lib/http.l 03feb21 Load @lib/sq.l in 'psh' lib/http.l 02feb21 Optional insert string in config keys src/httpGate.c doc/httpGate.html 01feb21 Typo ".pil" -> "./pil" doc/httpGate.html 28jan21 Typo "none" -> "nond" doc/tut.html 25jan21 Remove 'evCmd' from custom function keys lib/vip.l 23jan21 'fish' function "skip" return value src/apply.l doc/refF.html lib/vip.l 22jan21 em80, em90 and em100 styles lib.css 21jan21 Stack check in 'fish' src/apply.l 20jan21 Comment lib/tinymce.l 18jan21 Bug in 'pack' of external symbol names src/sym.l 17jan21 'pil' backport lib/compat.l 15jan21 Micro-templates lib/xhtml.l lib/xhtml/ Bug in 'pass' src/apply.l Call 'bufString' instead of 'pathString' in 'token' src/io.l 14jan21 Bug in 'bit?' src/big.l 08jan21 Minor cosmetics src/subr.l Improved terminal reset src/lib.c 05jan21 Debian release Dec20 Pil21 initial version ####### 21.0 ####### pil21/doc/structures0000644000000000000000000001632514044462111011612 0ustar # 05may21 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 org +---- next | +-> prv | | tag <----- Coroutines | | | | | | [rst] | | [env] | | ... | | [@] | | lim | | prg | | org | | next | +-- prv +---> 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 - Stack grows downwards - sizeof(float) = 4 bytes - sizeof(double) = 8 bytes pil21/doc/diff0000644000000000000000000000334714144674274010317 0ustar # 16nov21 Software Lab. Alexander Burger Differences to Pil64 ==================== + PilSrc ("PicoLisp Source") instead of PilAsm + No pre-installed PicoLisp required for bootstrapping + '*Run' not limited to 1024 FDs / 500 children + Shared libraries have ".so" extension + 'with' accepts 'var' instead of 'sym' + Map functions accept atomic arguments + Standard readline(3) library in REPL + 'history' function for readline + 'mix' accepts also negative arguments + 'native' * 'W', 'P' and 'T' result specifications * (T . any) direct Lisp argument * Number of fixpoint arguments not limited + '%@' function + 'struct' * Useful atomic result specifications + 'adr' returns a pointer usable by 'native' and 'struct' + 'info' returns the file argument in '@@' + '\~' marker in namespaces + Special 'priv' namespace + '%~' namespace search modification + 'intern' accepts namespace argument + 'plio' function + 'buf' function + 'tty' function + Various runtime checks + Lists of symbols as function parameters (destructuring, one-dimensional) + '*Winch' global SIGWINCH handler + Path names expand "~" for the HOME directory - 'lines' is not supported - 'tick' is not supported - 'arg' without arguments is not supported - 'tzo' is not supported - 'case' is more strict in expecting atomic keys - Second argument to 'name' (i.e. renaming) is not supported - Lambda-binding environment offset for 'eval' and 'run' only for '@' - 'T' argument to 'native' changed: No skipped call - 'pil' is not needed % '*Bye' cleared in children % '*Run' cleared in children: 'forked' is not needed % Main coroutine has a tag 'T' % 'file' returns NIL instead of "./" % 'edit' functionality is handled by 'vi' (Vip) % 'flood' moved from "@lib.l" to "@lib/simul.l" pil21/doc/index.html0000644000000000000000000000673513745761125011463 0ustar PicoLisp Docs pil21/doc/toc.html0000644000000000000000000000227313745761306011133 0ustar PicoLisp Doc TOC

PicoLisp Docs

pil21/doc/rlook.html0000644000000000000000000000320513745761443011472 0ustar PicoLisp RefLook pil21/doc/ref.html0000644000000000000000000031001314137442775011116 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
      +-----+-----+
      |  /  | VAL |
      +-----+-----+

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

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)

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.
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 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.

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.

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 coroutines are not supported: A coroutine cannot resume 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 (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- and logic-functions store the result of their controlling expression - respectively non-NIL results of their conditional expression - 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, if2, ifn, 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.

Argumnets 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 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 if2 ifn when unless cond nond case casq state while until loop do at for catch throw finally co yield ! e $ call ipid opid kill quit task fork detach pipe later timeout tasks abort bye
Mapping
apply pass maps map mapc maplist mapcar mapcon mapcan filter extract seek find pick fully cnt sum maxi mini fish by
Input/Output
path in out fd err ctl tty 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 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 dbs+ db: db aux collect 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 d unbug u v vi trace untrace traceAll proc hd bench bt lint lintAll select
System Functions
cmd argv opt version gc tty raw alarm sigio kids protect heap stack adr byte env trail up sys date time usec 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.html0000644000000000000000000005416214150127363011215 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) -> lst
Returns a sorted list of all (possibly namespaced) symbols and path names starting with the characters in any. 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^Jc 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.html0000644000000000000000000004105214137443142011211 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 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) -> any
Send the bell character to the console. See also space, prin and char. 

: (beep)
-> "^G"
(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 Delete)
   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 console input, and terminates when Ctrl-D or a non-empty line is entered (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.html0000644000000000000000000007310514112136244011211 0ustar C

C

*CPU
A global variable holding the target CPU (architecture). Possible values include "arm64", "x86-64", "ppc64", "emu" or "JVM". 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 this will immediately return the matching string. If neither throw nor an error occurs, the result of prg is returned. See also finally, quit and Error Handling. 

: (catch 'OK (println 1) (throw 'OK 999) (println 2))
1
-> 999
: (catch '("No such file") (in "doesntExist" (foo)))
-> "No such file"
(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 'lst ..) -> lst
Concatenates (destructively) one or several new list elements lst 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
Returs 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 and step. 

: (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
(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 resume 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 sym (or just sets standard I/O to a PTY if sym 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.html0000644000000000000000000007372314112130263011213 0ustar D

D

*DB
A global constant holding the external symbol {1}, the database root. All transient 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 and dm. 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 and 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
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 dbs+ and pool. 

(dbs
   (3 +Role +User +Sal)                         # 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
-> (1 2 1 0 2 4 4 4 4 4 4 4)
: (get '+Item 'Dbf)
-> (3 . 128)
: (get '+Item 'nr 'dbf)
-> (9 . 1024)
(dbs+ 'num . lst)
Extends the list of database sizes stored in *Dbs. num is the initial offset into the list. See also dbs. 

(dbs+ 9
   (1 +NewCls)                                  # (9 . 128)
   (3 (+NewCls nr nm)) )                        # (10 . 512)
(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) -> T
(debug 'sym 'cls) -> T
(debug '(sym . cls)) -> T
(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
(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 '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. 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.html0000644000000000000000000004720114033350356011215 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

: (de f (A)
   (list
      (eval 'A)
      (eval 'A 1)
      (eval 'A 2) ) )
-> f
: (de g (A)
   (f (inc A)) )
-> g
: (one A)
-> 1
: (g (inc A))
-> (3 2 1)
(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")
   (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) -> sym | NIL
Returns the argument any when it is an existing external symbol, otherwise NIL. 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.html0000644000000000000000000005153714155676037011241 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
Return the current file descriptor, typically of the closest in or out channel. 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
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. Unmodified subexpressions are shared. In any case, expressions following the symbol ^ are evaluated and the results (destructively) spliced into the result. 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)

: (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
(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. 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
   '((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)
(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
Runs prg on all database objects of the class cls, as given by the dbs definition. 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? '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.html0000644000000000000000000001531313746233146011225 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. Before collection (but after argument evaluation) the global variables @ and @@ are set to NIL. 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 :. 

: (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.html0000644000000000000000000002402714027036571011224 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
(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 [1]cdr and
   [2]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 [1]cdr and
   [2]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.html0000644000000000000000000004074614026335103011223 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. 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. If all elements are inserted in sorted order, the tree degenerates into a linear 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
(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
(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 for reading and writing 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 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 ipid, call, load, file, out, err, 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). 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}))))
(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 'sym ['nsp]) -> sym
Creates or finds an internal symbol. If a symbol with the name sym is already intern, it is returned. Otherwise, sym is interned in the current namespace and returned. If nsp is non-NIL, sym 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 (pack "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])
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.html0000644000000000000000000000523013360406146011217 0ustar J

J

+Joint
Class for bidirectional object relations, a subclass of +Link. Expects a (symbolic) attribute, and list of classes as type of the referred database object (of class +Entity). 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.html0000644000000000000000000000570614113641513011224 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]) -> 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. 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.html0000644000000000000000000005200014144720770011221 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
(Debug mode only) 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/native.l")

(gcc "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.html0000644000000000000000000005570714137443034011240 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 result list. 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 print. In the second form, the method definitions of cls are pretty-printed with pp. After each step, more waits for console input, and terminates when Ctrl-D or a non-empty line is entered. 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
inc>
leaf
nil
inc!
accept.                                # Stop
-> T

: (more (all) show)                    # 'show' all internal symbols
inc> 67292896
   *Dbg ((859 . "lib/db.l"))

leaf ((Tree) (let (Node (cdr (root Tree)) X) (while (val Node) (setq X (cadr @) Node (car @))) (cddr X)))
   *Dbg ((173 . "lib/btree.l"))

nil 67284680
   T (((@X) (^ @ (not @X))))
.                                      # Stop
-> T

: (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 (cdr Lst)) )

-> 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.html0000644000000000000000000003744314154751231011236 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
(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 pointer 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 pointer 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.

A C function may in turn call a function 


   long lisp(char*, long, long, long, long, long);

which accepts a symbol name as the first argument, and up to 5 numbers. lisp() calls that symbol with the five numbers, and expects a numeric return value. "Numbers" in this context are 64-bit scalars, and may not only represent integers, but also pointers or other encoded data. 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] ['typ ['any ..]]) -> obj
Creates and returns a new object. If flg is given and non-NIL, 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). typ (typically 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
(next) -> any
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.html0000644000000000000000000002357213753707675011256 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. 

(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 "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 opid, call, in, err, 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"
pil21/doc/refP.html0000644000000000000000000010322014117655743011235 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 the look-ahead covers only the next byte, so a multi-byte character might still block. 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 a cons pair of 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^Jc 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 never inserted into the search order, but is always searched first. (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
(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.html0000644000000000000000000000606614137443241011236 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 console input, and terminates when Ctrl-D or a non-empty line is entered. See also ?, pilog and solve. 

: (query (goal '((append @X @Y (a b c)))))
 @X=NIL @Y=(a b c)
 @X=(a) @Y=(b c).   # Stop
-> 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.html0000644000000000000000000007005214123546604011235 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
$ pil +
: (raw)
-> T
(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 and lambda. 

: (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
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
: (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"
(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 Prg
   (let A 12
      (println (cons 'Prg Prg) (cons 'A A))
      (run Prg 1) ) )
-> f
: (let (Prg 77  A 99)
   (f
      (println (cons 'Prg Prg) (cons 'A A)) ) )
(Prg (println (cons 'Prg Prg) (cons 'A A))) (A . 12)
(Prg . 77) (A . 99)
-> (A . 99)
pil21/doc/refS.html0000644000000000000000000011331314154751172011236 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
: (read)
123.45
-> 1235
: (scl 3)
-> 3
: (str "123.45")
-> (123450)
: (scl 1 (str "123.45"))
-> (1235)
: *Scl
-> 3
(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
(sect 'lst 'lst) -> lst
Returns the intersection of the lst arguments. 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|T] [var val ..]) -> obj | NIL
(Debug mode only) Interactive database function, loosely modelled after the SQL 'SELECT' command. A (limited) front-end to the Pilog select/3 predicate. 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 between the select function and 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 the get algorithm will be used to retrieve related data. See also Database and Pilog. 

: (select +Item)                       # Show all items
{B1} (+Item)
   nr 1
   pr 29900
   inv 100
   sup {C1}
   nm "Main Part"

{B2} (+Item)
   nr 2
   pr 1250
   inv 100
   sup {C2}
   nm "Spare Part"
.                                      # Stop
-> {B2}

: (select +Item nr 3)                  # Show only item 3
{B3} (+Item)
   nr 3
   sup {C1}
   pr 15700
   nm "Auxiliary Construction"
   inv 100
.                                      # Stop
-> {B3}

# 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)
(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
(skip ['any]) -> sym
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
: (sqrt 2.0 1.0)
-> 1414214
(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, the main stack segment size is 255 kB and coroutine sizes are 64 kB each. These sizes can only be changed when no coroutine is running (before starting any or after stopping all coroutines). If called without arguments, or if at least one coroutine is running, the current size in kilobytes is returned. Otherwise, the stack segment size is set to the first cnt argument, and optionally the main segment size is set to the second cnt argument. If there are running coroutines, pairs of their tags and unused stack spaces will be 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

## /* 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 '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, and sym1, sym2 and all following arguments are set as the current namespace list. See also pico, nsp, -symbols, private, local, 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.html0000644000000000000000000005632414075734650011253 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) ) ) ) )
(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. 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 pil, *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) -> sym
(trace 'sym 'cls) -> sym
(trace '(sym . cls)) -> sym
(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
(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 sym. See also OO Concepts, isa, class, new and object. 

: (type '{1A;3})
(+Address)
: (type '+DnButton)
-> (+Tiny +Rid +JS +Able +Button)
pil21/doc/refU.html0000644000000000000000000003257714077254607011261 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.html0000644000000000000000000001236414062161523011236 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.html0000644000000000000000000001624314113641533011240 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
Returns a transient symbol with all characters in lst packed in lines 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"
pil21/doc/refX.html0000644000000000000000000000247712207335300011237 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.html0000644000000000000000000000365414044151456011247 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.html0000644000000000000000000000622713741550521011246 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_.html0000644000000000000000000004603714144716143011260 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
: (format (*/ 3.0 1.5 1.0) *Scl)
-> "4.50"

: (scl 20)
-> 20
: (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 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 Ctrl-D or a non-empty line is entered. 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).                    # Stopped
-> 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.css0000644000000000000000000000073613745764607010750 0ustar /* 27oct20 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 { color: rgb(0%,40%,0%); } dt code { word-spacing: -0.04em; } pil21/doc/form/form.html0000644000000000000000000003655313407156304012253 0ustar PicoLisp Form Library mattias@inogu.se

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 Form Library

(c) Software Lab. Mattias Sundblad

This document describes the form library included with the PicoLisp system.

The purpose of this document is to go into the form library in more depth and hopefully supply an overview of the various components involved.

This document builds upon the information provided in Application Dev. Please start by going through this section of the documentation.

Also remember to 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).

A typical example

A typical usage of forms and form components can be found in the example application included with the PicoLisp distribution. This application has a number of search forms in app/gui.l and forms to display and edit objects, for example app/cusu.l.

Let's have a look at app/cusu.l. This file displays and allows you to edit objects of the class +Cusu (Customer/ Supplier, defined in app/er.l). The beginning of this file looks like this: 


########################################################################
(must "Customer/Supplier" Customer)

(menu ,"Customer/Supplier"
   (idForm ,"Customer/Supplier" '(choCuSu) 'nr '+CuSu T '(may Delete)
      '((: nr) " -- " (: nm))
      ....
########################################################################

The first line checks whether the user has the right permissions to access this page. After that a call to a function called 'menu' follows. This function is defined in app/gui.l and creates the menu and basic page layout of this application. Nested within the call to 'menu' is our first, direct encounter with a form function. In this case it is a call to 'idForm'. Let us look a little closer at this call.

The first parameter, "Customer/Supplier", is used in the form heading. Parameter number two is interesting. '(choCuSu) creates a dialog that makes is possible to search for an existing object to display/ edit, or create a new one. The function 'choCuSu'is defined in app/gui.l and uses another form function, called 'diaForm'. An abbreviated version is shown below. 


########################################################################
(de choCuSu (Dst)
   (diaform '(Dst)
      (<grid> "--.-.-."
         # Form components
         ... )
      (gui 'query '(+QueryChart) (cho)
         # Pilog query
         9
         '((This) (list This (: nr) This (: nm2) (: em) (: plz) (: ort) (: tel) (: mob))) )
      (<table> 'chart (choTtl ,"Customers/Suppliers" 'nr '+CuSu)
         # Table headers
         (do (cho)
            (<row> (alternating)
               (gui 1 '(+DstButton) Dst)
               ...
               (gui 9 '(+TelField)) ) ) )
      (<spread>
         (scroll (cho))
         (newButton T Dst '(+CuSu) ...)
         (cancelButton) ) ) )
########################################################################

As can be seen in app/gui.l, the search dialogs contain a lot of functionality. This is quite typical. 'choCuSu' starts off by calling 'diaform'. This function is used when we want a form to behave in a similar way to a dialog (See Alerts and Dialogs for a description of how dialogs work in the framework). The first part of our diaform is a 'grid' containing some form components. See application development for a more thorough description of form components.

The grid is followed by another gui component, this time a +QueryChart. The chart is an interesting, and very useful concept. The basic idea is to separate how data is presented in the gui from the internal representation. See charts for more information.

The +QueryChart has a Piloq query used to fetch the data we want to show from the database. This part is followed by a number, in this case 9, which tells the Chart how many columns of data to expect. The last part is a function that takes care of putting data into the chart gui from the dataset retrieved by the Pilog query.

Finally, a table is used to present the result. The number of columns in this table must match the number mentioned above, the one that tells the chart how many columns to expect.

What is described in the preceding section is a common way of structuring applications in PicoLisp. The objects are displayed and edited using idForms, which use diaforms to select or create new objects to view or edit. Please take some time to study the demo app included with the distribution. Another good idea is to start experimenting with some small application of your own. It is a very good way to get acquainted with the language and framework, and I highly recommend it! One way to do that would be to start making changes to the demo application. Just copy it to a directory of your choice and start exploring. It really is a lot of fun!

Form Library Function Reference

This section provides a reference manual for the form library functions. 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
  • tree - Database index tree specification
  • hook - Database hook object

Arguments evaluated by the function (depending on the context) are quoted (prefixed with the single quote character "'").

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

Forms
diaform form idForm
Utility functions
action alternating change chart cho choTtl curr disable error expires field <id> newUrl prev row *Throbber url
Button functions
saveButton closeButton okButton cancelButton choButton delButton yesButton noButton editButton searchButton resetButton newButton cloneButton
Alerts and dialogs
dialog alert note ask choDlg
Form field classes
+Auto +Button +BubbleButton +ClrButton +DelRowButton +DnButton +GoButton +UpButton +Drop +JS +OnClick +ShowButton +Checkbox +Radio +TextField +UndoButton +LinesField +ListTextField +PwField +UpField +RgbPicker +RedoButton +SymField +NumField +FixField +AtomField +DateField +TimeField +Img +Icon +FileField +Url +HttpField +MailField +TelField +SexField +JsField +BlobField +ClassField +DstButton +ChoButton +Choice +PickButton +InsRowButton
Charts
+Chart +Chart1 +QueryChart
Entity/ Relationship classes
+/R +E/R +SubE/R
Base classes
+gui +field +obj +hint
Prefix classes
+Align +AO +Chg +Clr0 +Dflt +Edit +Enum +Force +Obj +ObjView +ObjVal +Var +Cue +Trim +Uppc +Lowc +Rid +Set +Sgn +Val +Fmt +Able +Lock +View +Upd +Chk +Limit +Init +Map +Tip +Focus +Mono +DbHint +Close +Click
Styles and layouts
+Style +Tiny

Download

The PicoLisp system can be downloaded from the PicoLisp Download page. pil21/doc/form/refA.html0000644000000000000000000001126013633635036012156 0ustar A

A

(action Prg)
Top level wrapper function for the form event handling. Typically contains one or several calls to 'form'. 

    (app) # Start session

    (action                                            # Action handler
       (html 0 "Form" "@lib.css" NIL                   # HTTP/HTML protocol
          (form NIL                                    # Form
             (gui 'a '(+TextField) 10)                 # Text Field
             (gui '(+Button) "Print"                   # Button
                '(msg (val> (: home a))) ) ) ) )
See also Action Forms.
(alert Env . Prg)
Creates an alert dialog. 'Env' can contain additional css attributes, the framework adds the css class 'alert'. 'Prg' is the content you want to populate the alert with. See also Alerts and dialogs.
+Align
A '+TextField' prefix which causes a right-alignment of its content. Used internally to implement the numeric fields ('+NumField' and '+FixField'). See also +TextField, +NumField, +FixField.
(alternating)
alternating can be used to give table rows alternating colors. 

     (<table> 'chart (choTtl ,"Items" 'nr '+Item)
        (quote
           (btn) (align "#") (NIL ,"Description") (NIL ,"Supplier") (NIL
           ,"City") (align ,"Price") )
        (do (cho)
           (<row> (alternating)
              (gui 1 '(+DstButton) Dst) (gui 2 '(+NumField)) (gui 3 '(+ObjView
              +TextField) '(: nm)) (gui 4 '(+ObjView +TextField) '(: nm)) (gui 5
              '(+TextField)) (gui 6 '(+FixField) 2) ) ) )
The code above comes from the demo app included in the PicoLisp distribution, in gui.l. It produces a table with rows of alternating colors.
(ask Str . Prg)
Creates an alert dialog with a string, a 'Yes'- and a 'No'-button. 'Str' is the text that will populate the alert, 'Prg' is the action triggered by the 'Yes'- button. See also Alerts and dialogs.
+Able
Prefix class that takes an 'Exe' and disables a GUI component if the supplied 'Exe' returns NIL. 

    (gui '(+Able +TextField) '(may Order) 30)
In the example above, the text field is enabled for users with "Order" permissions.
+Auto
Prefix class that automatically presses a button. When called with 'This', it presses itself. +Auto can be used together with +Click to press a button after a certain amount of time has passed: 

    (gui '(+Click +Auto +Button) 420 'This 1000 "+" '(inc '*Number))
+Auto can be used to create simple animations or status updates: 
 (app) (action
       (html 0 "Auto" "@lib.css" NIL
          (form NIL
             (gui '(+JS +Button) "Wait" '(wait 6000)) (----) (gui '(+Click +Auto
             +Button) 2000 'This 2000 '(pop *Throbber)) ) ) )
See also +Click, +Button.
+AtomField
A modified +NumField that allows text as well. Text is presented with a monospaced font and numeric values are aligned. See also +NumField, +Mono and +TextField.
+AO
+AO, "Able object", takes an Exe argument which is used to determine whether the current object is editable or not. It also makes sure that the current form has an object and the this object is not in "deleted" state before evaluating the expression argument. See also +Able
pil21/doc/form/refB.html0000644000000000000000000000421712663601655012165 0ustar B

B

+BlobField
A field that handles data stored in external files, i.e. "Blob - binary large object". 

    (gui '(+BlobField) '(txt : home obj) 72 20)
The code above creates a textarea, size 72 x 20, and stores the text entered there in an external file. A corresponding, global variable, is created in main.l: 

    (setq
       *Pool "db/wiki/"
       *Blob "db/wiki/blob/"
       *Jnl (and (info "fifo/wiki") "fifo/wiki")
       *Salt (16 . "$6$@1$")
       *Css '("@lib.css" "wiki/lib.css")
       *WikiCss "wiki/wiki.css"
       *WikiPort 5000 )
Here, *Blob holds a path to the place where content from +BlobField will be stored. See also +/R, +TextField.
+Button
A basic button. A +Button takes:
  • A label, which may be either a string or the name of an image file.
  • An optional, alternative label. This is shown when the button is disabled.
  • An executable expression
For example:

    (gui '(+Button) "Enabled" "Disabled" '(doSomething))
See also +gui and Buttons.
+BubbleButton
A button used to move a row of data upwards in a chart. See also chart, +Tiny, +JS, +Able, +Tip and +Button.
pil21/doc/form/refC.html0000644000000000000000000004151513643557417012175 0ustar C

C

(cancelButton)
A cancel button. Uses the +Force and +Close prefix classes. See also +Force, +Close, +Button, gui.
(change Msg Env Exe Exe)
Workhorse function for '+UndoButton' and '+RedoButton'. When called in some button action, or as a side-effect in a '+Chg' function or similar, it maintains an undo- and a redo-stack for the current form. It takes:
  • A message to be displayed as a tooltip in the undo- and redo-button, to inform the user what is being un- or redone in case that button should be pressed.
  • An environment of variable bindings, to be pushed onto - and popped from - the stacks, and to be used during the un-/redo operations.
  • A single 'exe' for *un-doing* in that environment.
  • And one or several 'exe's (i.e. a 'prg') for *doing* in that environment.
Example: 

   (gui '(+UndoButton))
   (gui '(+RedoButton))
   ...
   (gui '(+Button) "Do something"
      '(change "Some change action"
          (env 'New (makeNewValue)  'Old (getCurrentValue))  # Build environment
          (restoreValue Old)                                 # Undo-expression
          (doSomething New) ) )                              # Do-expression
When this button is pressed, 'doSomething' is executed with the results of (makeNewValue) and (getCurrentValue). The tooltip of the undo-button will show "Undo: 'Some change action'". The redo-stack is cleared and the redo-button is disabled.

If now the undo-button is pressed, 'undoSomething' is executed with the saved results of (foo) and (bar). It should perform the opposite action of 'doSomething', effectively undoing the operation. The tooltip of the redo-button will now show "Redo: 'Some change action'", and the tooltip of the undo-button will show a possible previous undoable operation. Pressing the redo-button will *do* the operation again, and so on.

See also +UndoButton, +RedoButton.
(choButton 'Exe)
A button used to select or create an object of the same type as the one currently displayed. See also +Rid, +Tip, +Button, gui.
(chart @)
Returns the chart where the current field is, or any value accessible from that chart by applying the 'get' algorithm. 

    (chart) # chart
    (chart 'data 1) # The first line (list) of the chart's data.
+Chg
A prefix taking a function argument, which is called when the user changes the value of a field. That function receives the modified value, and may modify it again or perform side-effects with it like setting other fields (accessible with 'field').
+ChoButton
A class corresponding to (choButton 'Exe). +ChoButton is quite a general class. It can be used to select, or even do, anything. See also choButton, +Tiny, +Tip, +Button.
+Choice
Subclass of +ChoButton. Opens a dialog that allows the user to choose anything from a list, which is dynamically generated from the 'Exe' argument. See also +ChoButton, dialog.
(cho)
cho is a function that returns the number 16 if the diaform is used as a normal form (i.e. not as a dialog) or 8 if used in another context. It is typically used to show a different number of rows in a chart when the same chart is used as a dialog compared to when it is used on it's own. The following code fragment comes from the demo app included in the PicoLisp distribution, in gui.l. Here we can see cho being used to determine how many rows of data should be created, as well as making sure scrolling the data goes along with the number of rows. 
 . .
     (do (cho)
        (<row> (alternating)
           (gui 1 '(+DstButton) Dst) (gui 2 '(+NumField)) (gui 3 '(+ObjView
           +TextField) '(: nm)) (gui 4 '(+TextField)) (gui 5 '(+MailField)) (gui
           6 '(+TextField)) (gui 7 '(+TextField)) (gui 8 '(+TelField)) (gui 9
           '(+TelField)) ) ) )
  (<spread>
     (scroll (cho)) . .
See also diaform.
(choTtl Ttl X . @)
choTtl is a utility function typically used to set the title of a chart in a search dialog. The function combines a transient symbol, a text string, with the number of objects of a given type in the database. Here is an example from the demo app included in the PicoLisp distribution, in gui.l. 

    (choTtl ,"Customers/Suppliers" 'nr '+CuSu)
This example specifies an index, "...'nr '+CuSu)", and counts the number of +CuSu objects in that index. The result is combined with "Customers/Suppliers", setting the title of the data chart to, for example, "3 Customers/Suppliers". It is also possible to specify only the class, "... '+CuSu)". In that case the total number of entities of that class is used, regardless of any index.
(choDlg Dst Ttl Rel [Hook] [((+XyzField) ..) Exe Able])
choDlg, "choose dialog" creates a dialog that lets the user select or create an object, to be either jumped to (when called as a form), or taken into the destination field (when called as a dialog, see +DstButton). The following example comes from the demo app included with the PicoLisp distribution, in cusu.l. This file implements a form that handles objects of a class called +CuSu, "CustomerSupplier". +CuSu is connected to another class, +Sal, "Salutation". Using a choDlg in cusu.l allows a user to add or change the salutation belonging to the current object from the same GUI page used to edit other properties. 
 ,"Salutation" (choDlg 0 ,"Salutations" '(nm +Sal))
This code creates a choDlg that presents objects of the class +Sal using a diaform. Selecting an object in the choose dialog will close the dialog and adopts the selected value as the new salutation. See also diaform.
+Close
A button prefix class which closes the current form if it is a dialog. See also dialog, diaForm.
+Clr0
Prefix for a numeric field which maps zero to/from NIL.
+Click
Class that can be used together with +Auto to automatically click a button after a certain amount of time has passed. Strictly speaking, +Click is not limited to +Auto buttons, but that is the most common usage. 

    (gui '(+Click +Auto +Button) 420 'This 1000 '(pop
    *Throbber)
       '(with (: home)
          (for Col (: grid)
             (for This Col
                (let N # Count neighbors
                   (cnt
                      '((Dir) (get (Dir This) 'life)) (quote
                         west east south north ((X) (south (west X))) ((X)
                         (north (west X))) ((X) (south (east X))) ((X) (north
                         (east X))) ) )
                   (=: next # Next generation
                      (if (: life)
                         (>= 3 N 2) (= N 3) ) ) ) ) )
          (for Col (: grid) # Update
             (for This Col
                (=: life (: next)) ) ) ) )
See also +Auto, +Button.
+Chk
Prefix class used to implement on-the-fly field validation. For example, the following code uses +Chk in combination with the built-in validation from +NumField to only accept numbers not bigger than 9. 

    (app)

    (action
       (html 0 "+Chk" "@lib.css" NIL
          (form NIL
             (gui '(+Chk +NumField)
                '(or
                   (extra)
                   (and (> (val> This) 9) "Number too big") )
                12 )
             (gui '(+JS +Button) "Print"
                '(msg (val> (field -1))) ) ) ) )
+Chart
Charts are an important part of the GUI framework. The basic idea is to provide a separation between the way two-dimensional data (i.e. a tabular data, a list of lists) is presented in the gui and the way it is stored internally. Charts make it possible to display the data in rows and columns, scroll the data and connect it to gui components. The first argument to a +Chart is a number: 

    (gui (+Chart) 2)
    (<table> NIL NIL '((NIL "Text") (NIL "Number"))
       (do 1
          (<row> NIL
            (gui 1 '(+TextField) 20)
            (gui 2 '(+NumField) 10) ) ) )
This number tells the chart how many columns of data to expect. As can be seen in the code snippet above, the number '2' matches the number of gui components in the table. To make it possible for a +Chart to display data in a representation that is different from how the date is stored, you may pass two functions to a +Chart. The functions in question are a 'put' and a 'get' function, and they are responsible for 'translating' the data format between the gui and the internal representation. The first function is a 'put'- function that puts data into the GUI components from the internal representation and the second one is a 'get'- function gets data from the GUI components into the internal representation. 

    (gui '(+E/R +Chart) '(bin : home obj) 3
       '((This) (list (: nm)))                    # 'Put'- function
       '((L D)                                    # 'Get'- function
          (and D (put!> D 'nm (car L)))
          D ) )
    (<table> NIL "Binaries" '((NIL "Name"))
       (do 6
          (<row> NIL
             (gui 1 '(+Able +TextField) '(curr) 30)
             (gui 2 '(+DelRowButton))
             (gui 3 '(+BubbleButton)) ) ) )
All GUI components that follow a chart and that have a number as their first argument go into that chart. Typically, the components are arranged in a <table> but this is not a requirement. Any suitable layout works just as well. See also charts, +Chart1, +QueryChart and gui.
+Chart1
+Chart1 is a shortcut to +Chart, with the 'put'-function predefined to 'list' and the 'get'- function predefined to 'car'. This way, +Chart1 can directly map a one-dimensional list to a table. 

    (gui '(+Var +Chart1) (: mup -3) 3)
    (<table> 'chart NIL '((NIL "Media"))
       (do 3
          (<row> (alternating)
             (gui 1 '(+ObjView +TextField) '(: nm)) # Binary name
             (gui 2 '(+DelRowButton)) (gui 3 '(+BubbleButton)) ) )
       (<row> NIL (scroll 3 T)) )
The example above comes from the code running the PicoLisp wiki, in gui.l. In this code, a +Chart1 handles the data provided by (: mup -3) and the chart expects 3 columns. 'mup' is setup a little earlier in the code: 

    (=: mup
         (list
            (and (: obj mup) (in (blob @ 'txt) (till NIL T))) # txt
            NIL # sum
            NIL # min
            (: obj mup bin) ) )
'mup' is a list here, and (: mup -3) picks (: obj mup bin) from there. 'list' is applied as the 'put'- function, resulting in a list containing what is stored in the 'bin' property of the markup contained in the current object. In the table displaying the data, a combination of +ObjView and +TextField is used to create a link to the object: (gui 1 '(+ObjView +TextField) '(: nm)) See also +Chart, charts.
+Checkbox
A checkbox component, example: 

    ,"Hotel?" (gui '(+E/R +Checkbox) '(htl : home obj))
+Checkbox maps to a bool (T or NIL). In the example above, the 'htl' property of the current object will contain T or NIL, depending on whether the checkbox in the gui has been ticked or not. See also gui, +field and input fields.
+ClassField
A +ClassField is used to display and change the class of an object . 

    (gui '(+ClassField) '(: home obj) '(("Male" +Man) ("Female" +Woman)))
The example above displays and changes a person's sex from male to female and vice versa. See also +Map, +TextField.
cloneButton
This function creates a button used to clone, make a copy of the object in the current form. To customise the copy the form object, or it's class, may override the clone>- method (inherited from +Entity). See also +Rid, +Able, +Tip and +Button.
(closeButton Lbl 'Exe)
A close button. 'Exe' runs when the button is pressed and 'Lbl' is the button label. See also +Rid, +Close, +Button, gui.
+ClrButton
Clears all input fields. See also resetButton, +JS, +Tip and +Button.
+Cue
Prefix class used to initialize fields with a help text, hint, about what is supposed to be entered in the field. Displays the argument value within angular brackets if the current value of the field is NIL. Example: 

   (gui '(+Cue +TextField) "Please enter some text here" 30)
Causes an empty field to display "<Please enter some text here>".
(curr @)
Returns the data in the current row of the current chart, optionally applying the 'get' algorithm to any following arguments. 

    ...
    (<table> 'chart NIL
       '((NIL ,"File") (NIL ,"Delete")) (do 2
          (<row> NIL
             (gui 1 '(+DocObj +TextField) (curr)) # (gui 2 '(+DelRowButton)) ) )
             )
    ...
pil21/doc/form/refD.html0000644000000000000000000002140013633635005012152 0ustar D

D

+DbHint
+DbHint supplies autocomplete suggestions from the database. 

    (gui 'nam '(+Var +DbHint +TextField) '*UsrNam '(nam +User) 30)
This example shows a +TextField that has been extended with two classes, +Var and +DbHint. +Var connects the field to a variable and +DbHint fetches autocomplete suggestions from the database. As you can see, +DbHint is given the argument '(nam +User). This tells it to fetch the property "nam" from the class "+User". See also +hint, +Var and +TextField.
+Dflt
A prefix to specify a default value for a field. This is different from '+Init' which can be overwritten with an empty value (NIL). A '+Dflt' field will never contain NIL (unless the default value itself evaluates to NIL). See also +Init.
(diaform 'lst prg)
diaForm is a form that has a dual nature in that it can behave both as a form and as a dialog. When called from a form, by pressing a button (POST) it shows up as a dialog. Otherwise, when called via a link (GET), it shows up as a form. diaform is commonly used in search dialogs, often together with an idForm. This way, functionality to search for, select and edit objects is combined in a single page of the application. 

    (de choItem (Dst)
       (diaform '(Dst)
          (<grid> "--.-."
             ...
             ... )
          (gui 'query '(+QueryChart) (cho)
             ...
             ... )
          (<table> 'chart (choTtl ,"Items" 'nr '+Item)
             ...
             ... )
          (<spread>
             ...
             ... ) ) )
See also form, idForm, dialog.
(dialog Env . Prg)
Creates a dialog. 'Env' can contain additional css attributes, the framework adds the css class 'dialog'. 'Prg' is the content you want to populate the dialog with. See also Alerts and dialogs.
(disable Flg)
This function disables a form when called with a non-NIL argument. It overrides the standard form enable/disable, in that it can disable the form even if it would be otherwise enabled. This affects all components in this form. The following example makes a form read-only until Christmas: 

    (form NIL
       (disable (> (12 24) (cdr (date (date)))))  # Disable whole form
       (gui ..)
       .. )
In a disabled form, individual components can be activated using the +Rid prefix class. See also +Rid.
(delButton Able @Txt)
A delete button, marks an object as deleted. Includes a confirmation dialog. See also ask, note, , +Rid, +Able, +Tip, +Button and gui.
+DelRowButton
A button used to delete one row from a chart. See also chart, +Tiny, +Rid, +JS, +Able, +Tip and +Button.
+DnButton
A button used scroll a chart one row down. See also chart, +Tiny, +Rid, +JS, +Able, +GoButton, +Button and scrolling.
+Drop
+Drop is a prefix class for +Button and makes the most sense in combination with +UpField, for file uploads. The following example comes from the demo app in the PicoLisp distribution, in app/item.l: 

    (gui '(+Able +UpField) '(not (: home obj jpg)) 30)
    (gui '(+Drop +Button) '(field -1)
       '(if (: home obj jpg) ,"Uninstall" ,"Install")
          '(cond
             ((: home obj jpg)
                (ask ,"Uninstall Picture?"
                   (put!> (: home top 1 obj) 'jpg NIL) ) )
             ((: drop) (blob! (: home obj) 'jpg @)) ) )
Note "'(field -1)" in the example above. This part refers to the +UpField. See also +Button, field, +Able, +UpField and gui.
+DstButton
+DstButton, Destination button, has a dual behaviour, manifesting itself as a button or a plain link. The button is always labeled as "@", but if +DstButton is used in a dialog which chooses an object to be stored in a field of the calling form it manifests as a button. In this case, pressing the button stores the object in the destination field. Otherwise, +DstButton manifests itself as a plain link and clicking the link causes a jump to that object. Typical usage is in choice (search) dialogs, which are used both for jumping to objects and for selecting objects in other forms.
The following example uses a +DstButton when presenting the search result in a QueryChart. Since we are not about to choose an object to be stored in a field of the calling form, this +DstButton will manifest as a link and cause a jump to an object.
Given the following 'put'- function: 

    '((This) (list This This (: pa) (: ma) (: mate) (: job) (: dat)))
And presenting the result in a table: 

      (<table> 'chart NIL
         '((btn) (NIL "Name") (NIL "Father") (NIL "Mother") (NIL "Partner") (NIL "Occupation") (NIL "born"))
         (do (cho)
            (<row> (alternating)
               (gui 1 '(+DstButton) Dst)
               (gui 2 '(+ObjView +TextField) '(: nm))
               (gui 3 '(+ObjView +TextField) '(: nm))
               (gui 4 '(+ObjView +TextField) '(: nm))
               (gui 5 '(+ObjView +TextField) '(: nm))
               (gui 6 '(+TextField))
               (gui 7 '(+DateField)) ) ) )
See also +Set, +Able, +Close, +PickButton.
+DateField
+DateField accepts and returns a date value. 

    (gui '(+DateField) 10)
The date format displayed and accepted by the +DateField is determined by the current locale, and the field returns an error when a date not matching the locale is entered. +DateField does some extra work to handle user input, independant of locale. Entering a small number is expanded to mean day of the current month, and entering larger numbers expand to day/ month or day/month/year.
  • Entering "3" means the third day of the current month.
  • "031" or "0301" both expand to 3 January of the current year.
  • "01023" or "010203" expands to 1 February, 2003.
See also +TextField, gui, date and Time & Date.
pil21/doc/form/refE.html0000644000000000000000000000546712663570410012172 0ustar E

E

+Edit
Lock/Edit button prefix class used to gain or release exclusive write access to an object. See also +Rid, +Force and +Tip.
+E/R
Connects GUI elements to database entities. Like its parent class, +/R, +E/R takes a relation specification argument: 

    (gui '(+E/R +TextField) '(text : home obj) 40 4)
This example created a textarea, 40 x 4, and connects it to the 'text'- property of the current form object. See also +/R, data linkage.
(editButton Able Exe)
A function creating an "Edit" button. Takes one argument, "Able", deciding if the button should be clickable or not and one optional Exe argument that is run when clicking the button. This button locks the form object and makes the form editable by the current user. Another user trying to edit the same object at the same time will receive an error message. Here is an example from the code running the PicoLisp wiki, in doc.l. 

    (editButton '(may Wiki) '(_newMup))
'(may Wiki) makes sure that this page is only editable by users having a permission called "Wiki" and '(_newMup) is a function to be run when someone clicks the button. See also +AO, +Focus, +Edit, +Button.
+Enum
A prefix taking a list of items (e.g. strings for a '+TextField') which are mapped to sequential numbers.
(error Exe)
Can be called in a button action to signal an error to the user. The message is displayed near the offending field. See also +Button.
(expires)
expires shows when the current session expires. If Javascript is enabled and <ping> is called in the GUI top level, the session will never expire. In that case, this function is not needed.
pil21/doc/form/refF.html0000644000000000000000000000756413105774206012174 0ustar F

F

+field
Form field base class. See +CheckBox, +Radio, +TextField, +RgbPicker.
(field X . @)
Function to access another field from the current field. The first argument can be either a symbol (to access a named 'gui' component) or a positive or negative number (to access a field relative to the current one). In both cases the 'get' algorithm is applied to all following arguments. 

    (gui '(+View +TextField) '(field -1 'obj 'ort) 30)
+FixField
+FixField accepts and returns scaled fixpoint numbers. This field needs an argument that determines the scale factor. 

    (gui '(+FixField) 3 10)
See also +NumField, +TextField and Input fields.
+FileField
This field evaluates an 'exe' to find and open/create a file, then loads/modifies/stores the text in that file. See also +TextField.
+Focus
+Focus is a prefix class used to set the keyboard focus on a specific GUI element. For example, it can be used to put the initial focus on a specific input field in a search dialog. Examples of this usage can be found in the demo app supplied with the PicoLisp distribution, in gui.l: 

    (de choCuSu (Dst)
       (diaform '(Dst)
          (<grid> "--.-.-."
             ,"Number" (gui 'nr '(+Var +NumField) '*CuSuNr 10)
             ,"Name" (gui 'nm '(+Focus +Var +TextField) '*CuSuNm 30)
             ,"Phone" (gui 'tel '(+Var +TelField) '*CuSuTel 20)
             (searchButton '(init> (: home query)))
             ,"Zip" (gui 'plz '(+Var +TextField) '*CuSuPlz 10)
             ,"City" (gui 'ort '(+Var +TextField) '*CuSuOrt 30)
             ,"Mobile" (gui 'mob '(+Var +TelField) '*CuSuMob 20)
             (resetButton '(nr nm tel plz ort mob query)) )
             .
             .
             .
In the code above, +Focus is used to give initial focus to the "Name" input field.
+Force
Button prefix class which may force the action even if an error occurred. Without it, an 'error' will always inhibit further button handling. See also +Button.
+Fmt
+Fmt is a prefix class that combines +Set and +Val, taking two functions as arguments. This example will display upper case characters, while returning lower case characters internally: 

    (gui '(+Fmt +TextField) uppc lowc 30)
See also +Set, +Val and formatting.
form
The basic form function. Handles operations common to the concrete form types in the library. See idForm, diaform.
pil21/doc/form/refG.html0000644000000000000000000000207712663571205012171 0ustar G

G

+gui
GUI component base class. See +field, +Button, +Img and +JsField.
+GoButton
A button used to scroll charts. A +GoButton moves to a given position. See also chart, +Tiny, +Rid, +JS, +Able +UpButton, +DnButton and +Button.
pil21/doc/form/refH.html0000644000000000000000000000375612664020173012171 0ustar H

H

+hint
+hint is a base class used to implement autocomplete functionality in the GUI. See +Hint, +Hint1, +Hint2, +DbHint and +Obj.
+Hint
+Hint takes a function which is supposed to generate a list of matches for the argument string. See also +DbHint.
+Hint1
+Hint1 takes an expression that produces a list of all values to be used. Useful if there are not too many values, for example a small number of constant strings or a short DB selection.
+Hint2
+Hint2, "second hint", should be used in a field immediately after a +Choice- button, or after a +Hint1- field. It will then use the hint values of the preceding field. See also +Choice, +Hint1.
+HttpField
+HttpField stores a URL and creates a link to it in the gui. 
,"Home page" (gui '(+E/R +HttpField) '(hp : home obj) 40)
See also +Url, +MailField, +TelField and +TextField.
pil21/doc/form/refI.html0000644000000000000000000001245213105774320012164 0ustar I

I

(<id> )
Sets the object passed to a form in the '*ID' global via the URL into the form's 'obj' property. Takes care of handling enable/disable, locking, and displaying the object's name or similar property. Usually called in a HTML '<hN>' tag, or implicitly in 'idForm'. See also idForm.
(idForm Entity Cho Var Cls Able Del Lst . Prg)
idForm is used to display and edit objects in the system. Here is an example from the demo application included with the PicoLisp distribution, in item.l: 

    (menu ,"Item"
       (idForm ,"Item" '(choItem) 'nr '+Item T '(may Delete) '((: nr) " -- " (: nm))
          (<grid> 4
             ,"Number" NIL (gui '(+E/R +NumField) '(nr : home obj) 10) NIL
             ,"Description" NIL (gui '(+E/R +Cue +TextField) '(nm : home obj) ,"Item" 30) NIL
             ,"Supplier" (choCuSu 0)
             (gui '(+E/R +Obj +TextField) '(sup : home obj) '(nm +CuSu) 30)
             (gui '(+View +TextField) '(field -1 'obj 'ort) 30)
             ,"Inventory" NIL (gui '(+E/R +NumField) '(inv : home obj) 12)
             (gui '(+View +NumField) '(cnt> (: home obj)) 12)
             ,"Price" NIL (gui '(+E/R +FixField) '(pr : home obj) 2 12) )
          (--)
          (<grid> 2
             ,"Memo" (gui '(+BlobField) '(txt : home obj) 60 8)
             ,"Picture"
             (prog
                (gui '(+Able +UpField) '(not (: home obj jpg)) 30)
                (gui '(+Drop +Button) '(field -1)
                   '(if (: home obj jpg) ,"Uninstall" ,"Install")
                   '(cond
                      ((: home obj jpg)
                         (ask ,"Uninstall Picture?"
                            (put!> (: home top 1 obj) 'jpg NIL) ) )
                      ((: drop) (blob! (: home obj) 'jpg @)) ) ) ) )
          (<spread> NIL (editButton T))
          (gui '(+Upd +Img)
             '(and (: home obj jpg) (allow (blob (: home obj) 'jpg)))
             ,"Picture" ) ) )
The first argument to idForm is used to create a header, in our case "Item". This is followed by 'choItem(), which is a search function. This allows us to use both search and edit functionality from the same page. Then we have two arguments, 'nr '+Item used to count how many objects of a certain type is in the database.

The T argument that follows decides whether a user can edit objects in this form or not. Next up is '(may Delete), checking if the current user has permission to delete objects. Finally, the list '((: nr) "--" (: nm)) is passed to the idForm function. This is used to create a heading that is displayed when a single object has been selected. Our example will use the 'nr' and 'nm' properties of an +Item object combined with " -- ". The result is something like this: "Item: 2 -- Spare Part".

See also diaform, form.
+Icon
This class is somewhat similar to +Img, but is more dynamic. +Icon takes an 'exe' which can be used to show different icons depending on the situation.
+Img
Image form field. This field can take 4 arguments that affect the resulting html. These arguments are Alt, Url, Dx and Dy. 

    (gui '(+Upd +Img)
    '(and (: home obj jpg) (allow (blob (: home obj) 'jpg)))
    ,"Picture" "http://picolisp.com" 35 55) ) )
Alt, Dx and Dy all set properties in the resulting img tag: 

    <img src="..." alt="Picture" width="35" height="55 id=".." />
Adding a Url argument turns the resulting image into a link: 

    <a href="http://picolisp.com"><img src="..." alt="Picture" width="35" height="55 id=".."/></a>
See also +gui and +Upd.
+Init
Prefix class used to give an initial value to a GUI component. Takes an expression to give the field an initial value. 

    (gui '(+Init +TextField) "Initial value" 30)
+InsRowButton
This button inserts a new, empty, row in a chart. See also +Tiny, +JS, +Able, +Tip, +Button.
pil21/doc/form/refJ.html0000644000000000000000000000137114126123615012162 0ustar J

J

+JS
+JS is a Javascript prefix class. When a +Button uses this prefix, it will POST the page using Javascript. This may lead to a faster response and avoids flicker caused by reloading and rendering the page. More information is available in the application tutorial. See also +Button.
pil21/doc/form/refL.html0000644000000000000000000000512512664020221012157 0ustar L

L

+Limit
Prefix class controlling the maxlength attribute of the generated HTML input field, used to set a maximum limit of how many characters may be entered into the field. 

    (gui '(+Limit +TextField) 10 15)
+LinesField
A +LinesField maps text to a list of strings. +LinesField is typically used as a textarea, i.e. created by passing two dimensions as arguments: 

    (gui '(+LinesField) 10 4)
Text entered in the textarea will be split in a list of string, using newline as a delimiter: "I am a row of text
and I am a second row of text" -> ("I am a row of text" "and I am a second row of text") See also +TextField. and input fields.
+ListTextField
A +ListTextField maps text to a list of strings. Normally used as a single line text field and takes a list of delimiters as argument: 

    (gui '(+SetEAdr +E/R +ListTextField) '(to : home obj) '(", " "," " ") 60)
The example above creates a text field connected to the 'to' property of the current object. Entering e-mail addresses in this field, separated by a comma followed by a space, just a comma or just a space will map the addresses to a list: "foo@domain.com, bar@domain.com baz@domain.com" --> ("foo@domain.com" "bar@domain.com" "baz@domain.com") See also gui, +TextField and input fields.
+Lock
Prefix class that unconditionally locks a GUI element. This class takes no arguments. 

    (gui '(+Lock +TextField) 30)
See also +Able.
+Lowc
Prefix class, converts to lower case. 

    "Lower case" (gui '(+Lowc +TextField) 30)
See also +Uppc.
pil21/doc/form/refM.html0000644000000000000000000000375412663572136012206 0ustar M

M

+MailField
Handles e-mail addresses, creates "mailto:"- links. 

    ,"EMail" (gui '(+E/R +MailField) '(em : home obj) 40) ) )
See also +Url, +HttpField, +TelField and +TextField.
+Map
+Map is normally used with the combo box version of the text fields. +Map does a two-way translation and uses a list of cons pairs for lookup. The values in the CARs are displayed in the GUI and are mapped internally to the values in the CDRs. The following code displays "One", "Two" and "Three" to the user but uses 1, 2 and 3 internally. 

    (app)

    (action
       (html 0 "+Map" "@lib.css" NIL
          (form NIL
             (gui '(+Map +TextField)
                '(("One" . 1) ("Two" . 2) ("Three" . 3))
                '("One" "Two" "Three") )
             (gui '(+Button) "Print"
                '(msg (val> (field -1))) ) ) ) )
See also +Fmt, +TextField.
+Mono
+Mono is a style prefix class and is used to display text in a monospace font. Adds the css class "mono" to the element where this prefix class is used. 

    (gui '(+Mono +TextField) 30)
Text entered in the textfield above is rendered in a monospace font.
pil21/doc/form/refN.html0000644000000000000000000000601313633431326012167 0ustar N

N

(newButton Able Dst Args)
This function makes a button used to create a new object. The following code comes from the demo app supplied with the PicoLisp distribution, in gui.l, and makes a button that when clicked creates a new object of the class +CuSu. The new object is initialised with the values used in a search for an existing one, if any such terms have been entered. 

    (newButton T Dst '(+CuSu)
       '(nr genKey 'nr '+CuSu)
       'nm *CuSuNm
       'plz *CuSuPlz
       'ort *CuSuOrt
       'tel *CuSuTel
       'mob *CuSuMob )
See also +Rid, +Able, +Close, +Tip, +Button.
(newUrl @)
newUrl is used to create a new DB object. In this example, it is used as action code for a button. Pressing the button will create a new object of the class "+Bkng" and take the user to the page where such an object can be edited. 

    .
    .
    (gui 6 '(+Able +Button) T ,"Book"
       '(newUrl '(+Bkng)
          '(nr genKey 'nr '+Bkng)
          'pos (curr)
          'depd (: home obj depd)
          'dept (: home obj dept)
          'retd (: home obj retd)
          'rett (: home obj rett)
          'trsp (if (: home obj trf) ,"Yes" ,"No")
          'htl (if (: home obj htl) ,"Yes" ,"No") ) )
    .
    .
(noButton 'Exe)
A 'no' button. See also +Close, +Button and gui.
(note Str Lst)
An alert where Str is displayed as heading and the content of Lst is shown with each item on a separate row. An 'Ok' button concludes the note. See also alert, okButton and Alerts and dialogs.
+NumField
+NumField accepts a number and returns a number. An error message is issued if a value that is not a number or cannot be converted to a number is entered. Large numbers are displayed with a thousands-separator, as determined by the current locale. 

    (gui '(+NumField) 10)
See also +TextField and Input fields.
pil21/doc/form/refO.html0000644000000000000000000001077413105774451012204 0ustar O

O

+obj
+obj is a base class used to turn a DB object into a first class GUI item. See +Obj, +ObjView and +ObjVal.
+Obj
Holds an object, like a '+NumField' holds (i.e. converts, checks etc. ) a number or a '+DateField' holds a date and so on. This way, a DB object becomes a first class GUI item just like the primitives string, number etc. In addition, +Objsupplies suggestions from the database, using dbHint. 

    (gui '(+E/R +Obj +TextField) '(pa : home obj) '(nm +Man) 30)
Here, the +TextField is connected to the 'pa'- property of the current form object. Since we are using +Obj in combination with +TextField, the database will suggest names from the 'nm'- property of the class +Man. See also +NumField, +DateField, dbHint, +hint, +obj.
+ObjView
Similar to +Obj, but not editable (view-only). Therefore it is free to display an arbitrary attribute of an object, or even the result of an arbitrary formatting expression, while still allowing to click on it and jump to the object's GUI form, as determined by the url>- method (or a custom method supplied as an optional argument to +ObjView. Such an optional method is accepted by all subclasses of +obj). A common use of +ObjView is when presenting data in a chart. Given the following 'put'- function: 

    '((This) (list This This (: pa) (: ma) (: mate) (: job) (: dat)))
The data can be displayed with the following table: 

      (<table> 'chart NIL
         '((btn) (NIL "Name") (NIL "Father") (NIL "Mother") (NIL "Partner") (NIL "Occupation") (NIL "born"))
         (do (cho)
            (<row> (alternating)
               (gui 1 '(+DstButton) Dst)
               (gui 2 '(+ObjView +TextField) '(: nm))
               (gui 3 '(+ObjView +TextField) '(: nm))
               (gui 4 '(+ObjView +TextField) '(: nm))
               (gui 5 '(+ObjView +TextField) '(: nm))
               (gui 6 '(+TextField))
               (gui 7 '(+DateField)) ) ) )
Columns 2, 3 and 4 use +ObjView to display the name of the 'pa', 'ma' and 'mate' relations of the current object respectively. See also +Obj, +obj.
+ObjVal
Like +Obj, but automatically creates a new object if one does not exist and an attribute value is entered into a field. See also +Obj, +obj.
+OnClick
A prefix class used in combination with +Button. +OnClick takes javascript code as an argument. This code is then executed by the browser when the button is clicked. A short example would look like this: 

    (gui '(+OnClick +Button) "alert('OK')" "Alert")
The PicoLisp wiki includes a good article that explains +OnClick in depth. See also +Button and gui.
(okButton 'Exe)
A button with the label "Ok". If 'Exe' is passed in, the button uses the prefix classes +Force and +Close, otherwise only +Close is used. See also +Force, +Close, +Button and gui.
pil21/doc/form/refP.html0000644000000000000000000000270513036154174012175 0ustar P

P

+PickButton
A button labeled "@", used for selecting an object. Like +ChoButton, it is a convenience class to provide a style and a tooltip. See also +Tiny, +Tip, +Button, +ChoButton.
(prev @)
Same as 'row' but for the preceding row. The function implementation looks like this: 

    (de prev @
       (pass get (: chart 1 data) (row -1)) )
See row.
+PwField
A standard password field. Does not echo the entered characters back. Example: 

    (gui 'pw '(+PwField) 20 "Password")
This produces a <passwd> html tag. See also gui, +TextField and input fields.
pil21/doc/form/refQ.html0000644000000000000000000001452213105774612012200 0ustar Q

Q

+QueryChart
In addition to the 'standard' arguments passes to charts, the +QueryChart takes two additional ones. First, the number of initial rows to fetch and second a Pilog query that retrieves data. Typically used in search dialogs, as the following example from the demo app supplied with the PicoLisp distribution. 

    (de choItem (Dst)
       (diaform '(Dst)
          (<grid> "--.-."
             ,"Number" (gui 'nr '(+Focus +Var +NumField) '*ItemNr 10)
             ,"Supplier" (gui 'sup '(+Var +TextField) '*ItemSup 20)
             (searchButton '(init> (: home query)))
             ,"Description" (gui 'nm '(+Var +TextField) '*ItemNm 30)
             ,"Price" (gui 'pr '(+Var +FixField) '*ItemPr 2 12)
             (resetButton '(nr nm pr sup query)) )
          (gui 'query '(+QueryChart) (cho)
             '(goal
                (quote
                   @Nr (and *ItemNr (cons @ T))
                   @Nm *ItemNm
                   @Pr (and *ItemPr (cons @ T))
                   @Sup *ItemSup
                   (select (@@)
                      ((nr +Item @Nr) (nm +Item @Nm) (pr +Item @Pr) (nm +CuSu @Sup (sup +Item)))
                         (range @Nr @@ nr)
                         (part @Nm @@ nm)
                         (range @Pr @@ pr)
                         (tolr @Sup @@ sup nm) ) ) )
             6
             '((This) (list This (: nr) This (: sup) (: sup ort) (: pr))) )
             (<table> 'chart (choTtl ,"Items" 'nr '+Item)
                (quote
                   (btn)
                   (align "#")
                   (NIL ,"Description")
                   (NIL ,"Supplier")
                   (NIL ,"City")
                   (align ,"Price") )
                (do (cho)
                   (<row> (alternating)
                      (gui 1 '(+DstButton) Dst)
                      (gui 2 '(+NumField))
                      (gui 3 '(+ObjView +TextField) '(: nm))
                      (gui 4 '(+ObjView +TextField) '(: nm))
                      (gui 5 '(+TextField))
                      (gui 6 '(+FixField) 2) ) ) )
             (<spread>
                (scroll (cho))
                (newButton T Dst '(+Item)
                '(nr genKey 'nr '+Item)
                'nm *ItemNm
                'pr *ItemPr )
                (cancelButton) ) ) )
The first argument to +QueryChart, (cho), returns a number that decides how many rows of data should be fetched. The same call is used a little later to draw the table presenting the data as well. Following that argument is the Pilog query used to fetch the data we wish to display. 

    '(goal
       (quote
          @Nr (and *ItemNr (cons @ T))
          @Nm *ItemNm
          @Pr (and *ItemPr (cons @ T))
          @Sup *ItemSup
          (select (@@)
             ((nr +Item @Nr) (nm +Item @Nm) (pr +Item @Pr) (nm +CuSu @Sup (sup +Item)))
                (range @Nr @@ nr)
                (part @Nm @@ nm)
                (range @Pr @@ pr)
                (tolr @Sup @@ sup nm) ) ) )
The Pilog query is followed by a number, in this case 6, that tells how many columns are used when presenting the data. This is the normal column count, as inherited from +Chart, and it matches up with the number of columns in our table. 

    (<table> 'chart (choTtl ,"Items" 'nr '+Item)
       (quote
          (btn)
          (align "#")
          (NIL ,"Description")
          (NIL ,"Supplier")
          (NIL ,"City")
          (align ,"Price") )
       (do (cho)
          (<row> (alternating)
             (gui 1 '(+DstButton) Dst)
             (gui 2 '(+NumField))
             (gui 3 '(+ObjView +TextField) '(: nm))
             (gui 4 '(+ObjView +TextField) '(: nm))
             (gui 5 '(+TextField))
             (gui 6 '(+FixField) 2) ) ) )
The +QueryChart in the example uses a 'put'- function to put data into the GUI components from the result of the Pilog query. 

    '((This) (list This (: nr) This (: sup) (: sup ort) (: pr)))
The 'put'- function is applied to each row and places the desired content into the GUI. Since this chart is read only, i.e. contains no input fields, the corresponding 'get'- function can be omitted. Each item in the list produced by our 'put'- function matches up with a column in the table presenting the result. The first item, This, is used to create a link to the object, in column 1 of the table: (gui 1 '(+DstButton) Dst) Item number 2, (: nr), maps to the second column, showing the number of the object in question: (gui 2 '(+NumField)) The two following items, This and (: sup) each map to a combination of +ObjView and +TextField: 

    (gui 3 '(+ObjView +TextField) '(: nm))
    (gui 4 '(+ObjView +TextField) '(: nm))
The +ObjView is used to create a link to an object, in both cases displaying the (: nm) property of each object. Finally, the name of the town where the supplier is located and the price of the item are displayed. The 'put'- function supplies these values: (: sup ort) and (: pr), which are mapped to the following columns in the table: 

    (gui 5 '(+TextField))
    (gui 6 '(+FixField) 2)
See also +Chart, cho, gui, +DstButton, +NumField, diaform, +ObjView, +TextField, +FixField, charts and the select predicate.
pil21/doc/form/refR.html0000644000000000000000000001140513643557477012215 0ustar R

R

+/R
Base class for entity relations. +/R takes an entity specification, which is a cons pair with a relation in its CAR and an expression, evaluating to an object, in its CDR. For example: 

    '(text : home obj)
+/R is used in locked, read-only, GUI components. It does not modify the value in the object. However, that does not happen in '+Lock'ed components anyway. See also +E/R, +Lock.
+Radio
A radio button component. Example: 

    '(<grid> 2
        "Radio A" (gui '(+Var +Radio) '*DemoRadio NIL "A")
        "Radio B" (gui '(+Radio)  -1 "B")
        "Radio C" (gui '(+Radio)  -2 "C") )

+Radio components only makes sense as a group. The first argument to a +Radio component is either NIL or a field reference. If the first argument is NIL, the component in question will be the 'leader component' of a radio group. In the example above "Radio A" holds this position.

The following +Radio components in our example have a field reference as their first argument. This reference points back to the 'leader component' of the radio group. Our example uses a relative, numeric, offset to another field, but the symbolic name of a field can also be used.

The 'leader component' of a radio group takes care of holding the resulting value. As can be seen above, the first +Radio component uses a prefix class, +Var. This class is used to connect a variable to a gui component. Since this is the 'leader' of the radio group, its variable (*DemoRadio) will be populated with the value that results from selecting one of the radio buttons.

See also gui, +field and input fields.
+RedoButton
A 'Redo' button. See change, +UndoButton.
(repl Attr)
A form with a Lisp REPL. Runs a REPL in the browser and opens up the server completely, which is obviously a big security risk. Use with caution!
+RgbPicker
A color picker component. Produces an html color picker, <input type="color"...> . See also +field.
+Rid
Prefix class used to remove the form lock from a certain component, i.e. get rid of the lock. 

   "Some text" (gui (+Rid +TextField) 30)
The text field in the above example has had the lock removed by +Rid and is editable even when the current form as such is locked. Worth noting though is that the field may still have it's own +Able expression, which may happen to disable it again. See also +Able.
(resetButton Lst)
This function creates a button that clears the content from a number of GUI fields. Takes a list of fields to clear as argument. Often used in search dialogs, as in the following example. This code comes from the demo app included in the PicoLisp distribution, in gui.l. In this case, the button created resets, clears, the GUI fields named nr, nm, pr, sup and query. 

    (resetButton '(nr nm pr sup query)))
The list of fields to clear can also contain an expression used to populate the field with a new value, instead of emptying the field. 

    (resetButton '((dat date) nr nm))
See also +Force, +ClrButton.
(row D)
Returns the numeric offset of the current row (no arguments), or of a relative neighbor row (numeric argument) of the current chart. The implementation looks like this: 

    (de row (D)
       (+ (: chart 1 ofs) (: chart 2) -1 (or D 0)) )
See also prev.
pil21/doc/form/refS.html0000644000000000000000000001466213105775073012211 0ustar S

S

(saveButton Exe)
A button with the label "Save". 'Exe' is the code that runs when the button is pressed. 

    (saveButton
       '(let Obj (: home obj)
          (when (: home org)  # Reply
             (dbSync)
             (put> (: home org mup) 'rpl
                (append
                   (: home org mup rpl)
                   (cons (setq Obj (new (db: +Doc) '(+Doc)))) ) )
             (commit 'upd) )
          (apply 'newMup> (: home mup) Obj)
          (off *ID)
          (url (ext.html (or (: home org) Obj))) ) )
The above code is an example from the code running the PicoLisp wiki, in gui.l. The button is passed a code argument that checks if a reply has been written to the current object, creating markup code and syncing the database. In effect, an entire "miniature program" is connected to the save button to be run when someone clicks it. See also +Button.
(searchButton Exe)
Creates a button with the label "Search" and takes an Exe argument. Here is an example from the demo app included with the PicoLisp distribution, in gui.l. 

    (searchButton '(init> (: home query)))
This is from one of the search dialogs and is given '(init> (: home query)) as argument. When the search button if pressed, the argument code is run. In this case, the pilog query in the search dialog is initiated. See also +Rid, +JS, +Tip, +Button.
+SexField
+SexField displays a choice between "Male" or "Female" and stores T or 0 respectively, depending on what the user selects. 

    ,"Sex" (gui '(+E/R +SexField) '(sex : home obj))
See also +Map, gui and +TextField.
+Sgn
"Signum" prefix for numeric fields causing negative number to show in red color.
+ShowButton
This button generates HTML that is displayed outside of the current form. One way of using this is in report creation and similar tasks. An example of this can be found in the demo app: 

      (gui '(+ShowButton) NIL
         '(csv ,"Inventory"
            (<table> 'chart NIL
               (<!>
                  (quote
                     (align)
                     (NIL ,"Description")
                     (align ,"Inventory")
                     (NIL ,"Supplier")
                     NIL
                     (NIL ,"Zip")
                     (NIL ,"City")
                     (align ,"Price") ) )
               (catch NIL
                  (pilog
                     (quote
                        @Rng (cons *InvFrom (or *InvTill T))
                        @Nm *InvNm
                        @Sup *InvSup
                        (select (@Item)
                           ((nr +Item @Rng) (nm +Item @Nm) (sup +Item @Sup))
                           (range @Rng @Item nr)
                           (part @Nm @Item nm)
                           (same @Sup @Item sup) ) )
                     (with @Item
                        (<row> (alternating)
                           (<+> (: nr) This)
                           (<+> (: nm) This)
                           (<+> (cnt> This))
                           (<+> (: sup nm) (: sup))
                           (<+> (: sup nm2))
                           (<+> (: sup plz))
                           (<+> (: sup ort))
                           (<-> (money (: pr))) ) )
                     (at (0 . 10000) (or (flush) (throw))) ) ) ) ) ) ) )
The above code from inventory.l produces a CSV file with the current inventory. See also +Button.
+SymField
+SymField interns the text entered.
+SubE/R
This class refers to a relation in an object which is '+Link'ed or '+Join'ed from the current form's object. Here is an example: 

   (class +Instr +Entity)
   (rel foo (+Joint) ins (+Foo))
   (rel ma (+String))
   (rel ha (+String))
A +Foo object may have an +Instr object. The +Instr object in turn has two +String properties, 'ma' and 'ha'. Using +SubE/R allows us to write this in the GUI of +Foo: 

   (gui '(+SubE/R +TextField) '(ma ins +Instr) 30)
   (gui '(+SubE/R +TextField) '(ha ins +Instr) 30)
This makes it possible to edit 'ma' and 'ha' from the +Instr- object in the GUI for the +Foo- object, and no separate form is needed for +Instr.
+Set
+Set takes an argument function that is called each time the field in question is set to a value. For example, the following snippet can be used to convert user input to upper case: 

    (gui '(+Set +TextField) uppc 30)
See also +Val, +Fmt, Formatting.
+Style
Adds a css class name to a GUI component. 

    (gui '(+Style +View +TextField) "mono"
       '(pack
          (make
             (for Col (: home grid)
                (for This Col
                   (link (if (: life) "X " "  ")) )
                (link "^J") ) ) )
       40 20 )
In this example, the class "mono" is added to a +TextField.
pil21/doc/form/refT.html0000644000000000000000000001004112663574354012204 0ustar T

T

+TextField
Apart from it's usage as an input field, +TextField is used as the basis for a number of other components. The actual appearance depends on the arguments supplied. Without any arguments, plain HTML text is created: 

    (gui '(+TextField))
When supplied with a single numerical argument, a normal text field is created: 

    (gui '(+TextField) 10)
If two numerical arguments are provided, a text area is created: 

    (gui '(+TextField) 10 4)
If the argument is a list of values, a drop-down selection is created: 

    (gui '(+TextField) '("Value 1" "Value 2" "Value 3"))
A string can be passed in as well. This will be used as a label: 

    (gui '(+TextField) 10 "Text field")
    (gui '(+TextField) 10 4 "Text area")
    (gui '(+TextField) '("Value 1" "Value 2" "Value 3") "Selection")
See also gui, +field and input fields.
*Throbber
A list of strings, used to provide an animated label form +Auto buttons. 

    (gui '(+Click +Auto +Button) 420 'This 1000 '(pop *Throbber)
       '(...) )
See also +Click, +Auto, +Button.
+TimeField
+TimeField accepts and returns a time value. An error is issued if the input can not be converted to a time value. 

    (gui '(+TimeField) 8)
A +TimeField with the width set to '8', as in the example above, displays time in the format HH:MM:SS. If the width is set to '5' instead, time will be displayed using the format HH:MM. See also +TextField, +DateField, time and Time & Date.
+Tiny
+Tiny adds a css class, "tiny", and is often used when creating buttons. The effect when using the css provided with the framework is to produce a component with a smaller size. 

    (class +PickButton +Tiny +Tip +Button)
+TelField
+TelField handles telephone numbers, displays an error if the input is not a valid telephone number according to the current locale. 

    ,"Mobile" (gui '(+E/R +TelField) '(mob : home obj) 40)
See also +Url, +HttpField, +MailField, +TextField and Telephone numbers.
+Tip
+Tip adds a tooltip text shown when hovering the mouse pointer over the element where this prefix class is added. Controls the "title"- attribute of the generated HTML. 

    (gui '(+Tip +TextField) "Tooltip text shown on mouse-over" 30)
+Trim
Prefix class that trims trailing whitespace. 

    "Name" (gui '(+Trim +TextField) 30)
pil21/doc/form/refU.html0000644000000000000000000000617512663574472012223 0ustar U

U

+UndoButton
An 'Undo' button. See change, +RedoButton.
+UpField
A file upload field. Example: 

    (gui '(+UpField) 30)
Often used together with +Drop. See also +TextField.
+UpButton
A button used scroll a chart one row up. See also chart, +Tiny, +Rid, +JS, +Able +GoButton, +Button and scrolling.
+Upd
+Upd is a prefix class that can be used to override the upd> method in existing classes. The following example uses +Upd to print updated values to standard error: 

    (app)
    (default *Number 0)

    (action
       (html 0 "+Upd" "@lib.css" NIL
          (form NIL
             (gui '(+Upd +Var +NumField)
                '(prog (extra) (msg *Number))
                '*Number 8 )
             (gui '(+JS +Button) "Increment"
                '(inc '*Number) ) ) ) )
+Url
Constructs a URL, building it up with session id and an icon. May be used as a prefix class in several, "clickable", classes but is useful by itself too. The following example makes a context clickable: 

   (gui '(+View +Url +TextField)
      '(and (port> (: home obj)) (pack "https://foo.net/" @))
      '((Url) (pack Url "/umc/adm.l?*PW=" (pw))) )
See also +HttpField, +MailField, +TelField and +TextField.
(url URL . @)
Can be called in a button action to jump to an arbitrary URL instead of the normal re-display of the current form. 

    (gui '(+Rid +Button) "Contemporaries"
       '(url "!contemporaries" (: home obj)) )
See also +Button, +Rid.
+Uppc
Prefix class, converts to upper case. 

  "Upper case" (gui '(+Uppc +TextField) 30)
See also +Lowc.
pil21/doc/form/refV.html0000644000000000000000000000326213042045043012171 0ustar V

V

+Val
Takes a function that gets called each time a field's value is retrieved. The following example returns the square of the field's value: 

    (gui '(+Val +NumField) '((N) (* N N)) 10)
See also +Set, +Fmt, Formatting.
+Var
Links a form field to a variable. 

    "Occupation" (gui 'job '(+Var +TextField) '*PrsJob 20)
This example links a text field to the variable *PrsJob. See also +E/R.
+View
Like +Lock, view is a prefix class that disables a GUI component. However, +View can take a functional argument: 

    (gui '(+Sgn +View +FixField) '(sum> (: home obj)) 2 12) ) )
This example is a snippet from the demo app included with the PicoLisp distribution, in ord.l. The code produces a disabled text field that displays the total order sum of the current order object. See also +Lock, +Upd, +Init.
pil21/doc/form/refY.html0000644000000000000000000000105612663574633012217 0ustar Y

Y

(yesButton Exe)
A yes button. See also +Close, +Button and gui.
pil21/doc/app.html0000600000000000000000000031471214126123442011105 0ustar PicoLisp Application Development abu@software-lab.de
mattias@inogu.se

PicoLisp Application Development

(c) Software Lab. Alexander Burger, Mattias Sundblad

This document presents an introduction to writing browser-based applications in PicoLisp.

It concentrates on the XHTML/CSS GUI-Framework (as opposed to the previous Java-AWT, Java-Swing and Plain-HTML frameworks), which is easier to use, more flexible in layout design, and does not depend on plug-ins, JavaScript, cookies or CSS.

A plain HTTP/HTML GUI has various advantages: It runs on any browser, and can be fully driven by scripts ("@lib/scrape.l").

To be precise: CSS can be used to enhance the layout. And browsers with JavaScript will respond faster and smoother. But this framework works just fine in browsers which do not know anything about CSS or JavaScript. All examples were also tested using the w3m text browser.

For basic informations about the PicoLisp system please look at the PicoLisp Reference and the PicoLisp Tutorial. Knowledge of HTML, and a bit of CSS and HTTP is assumed.

The examples assume that PicoLisp was started from a global installation (see Installation).

Static Pages

You can use PicoLisp to generate static HTML pages. This does not make much sense in itself, because you could directly write HTML code as well, but it forms the base for interactive applications, and allows us to introduce the application server and other fundamental concepts.

Hello World

To begin with a minimal application, please enter the following two lines into a generic source file named "project.l" in the PicoLisp installation directory. 


########################################################################
(html 0 "Hello" "@lib.css" NIL
   "Hello World!" )
########################################################################

(We will modify and use this file in all following examples and experiments. Whenever you find such a program snippet between hash ('#') lines, just copy and paste it into your "project.l" file, and press the "reload" button of your browser to view the effects)

Start the application server

Open a second terminal window, and start a PicoLisp application server 


$ pil @lib/http.l @lib/xhtml.l @lib/form.l  --server 8080 project.l  +

No prompt appears. The server just sits, and waits for connections. You can stop it later by hitting Ctrl-C in that terminal, or by executing 'killall pil' in some other window.

(In the following, we assume that this HTTP server is up and running)

Now open the URL 'http://localhost:8080' with your browser. You should see an empty page with a single line of text.

How does it work?

The above line loads the debugger (via the '+' switch), the HTTP server code ("@lib/http.l"), the XHTML functions ("@lib/xhtml.l") and the input form framework ("@lib/form.l", it will be needed later for interactive forms).

Then the -server function is called (a front-end to server) with a port number and a default URL. It will listen on that port for incoming HTTP requests in an endless loop. Whenever a GET request arrives on port 8080, the file "project.l" will be (load)ed, causing the evaluation (= execution) of all its Lisp expressions.

During that execution, all data written to the current output channel is sent directly to the browser. The code in "project.l" is responsible to produce HTML (or anything else the browser can understand).

URL Syntax

The PicoLisp application server uses a slightly specialized syntax when communicating URLs to and from a client. The "path" part of an URL - which remains when

  • the preceding protocol, host and port specifications,
  • and the trailing question mark plus arguments
are stripped off - is interpreted according so some rules. The most prominent ones are:

  • If a path starts with an exclamation-mark ('!'), the rest (without the '!') is taken as the name of a Lisp function to be called. All arguments following the question mark are passed to that function.
  • If a path ends with ".l" (a dot and a lower case 'L'), it is taken as a Lisp source file name to be (load)ed. This is the most common case, and we use it in our example "project.l".
  • If the extension of a file name matches an entry in the global mime type table *Mimes, the file is sent to the client with mime-type and max-age values taken from that table.
  • Otherwise, the file is sent to the client with a mime-type of "application/octet-stream" and a max-age of 1 second.

An application is free to extend or modify the *Mimes table with the mime function. For example 


(mime "doc" "application/msword" 60)

defines a new mime type with a max-age of one minute.

Argument values in URLs, following the path and the question mark, are encoded in such a way that Lisp data types are preserved:

  • An internal symbol starts with a dollar sign ('$')
  • A number starts with a plus sign ('+')
  • An external (database) symbol starts with dash ('-')
  • A list (one level only) is encoded with underscores ('_')
  • Otherwise, it is a transient symbol (a plain string)

In that way, high-level data types can be directly passed to functions encoded in the URL, or assigned to global variables before a file is loaded.

Security

It is, of course, a huge security hole that - directly from the URL - any Lisp source file can be loaded, and any Lisp function can be called. For that reason, applications must take care to declare exactly which files and functions are to be allowed in URLs. The server checks a global variable *Allow, and - when its value is non-NIL - denies access to anything that does not match its contents.

Normally, *Allow is not manipulated directly, but set with the allowed and allow functions 


(allowed ("app/")
   "!start" "!stop" "@lib.css" "!psh" )

This is usually called at the beginning of an application, and allows access to the directory "app/", to the functions 'start', 'stop' and 'psh', and to the file "@lib.css".

Later in the program, *Allow may be dynamically extended with allow 


(allow "!foo")
(allow "newdir/" T)

This adds the function 'foo', and the directory "newdir/", to the set of allowed items.

The ".pw" File

For a variety of security checks (most notably for using the psh function, as in some later examples) it is necessary to create a file named ".pw" in the PicoLisp installation directory. This file should contain a single line of arbitrary data, to be used as a password for identifying local resources.

The recommeded way to create this file is to call the pw function, defined in "@lib/http.l" 


$ pil @lib/http.l -'pw 12' -bye

Please execute this command.

The html Function

Now back to our "Hello World" example. In principle, you could write "project.l" as a sequence of print statements 


########################################################################
(prinl "HTTP/1.0 200 OK^M")
(prinl "Content-Type: text/html; charset=utf-8")
(prinl "^M")
(prinl "<html>")
(prinl "Hello World!")
(prinl "</html>")
########################################################################

but using the html function is much more convenient.

Moreover, html is nothing more than a printing function. You can see this easily if you connect a PicoLisp Shell (psh) to the server process (you must have generated a ".pw" file for this), and enter the html statement 


$ /usr/lib/picolisp/bin/psh 8080
: (html 0 "Hello" "@lib.css" NIL "Hello World!")
HTTP/1.0 200 OK
Server: PicoLisp
Date: Fri, 29 Dec 2006 07:28:58 GMT
Cache-Control: max-age=0
Cache-Control: no-cache
Content-Type: text/html; charset=utf-8

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>Hello</title>
<base href="http://localhost:8080/"/>
<link rel="stylesheet" type="text/css" href="http://localhost:8080/@lib.css"/>
</head>
<body>Hello World!</body>
</html>
-> </html>
:  # (type Ctrl-D here to terminate PicoLisp)

These are the arguments to html:

  1. 0: A max-age value for cache-control (in seconds, zero means "no-cache"). You might pass a higher value for pages that change seldom, or NIL for no cache-control at all.
  2. "Hello": The page title.
  3. "@lib.css": A CSS-File name. Pass NIL if you do not want to use any CSS-File, or a list of file names if you want to give more than one CSS-File.
  4. NIL: A CSS style attribute specification (see the description of CSS Attributes below). It will be passed to the body tag.

After these four arguments, an arbitrary number of expressions may follow. They form the body of the resulting page, and are evaluated according to a special rule. This rule is slightly different from the evaluation of normal Lisp expressions:

  • If an argument is an atom (a number or a symbol (string)), its value is printed immediately.
  • Otherwise (a list), it is evaluated as a Lisp function (typically some form of print statement).

Therefore, our source file might as well be written as: 


########################################################################
(html 0 "Hello" "@lib.css" NIL
   (prinl "Hello World!") )
########################################################################

The most typical print statements will be some HTML-tags: 


########################################################################
(html 0 "Hello" "@lib.css" NIL
   (<h1> NIL "Hello World!")
   (<br> "This is some text.")
   (ht:Prin "And this is a number: " (+ 1 2 3)) )
########################################################################

<h1> and <br> are tag functions. <h1> takes a CSS attribute as its first argument.

Note the use of ht:Prin instead of prin. ht:Prin should be used for all direct printing in HTML pages, because it takes care to escape special characters.

CSS Attributes

The html function above, and many of the HTML tag functions, accept a CSS attribute specification. This may be either an atom, a cons pair, or a list of cons pairs. We demonstrate the effects with the <h1> tag function.

An atom (usually a symbol or a string) is taken as a CSS class name 


: (<h1> 'foo "Title")
<h1 class="foo">Title</h1>

For a cons pair, the CAR is taken as an attribute name, and the CDR as the attribute's value 


: (<h1> '(id . bar) "Title")
<h1 id="bar">Title</h1>

Consequently, a list of cons pairs gives a set of attribute-value pairs 


: (<h1> '((id . "abc") (lang . "de")) "Title")
<h1 id="abc" lang="de">Title</h1>

Tag Functions

All pre-defined XHTML tag functions can be found in "@lib/xhtml.l". We recommend to look at their sources, and to experiment a bit, by executing them at a PicoLisp prompt, or by pressing the browser's "Reload" button after editing the "project.l" file.

For a suitable PicoLisp prompt, either execute (in a separate terminal window) the PicoLisp Shell (psh) command (works only if the application server is running, and you did generate a ".pw" file) 


$ /usr/lib/picolisp/bin/psh 8080
:

or start the interpreter stand-alone, with "@lib/xhtml.l" loaded 


$ pil @lib/http.l @lib/xhtml.l +
:

Note that for all these tag functions the above tag body evaluation rule applies.

Simple Tags

Most tag functions are simple and straightforward. Some of them just print their arguments 


: (<br> "Hello world")
Hello world<br/>

: (<em> "Hello world")
<em>Hello world</em>

while most of them take a CSS attribute specification as their first argument (like the <h1> tag above) 


: (<div> 'main "Hello world")
<div class="main">Hello world</div>

: (<p> NIL "Hello world")
<p>Hello world</p>

: (<p> 'info "Hello world")
<p class="info">Hello world</p>

All of these functions take an arbitrary number of arguments, and may nest to an arbitrary depth (as long as the resulting HTML is legal) 


: (<div> 'main
   (<h1> NIL "Head")
   (<p> NIL
      (<br> "Line 1")
      "Line"
      (<nbsp>)
      (prin (+ 1 1)) ) )
<div class="main"><h1>Head</h1>
<p>Line 1<br/>
Line 2</p>
</div>

(Un)ordered Lists

HTML-lists, implemented by the <ol> and <ul> tags, let you define hierarchical structures. You might want to paste the following code into your copy of "project.l": 


########################################################################
(html 0 "Unordered List" "@lib.css" NIL
   (<ul> NIL
      (<li> NIL "Item 1")
      (<li> NIL
         "Sublist 1"
         (<ul> NIL
            (<li> NIL "Item 1-1")
            (<li> NIL "Item 1-2") ) )
      (<li> NIL "Item 2")
      (<li> NIL
         "Sublist 2"
         (<ul> NIL
            (<li> NIL "Item 2-1")
            (<li> NIL "Item 2-2") ) )
      (<li> NIL "Item 3") ) )
########################################################################

Here, too, you can put arbitrary code into each node of that tree, including other tag functions.

Tables

Like the hierarchical structures with the list functions, you can generate two-dimensional tables with the <table> and <row> functions.

The following example prints a table of numbers and their squares: 


########################################################################
(html 0 "Table" "@lib.css" NIL
   (<table> NIL NIL NIL
      (for N 10                                    # A table with 10 rows
         (<row> NIL N (prin (* N N))) ) ) )     # and 2 columns
########################################################################

The first argument to <table> is the usual CSS attribute, the second an optional title ("caption"), and the third an optional list specifying the column headers. In that list, you may supply a list for a each column, with a CSS attribute in its CAR, and a tag body in its CDR for the contents of the column header.

The body of <table> contains calls to the <row> function. This function is special in that each expression in its body will go to a separate column of the table. If both for the column header and the row function an CSS attribute is given, they will be combined by a space and passed to the HTML <td> tag. This permits distinct CSS specifications for each column and row.

As an extension of the above table example, let's pass some attributes for the table itself (not recommended - better define such styles in a CSS file and then just pass the class name to <table>), right-align both columns, and print each row in an alternating red and blue color 


########################################################################
(html 0 "Table" "@lib.css" NIL
   (<table>
      '((width . "200px") (style . "border: dotted 1px;"))    # table style
      "Square Numbers"                                        # caption
      '((align "Number") (align "Square"))                    # 2 headers
      (for N 10                                                  # 10 rows
         (<row> (xchg '(red) '(blue))                         # red or blue
            N                                                 # 2 columns
            (prin (* N N) ) ) ) ) )
########################################################################

If you wish to concatenate two or more cells in a table, so that a single cell spans several columns, you can pass the symbol '-' for the additional cell data to <row>. This will cause the data given to the left of the '-' symbols to expand to the right.

You can also directly specify table structures with the simple <th>, <tr> and <td> tag functions.

If you just need a two-dimensional arrangement of components, the even simpler <grid> function might be convenient: 


########################################################################
(html 0 "Grid" "@lib.css" NIL
   (<grid> 3
      "A" "B" "C"
      123 456 789 ) )
########################################################################

It just takes a specification for the number of columns (here: 3) as its first argument, and then a single expression for each cell. Instead of a number, you can also pass a list of CSS attributes. Then the length of that list will determine the number of columns. You can change the second line in the above example to 


   (<grid> '(NIL NIL right)

Then the third column will be right aligned.

Menus and Tabs

The two most powerful tag functions are <menu> and <tab>. Used separately or in combination, they form a navigation framework with

  • menu items which open and close submenus
  • submenu items which switch to different pages
  • tabs which switch to different subpages

The following example is not very useful, because the URLs of all items link to the same "project.l" page, but it should suffice to demonstrate the functionality: 


########################################################################
(html 0 "Menu+Tab" "@lib.css" NIL
   (<div> '(id . menu)
      (<menu>
         ("Item" "project.l")                      # Top level item
         (NIL (<hr>))                              # Plain HTML
         (T "Submenu 1"                            # Submenu
            ("Subitem 1.1" "project.l")
            (T "Submenu 1.2"
               ("Subitem 1.2.1" "project.l")
               ("Subitem 1.2.2" "project.l")
               ("Subitem 1.2.3" "project.l") )
            ("Subitem 1.3" "project.l") )
         (T "Submenu 2"
            ("Subitem 2.1" "project.l")
            ("Subitem 2.2" "project.l") ) ) )
   (<div> '(id . main)
      (<h1> NIL "Menu+Tab")
      (<tab>
         ("Tab1"
            (<h3> NIL "This is Tab 1") )
         ("Tab2"
            (<h3> NIL "This is Tab 2") )
         ("Tab3"
            (<h3> NIL "This is Tab 3") ) ) ) )
########################################################################

<menu> takes a sequence of menu items. Each menu item is a list, with its CAR either

  • NIL: The entry is not an active menu item, and the rest of the list may consist of arbitrary code (usually HTML tags).
  • T: The second element is taken as a submenu name, and a click on that name will open or close the corresponding submenu. The rest of the list recursively specifies the submenu items (may nest to arbitrary depth).
  • Otherwise: The menu item specifies a direct action (instead of opening a submenu), where the first list element gives the item's name, and the second element the corresponding URL.

<tab> takes a list of subpages. Each page is simply a tab name, followed by arbitrary code (typically HTML tags).

Note that only a single menu and a single tab may be active at the same time.

Interactive Forms

In HTML, the only possibility for user input is via <form> and <input> elements, using the HTTP POST method to communicate with the server.

"@lib/xhtml.l" defines a function called <post>, and a collection of input tag functions, which allow direct programming of HTML forms. We will supply only one simple example: 


########################################################################
(html 0 "Simple Form" "@lib.css" NIL
   (<post> NIL "project.l"
      (<field> 10 '*Text)
      (<submit> "Save") ) )
########################################################################

This associates a text input field with a global variable *Text. The field displays the current value of *Text, and pressing the submit button causes a reload of "project.l" with *Text set to any string entered by the user.

An application program could then use that variable to do something useful, for example store its value in a database.

The problem with such a straightforward use of forms is that

  1. they require the application programmer to take care of maintaining lots of global variables. Each input field on the page needs an associated variable for the round trip between server and client.
  2. they do not preserve an application's internal state. Each POST request spawns an individual process on the server, which sets the global variables to their new values, generates the HTML page, and terminates thereafter. The application state has to be passed along explicitly, e.g. using <hidden> tags.
  3. they are not very interactive. There is typically only a single submit button. The user fills out a possibly large number of input fields, but changes will take effect only when the submit button is pressed.

Though we wrote a few applications in that style, we recommend the GUI framework provided by "@lib/form.l". It does not need any variables for the client/server communication, but implements a class hierarchy of GUI components for the abstraction of application logic, button actions and data linkage.

Sessions

First of all, we need to establish a persistent environment on the server, to handle each individual session (for each connected client).

Technically, this is just a child process of the server we started above, which does not terminate immediately after it sent its page to the browser. It is achieved by calling the app function somewhere in the application's startup code. 


########################################################################
(app)  # Start a session

(html 0 "Simple Session" "@lib.css" NIL
   (<post> NIL "project.l"
      (<field> 10 '*Text)
      (<submit> "Save") ) )
########################################################################

Nothing else changed from the previous example. However, when you connect your browser and then look at the terminal window where you started the application server, you'll notice a colon, the PicoLisp prompt 


$ pil @lib/http.l @lib/xhtml.l @lib/form.l  --server 8080 project.l  +
:

Tools like the Unix ps utility will tell you that now two picolisp processes are running, the first being the parent of the second.

If you enter some text, say "abcdef", into the text field in the browser window, press the submit button, and inspect the Lisp *Text variable, 


: *Text
-> "abcdef"

you see that we now have a dedicated PicoLisp process, "connected" to the client.

You can terminate this process (like any interactive PicoLisp) by hitting Ctrl-D on an empty line. Otherwise, it will terminate by itself if no other browser requests arrive within a default timeout period of 5 minutes.

To start a (non-debug) production version, the server is commonly started without the '+' flag, and with -wait 


$ pil @lib/http.l @lib/xhtml.l @lib/form.l  --server 8080 project.l  -wait

In that way, no command line prompt appears when a client connects.

Action Forms

Now that we have a persistent session for each client, we can set up an active GUI framework.

This is done by wrapping the call to the html function with action. Inside the body of html can be - in addition to all other kinds of tag functions - one or more calls to form 


########################################################################
(app)                                              # Start session

(action                                            # Action handler
   (html 0 "Form" "@lib.css" NIL                   # HTTP/HTML protocol
      (form NIL                                    # Form
         (gui 'a '(+TextField) 10)                 # Text Field
         (gui '(+Button) "Print"                   # Button
            '(msg (val> (: home a))) ) ) ) )
########################################################################

Note that there is no longer a global variable like *Text to hold the contents of the input field. Instead, we gave a local, symbolic name 'a' to a +TextField component 


         (gui 'a '(+TextField) 10)                 # Text Field

Other components can refer to it 


            '(msg (val> (: home a)))

(: home) is always the form which contains this GUI component. So (: home a) evaluates to the component 'a' in the current form. As msg prints its argument to standard error, and the val> method retrieves the current contents of a component, we will see on the console the text typed into the text field when we press the button.

An action without embedded forms - or a form without a surrounding action - does not make much sense by itself. Inside html and form, however, calls to HTML functions (and any other Lisp functions, for that matter) can be freely mixed.

In general, a typical page may have the form 


(action                                            # Action handler
   (html ..                                        # HTTP/HTML protocol
      (<h1> ..)                                    # HTML tags
      (form NIL                                    # Form
         (<h3> ..)
         (gui ..)                                  # GUI component(s)
         (gui ..)
         .. )
      (<h2> ..)
      (form NIL                                    # Another form
         (<h3> ..)
         (gui ..)                                  # GUI component(s)
         .. )
      (<br> ..)
      .. ) )

The gui Function

The most prominent function in a form body is gui. It is the workhorse of GUI construction.

Outside of a form body, gui is undefined. Otherwise, it takes an optional alias name, a list of classes, and additional arguments as needed by the constructors of these classes. We saw this example before 


         (gui 'a '(+TextField) 10)                 # Text Field
Here, 'a' is an alias name for a component of type (+TextField). The numeric argument 10 is passed to the text field, specifying its width. See the chapter on GUI Classes for more examples.

During a GET request, gui is basically a front-end to new. It builds a component, stores it in the internal structures of the current form, and initializes it by sending the init> message to the component. Finally, it sends it the show> message, to produce HTML code and transmit it to the browser.

During a POST request, gui does not build any new components. Instead, the existing components are re-used. So gui does not have much more to do than sending the show> message to a component.

Control Flow

HTTP has only two methods to change a browser window: GET and POST. We employ these two methods in a certain defined, specialized way:

  • GET means, a new page is being constructed. It is used when a page is visited for the first time, usually by entering an URL into the browser's address field, or by clicking on a link (which is often a submenu item or tab).
  • POST is always directed to the same page. It is triggered by a button press, updates the corresponding form's data structures, and executes that button's action code.

A button's action code can do almost anything: Read and modify the contents of input fields, communicate with the database, display alerts and dialogs, or even fake the POST request to a GET, with the effect of showing a completely different document (See Switching URLs).

GET builds up all GUI components on the server. These components are objects which encapsulate state and behavior of the HTML page in the browser. Whenever a button is pressed, the page is reloaded via a POST request. Then - before any output is sent to the browser - the action function takes control. It performs error checks on all components, processes possible user input on the HTML page, and stores the values in correct format (text, number, date, object etc.) in each component.

The state of a form is preserved over time. When the user returns to a previous page with the browser's BACK button, that state is reactivated, and may be POSTed again.

The following silly example displays two text fields. If you enter some text into the "Source" field, you can copy it in upper or lower case to the "Destination" field by pressing one of the buttons 


########################################################################
(app)

(action
   (html 0 "Case Conversion" "@lib.css" NIL
      (form NIL
         (<grid> 2
            "Source" (gui 'src '(+TextField) 30)
            "Destination" (gui 'dst '(+Lock +TextField) 30) )
         (gui '(+JS +Button) "Upper Case"
            '(set> (: home dst)
               (uppc (val> (: home src))) ) )
         (gui '(+JS +Button) "Lower Case"
            '(set> (: home dst)
               (lowc (val> (: home src))) ) ) ) ) )
########################################################################

The +Lock prefix class in the "Destination" field makes that field read-only. The only way to get some text into that field is by using one of the buttons.

Switching URLs

Because an action code runs before html has a chance to output an HTTP header, it can abort the current page and present something different to the user. This might, of course, be another HTML page, but would not be very interesting as a normal link would suffice. Instead, it can cause the download of dynamically generated data.

The next example shows a text area and two buttons. Any text entered into the text area is exported either as a text file via the first button, or a PDF document via the second button 


########################################################################
(load "@lib/ps.l")

(app)

(action
   (html 0 "Export" "@lib.css" NIL
      (form NIL
         (gui '(+TextField) 30 8)
         (gui '(+Button) "Text"
            '(let Txt (tmp "export.txt")
               (out Txt (prinl (val> (: home gui 1))))
               (url Txt) ) )
         (gui '(+Button) "PDF"
            '(psOut NIL "foo"
               (a4)
               (indent 40 40)
               (down 60)
               (hline 3)
               (font (14 . "Times-Roman")
                  (ps (val> (: home gui 1))) )
               (hline 3)
               (page) ) ) ) ) )
########################################################################

(a text area is built when you supply two numeric arguments (columns and rows) to a +TextField class)

The action code of the first button creates a temporary file (i.e. a file named "export.txt" in the current process's temporary space), prints the value of the text area (this time we did not bother to give it a name, we simply refer to it as the form's first gui list element) into that file, and then calls the url function with the file name.

The second button uses the PostScript library "@lib/ps.l" to create a temporary file "foo.pdf". Here, the temporary file creation and the call to the url function is hidden in the internal mechanisms of psOut. The effect is that the browser receives a PDF document and displays it.

Alerts and Dialogs

Alerts and dialogs are not really what they used to be ;-)

They do not "pop up". In this framework, they are just a kind of simple-to-use, pre-fabricated form. They can be invoked by a button's action code, and appear always on the current page, immediately preceding the form which created them.

Let's look at an example which uses two alerts and a dialog. In the beginning, it displays a simple form, with a locked text field, and two buttons 


########################################################################
(app)

(action
   (html 0 "Alerts and Dialogs" "@lib.css" NIL
      (form NIL
         (gui '(+Init +Lock +TextField) "Initial Text" 20 "My Text")
         (gui '(+Button) "Alert"
            '(alert NIL "This is an alert " (okButton)) )
         (gui '(+Button) "Dialog"
            '(dialog NIL
               (<br> "This is a dialog.")
               (<br>
                  "You can change the text here "
                  (gui '(+Init +TextField) (val> (: top 1 gui 1)) 20) )
               (<br> "and then re-submit it to the form.")
               (gui '(+Button) "Re-Submit"
                  '(alert NIL "Are you sure? "
                     (yesButton
                        '(set> (: home top 2 gui 1)
                           (val> (: home top 1 gui 1)) ) )
                     (noButton) ) )
               (cancelButton) ) ) ) ) )
########################################################################

The +Init prefix class initializes the "My Text" field with the string "Initial Text". As the field is locked, you cannot modify this value directly.

The first button brings up an alert saying "This is an alert.". You can dispose it by pressing "OK".

The second button brings up a dialog with an editable text field, containing a copy of the value from the form's locked text field. You can modify this value, and send it back to the form, if you press "Re-Submit" and answer "Yes" to the "Are you sure?" alert.

A Calculator Example

Now let's forget our "project.l" test file for a moment, and move on to a more substantial and practical, stand-alone, example. Using what we have learned so far, we want to build a simple bignum calculator. ("bignum" because PicoLisp can do only bignums)

It uses a single form, a single numeric input field, and lots of buttons. It can be found in the PicoLisp distribution (e.g. under "/usr/share/picolisp/") in "misc/calc.l", together with a directly executable wrapper script "misc/calc".

To use it, change to the PicoLisp installation directory, and start it as 


$ misc/calc

or call it with an absolute path, e.g. 


$ /usr/share/picolisp/misc/calc

If you like to get a PicoLisp prompt for inspection, start it instead as 


$ pil misc/calc.l -main -go +

Then - as before - point your browser to 'http://localhost:8080'.

The code for the calculator logic and the GUI is rather straightforward. The entry point is the single function calculator. It is called directly (as described in URL Syntax) as the server's default URL, and implicitly in all POST requests. No further file access is needed once the calculator is running.

Note that for a production application, we inserted an allow-statement (as recommended by the Security chapter) 


(allowed NIL "!calculator" "@lib.css")

at the beginning of "misc/calc.l". This will restrict external access to that single function.

The calculator uses three global variables, *Init, *Accu and *Stack. *Init is a boolean flag set by the operator buttons to indicate that the next digit should initialize the accumulator to zero. *Accu is the accumulator. It is always displayed in the numeric input field, accepts user input, and it holds the results of calculations. *Stack is a push-down stack, holding postponed calculations (operators, priorities and intermediate results) with lower-priority operators, while calculations with higher-priority operators are performed.

The function digit is called by the digit buttons, and adds another digit to the accumulator.

The function calc does an actual calculation step. It pops the stack, checks for division by zero, and displays an error alert if necessary.

operand processes an operand button, accepting a function and a priority as arguments. It compares the priority with that in the top-of-stack element, and delays the calculation if it is less.

finish is used to calculate the final result.

The calculator function has one numeric input field, with a width of 60 characters 


         (gui '(+Var +NumField) '*Accu 60)

The +Var prefix class associates this field with the global variable *Accu. All changes to the field will show up in that variable, and modification of that variable's value will appear in the field.

The square root operator button has an +Able prefix class 


         (gui '(+Able +JS +Button) '(ge0 *Accu) (char 8730)
            '(setq *Accu (sqrt *Accu)) )

with an argument expression which checks that the current value in the accumulator is positive, and disables the button if otherwise.

The rest of the form is just an array (grid) of buttons, encapsulating all functionality of the calculator. The user can enter numbers into the input field, either by using the digit buttons, or by directly typing them in, and perform calculations with the operator buttons. Supported operations are addition, subtraction, multiplication, division, sign inversion, square root and power (all in bignum integer arithmetic). The 'C' button just clears the accumulator, while the 'A' button also clears all pending calculations.

All that in 53 lines of code!

Charts

Charts are virtual components, maintaining the internal representation of two-dimensional data.

Typically, these data are nested lists, database selections, or some kind of dynamically generated tabular information. Charts make it possible to view them in rows and columns (usually in HTML tables), scroll up and down, and associate them with their corresponding visible GUI components.

In fact, the logic to handle charts makes up a substantial part of the whole framework, with large impact on all internal mechanisms. Each GUI component must know whether it is part of a chart or not, to be able to handle its contents properly during updates and user interactions.

Let's assume we want to collect textual and numerical data. We might create a table 


########################################################################
(app)

(action
   (html 0 "Table" "@lib.css" NIL
      (form NIL
         (<table> NIL NIL '((NIL "Text") (NIL "Number"))
            (do 4
               (<row> NIL
                  (gui '(+TextField) 20)
                  (gui '(+NumField) 10) ) ) )
         (<submit> "Save") ) ) )
########################################################################

with two columns "Text" and "Number", and four rows, each containing a +TextField and a +NumField.

You can enter text into the first column, and numbers into the second. Pressing the "Save" button stores these values in the components on the server (or produces an error message if a string in the second column is not a legal number).

There are two problems with this solution:

  1. Though you can get at the user input for the individual fields, e.g. 
    
: (val> (get *Top 'gui 2))  # Value in the first row, second column
-> 123
    there is no direct way to get the whole data structure as a single list. Instead, you have to traverse all GUI components and collect the data.
  2. The user cannot input more than four rows of data, because there is no easy way to scroll down and make space for more.

A chart can handle these things: 


########################################################################
(app)

(action
   (html 0 "Chart" "@lib.css" NIL
      (form NIL
         (gui '(+Chart) 2)                         # Inserted a +Chart
         (<table> NIL NIL '((NIL "Text") (NIL "Number"))
            (do 4
               (<row> NIL
                  (gui 1 '(+TextField) 20)         # Inserted '1'
                  (gui 2 '(+NumField) 10) ) ) )    # Inserted '2'
         (<submit> "Save") ) ) )
########################################################################

Note that we inserted a +Chart component before the GUI components which should be managed by the chart. The argument '2' tells the chart that it has to expect two columns.

Each component got an index number (here '1' and '2') as the first argument to gui, indicating the column into which this component should go within the chart.

Now - if you entered "a", "b" and "c" into the first, and 1, 2, and 3 into the second column - we can retrieve the chart's complete contents by sending it the val> message 


: (val> (get *Top 'chart 1))  # Retrieve the value of the first chart
-> (("a" 1) ("b" 2) ("c" 3))

BTW, a more convenient function is chart 


: (val> (chart))  # Retrieve the value of the current chart
-> (("a" 1) ("b" 2) ("c" 3))

chart can be used instead of the above construct when we want to access the "current" chart, i.e. the chart most recently processed in the current form.

Scrolling

To enable scrolling, let's also insert two buttons. We use the pre-defined classes +UpButton and +DnButton 


########################################################################
(app)

(action
   (html 0 "Scrollable Chart" "@lib.css" NIL
      (form NIL
         (gui '(+Chart) 2)
         (<table> NIL NIL '((NIL "Text") (NIL "Number"))
            (do 4
               (<row> NIL
                  (gui 1 '(+TextField) 20)
                  (gui 2 '(+NumField) 10) ) ) )
         (gui '(+UpButton) 1)                   # Inserted two buttons
         (gui '(+DnButton) 1)
         (----)
         (<submit> "Save") ) ) )
########################################################################

to scroll down and up a single (argument '1') line at a time.

Now it is possible to enter a few rows of data, scroll down, and continue. It is not necessary (except in the beginning, when the scroll buttons are still disabled) to press the "Save" button, because any button in the form will send changes to the server's internal structures before any action is performed.

Put and Get Functions

As we said, a chart is a virtual component to edit two-dimensional data. Therefore, a chart's native data format is a list of lists: Each sublist represents a single row of data, and each element of a row corresponds to a single GUI component.

In the example above, we saw a row like 


   ("a" 1)

being mapped to 


   (gui 1 '(+TextField) 20)
   (gui 2 '(+NumField) 10)

Quite often, however, such a one-to-one relationship is not desired. The internal data structures may have to be presented in a different form to the user, and user input may need conversion to an internal representation.

For that, a chart accepts - in addition to the "number of columns" argument - two optional function arguments. The first function is invoked to 'put' the internal representation into the GUI components, and the second to 'get' data from the GUI into the internal representation.

A typical example is a chart displaying customers in a database. While the internal representation is a (one-dimensional) list of customer objects, 'put' expands each object to a list with, say, the customer's first and second name, telephone number, address and so on. When the user enters a customer's name, 'get' locates the matching object in the database and stores it in the internal representation. In the following, 'put' will in turn expand it to the GUI.

For now, let's stick with a simpler example: A chart that holds just a list of numbers, but expands in the GUI to show also a textual form of each number (in German). 


########################################################################
(app)

(load "@lib/zahlwort.l")

(action
   (html 0 "Numerals" "@lib.css" NIL
      (form NIL
         (gui '(+Init +Chart) (1 5 7) 2
            '((N) (list N (zahlwort N)))
            car )
         (<table> NIL NIL '((NIL "Numeral") (NIL "German"))
            (do 4
               (<row> NIL
                  (gui 1 '(+NumField) 9)
                  (gui 2 '(+Lock +TextField) 90) ) ) )
         (gui '(+UpButton) 1)
         (gui '(+DnButton) 1)
         (----)
         (<submit> "Save") ) ) )
########################################################################

"@lib/zahlwort.l" defines the utility function zahlwort, which is required later by the 'put' function. zahlwort accepts a number and returns its wording in German.

Now look at the code 


         (gui '(+Init +Chart) (1 5 7) 2
            '((N) (list N (zahlwort N)))
            car )

We prefix the +Chart class with +Init, and pass it a list of numbers (1 5 7) for the initial value of the chart. Then, following the '2' (the chart has two columns), we pass a 'put' function 


            '((N) (list N (zahlwort N)))

which takes a number and returns a list of that number and its wording, and a 'get' function 


            car )

which in turn accepts such a list and returns a number, which happens to be the list's first element.

You can see from this example that 'get' is the inverse function of 'put'. 'get' can be omitted, however, if the chart is read-only (contains no (or only locked) input fields).

The field in the second column 


                  (gui 2 '(+Lock +TextField) 90) ) ) )

is locked, because it displays the text generated by 'put', and is not supposed to accept any user input.

When you start up this form in your browser, you'll see three pre-filled lines with "1/eins", "5/fünf" and "7/sieben", according to the +Init argument (1 5 7). Typing a number somewhere into the first column, and pressing ENTER or one of the buttons, will show a suitable text in the second column.

GUI Classes

In previous chapters we saw examples of GUI classes like +TextField, +NumField or +Button, often in combination with prefix classes like +Lock, +Init or +Able. Now we take a broader look at the whole hierarchy, and try more examples.

The abstract class +gui is the base of all GUI classes. A live view of the class hierarchy can be obtained with the dep ("dependencies") function: 


: (dep '+gui)
+gui
   +Img
   +field
      +Radio
      +TextField
         +UpField
         +PwField
         +BlobField
         +FileField
         +TimeField
         +DateField
         +MailField
         +AtomField
         +HttpField
         +LinesField
         +ClassField
         +TelField
         +numField
            +NumField
            +FixField
         +SymField
         +SexField
         +ListTextField
      +Checkbox
   +Button
      +BubbleButton
      +DelRowButton
      +DnButton
      +GoButton
      +UpButton
      +ChoButton
         +Choice
      +ClrButton
      +PickButton
         +DstButton
      +todoButton
         +RedoButton
         +UndoButton
      +ShowButton
-> +gui

We see, for example, that +DnButton is a subclass of +Button, which in turn is a subclass of +gui. Inspecting +DnButton directly 


: (dep '+DnButton)
   +Tiny
   +Rid
   +JS
   +Able
      +gui
   +Button
+DnButton
-> +DnButton

shows that +DnButton inherits from +Tiny, +Rid, +Able and +Button. The actual definition of +DnButton can be found in "@lib/form.l" 


(class +DnButton +Tiny +Rid +JS +Able +Button)
...

In general, "@lib/form.l" is the ultimate reference to the framework, and should be freely consulted. See also the form library reference.

Input Fields

Input fields implement the visual display of application data, and allow - when enabled - input and modification of these data.

On the HTML level, they can take the form of

  • Normal text input fields
  • Textareas
  • Checkboxes
  • Drop-down selections
  • Password fields
  • HTML links
  • Plain HTML text

Except for checkboxes, which are implemented by the Checkbox class, all these HTML representations are generated by +TextField and its content-specific subclasses like +NumField, +DateField etc. Their actual appearance (as one of the above forms) depends on their arguments:

We saw already "normal" text fields. They are created with a single numeric argument. This example creates an editable field with a width of 10 characters: 


   (gui '(+TextField) 10)

If you supply a second numeric for the line count ('4' in this case), you'll get a text area: 


   (gui '(+TextField) 10 4)

Supplying a list of values instead of a count yields a drop-down selection (combo box): 


   (gui '(+TextField) '("Value 1" "Value 2" "Value 3"))

In addition to these arguments, you can pass a string. Then the field is created with a label: 


   (gui '(+TextField) 10 "Plain")
   (gui '(+TextField) 10 4 "Text Area")
   (gui '(+TextField) '("Value 1" "Value 2" "Value 3") "Selection")

Finally, without any arguments, the field will appear as a plain HTML text: 


   (gui '(+TextField))

This makes mainly sense in combination with prefix classes like +Var and +Obj, to manage the contents of these fields, and achieve special behavior as HTML links or scrollable chart values.

Numeric Input Fields

A +NumField returns a number from its val> method, and accepts a number for its set> method. It issues an error message when user input cannot be converted to a number.

Large numbers are shown with a thousands-separator, as determined by the current locale. 


########################################################################
(app)

(action
   (html 0 "+NumField" "@lib.css" NIL
      (form NIL
         (gui '(+NumField) 10)
         (gui '(+JS +Button) "Print value"
            '(msg (val> (: home gui 1))) )
         (gui '(+JS +Button) "Set to 123"
            '(set> (: home gui 1) 123) ) ) ) )
########################################################################

A +FixField needs an additional scale factor argument, and accepts/returns scaled fixpoint numbers.

The decimal separator is determined by the current locale. 


########################################################################
(app)

(action
   (html 0 "+FixField" "@lib.css" NIL
      (form NIL
         (gui '(+FixField) 3 10)
         (gui '(+JS +Button) "Print value"
            '(msg (format (val> (: home gui 1)) 3)) )
         (gui '(+JS +Button) "Set to 123.456"
            '(set> (: home gui 1) 123456) ) ) ) )
########################################################################

Time & Date

A +DateField accepts and returns a date value. 


########################################################################
(app)

(action
   (html 0 "+DateField" "@lib.css" NIL
      (form NIL
         (gui '(+DateField) 10)
         (gui '(+JS +Button) "Print value"
            '(msg (datStr (val> (: home gui 1)))) )
         (gui '(+JS +Button) "Set to \"today\""
            '(set> (: home gui 1) (date)) ) ) ) )
########################################################################

The format displayed to - and entered by - the user depends on the current locale (see datStr and expDat). You can change it, for example to 


: (locale "DE" "de")
-> NIL

If no locale is set, the format is YYYY-MM-DD. Some pre-defined locales use patterns like DD.MM.YYYY (DE), YYYY/MM/DD (JP), DD/MM/YYYY (UK), or MM/DD/YYYY (US).

An error is issued when user input does not match the current locale's date format.

Independent from the locale setting, a +DateField tries to expand abbreviated input from the user. A small number is taken as that day of the current month, larger numbers expand to day and month, or to day, month and year:

  • "7" gives the 7th of the current month
  • "031" or "0301" give the 3rd of January of the current year
  • "311" or "3101" give the 31st of January of the current year
  • "0311" gives the 3rd of November of the current year
  • "01023" or "010203" give the first of February in the year 2003
  • and so on

Similar is the +TimeField. It accepts and returns a time value. 


########################################################################
(app)

(action
   (html 0 "+TimeField" "@lib.css" NIL
      (form NIL
         (gui '(+TimeField) 8)
         (gui '(+JS +Button) "Print value"
            '(msg (tim$ (val> (: home gui 1)))) )
         (gui '(+JS +Button) "Set to \"now\""
            '(set> (: home gui 1) (time)) ) ) ) )
########################################################################

When the field width is '8', like in this example, time is displayed in the format HH:MM:SS. Another possible value would be '5', causing +TimeField to display its value as HH:MM.

An error is issued when user input cannot be converted to a time value.

The user may omit the colons. If he inputs just a small number, it should be between '0' and '23', and will be taken as a full hour. '125' expands to "12:05", '124517' to "12:45:17", and so on.

Telephone Numbers

Telephone numbers are represented internally by the country code (without a leading plus sign or zero) followed by the local phone number (ideally separated by spaces) and the phone extension (ideally separated by a hyphen). The exact format of the phone number string is not enforced by the GUI, but further processing (e.g. database searches) normally uses fold for better reproducibility.

To display a phone number, +TelField replaces the country code with a single zero if it is the country code of the current locale, or prepends it with a plus sign if it is a foreign country (see telStr).

For user input, a plus sign or a double zero is simply dropped, while a single leading zero is replaced with the current locale's country code (see expTel). 


########################################################################
(app)
(locale "DE" "de")

(action
   (html 0 "+TelField" "@lib.css" NIL
      (form NIL
         (gui '(+TelField) 20)
         (gui '(+JS +Button) "Print value"
            '(msg (val> (: home gui 1))) )
         (gui '(+JS +Button) "Set to \"49 1234 5678-0\""
            '(set> (: home gui 1) "49 1234 5678-0") ) ) ) )
########################################################################

Checkboxes

A +Checkbox is straightforward. User interaction is restricted to clicking it on and off. It accepts boolean (NIL or non-NIL) values, and returns T or NIL. 


########################################################################
(app)

(action
   (html 0 "+Checkbox" "@lib.css" NIL
      (form NIL
         (gui '(+Checkbox))
         (gui '(+JS +Button) "Print value"
            '(msg (val> (: home gui 1))) )
         (gui '(+JS +Button) "On"
            '(set> (: home gui 1) T) )
         (gui '(+JS +Button) "Off"
            '(set> (: home gui 1) NIL) ) ) ) )
########################################################################

Field Prefix Classes

A big part of this framework's power is owed to the combinatorial flexibility of prefix classes for GUI- and DB-objects. They allow to surgically override individual methods in the inheritance tree, and can be combined in various ways to achieve any desired behavior.

Technically, there is nothing special about prefix classes. They are just normal classes. They are called "prefix" because they are intended to be written before other classes in a class's or object's list of superclasses.

Usually they take their own arguments for their T method from the list of arguments to the gui function.

Initialization

+Init overrides the init> method for that component. The init> message is sent to a +gui component when the page is loaded for the first time (during a GET request). +Init takes an expression for the initial value of that field. 


   (gui '(+Init +TextField) "This is the initial text" 30)

Other classes which automatically give a value to a field are +Var (linking the field to a variable) and +E/R (linking the field to a database entity/relation).

+Cue can be used, for example in "mandatory" fields, to give a hint to the user about what he is supposed to enter. It will display the argument value, in angular brackets, if and only if the field's value is NIL, and the val> method will return NIL despite the fact that this value is displayed.

Cause an empty field to display "<Please enter some text here>": 


   (gui '(+Cue +TextField) "Please enter some text here" 30)

Disabling and Enabling

An important feature of an interactive GUI is the context-sensitive disabling and enabling of individual components, or of a whole form.

The +Able prefix class takes an argument expression, and disables the component if this expression returns NIL. We saw an example for its usage already in the square root button of the calculator example. Or, for illustration purposes, imagine a button which is supposed to be enabled only after Christmas 


   (gui '(+Able +Button)
      '(>= (cdr (date (date))) (12 24))
      "Close this year"
      '(endOfYearProcessing) )

or a password field that is disabled as long as somebody is logged in 


   (gui '(+Able +PwField) '(not *Login) 10 "Password")

A special case is the +Lock prefix, which permanently and unconditionally disables a component. It takes no arguments 


   (gui '(+Lock +NumField) 10 "Count")

('10' and "Count" are for the +NumField), and creates a read-only field.

The whole form can be disabled by calling disable with a non-NIL argument. This affects all components in this form. Staying with the above example, we can make the form read-only until Christmas 


   (form NIL
      (disable (> (12 24) (cdr (date (date)))))  # Disable whole form
      (gui ..)
      .. )

Even in a completely disabled form, however, it is often necessary to re-enable certain components, as they are needed for navigation, scrolling, or other activities which don't affect the contents of the form. This is done by prefixing these fields with +Rid (i.e. getting "rid" of the lock). 


   (form NIL
      (disable (> (12 24) (cdr (date (date)))))
      (gui ..)
      ..
      (gui '(+Rid +Button) ..)  # Button is enabled despite the disabled form
      .. )

Formatting

GUI prefix classes allow a fine-grained control of how values are stored in - and retrieved from - components. As in predefined classes like +NumField or +DateField, they override the set> and/or val> methods.

+Set takes an argument function which is called whenever that field is set to some value. To convert all user input to upper case 


   (gui '(+Set +TextField) uppc 30)

+Val is the complement to +Set. It takes a function which is called whenever the field's value is retrieved. To return the square of a field's value 


   (gui '(+Val +NumField) '((N) (* N N)) 10)

+Fmt is just a combination of +Set and +Val, and takes two functional arguments. This example will display upper case characters, while returning lower case characters internally 


   (gui '(+Fmt +TextField) uppc lowc 30)

+Map does (like +Fmt) a two-way translation. It uses a list of cons pairs for a linear lookup, where the CARs represent the displayed values which are internally mapped to the values in the CDRs. If a value is not found in this list during set> or val>, it is passed through unchanged.

Normally, +Map is used in combination with the combo box incarnation of text fields (see Input Fields). This example displays "One", "Two" and "Three" to the user, but returns a number 1, 2 or 3 internally 


########################################################################
(app)

(action
   (html 0 "+Map" "@lib.css" NIL
      (form NIL
         (gui '(+Map +TextField)
            '(("One" . 1) ("Two" . 2) ("Three" . 3))
            '("One" "Two" "Three") )
         (gui '(+Button) "Print"
            '(msg (val> (field -1))) ) ) ) )
########################################################################

Side Effects

Whenever a button is pressed in the GUI, any changes caused by action in the current environment (e.g. the database or application state) need to be reflected in the corresponding GUI fields. For that, the upd> message is sent to all components. Each component then takes appropriate measures (e.g. refresh from database objects, load values from variables, or calculate a new value) to update its value.

While the upd> method is mainly used internally, it can be overridden in existing classes via the +Upd prefix class. Let's print updated values to standard error 


########################################################################
(app)
(default *Number 0)

(action
   (html 0 "+Upd" "@lib.css" NIL
      (form NIL
         (gui '(+Upd +Var +NumField)
            '(prog (extra) (msg *Number))
            '*Number 8 )
         (gui '(+JS +Button) "Increment"
            '(inc '*Number) ) ) ) )
########################################################################

Validation

To allow automatic validation of user input, the chk> message is sent to all components at appropriate times. The corresponding method should return NIL if the value is all right, or a string describing the error otherwise.

Many of the built-in classes have a chk> method. The +NumField class checks for legal numeric input, or the +DateField for a valid calendar date.

An on-the-fly check can be implemented with the +Chk prefix class. The following code only accepts numbers not bigger than 9: The or expression first delegates the check to the main +NumField class, and - if it does not give an error - returns an error string when the current value is greater than 9. 


########################################################################
(app)

(action
   (html 0 "+Chk" "@lib.css" NIL
      (form NIL
         (gui '(+Chk +NumField)
            '(or
               (extra)
               (and (> (val> This) 9) "Number too big") )
            12 )
         (gui '(+JS +Button) "Print"
            '(msg (val> (field -1))) ) ) ) )
########################################################################

A more direct kind of validation is built-in via the +Limit class. It controls the maxlength attribute of the generated HTML input field component. Thus, it is impossible to type more characters than allowed into the field. 


########################################################################
(app)

(action
   (html 0 "+Limit" "@lib.css" NIL
      (form NIL
         (gui '(+Limit +TextField) 4 8)
         (gui '(+JS +Button) "Print"
            '(msg (val> (field -1))) ) ) ) )
########################################################################

Data Linkage

Although set> and val> are the official methods to get a value in and out of a GUI component, they are not very often used explicitly. Instead, components are directly linked to internal Lisp data structures, which are usually either variables or database objects.

The +Var prefix class takes a variable (described as the var data type - either a symbol or a cons pair - in the Function Reference). In the following example, we initialize a global variable with the value "abc", and let a +TextField operate on it. The "Print" button can be used to display its current value. 


########################################################################
(app)

(setq *TextVariable "abc")

(action
   (html 0 "+Var" "@lib.css" NIL
      (form NIL
         (gui '(+Var +TextField) '*TextVariable 8)
         (gui '(+JS +Button) "Print"
            '(msg *TextVariable) ) ) ) )
########################################################################

+E/R takes an entity/relation specification. This is a cons pair, with a relation in its CAR (e.g. nm, for an object's name), and an expression in its CDR (typically (: home obj), the object stored in the obj property of the current form).

For an isolated, simple example, we create a temporary database, and access the nr and nm properties of an object stored in a global variable *Obj. 


########################################################################
(when (app)                # On start of session
   (class +Tst +Entity)    # Define data model
   (rel nr (+Number))      # with a number
   (rel nm (+String))      # and a string
   (pool (tmp "db"))       # Create temporary DB
   (setq *Obj              # and a single object
      (new! '(+Tst) 'nr 1 'nm "New Object") ) )

(action
   (html 0 "+E/R" "@lib.css" NIL
      (form NIL
         (gui '(+E/R +NumField) '(nr . *Obj) 8)    # Linkage to 'nr'
         (gui '(+E/R +TextField) '(nm . *Obj) 20)  # Linkage to 'nm'
         (gui '(+JS +Button) "Show"                # Show the object
            '(out 2 (show *Obj)) ) ) ) )           # on standard error
########################################################################

Buttons

Buttons are, as explained in Control Flow, the only way (via POST requests) for an application to communicate with the server.

Basically, a +Button takes

  • a label, which may be either a string or the name of an image file
  • an optional alternative label, shown when the button is disabled
  • and an executable expression.

Here is a minimal button, with just a label and an expression: 


   (gui '(+Button) "Label" '(doSomething))

And this is a button displaying different labels, depending on the state: 


   (gui '(+Button) "Enabled" "Disabled" '(doSomething))

To show an image instead of plain text, the label(s) must be preceeded by the T symbol: 


   (gui '(+Button) T "img/enabled.png" "img/disabled.png" '(doSomething))

The expression will be executed during action handling (see Action Forms), when this button was pressed.

Like other components, buttons can be extended and combined with prefix classes, and a variety of predefined classes and class combinations are available.

Dialog Buttons

Buttons are essential for the handling of alerts and dialogs. Besides buttons for normal functions, like scrolling in charts or other side effects, special buttons exist which can close an alert or dialog in addition to doing their principal job.

Such buttons are usually subclasses of +Close, and most of them can be called easily with ready-made functions like closeButton, cancelButton, yesButton or noButton. We saw a few examples in Alerts and Dialogs.

Active JavaScript

When a button inherits from the +JS class (and JavaScript is enabled in the browser), that button will possibly show a much faster response in its action.

The reason is that the activation of a +JS button will - instead of doing a normal POST - first try to send only the contents of all GUI components via an XMLHttpRequest to the server, and receive the updated values in response. This avoids the flicker caused by reloading and rendering of the whole page, is much faster, and also does not jump to the beginning of the page if it is larger than the browser window. The effect is especially noticeable while scrolling in charts.

Only if this fails, for example because an error message was issued, or a dialog popped up, it will fall back, and the form will be POSTed in the normal way.

Thus it makes no sense to use the +JS prefix for buttons that cause a change of the HTML code, open a dialog, or jump to another page. In such cases, overall performance will even be worse, because the XMLHttpRequest is tried first (but in vain).

When JavaScript is disabled int the browser, the XMLHttpRequest will not be tried at all. The form will be fully usable, though, with identical functionality and behavior, just a bit slower and not so smooth.

A Minimal Complete Application

The PicoLisp release includes in the "app/" directory a minimal, yet complete reference application. This application is typical, in the sense that it implements many of the techniques described in this document, and it can be easily modified and extended. In fact, we use it as templates for our own production application development.

It is a kind of simplified ERP system, containing customers/suppliers, products (items), orders, and other data. The order input form performs live updates of customer and product selections, price, inventory and totals calculations, and generates on-the-fly PDF documents. Fine-grained access permissions are controlled via users, roles and permissions. It comes localized in seven languages (English, Spanish, German, Norwegian, Swedish, Russian and Japanese), with some initial data and two sample reports.

Since this reference application employs so many of the typical techniques used in writing PicoLisp applications, taking the time to study it is time very well invested. Another good way to get acquainted with the language and framework is to start experimenting by writing small applications of your own. Copying and making changes to the reference application is a very good way to get started with this, and I highly recommend doing so.

Getting Started

For a global installation (see Installation), please create a symbolic link to the place where the program files are installed. This is necessary because the application needs read/write access to the current working directory (for the database and other runtime data). 


$ ln -s /usr/share/picolisp/app

As ever, you may start up the application in debugging mode 


$ pil app/main.l -main -go +

or in (non-debug) production mode 


$ pil app/main.l -main -go -wait

and go to 'http://localhost:8080' with your browser. You can login as user "admin", with password "admin". The demo data contain several other users, but those are more restricted in their role permissions.

Another possibility is to try the online version of this application at app.7fach.de.

Localization

Before or after you logged in, you can select another language, and click on the "Change" button. This will effect all GUI components (though not text from the database), and also the numeric, date and telephone number formats.

Navigation

The navigation menu on the left side shows two items "Home" and "logout", and three submenus "Data", "Report" and "System".

Both "Home" and "logout" bring you back to the initial login form. Use "logout" if you want to switch to another user (say, for another set of permissions), and - more important - before you close your browser, to release possible locks and process resources on the server.

The "Data" submenu gives access to application specific data entry and maintenance: Orders, product items, customers and suppliers. The "Report" submenu contains two simple inventory and sales reports. And the "System" submenu leads to role and user administration.

You can open and close each submenu individually. Keeping more than one submenu open at a time lets you switch rapidly between different parts of the application.

The currently active menu item is indicated by a highlighted list style (no matter whether you arrived at this page directly via the menu or by clicking on a link somewhere else).

Choosing Objects

Each item in the "Data" or "System" submenu opens a search dialog for that class of entities. You can specify a search pattern, press the top right "Search" button (or just ENTER), and scroll through the list of results.

While the "Role" and "User" entities present simple dialogs (searching just by name), other entities can be searched by a variety of criteria. In those cases, a "Reset" button clears the contents of the whole dialog. A new object can be created with bottom right "New" button.

In any case, the first column will contain either a "@"-link (to jump to that object) or a "@"-button (to insert a reference to that object into the current form).

By default, the search will list all database objects with an attribute value greater than or equal to the search criterion. The comparison is done arithmetically for numbers, and alphabetically (case sensitive!) for text. This means, if you type "Free" in the "City" field of the "Customer/Supplier" dialog, the value of "Freetown" will be matched. On the other hand, an entry of "free" or "town" will yield no hits.

Some search fields, however, show a different behavior depending on the application:

  • The names of persons, companies or products allow a tolerant search, matching either a slightly misspelled name ("Mühler" instead of "Miller") or a substring ("Oaks" will match "Seven Oaks Ltd.").
  • The search field may specify an upper instead of a lower limit, resulting in a search for database objects with an attribute value less than or equal to the search criterion. This is useful, for example in the "Order" dialog, to list orders according to their number or date, by starting with the newest then and going backwards.

Using the bottom left scroll buttons, you can scroll through the result list without limit. Clicking on a link will bring up the corresponding object. Be careful here to select the right column: Some dialogs (those for "Item" and "Order") also provide links for related entities (e.g. "Supplier").

Editing

A database object is usually displayed in its own individual form, which is determined by its entity class.

The basic layout should be consistent for all classes: Below the heading (which is usually the same as the invoking menu item) is the object's identifier (name, number, etc.), and then a row with an "Edit" button on the left, and "Delete" button, a "Select" button and two navigation links on the right side.

The form is brought up initially in read-only mode. This is necessary to prevent more than one user from modifying an object at the same time (and contrary to the previous PicoLisp Java frameworks, where this was not a problem because all changes were immediately reflected in the GUIs of other users).

So if you want to modify an object, you have to gain exclusive access by clicking on the "Edit" button. The form will be enabled, and the "Edit" button changes to "Done". Should any other user already have reserved this object, you will see a message telling his name and process ID.

An exception to this are objects that were just created with "New". They will automatically be reserved for you, and the "Edit" button will show up as "Done".

The "Delete" button pops up an alert, asking for confirmation. If the object is indeed deleted, this button changes to "Restore" and allows to undelete the object. Note that objects are never completely deleted from the database as long as there are any references from other objects. When a "deleted" object is shown, its identifier appears in square brackets.

The "Select" button (re-)displays the search dialog for this class of entities. The search criteria are preserved between invocations of each dialog, so that you can conveniently browse objects in this context.

The navigation links, pointing left and right, serve a similar purpose. They let you step sequentially through all objects of this class, in the order of the identifier's index.

Other buttons, depending on the entity, are usually arranged at the bottom of the form. The bottom rightmost one should always be another "Edit" / "Done" button.

As we said in the chapter on Scrolling, any button in the form will save changes to the underlying data model. As a special case, however, the "Done" button releases the object and reverts to "Edit". Besides this, the edit mode will also cease as soon as another object is displayed, be it by clicking on an object link (the pencil icon), the top right navigation links, or a link in a search dialog.

Buttons vs. Links

The only way to interact with a HTTP-based application server is to click either on a HTML link, or on a submit button (see also Control Flow). It is essential to understand the different effects of such a click on data entered or modified in the current form.

  • A click on a link will leave or reload the page. Changes are discarded.
  • A click on a button will commit changes, and perform the associated action.

For that reason the layout design should clearly differentiate between links and buttons. Image buttons are not a good idea when in other places images are used for links. The standard button components should be preferred; they are usually rendered by the browser in a non-ambiguous three-dimensional look and feel.

Note that if JavaScript is enabled in the browser, changes will be automatically committed to the server.

The enabled or disabled state of a button is an integral part of the application logic. It must be indicated to the user with appropriate styles.

The Data Model

The data model for this mini application consists of only six entity classes (see the E/R diagram at the beginning of "app/er.l"):

  • The three main entities are +CuSu (Customer/Supplier), +Item (Product Item) and +Ord (Order).
  • A +Pos object is a single position in an order.
  • +Role and +User objects are needed for authentication and authorization.

The classes +Role and +User are defined in "@lib/adm.l". A +Role has a name, a list of permissions, and a list of users assigned to this role. A +User has a name, a password and a role.

In "app/er.l", the +Role class is extended to define an url> method for it. Any object whose class has such a method is able to display itself in the GUI. In this case, the file "app/role.l" will be loaded - with the global variable *ID pointing to it - whenever an HTML link to this role object is activated.

The +User class is also extended. In addition to the login name, a full name, telephone number and email address is declared. And, of course, the ubiquitous url> method.

The application logic is centered around orders. An order has a number, a date, a customer (an instance of +CuSu) and a list of positions (+Pos objects). The sum> method calculates the total amount of this order.

Each position has an +Item object, a price and a quantity. The price in the position overrides the default price from the item.

Each item has a number, a description, a supplier (also an instance of +CuSu), an inventory count (the number of these items that were counted at the last inventory taking), and a price. The cnt> method calculates the current stock of this item as the difference of the inventory and the sold item counts.

The call to dbs at the end of "app/er.l" configures the physical database storage. Each of the supplied lists has a number in its CAR which determines the block size as (64 << N) of the corresponding database file. The CDR says that the instances of this class (if the element is a class symbol) or the tree nodes (if the element is a list of a class symbol and a property name) are to be placed into that file. This allows for some optimizations in the database layout.

Usage

When you are connected to the application (see Getting Started) you might try to do some "real" work with it. Via the "Data" menu (see Navigation) you can create or modify customers, suppliers, items and orders, and produce simple overviews via the "Report" menu.

Customer/Supplier

Source in "app/cusu.l"

The Customer/Supplier search dialog (choCuSu in "app/gui.l") supports a lot of search criteria. These become necessary when the database contains a large number of customers, and can filter by zip, by phone number prefixes, and so on.

In addition to the basic layout (see Editing), the form is divided into four separate tabs. Splitting a form into several tabs helps to reduce traffic, with possibly better GUI response. In this case, four tabs are perhaps overkill, but ok for demonstration purposes, and they leave room for extensions.

Be aware that when data were modified in one of the tabs, the "Done" button has to be pressed before another tab is clicked, because tabs are implemented as HTML links (see Buttons vs. Links).

New customers or suppliers will automatically be assigned the next free number. You can enter another number, but an error will result if you try to use an existing number. The "Name" field is mandatory, you need to overwrite the "<Name>" clue.

Phone and fax numbers in the "Contact" tab must be entered in the correct format, depending on the locale (see Telephone Numbers).

The "Memo" tab contains a single text area. It is no problem to use it for large pieces of text, as it gets stored in a database blob internally.

The general layout of cusu.l is quite similar to the other source files making up the demo application. Since this is such a typical way of structuring PicoLisp applications, let's have a more detailed look. The beginning of cusu.l looks like this: 


########################################################################
(must "Customer/Supplier" Customer)

(menu ,"Customer/Supplier"
   (idForm ,"Customer/Supplier" '(choCuSu) 'nr '+CuSu T '(may Delete)
      '((: nr) " -- " (: nm))
      ....
########################################################################

The first line checks whether the user has the right permissions to access this page. After that a call to a function called (menu) follows. This function is defined in app/gui.l and creates the menu and basic page layout used in this application. Nested within the call to (menu) is our first, direct, encounter with a form function. In this case it is a call to (idForm). Let us look a little closer at this call.

The first parameter, "Customer/Supplier", is used in the form heading. Parameter number two is interesting. '(choCuSu) creates a dialog that makes is possible to search for an existing object to display/ edit, or create a new one. (choCuSu) is defined in app/gui.l and uses another form function, called (diaform). An abbreviated version is shown below. 


########################################################################
(de choCuSu (Dst)
   (diaform '(Dst)
      (<grid> "--.-.-."
         # Form components
         ... )
      (gui 'query '(+QueryChart) (cho)
         # Pilog query
         9
         '((This) (list This (: nr) This (: nm2) (: em) (: plz) (: ort) (: tel) (: mob))) )
      (<table> 'chart (choTtl ,"Customers/Suppliers" 'nr '+CuSu)
         # Table headers
         (do (cho)
            (<row> (alternating)
               (gui 1 '(+DstButton) Dst)
               ...
               (gui 9 '(+TelField)) ) ) )
      (<spread>
         (scroll (cho))
         (newButton T Dst '(+CuSu) ...)
         (cancelButton) ) ) )
########################################################################

(choCuSu) starts off by calling (diaform). This function is used when we want a form to behave in a similar way to a dialog (See Alerts and Dialogs for a description of how dialogs work in this framework). The first part of our diaform is a (<grid>) containing some form components.

The grid is followed by another gui component, this time a +QueryChart. The chart is an interesting, and very useful, concept. The basic idea is to separate how data is presented in the gui from the internal representation. See charts for more information.

The +QueryChart uses a Pilog query to fetch the data we wish to show from the database. This part is followed by a number, in this case 9, which tells the Chart how many columns of data to expect. The final part is a function that takes care of putting data into the gui from the dataset retrieved by the Pilog query. A table is used to present the result. The number of columns in this table must match the number mentioned above, the one that tells the chart how many columns to expect.

What is here is a common way of structuring applications in PicoLisp. Objects are displayed and edited using (idForm), which in turn use (diaform) to select or create new objects to view or edit.

Item

Source in "app/item.l"

Items also have a unique number, and a mandatory "Description" field.

To assign a supplier, click on the "+" button. The Customer/Supplier search dialog will appear, and you can pick the desired supplier with the "@" button in the first column. Alternatively, if you are sure to know the exact spelling of the supplier's name, you can also enter it directly into the text field.

In the search dialog you may also click on a link, for example to inspect a possible supplier, and then return to the search dialog with the browser's back button. The "Edit" mode will then be lost, however, as another object has been visited (this is described in the last part of Editing).

You can enter an inventory count, the number of items currently in stock. The following field will automatically reflect the remaining pieces after some of these items were sold (i.e. referenced in order positions). It cannot be changed manually.

The price should be entered with the decimal separator according to the current locale. It will be formatted with two places after the decimal separator.

The "Memo" is for an arbitrary info text, like in Customer/Supplier above, stored in a database blob.

Finally, a JPEG picture can be stored in a blob for this item. Choose a file with the browser's file select control, and click on the "Install" button. The picture will appear at the bottom of the page, and the "Install" button changes to "Uninstall", allowing the picture's removal.

Order

Source in "app/ord.l"

Oders are identified by number and date.

The number must be unique. It is assigned when the order is created, and cannot be changed for compliance reasons.

The date is initialized to "today" for a newly created order, but may be changed manually. The date format depends on the locale. It is YYYY-MM-DD (ISO) by default, DD.MM.YYYY in the German and YYYY/MM/DD in the Japanese locale. As described in Time & Date, this field allows input shortcuts, e.g. just enter the day to get the full date in the current month.

To assign a customer to this order, click on the "+" button. The Customer/Supplier search dialog will appear, and you can pick the desired customer with the "@" button in the first column (or enter the name directly into the text field), just as described above for Items.

Now enter order the positions: Choose an item with the "+" button. The "Price" field will be preset with the item's default price, you may change it manually. Then enter a quantity, and click a button (typically the "+" button to select the next item, or a scroll button go down in the chart). The form will be automatically recalculated to show the total prices for this position and the whole order.

Instead of the "+" or scroll buttons, as recommended above, you could of course also press the "Done" button to commit changes. This is all right, but has the disadvantage that the button must be pressed a second time (now "Edit") if you want to continue with the entry of more positions.

The "x" button at the right of each position deletes that position without further confirmation. It has to be used with care!

The "^" button is a "bubble" button. It exchanges a row with the row above it. Therefore, it can be used to rearrange all items in a chart, by "bubbling" them to their desired positions.

The "PDF-Print" button generates and displays a PDF document for this order. The browser should be configured to display downloaded PDF documents in an appropriate viewer. The source for the postscript generating method is in "app/lib.l". It produces one or several A4 sized pages, depending on the number of positions.

Reports

Sources in "app/inventory.l and "app/sales.l"

The two reports ("Inventory" and "Sales") come up with a few search fields and a "Show" button.

If no search criteria are entered, the "Show" button will produce a listing of the relevant part of the whole database. This may take a long time and cause a heavy load on the browser if the database is large.

So in the normal case, you will limit the domain by stating a range of item numbers, a description pattern, and/or a supplier for the inventory report, or a range of order dates and/or a customer for the sales report. If a value in a range specification is omitted, the range is considered open in that direction.

At the end of each report appears a "CSV" link. It downloads a file with the TAB-separated values generated by this report. pil21/src/Makefile0000644000000000000000000000371614107423751011135 0ustar # 19aug21 Software Lab. Alexander Burger .SILENT: CC = clang PIL = ../pil # pil ASM = opt -O3 # llvm-as LLC = llc LINK = llvm-link MAIN = -rdynamic -lc -lutil -lm -ldl -lreadline -lffi SHARED = -shared STRIP = strip 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 $(MAIN) $(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 -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 pil21/src/sysdefs.c0000644000000000000000000000451514103140611011302 0ustar // 06aug21 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); 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.l0000644000000000000000000013247614037307113011373 0ustar # 19apr21 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 end (Map) (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)") ) ) (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 (pack (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 "@" (putMap Sym) " = " (unless (and Val (not *Shared)) "external ") "global " (type Typ) ) (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) (prin " i64 " (if (sub? "*" Typ) "ptrtoint" "sext") " (" (cadr Lst) " " (caddr Lst) " to i64)") ) (NIL (prin " i64 ptrtoint (" (func pico~@) " @" (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 (let @P (or P (llvm~b8 @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 () (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) ((N) (ssa (inc '*Ssa) "alloca " '@Typ ", " (if (num? N) 'i64 (val N)) " " N ) (def (pack "%" *Ssa) '@Ptr) ) (llvm~b8 i8 i8*) (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.l0000644000000000000000000016177614155146420010607 0ustar # 11dec21 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) (tosInFile popInFiles tosOutFile popOutFiles popErrFiles popCtlFiles) (de void tosInFile ()) (de void popInFiles ()) (de void tosOutFile ()) (de void popOutFiles ()) (de void popErrFiles ()) (de void popCtlFiles ()) (local) (stop unwind) # Stop coroutine (de void stop ((i8* . Crt)) ((coroutine Crt) tag 0) # Set unused (while ((coroutine Crt) nxt) # Find bottom (setq Crt @) ) (until ((coroutine Crt) tag) # Free stack space (setq Crt ((coroutine Crt) prv)) ((coroutine Crt) nxt null) ) ) # 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)) ) (until (== (val $CtlFrames) (Ca: (env $CtlFrames i8*))) (popCtlFiles) ) (until (== (val $ErrFrames) (Ca: (env $ErrFrames i8*))) (popErrFiles) ) (unless (== (val $OutFrames) (Ca: (env $OutFrames i8*))) (loop (popOutFiles) (? (== (val $OutFrames) (Ca: (env $OutFrames i8*)))) ) (tosOutFile) ) (unless (== (val $InFrames) (Ca: (env $InFrames i8*))) (loop (popInFiles) (? (== (val $InFrames) (Ca: (env $InFrames i8*)))) ) (tosInFile) ) (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) 4096)) (set $At (Crt: at)) ) ) ) (memcpy (env) (Ca: (env)) (env T) T) (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) ) (unless (== (val $OutFrames) (val $Stdout)) (loop (popOutFiles) (? (== (val $OutFrames) (val $Stdout))) ) (tosOutFile) ) (unless (== (val $InFrames) (val $Stdin)) (loop (popInFiles) (? (== (val $InFrames) (val $Stdin))) ) (tosInFile) ) ) ) # Exit (local) (finish giveup bye execErr) (de NIL finish ((i32 . N)) (setCooked) (exit N) ) (de NIL giveup ((i8* . Fmt) (i8* . Msg)) (stderrMsg Fmt Msg) (finish 1) ) (de NIL bye ((i32 . N)) (unless (val $InBye) (set $InBye YES) (unwind null) (exec (val $Bye)) ) (flushAll) (finish 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") null) ) @ ) (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) (let (Out (val $OutFile) Put (val (i8** $Put))) (set $OutFile (val 3 (val $OutFiles)) # Stderr $Put (fun (void i8) _putStdout) ) (rlHide) (prog1 (run (cdr Exe)) (rlShow) (set (i8** $Put) Put $OutFile Out) ) ) ) # (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) ) ) ) # Try to load dynamic library (local) sharedLib (de i1 sharedLib (Sym) (let (Nm (xName 0 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") # 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) 0) ((> 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) ) (? (and (== X A) (== Y B)) 0) (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 Exe (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 Exe (evSym X)) S (bufString Nm (b8 (bufSize Nm))) ) (if (atom (shift X)) (mkStr (getenv S)) (let (Y (evSym X) Nm2 (xName Exe 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 Exe (evSym (cdr Exe))) P (getcwd null 0) ) (if P (prog1 (if (lt0 (chdir (pathString 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 Exe (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 Exe @) (val $AV0)) @ ) ) # (dir ['any] ['flg]) -> lst (de _dir (Exe) (let X (cdr Exe) (if (getDir (if (nil? (evSym X)) ($ ".") (let Nm (xName Exe @) (pathString 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 Exe (set $At2 (evSym X))) Size (b64 1) ) (if (lt0 (fileInfo (nil? (eval (car (shift X)))) (pathString 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 Exe 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 Exe 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 Exe (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 (set $StkBrk (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))) $DB $Db1 # Database root constant (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 (loop (repl 0 ($ ": ") $Nil) ) ) (end "base.map") pil21/src/vers.l0000644000000000000000000000015314162303506010615 0ustar # 27dec21 Software Lab. Alexander Burger (symbols '(llvm)) (local) *Version (pico~de *Version 21 12 27) 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.l0000644000000000000000000004422414144675037010603 0ustar # 16nov21 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 $Current i8* null) # Current coroutine (var $Coroutines i8* null) # Coroutines (var $StkBrk i8* null) # Stack break (var $StkLimit i8* null) # Stack limit: StackN-Size+4096 (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 $InFiles i8** null) # Input files (var $InFDs i32 0) # Number of input files (var $OutFiles i8** null) # Output files (var $InFile i8* null) # Input file (var $OutFile i8* null) # Output file (var $Chr i32 0) # Single-char look ahead (var $Put (void i8) null) # Character output function (var $Get (i32) null) # Character input function (var $PutBin (void i8) null) # Binary output function (var $GetBin (i32) null) # Binary input function (var $OutFDs i32 0) # Number of ourput files (var $Poll i64* null) # Poll entries (var $Nfds i32 0) # Number of poll entries (var $SeedL i64 0) # Random seed low (var $SeedH i64 0) # Random seed high (var $USec i64 0) # Startup microseconds (var $TickU i64 0) # Ticks in user time (var $TickS i64 0) # Ticks in system time (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) ($CPU "*CPU" 0) ($Pid "*Pid" 0) ($PPid "*PPid" $Nil) ($DB "*DB" 0) # Database root constant ($Meth "meth" __meth) ($Quote "quote" _quote) ($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) # 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 "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 "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 "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 "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 "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 "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 ($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 ($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 ($Parser i64* null) # String parser ($Intern $Pico1) # Current namespaces of internal symbols ($Next $Nil) # Next vararg ($Typ 0) # Method type ($Key 0) # Method key ($Make 0) # 'make' environment ($Yoke 0) ($Protect i32 0) # Signal protection ($Trace i32 0) ) # Trace level # 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 $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.l0000644000000000000000000002617714155123275010414 0ustar # 11dec21 Software Lab. Alexander Burger (symbols '(llvm)) (local) (inFile outFile dbFile ioFrame) # 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 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 # 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 (env (env T) i8) # Saved environment (rst 0 i8) ) # Restart jmp_buf (JmpBufSize) # Coroutines (local) coroutine (struct coroutine (tag 8 any) # Coroutine tag (prv 8 i8*) # Previous coroutine (nxt 8 i8*) # Next coroutine (org 8 i8*) # Originator (prg 8 any) # Code body (lim 8 i8*) # Stack limit (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 (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 # libc (local) (malloc realloc free fork getenv setenv getpid getpgrp setsid alarm setpgid execvp isatty openpty login_tty tcgetattr 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 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) (readline add_history history_list clear_history) (de T i8* readline (i8*)) (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 i32 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 rlHide rlShow rlSigBeg rlSigEnd currentLine) (de T void initReadline ()) (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 sigUnblock (i32)) (de T void iSignal (i32 i8*)) (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 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*)) # 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) (flushAll newline space outWord outString print repl) (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) brkLoad (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 (val $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 ) pil21/src/gc.l0000644000000000000000000003164014036266471010245 0ustar # 16apr21 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 -ZERO) # 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 (mark (val $Intern)) # Current namespaces (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 (Ca: tag)) ) (mark (Ca: fin)) # Mark 'fin' (mark (Ca: (env $Intern any))) (setq Ca (Ca: link)) ) ) ) (let Crt (val $Coroutines) (while Crt (let Crt: (coroutine Crt) (when (and (Crt: tag) (Crt: at)) (mark (Crt: tag)) (mark (Crt: prg)) (mark (Crt: at)) (mark (Crt: (env $Intern any))) (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: (env $Intern any))) (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 (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 (set $At $Nil $At2 $Nil) (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.l0000644000000000000000000014502114155363232010407 0ustar # 12dec21 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 fmtWord 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 fmtWord ((i64 . N) (i64 . Scl) (i8 . Sep) (i8 . Ign) (i64* . P)) (when (> N 9) (setq Scl (fmtWord (/ 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 ) # 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))) ) ) (cond ((ge0 Scl) # Build symbol (when Sign (byteSym (char "-") P) ) (let N (* (shr (- TopA Acc) 3) 18) # Calculate length~1 (let D (val TopA) (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 (fmtWord (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) (? (== 1 D)) (byteSym (+ (i8 (/ N D)) (char "0")) P) (setq N (% N D) D (/ D 10)) ) (byteSym (+ (i8 N) (char "0")) P) ) ) 0 ) ((== Scl -1) # Direct print (when Sign (call $Put (char "-")) ) # Output sign (outWord (val TopA)) # Output highest word (while (>= (dec 'TopA) Acc) (let (N (val TopA) D 100000000000000000) (loop (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 ) (T # Calculate length (let (N (* (shr (- TopA Acc) 3) 18) D (val TopA)) (loop (inc 'N) (? (=0 (setq D (/ D 10)))) ) (when Sign (inc 'N) ) (cnt N) ) ) ) ) ) ) # (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.l0000644000000000000000000016546514144715772010504 0ustar # 16nov21 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)) -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 @) 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 '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) ) ) ) ) (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) ) ) ) ) ) ) ) # (intern 'sym ['nsp]) -> sym (de _intern (Exe) (let (X (cdr Exe) Sym (save (needSymb Exe (eval (++ X)))) ) (cond ((sym? (val (tail Sym))) $Nil) # External symbol ((== (name @) ZERO) $Nil) # Anonymous symbol (T (let Nm @ (if (nil? (eval (car 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 Exe 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 0 X))) (let (P (push 0 (xName 0 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 Exe Y))) Z ) (T (let P (push 0 (xName Exe 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) (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 (set 2 X (cons $Nil (cons Key $Nil))) $Nil ) (? (atom (setq Y (cdr (setq X Y)))) (set 2 X (cons Key $Nil)) $Nil ) ) (T # Entry is greater (? (atom Y) # No link yet (set 2 X (cons (cons Key $Nil) $Nil)) $Nil ) (? (atom (setq Y (car (setq X Y)))) (set X (cons Key $Nil)) $Nil ) ) ) (setq X Y) ) ) (set Var (cons Key $Nil)) $Nil ) ) ) (de idxGet (Var Key) (let X (val Var) (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) (if (== Key ZERO) (val Sym) (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) ) (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? (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 Exe 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 Exe 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 Exe 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.l0000644000000000000000000027147114160103372010257 0ustar # 20dec21 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) In (val P)) (when (== In (val $InFile)) (set $Chr ((inFile (set $InFile (val (val $InFiles)))) chr) ) ) # Stdin (when In (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) Out (val P)) (when (== Out (val $OutFile)) (set $OutFile (val 2 (val $OutFiles))) ) # Stdout (when Out ((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 (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) (ifn P (loop # Non-circular (binPrint (car X)) (? (nil? (shift X)) (call $PutBin END) ) (? (atom X) (call $PutBin DOT) (binPrint X) ) ) (let Flg (== P X) # Fully circular (loop # Non-circular part (binPrint (car X)) (? (== P (shift X))) ) (call $PutBin DOT) (unless Flg (call $PutBin BEG) (loop # Circular part (binPrint (car X)) (? (== P (shift X))) ) (call $PutBin DOT) ) (call $PutBin END) ) ) ) ) ((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 ((ioFrame In) file)) fd) ((outFile ((ioFrame Out) file)) fd) ) ) ) ) ) (local) (pushInFile pushOutFile pushErrFile pushCtlFile) (de void pushInFile ((i8* . Io) (i8* . In) (i32 . Pid)) (let Io: (ioFrame Io) (when (val $InFile) ((inFile @) chr (val $Chr)) ) (when (Io: link (val $InFrames)) ((ioFrame @) fun (val (i8** $Get))) ) (set $Get (fun (i32) _getStdin)) (set $Chr ((inFile (Io: file (set $InFile In))) chr) ) (Io: pid Pid) (set $InFrames (Io:)) ) ) (de void pushOutFile ((i8* . Io) (i8* . Out) (i32 . Pid)) (let Io: (ioFrame Io) (when (Io: link (val $OutFrames)) ((ioFrame @) fun (val (i8** $Put))) ) (set $Put (fun (void i8) _putStdout)) (Io: file (set $OutFile Out)) (Io: pid Pid) (set $OutFrames (Io:)) ) ) (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 tosInFile popOutFiles tosOutFile popErrFiles popCtlFiles) (de void popInFiles () (let (Io: (ioFrame (val $InFrames)) In: (inFile (Io: file))) (when (ge0 (In: fd)) (ifn (Io: pid) (In: chr (val $Chr)) (close (In: fd)) (closeInFile (In: fd)) (when (> (Io: pid) 1) (waitFile @) ) ) ) (set $InFrames (Io: link)) ) ) (de void tosInFile () (let Io: (ioFrame (val $InFrames)) (set $Chr ((inFile (set $InFile (Io: file))) chr) (i8** $Get) (Io: fun) ) ) ) (de void popOutFiles () (flush (val $OutFile)) (let (Io: (ioFrame (val $OutFrames)) Out: (outFile (Io: file))) (when (ge0 (Out: fd)) (when (Io: pid) (close (Out: fd)) (closeOutFile (Out: fd)) (when (> (Io: pid) 1) (waitFile @) ) ) ) (set $OutFrames (Io: link)) ) ) (de void tosOutFile () (let Io: (ioFrame (val $OutFrames)) (set $OutFile (Io: file) (i8** $Put) (Io: fun) ) ) ) (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 Exe (evSym (cdr Exe))) (mkStr (pathString Nm (b8 (pathSize Nm)))) ) ) (local) (pollfd hasData inReady 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 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 @) (let (Cld2 (val $Child) # Iterate children Cld Cld2) (Cld2: pid) (or (=0 (val Pn)) (== @ (Cld2: pid))) ) (wrChild Cld2 Buf (val 2 Pn)) ) ) (setq Cld2 (ofs Cld2 (child T))) ) ) ) (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) (run (cdr Y)) ) ) ) ) # Run body ((<> (i32 (int @)) Fd) (when (inReady @ NO) (set $At (car X)) # File descriptor (run (cdr X)) ) ) ) ) ) ) # Run body (and (gt0 Ms) (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 0)) (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)) (let Io: (ioFrame 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 Exe 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) (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 Exe (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 Exe (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)) (let Io: (ioFrame 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 Exe 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 (openWrAppend 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 Exe (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 Exe (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 Exe 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 Exe 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 testEsc anonymous rdAtom rdl rdList) (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 (readline (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) ) ) ) (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 "^H"))) ((char "e") (set $Chr (char "^["))) ((char "n") (set $Chr (char "^J"))) ((char "r") (set $Chr (char "^M"))) ((char "t") (set $Chr (char "^I"))) (T (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"))) ) ) ) (set $Chr 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 (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) (loop (? (== (skip) (char ")")) # Empty list (call $Get) $Nil ) (? (== @ (char "]")) $Nil) # Empty list (? (<> @ (char "~")) # Read macro (let R (save (cons (read0 NO) $Nil)) (rdl R R) R ) ) (call $Get) (let (X (save (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)) (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 (val $Chr) (unless C (setq C (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 0 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]) -> sym (de _key (Exe) (flushAll) (let Raw (val Termio) (prog2 (setRaw) (if (waitFd Exe 0 (if (nil? (eval (cadr Exe))) 292MY (xCnt Exe @) ) ) (let C (stdinByte) (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 Chr (val $Chr) (unless Chr (setq Chr (call $Get)) ) (if (lt0 Chr) $Nil (mkChar Chr)) ) ) # (char) -> sym # (char 'cnt) -> sym # (char T) -> sym # (char 'sym) -> cnt (de _char (Exe) (let X (cdr Exe) (cond ((atom X) (let Chr (val $Chr) (unless Chr (setq 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 Exe 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 Exe 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 Exe (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 (val $Chr) (unless C (setq C (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) (tosInFile) ) ) ) # (out 'any . prg) -> any (de _out (Exe) (let X (cdr Exe) (wrOpen Exe (eval (++ X)) (b8 (ioFrame T))) (prog1 (run X) (popOutFiles) (tosOutFile) ) ) ) # (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) ) ) ) # (fd) -> cnt (de _fd (Exe) (cnt (i64 (currFd Exe))) ) (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) (In: pid 0) (setq In (In: link)) ) ) ) (let Out (val $OutFrames) # Clear pids in OutFrames (while Out (let Out: (ioFrame Out) (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) (tosInFile) ) ) ) ) ) # 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 (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 Exe (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 Exe 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 Exe 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 (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 -1 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 @ (ifn (== X (isIntern Nm $PrivT)) (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) # White space (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 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) (ifn P (loop # Non-circular (print (car X)) (? (nil? (shift X))) (? (atom X) (outString ($ " . ")) (print X) ) (space) ) (let Flg (== P X) # Fully circular (loop # Non-circular part (print (car X)) (space) (? (== P (shift X))) ) (call $Put (char ".")) (unless Flg (space) (call $Put (char "(")) (loop # Circular part (print (car X)) (space) (? (== P (shift X))) ) (call $Put (char ".")) (call $Put (char ")")) ) ) ) ) (call $Put (char ")")) ) ) ) (de void prin (X) (sigChk 0) (unless (nil? X) (cond ((cnt? X) (outNum X)) ((big? X) (fmtNum X -1 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 ) ) ) ) (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) (repl loadAll) (de repl (Exe (i8* . Prmt) X) (when (num? X) (argErr Exe X) ) (if (and (sym? X) (== (firstByte X) (char "-"))) (let E (save (parse (xName Exe X) YES (hex "5D0A") 0)) # '\n', ']', EOF (evList E) ) (let (Int (save (val $Intern)) Pr1 (save (val $PrivT)) Pr2 (save (val 2 $PrivT)) Tr1 (save (val $Transient)) Tr2 (save (val 2 $Transient)) V (link (push -ZERO NIL)) At (link (push -ZERO NIL)) Raw (val Termio) ) (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) (loop (let Y (ifn (== (val $InFile) (val (val $InFiles))) # Stdin (read1 0) (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 ) ) ) (prog2 (set $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) ) ) ) ) (? (nil? Y)) (set V Y) (if (or (<> (val $InFile) (val (val $InFiles))) # Stdin (val $Chr) (=0 Prmt) ) (setq X (eval Y)) (flushAll) (let A (set At (val $At)) (setq X (eval Y)) (set $At3 (val $At2) $At2 A $At X ) ) (outString ($ "-> ")) (flushAll) (print X) (newline) ) ) ) (popInFiles) (tosInFile) (when Raw (setRaw) ) (set 2 $Transient Tr2) (set $Transient Tr1) (set 2 $PrivT Pr2) (set $PrivT Pr1) (set $Intern Int) 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.l0000644000000000000000000014040314036234732010232 0ustar # 16apr21 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) -> sym | NIL (de _extQ (Exe) (let X (eval (cadr Exe)) (if (and (symb? X) (sym? (val (tail X))) (isLife X) ) X $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) (when (val $DbJnl) (fclose @) (set $DbJnl null) ) (when (val $DbLog) (fclose @) (set $DbLog null) ) ) (unless (nil? Sym1) (let (Nm (xName Exe 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 $DBs Fnr $MaxBlkSize Max $DbBlock (alloc (val $DbBlock) (i64 Max)) ) ) ) (unless (nil? Sym2) # Replication journal (let Nm (xName Exe 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 Exe 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 Exe 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 Exe 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 0) # 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 0) # 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 0) (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 Exe (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.l0000644000000000000000000005213714002747013010772 0ustar # 23jan21 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) (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) ) ) # (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)) ) (fish E (save (eval (++ X))) (ofs P 3) R (eval (car X)) ) (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.l0000644000000000000000000014515314107724100010613 0ustar # 20aug21 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 '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 (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) ) (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) @) (car Z) ) ) ) ) ) (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] ['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 (T (let Nm (newId Exe # External (if (cnt? Y) (i32 (int @)) 1) ) (prog1 (extern Nm) (set (tail @) (sign (shr 1 (add Nm Nm) 1)) ) ) ) ) ) ) ) # Set "dirty" (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 (put Obj (set K (eval (++ X))) (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) (? (gt0 (extra (car Lst) Key)) @) # 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) (when (le0 (extra (val $This) Key)) (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)) ) ) ) ) # (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 (++ V)) (? (=0 (& (setq R (loop1 X)) 1))) ) ) ) ) (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 (++ V)) (? (=0 (& (setq R (loop1 X)) 1))) (set Y (+ (val Y) (hex "10"))) ) (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))))) (prog1 (run X) (set Y (val P) $Bind (val 3 P)) ) ) ) # (catch 'any . prg) -> any (de _catch (Exe) (let (X (cdr Exe) Ca: (caFrame (b8 (+ (val JmpBufSize) (caFrame T)))) ) (Ca: tag (eval (++ X))) (Ca: link (val $Catch)) (set $Catch (Ca:)) (Ca: fin ZERO) (Ca: co (val $Current)) (memcpy (Ca: (env)) (env) (env T) T) (prog1 (if (setjmp (Ca: (rst))) (val $Ret) (run X) ) (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)))) ) (Ca: tag 0) (Ca: link (val $Catch)) (set $Catch (Ca:)) (Ca: fin (++ X)) (Ca: co (val $Current)) (memcpy (Ca: (env)) (env) (env T) T) (prog1 (save (run X)) (eval (Ca: fin)) (set $Catch (Ca: link)) ) ) ) # Coroutines (local) (reentErr saveCoIO saveCoEnv loadCoEnv) (de NIL reentErr (Exe Tag) (err Exe Tag ($ "Reentrant coroutine") null) ) # Switch coroutines (de void saveCoIO () ((ioFrame (val $OutFrames)) fun (val (i8** $Put))) (let Io: (ioFrame (val $InFrames)) (Io: fun (val (i8** $Get))) ((inFile (Io: file)) chr (val $Chr)) ) ) (de void saveCoEnv ((i8* . Crt)) (let Crt: (coroutine Crt) (Crt: at (val $At)) # Not running (memcpy (Crt: (env)) (env) (env T) T) ) ) (de loadCoEnv ((i8* . Crt)) (let Crt: (coroutine (set $Current Crt)) (set $StkLimit (+ (Crt: lim) 4096)) (memcpy (env) (Crt: (env)) (env T) T) (tosInFile) (tosOutFile) (set $At (Crt: at)) (Crt: at 0) # Running (val $Ret) ) ) # (co ['any [. prg]]) -> any (de _co (Exe) (let X (cdr Exe) (if (atom X) (if (val $Current) ((coroutine @) tag) $Nil ) (let Tag (eval (++ X)) (cond ((pair X) # 'prg' (unless (val $Coroutines) # First call (let Main: (coroutine (alloc null (+ (val JmpBufSize) (coroutine T)))) (Main: tag $T) # Tag 'T' (Main: prv null) (Main: nxt null) (Main: org null) (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 (Main:))) ) ) (let (Src: (coroutine (val $Current)) Crt (val $Coroutines) P (i8* null) ) (saveCoIO) (saveCoEnv (Src:)) (loop (let Crt: (coroutine Crt) (when (== Tag (Crt: tag)) # Found running coroutine (unless (Crt: at) (reentErr Exe Tag) ) (when (setjmp (Src: (rst))) (ret (loadCoEnv (Src:))) ) (set $Ret $Nil) (longjmp (Crt: (rst)) 1) ) (or P (Crt: tag) # Unused (setq P Crt) ) # Remember next free slot (? (=0 (Crt: nxt))) (setq Crt @) ) ) # Start new coroutine (when (setjmp (Src: (rst))) (ret (loadCoEnv (Src:))) ) (if P (stack P) # Use free slot (stack ((coroutine Crt) lim)) # Found no free slot (setq P (b8 (+ (val JmpBufSize) (coroutine T)))) ((coroutine Crt) nxt P) ((coroutine P) prv Crt) ((coroutine P) nxt null) ) (let Dst: (coroutine P) (Dst: tag Tag) (Dst: org (val $Current)) (Dst: prg X) (let (Siz (val $StkSize) Stk (stack)) (memset (Dst: lim (stack (ofs P (- Siz)))) 7 (- Siz 256) T ) (stack Stk) ) (Dst: at 0) (Dst: lnk (val $Link)) (Dst: bnd (set $Bind (push ZERO $At (val $Bind) Exe)) ) # [0 @ LINK exe] (Dst: ca (val $Catch)) (Dst: in (val $InFrames)) (Dst: out (val $OutFrames)) (Dst: err (val $ErrFrames)) (Dst: ctl (val $CtlFrames)) (memcpy (Dst: (env)) (env) (env T) T) (set # Init local env $Next $Nil $Make 0 $Yoke 0 $Current (Dst:) $StkLimit (+ (Dst: lim) 4096) ) (set $Ret (run X)) (stop (Dst:)) # Stop coroutine (longjmp ((coroutine (Dst: org)) (rst)) 1) ) ) ) ((t? Tag) (err Exe 0 ($ "Can't stop main routine") null) ) ((val $Coroutines) (let Crt @ # Stop coroutine (loop (let Crt: (coroutine Crt) (? (== Tag (Crt: tag)) # Found coroutine (stop (Crt:)) ) # Stop it (? (=0 (setq Crt (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)) Dst: (coroutine (cond ((not (nil? Tag)) (loop (let Crt: (coroutine Crt) (? (== Tag (Crt: tag)) (unless (Crt: at) (reentErr Exe Tag) ) Crt ) (unless (setq Crt (Crt: nxt)) (err Exe Tag ($ "Coroutine not found") null) ) ) ) ) ((Src: org) @) (T (err Exe 0 ($ "Tag expected") null)) ) ) 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) ) ) (let Q (Src: bnd) (set 3 Q Bnd) (set $Bind Q) ) ) (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: (ioFrame 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: (ioFrame 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)) (let P (val $CtlFrames) # Restore CtlFrames (Src: ctl P) (while Ctl (let Ctl: (ioFrame Ctl) (setq Ctl (Ctl: link)) (Ctl: link P) (setq P (Ctl:)) ) ) (Src: (env $CtlFrames i8*) P) ) (let P (val $ErrFrames) # Restore ErrFrames (Src: err P) (while Err (let Err: (ioFrame Err) (setq Err (Err: link)) (Err: link P) (setq P (Err:)) ) ) (Src: (env $ErrFrames i8*) P) ) (let P (val $OutFrames) # 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 (val $InFrames) # 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 (val $Catch) # 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 (val $Bind) # Restore bindings (set 3 (Src: bnd) P) (setq P (Src: bnd)) (Src: bnd P) (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 (val $Link) # 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) ) (let Raw (val Termio) (setCooked) (pushOutFile (b8 (ioFrame T)) (val 2 (val $OutFiles)) 0) # Stdout (print Exe) (newline) (repl 0 ($ "! ") $Nil) (popOutFiles) (tosOutFile) (when Raw (setRaw) ) ) (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) (tosInFile) (popOutFiles) (tosOutFile) (prog1 (if (pair (cdr Exe)) (run @) (eval (val $Up)) ) (pushOutFile (Out:) (Out: file) (Out: pid)) (pushInFile (In:) (In: file) (In: pid)) (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 Exe (evSym X)) ) (set Av (pathString Cmd (b8 (pathSize Cmd)))) (let A Av (while (pair (shift X)) (let Nm (xName Exe (evSym X)) (set (inc 'A) (bufString Nm (b8 (bufSize Nm))) ) ) ) (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 Exe (evSym X)) ) (set Av (pathString Cmd (b8 (pathSize Cmd)))) (let A Av (while (pair (shift X)) (let Nm (xName Exe (evSym X)) (set (inc 'A) (bufString Nm (b8 (bufSize Nm))) ) ) ) (set (inc 'A) null) ) (flushAll) (cond ((lt0 (fork)) (forkErr Exe)) ((=0 @) # In child (setpgid 0 0) # Set process group (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 (tcsetpgrp 0 Pid) (loop (while (lt0 (waitWuntraced Pid Res)) (unless (== (gErrno) EINTR) (err Exe 0 ($ "wait pid") null) ) (sigChk Exe) ) (tcsetpgrp 0 (getpgrp)) (? (=0 (wifStopped Res)) (set $At2 (cnt (i64 (val Res)))) (if (val Res) $Nil $T) ) (repl 0 ($ "+ ") $Nil) (tcsetpgrp 0 Pid) (kill Pid (val SIGCONT Sig)) ) ) ) ) # (ipid) -> pid | NIL (de _ipid (Exe) (let Io: (ioFrame (val $InFrames)) (if (and (Io:) (> (Io: pid) 1)) (cnt (i64 (Io: pid))) $Nil ) ) ) # (opid) -> pid | NIL (de _opid (Exe) (let Io: (ioFrame (val $OutFrames)) (if (and (Io:) (> (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.l0000644000000000000000000014677214155670254010644 0ustar # 13dec21 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 $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) (set (val $Yoke) (eval (++ X))) (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 'lst ..) -> lst (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 (save @) R (safe (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 -2 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)) ) (loop (? (atom Z) $Nil) (let C (car Z) (? (and (pair C) (equal Y (car C))) C) ) (shift Z) ) ) ) # (rassoc 'any 'lst) -> lst (de _rassoc (Exe) (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) ) (loop (? (atom Z) $Nil) (let C (car Z) (? (and (pair C) (equal Y (cdr C))) C) ) (shift Z) ) ) ) # (asoq 'any 'lst) -> lst (de _asoq (Exe) (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) ) (loop (? (atom Z) $Nil) (let C (car Z) (? (and (pair C) (== Y (car C))) C) ) (shift Z) ) ) ) # (rasoq 'any 'lst) -> lst (de _rasoq (Exe) (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X)) ) (loop (? (atom Z) $Nil) (let C (car Z) (? (and (pair C) (== Y (cdr C))) C) ) (shift Z) ) ) ) # (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) fill (de fill (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 (fill 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 (fill X Y) @ X) ) Z ) ) ) (let V (fill Z Y) (cond (V (save V (cons V (if (fill X Y) @ X) ) ) ) ((fill X Y) (cons Z @) ) (T 0) ) ) ) ) ) ) ) # (fill 'any ['sym|lst]) -> any (de _fill (Exe) (let (X (cdr Exe) Y (save (eval (++ X)))) (if (fill Y (save (eval (car X)))) @ 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)) B (push NIL $Nil ZERO NIL) A (push NIL B ZERO NIL) E (push NIL A ZERO (eval (car X)) NIL) # [car cdr name fun link] P ) (set B (ofs B 3) A (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 (setq P (val In1)))) (set In0 (cdr (setq P (val In0)))) ) (let (Tail0 (ofs P 1) Tail1 0 Last (car P)) (set Out0 P Out1 $Nil) (set 2 P $Nil) (while (or (pair (val In0)) (pair (val In1))) (cond ((atom (val In1)) (set In0 (cdr (setq P (val In0)))) (when (lt0 (cmpSort (car P) Last)) (xchg 'Tail0 'Tail1) ) ) ((atom (val In0)) (set In1 (cdr (setq P (val In1)))) (when (lt0 (cmpSort (car P) Last)) (xchg 'Tail0 'Tail1) ) ) ((lt0 (cmpSort (caar In0) Last)) (if (ge0 (cmpSort (caar In1) Last)) (set In1 (cdr (setq P (val In1)))) (if (lt0 (cmpSort (caar In0) (caar In1))) (set In0 (cdr (setq P (val In0)))) (set In1 (cdr (setq P (val In1)))) ) (xchg 'Tail0 'Tail1) ) ) ((lt0 (cmpSort (caar In1) Last)) (set In0 (cdr (setq P (val In0)))) ) ((lt0 (cmpSort (caar In0) (caar In1))) (set In0 (cdr (setq P (val In0)))) ) (T (set In1 (cdr (setq P (val In1))))) ) (setq Tail0 (ofs (if Tail0 (set Tail0 P) (set Out1 P) ) 1 ) ) (set 2 P $Nil) (setq Last (car P)) ) ) (? (atom (val Out1)) (val Out0)) ) ) ) ) ) ) pil21/src/pico.h0000644000000000000000000000271314155316701010573 0ustar // 12dec21 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 #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) uint64_t name(uint64_t); uint64_t number(uint64_t); uint64_t length(uint64_t); uint64_t box64(uint64_t); 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.c0000644000000000000000000023621414155317071010410 0ustar // 12dec21 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) { snprintf(buf, siz, fmt, arg); } 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; } 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 int Tio; struct termios OrgTermio, *Termio; static void tcSet(struct termios *p) { while (tcsetattr(STDIN_FILENO, TCSADRAIN, p) && errno == EINTR); } void stopTerm(void) { sigset_t mask; if (Tio) { tcSet(&OrgTermio); sigUnblock(SIGTSTP); signal(SIGTSTP, SIG_DFL), raise(SIGTSTP); if (Termio) tcSet(Termio); } } 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) { gettimeofday(&Tv, NULL); Time = localtime(&Tv.tv_sec); return Time->tm_year+1900 | (Time->tm_mon+1) << 16 | Time->tm_mday << 24; } int64_t getGmDate(void) { gettimeofday(&Tv, NULL); 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; gettimeofday(&Tv, NULL); 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 || stk.rlim_cur == RLIM_INFINITY) return NULL; return (char*)&stk - stk.rlim_cur + 16384; } int64_t fileInfo(int lnk, 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 = 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; 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 uint64_t name(uint64_t x) { while (!num(x)) x = cdr(x); return x; } uint64_t number(uint64_t x) { uint64_t n = cnt(x)? x >> 4 : val(dig(x)); return sign(x)? -n : n; } uint64_t length(uint64_t x) { int n = 0; while (!atom(x)) ++n, x = cdr(x); return (int32_t)n; } uint64_t box64(uint64_t x) { return x & 0xF000000000000000? boxNum(x) : x << 4 | 2; } // Native library interface #define FMAX ((float)UINT64_MAX) #define DMAX ((double)UINT64_MAX) int 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)) 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; } // 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.ll0000644000000000000000001447145414162303700010745 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 @$Current = global i8* null @$Coroutines = global i8* null @$StkBrk = 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 @$InFiles = global i8** null @$InFDs = global i32 0 @$OutFiles = global i8** null @$InFile = global i8* null @$OutFile = global i8* null @$Chr = global i32 0 @$Put = global void(i8)* null @$Get = global i32()* null @$PutBin = global void(i8)* null @$GetBin = global i32()* null @$OutFDs = global i32 0 @$Poll = global i64* null @$Nfds = global i32 0 @$SeedL = global i64 0 @$SeedH = global i64 0 @$USec = global i64 0 @$TickU = global i64 0 @$TickS = 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 [870 x i64] [ ; # [0] NIL i64 79992034, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 0, ; # [32] ~ i64 2018, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 40) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 40) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 48) to i64), ; # [80] pico i64 29900576514, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 64) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 88) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 40) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 112) to i64), ; # [144] priv i64 31785953026, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [224] *DB i64 69485218, i64 0, ; # [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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), ; # [288] N i64 1250, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [304] C i64 1074, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [320] S i64 1330, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [336] B i64 1058, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [352] I i64 1170, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [368] P i64 1282, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [384] W i64 1394, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [448] @@ i64 263170, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [464] @@@ i64 67372034, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [480] This i64 30980605250, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [496] *Prompt i64 524395401951117986, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [512] *Zap i64 30166852258, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [528] *Ext i64 31264625314, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [576] *Class i64 2031030286693026, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [592] *Run i64 29650920098, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [608] *Hup i64 30187750050, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [624] *Sig1 i64 3395013653154, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [640] *Sig2 i64 3463733129890, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [656] *Winch i64 1836420215173794, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [672] *TStp1 i64 869744923460258, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [688] *TStp2 i64 887337109504674, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [704] *Term i64 7521130857122, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [720] ^ i64 1506, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [736] *Err i64 30721462946, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [752] *Msg i64 27769754274, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [768] *Uni i64 28301415074, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [784] *Fork i64 7383702332066, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [800] *Bye i64 27239129762, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [816] *Dbg i64 27751891618, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), ; # [832] complete i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 852) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 7310579611546251107, i64 2, ; # [864] gc i64 407154, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_gc to i8*), i32 2) to i64), ; # [880] format i64 2047388749854306, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_format to i8*), i32 2) to i64), ; # [896] + i64 690, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_add to i8*), i32 2) to i64), ; # [912] - i64 722, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_sub to i8*), i32 2) to i64), ; # [928] inc i64 104261266, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_inc to i8*), i32 2) to i64), ; # [944] dec i64 104224322, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_dec to i8*), i32 2) to i64), ; # [960] * i64 674, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_mul to i8*), i32 2) to i64), ; # [976] */ i64 193186, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_mulDiv to i8*), i32 2) to i64), ; # [992] / i64 754, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_div to i8*), i32 2) to i64), ; # [1008] % i64 594, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rem to i8*), i32 2) to i64), ; # [1024] >> i64 254946, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_shr to i8*), i32 2) to i64), ; # [1040] rev i64 124147490, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rev to i8*), i32 2) to i64), ; # [1056] lt0 i64 50808514, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_lt0 to i8*), i32 2) to i64), ; # [1072] le0 i64 50747074, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_le0 to i8*), i32 2) to i64), ; # [1088] ge0 i64 50746994, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_ge0 to i8*), i32 2) to i64), ; # [1104] gt0 i64 50808434, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_gt0 to i8*), i32 2) to i64), ; # [1120] abs i64 120989202, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_abs to i8*), i32 2) to i64), ; # [1136] bit? i64 17033500194, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_bitQ to i8*), i32 2) to i64), ; # [1152] & i64 610, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_bitAnd to i8*), i32 2) to i64), ; # [1168] | i64 1986, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_bitOr to i8*), i32 2) to i64), ; # [1184] x| i64 509826, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_bitXor to i8*), i32 2) to i64), ; # [1200] sqrt i64 31258515250, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_sqrt to i8*), i32 2) to i64), ; # [1216] seed i64 26949867314, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_seed to i8*), i32 2) to i64), ; # [1232] hash i64 28038272642, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_hash to i8*), i32 2) to i64), ; # [1248] rand i64 26959288098, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rand to i8*), i32 2) to i64), ; # [1264] name i64 27226674914, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_name to i8*), i32 2) to i64), ; # [1280] nsp i64 117913314, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_nsp to i8*), i32 2) to i64), ; # [1296] sp? i64 66520882, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_spQ to i8*), i32 2) to i64), ; # [1312] pat? i64 17033467650, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_patQ to i8*), i32 2) to i64), ; # [1328] fun? i64 17027257954, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_funQ to i8*), i32 2) to i64), ; # [1344] getd i64 26965595762, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_getd to i8*), i32 2) to i64), ; # [1360] all i64 113690130, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_all to i8*), i32 2) to i64), ; # [1376] symbols i64 519821567523788594, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_symbols to i8*), i32 2) to i64), ; # [1392] intern i64 1943001719301778, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_intern to i8*), i32 2) to i64), ; # [1408] ==== i64 16438776786, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_hide to i8*), i32 2) to i64), ; # [1424] box? i64 17037719074, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_boxQ to i8*), i32 2) to i64), ; # [1440] str? i64 17031448370, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_strQ to i8*), i32 2) to i64), ; # [1456] zap i64 117839778, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_zap to i8*), i32 2) to i64), ; # [1472] chop i64 30181590578, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_chop to i8*), i32 2) to i64), ; # [1488] pack i64 28826801922, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_pack to i8*), i32 2) to i64), ; # [1504] glue i64 27235108466, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_glue to i8*), i32 2) to i64), ; # [1520] text i64 31264757570, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_text to i8*), i32 2) to i64), ; # [1536] pre? i64 17017808642, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_preQ to i8*), i32 2) to i64), ; # [1552] sub? i64 17014675250, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_subQ to i8*), i32 2) to i64), ; # [1568] val i64 113645410, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_val to i8*), i32 2) to i64), ; # [1584] set i64 122050354, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_set to i8*), i32 2) to i64), ; # [1600] setq i64 30455256882, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_setq to i8*), i32 2) to i64), ; # [1616] swap i64 30166972210, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_swap to i8*), i32 2) to i64), ; # [1632] xchg i64 27758311298, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_xchg to i8*), i32 2) to i64), ; # [1648] on i64 452338, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_on to i8*), i32 2) to i64), ; # [1664] off i64 107374322, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_off to i8*), i32 2) to i64), ; # [1680] onOff i64 7036850333426, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_onOff to i8*), i32 2) to i64), ; # [1696] zero i64 29916288930, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_zero to i8*), i32 2) to i64), ; # [1712] one i64 106358514, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_one to i8*), i32 2) to i64), ; # [1728] default i64 524325579192161858, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_default to i8*), i32 2) to i64), ; # [1744] push i64 28038354690, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_push to i8*), i32 2) to i64), ; # [1760] push1 i64 3395292714754, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_push1 to i8*), i32 2) to i64), ; # [1776] push1q i64 1991312315733762, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_push1q to i8*), i32 2) to i64), ; # [1792] pop i64 117896962, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_pop to i8*), i32 2) to i64), ; # [1808] ++ i64 176818, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_popq to i8*), i32 2) to i64), ; # [1824] shift i64 7998950246194, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_shift to i8*), i32 2) to i64), ; # [1840] cut i64 122115634, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cut to i8*), i32 2) to i64), ; # [1856] del i64 113661506, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_del to i8*), i32 2) to i64), ; # [1872] queue i64 6972180485906, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_queue to i8*), i32 2) to i64), ; # [1888] fifo i64 29903722082, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_fifo to i8*), i32 2) to i64), ; # [1904] rid i64 105289506, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rid to i8*), i32 2) to i64), ; # [1920] enum i64 29382600274, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_enum to i8*), i32 2) to i64), ; # [1936] enum? i64 4358709634642, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_enumQ to i8*), i32 2) to i64), ; # [1952] idx i64 126240402, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_idx to i8*), i32 2) to i64), ; # [1968] lup i64 117921474, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_lup to i8*), i32 2) to i64), ; # [1984] put i64 122115842, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_put to i8*), i32 2) to i64), ; # [2000] get i64 122050162, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_get to i8*), i32 2) to i64), ; # [2016] prop i64 30181631746, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_prop to i8*), i32 2) to i64), ; # [2032] ; i64 946, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_semicol to i8*), i32 2) to i64), ; # [2048] =: i64 238546, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_setCol to i8*), i32 2) to i64), ; # [2064] : i64 930, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_col to i8*), i32 2) to i64), ; # [2080] :: i64 238498, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_propCol to i8*), i32 2) to i64), ; # [2096] putl i64 29113145090, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_putl to i8*), i32 2) to i64), ; # [2112] getl i64 29113079410, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_getl to i8*), i32 2) to i64), ; # [2128] wipe i64 27229853554, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_wipe to i8*), i32 2) to i64), ; # [2144] meta i64 26160289490, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_meta to i8*), i32 2) to i64), ; # [2160] low? i64 17036670658, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_lowQ to i8*), i32 2) to i64), ; # [2176] upp? i64 17029334866, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_uppQ to i8*), i32 2) to i64), ; # [2192] lowc i64 26700347074, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_lowc to i8*), i32 2) to i64), ; # [2208] uppc i64 26693011282, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_uppc to i8*), i32 2) to i64), ; # [2224] fold i64 26957248098, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_fold to i8*), i32 2) to i64), ; # [2240] path i64 28039321346, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_path to i8*), i32 2) to i64), ; # [2256] wait i64 31249012594, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_wait to i8*), i32 2) to i64), ; # [2272] sync i64 26690950962, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_sync to i8*), i32 2) to i64), ; # [2288] hear i64 30703769218, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_hear to i8*), i32 2) to i64), ; # [2304] tell i64 29104691010, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_tell to i8*), i32 2) to i64), ; # [2320] poll i64 29104731906, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_poll to i8*), i32 2) to i64), ; # [2336] read i64 26945672994, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_read to i8*), i32 2) to i64), ; # [2352] key i64 127293106, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_key to i8*), i32 2) to i64), ; # [2368] peek i64 28828915458, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_peek to i8*), i32 2) to i64), ; # [2384] char i64 30703781426, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_char to i8*), i32 2) to i64), ; # [2400] skip i64 30175311666, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_skip to i8*), i32 2) to i64), ; # [2416] eol i64 113702482, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_eol to i8*), i32 2) to i64), ; # [2432] eof i64 107411026, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_eof to i8*), i32 2) to i64), ; # [2448] from i64 29376325218, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_from to i8*), i32 2) to i64), ; # [2464] till i64 29104707394, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_till to i8*), i32 2) to i64), ; # [2480] line i64 27227756226, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_line to i8*), i32 2) to i64), ; # [2496] in i64 452242, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_in to i8*), i32 2) to i64), ; # [2512] out i64 122115826, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_out to i8*), i32 2) to i64), ; # [2528] err i64 120006226, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_err to i8*), i32 2) to i64), ; # [2544] ctl i64 113722930, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_ctl to i8*), i32 2) to i64), ; # [2560] fd i64 411234, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_fd to i8*), i32 2) to i64), ; # [2576] pipe i64 27229853442, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_pipe to i8*), i32 2) to i64), ; # [2592] open i64 29634266866, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_open to i8*), i32 2) to i64), ; # [2608] close i64 6971654063666, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_close to i8*), i32 2) to i64), ; # [2624] echo i64 29905794642, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_echo to i8*), i32 2) to i64), ; # [2640] prin i64 29638469378, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_prin to i8*), i32 2) to i64), ; # [2656] prinl i64 7451341956866, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_prinl to i8*), i32 2) to i64), ; # [2672] space i64 6967344432946, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_space to i8*), i32 2) to i64), ; # [2688] print i64 8001097770754, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_print to i8*), i32 2) to i64), ; # [2704] printsp i64 506434260758374146, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_printsp to i8*), i32 2) to i64), ; # [2720] println i64 497303916201322242, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_println to i8*), i32 2) to i64), ; # [2736] flush i64 7177818785378, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_flush to i8*), i32 2) to i64), ; # [2752] rewind i64 1766806057801506, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rewind to i8*), i32 2) to i64), ; # [2768] ext i64 122127954, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_ext to i8*), i32 2) to i64), ; # [2784] plio i64 29906880258, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_plio to i8*), i32 2) to i64), ; # [2800] rd i64 411426, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rd to i8*), i32 2) to i64), ; # [2816] pr i64 468738, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_pr to i8*), i32 2) to i64), ; # [2832] wr i64 468850, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_wr to i8*), i32 2) to i64), ; # [2848] any i64 127329810, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_any to i8*), i32 2) to i64), ; # [2864] sym i64 114792242, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_sym to i8*), i32 2) to i64), ; # [2880] str i64 120014642, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_str to i8*), i32 2) to i64), ; # [2896] load i64 26945713858, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_load to i8*), i32 2) to i64), ; # [2912] ext? i64 17033561682, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_extQ to i8*), i32 2) to i64), ; # [2928] rollback i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 2948) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rollback to i8*), i32 2) to i64), i64 7738135660106379122, i64 2, ; # [2960] extern i64 1943001719342674, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_extern to i8*), i32 2) to i64), ; # [2976] pool i64 29107877634, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_pool to i8*), i32 2) to i64), ; # [2992] pool2 i64 3465081714434, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_pool2 to i8*), i32 2) to i64), ; # [3008] journal i64 488102791669544610, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_journal to i8*), i32 2) to i64), ; # [3024] id i64 411282, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_id to i8*), i32 2) to i64), ; # [3040] blk i64 112641570, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_blk to i8*), i32 2) to i64), ; # [3056] seq i64 118904626, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_seq to i8*), i32 2) to i64), ; # [3072] lieu i64 31513286338, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_lieu to i8*), i32 2) to i64), ; # [3088] lock i64 28826859202, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_lock to i8*), i32 2) to i64), ; # [3104] touch i64 7173523830594, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_touch to i8*), i32 2) to i64), ; # [3120] commit i64 2047938500425266, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_commit to i8*), i32 2) to i64), ; # [3136] mark i64 28842530514, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_mark to i8*), i32 2) to i64), ; # [3152] free i64 27218355810, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_free to i8*), i32 2) to i64), ; # [3168] dbck i64 28826805826, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_dbck to i8*), i32 2) to i64), ; # [3184] apply i64 8344165615122, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_apply to i8*), i32 2) to i64), ; # [3200] pass i64 30991062786, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_pass to i8*), i32 2) to i64), ; # [3216] maps i64 30987917010, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_maps to i8*), i32 2) to i64), ; # [3232] map i64 117839570, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_map to i8*), i32 2) to i64), ; # [3248] mapc i64 26692949714, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_mapc to i8*), i32 2) to i64), ; # [3264] maplist i64 524447902824011474, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_maplist to i8*), i32 2) to i64), ; # [3280] mapcar i64 2012201691256530, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_mapcar to i8*), i32 2) to i64), ; # [3296] mapcon i64 1942795019753170, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_mapcon to i8*), i32 2) to i64), ; # [3312] mapcan i64 1941832947078866, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_mapcan to i8*), i32 2) to i64), ; # [3328] filter i64 2012481128404578, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_filter to i8*), i32 2) to i64), ; # [3344] extract i64 524165879706388050, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_extract to i8*), i32 2) to i64), ; # [3360] seek i64 28828915506, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_seek to i8*), i32 2) to i64), ; # [3376] find i64 26959320674, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_find to i8*), i32 2) to i64), ; # [3392] pick i64 28826834690, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_pick to i8*), i32 2) to i64), ; # [3408] fully i64 8344161441378, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_fully to i8*), i32 2) to i64), ; # [3424] cnt i64 122086962, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cnt to i8*), i32 2) to i64), ; # [3440] sum i64 114775858, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_sum to i8*), i32 2) to i64), ; # [3456] maxi i64 28311951058, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_maxi to i8*), i32 2) to i64), ; # [3472] mini i64 28301498066, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_mini to i8*), i32 2) to i64), ; # [3488] fish i64 28038305378, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_fish to i8*), i32 2) to i64), ; # [3504] by i64 497186, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_by to i8*), i32 2) to i64), ; # [3520] as i64 472594, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_as to i8*), i32 2) to i64), ; # [3536] lit i64 122066626, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_lit to i8*), i32 2) to i64), ; # [3552] eval i64 29093226066, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_eval to i8*), i32 2) to i64), ; # [3568] run i64 115824418, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_run to i8*), i32 2) to i64), ; # [3584] def i64 107370050, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_def to i8*), i32 2) to i64), ; # [3600] de i64 415298, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_de to i8*), i32 2) to i64), ; # [3616] dm i64 448066, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_dm to i8*), i32 2) to i64), ; # [3632] box i64 126285346, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_box to i8*), i32 2) to i64), ; # [3648] new i64 125196002, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_new to i8*), i32 2) to i64), ; # [3664] type i64 27229919042, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_type to i8*), i32 2) to i64), ; # [3680] isa i64 102184594, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_isa to i8*), i32 2) to i64), ; # [3696] method i64 1766874505696978, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_method to i8*), i32 2) to i64), ; # [3712] send i64 26959304498, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_send to i8*), i32 2) to i64), ; # [3728] try i64 127346498, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_try to i8*), i32 2) to i64), ; # [3744] super i64 7861250250546, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_super to i8*), i32 2) to i64), ; # [3760] extra i64 6696513013330, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_extra to i8*), i32 2) to i64), ; # [3776] and i64 105309714, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_and to i8*), i32 2) to i64), ; # [3792] or i64 468722, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_or to i8*), i32 2) to i64), ; # [3808] nand i64 26959288034, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_nand to i8*), i32 2) to i64), ; # [3824] nor i64 119994082, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_nor to i8*), i32 2) to i64), ; # [3840] xor i64 119994242, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_xor to i8*), i32 2) to i64), ; # [3856] bool i64 29107877410, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_bool to i8*), i32 2) to i64), ; # [3872] not i64 122091234, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_not to i8*), i32 2) to i64), ; # [3888] nil i64 113678050, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_nil to i8*), i32 2) to i64), ; # [3904] t i64 1858, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_t to i8*), i32 2) to i64), ; # [3920] prog i64 27765712642, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_prog to i8*), i32 2) to i64), ; # [3936] prog1 i64 3395020072706, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_prog1 to i8*), i32 2) to i64), ; # [3952] prog2 i64 3463739549442, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_prog2 to i8*), i32 2) to i64), ; # [3968] if i64 419474, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_if to i8*), i32 2) to i64), ; # [3984] ifn i64 115762834, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_ifn to i8*), i32 2) to i64), ; # [4000] if2 i64 52848274, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_if2 to i8*), i32 2) to i64), ; # [4016] when i64 29634234226, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_when to i8*), i32 2) to i64), ; # [4032] unless i64 2031031360612178, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_unless to i8*), i32 2) to i64), ; # [4048] cond i64 26959345202, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cond to i8*), i32 2) to i64), ; # [4064] nond i64 26959345378, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_nond to i8*), i32 2) to i64), ; # [4080] case i64 27232966194, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_case to i8*), i32 2) to i64), ; # [4096] casq i64 30454191666, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_casq to i8*), i32 2) to i64), ; # [4112] state i64 6971907852082, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_state to i8*), i32 2) to i64), ; # [4128] while i64 6969768707954, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_while to i8*), i32 2) to i64), ; # [4144] until i64 7450011297618, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_until to i8*), i32 2) to i64), ; # [4160] at i64 476690, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_at to i8*), i32 2) to i64), ; # [4176] do i64 456258, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_do to i8*), i32 2) to i64), ; # [4192] loop i64 30181619394, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_loop to i8*), i32 2) to i64), ; # [4208] for i64 119993954, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_for to i8*), i32 2) to i64), ; # [4224] with i64 28039354226, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_with to i8*), i32 2) to i64), ; # [4240] bind i64 26959320610, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_bind to i8*), i32 2) to i64), ; # [4256] job i64 103216802, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_job to i8*), i32 2) to i64), ; # [4272] let i64 122050242, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_let to i8*), i32 2) to i64), ; # [4288] let? i64 17033483970, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_letQ to i8*), i32 2) to i64), ; # [4304] use i64 106379090, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_use to i8*), i32 2) to i64), ; # [4320] buf i64 107435554, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_buf to i8*), i32 2) to i64), ; # [4336] catch i64 7173522724402, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_catch to i8*), i32 2) to i64), ; # [4352] throw i64 8207534032706, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_throw to i8*), i32 2) to i64), ; # [4368] finally i64 546842958862128738, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_finally to i8*), i32 2) to i64), ; # [4384] co i64 456242, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_co to i8*), i32 2) to i64), ; # [4400] yield i64 6901045041042, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_yield to i8*), i32 2) to i64), ; # [4416] ! i64 530, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_break to i8*), i32 2) to i64), ; # [4432] e i64 1618, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_e to i8*), i32 2) to i64), ; # [4448] $ i64 578, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_trace to i8*), i32 2) to i64), ; # [4464] exec i64 26681509458, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_exec to i8*), i32 2) to i64), ; # [4480] call i64 29104674354, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_call to i8*), i32 2) to i64), ; # [4496] ipid i64 26954106514, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_ipid to i8*), i32 2) to i64), ; # [4512] opid i64 26954106610, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_opid to i8*), i32 2) to i64), ; # [4528] kill i64 29104707250, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_kill to i8*), i32 2) to i64), ; # [4544] fork i64 28842587746, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_fork to i8*), i32 2) to i64), ; # [4560] detach i64 1836416737105474, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_detach to i8*), i32 2) to i64), ; # [4576] bye i64 106403362, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_bye to i8*), i32 2) to i64), ; # [4592] car i64 119936562, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_car to i8*), i32 2) to i64), ; # [4608] cdr i64 119948850, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cdr to i8*), i32 2) to i64), ; # [4624] caar i64 30703752754, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_caar to i8*), i32 2) to i64), ; # [4640] cadr i64 30706898482, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cadr to i8*), i32 2) to i64), ; # [4656] cdar i64 30703765042, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cdar to i8*), i32 2) to i64), ; # [4672] cddr i64 30706910770, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cddr to i8*), i32 2) to i64), ; # [4688] caaar i64 7860160697906, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_caaar to i8*), i32 2) to i64), ; # [4704] caadr i64 7860966004274, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_caadr to i8*), i32 2) to i64), ; # [4720] cadar i64 7860163843634, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cadar to i8*), i32 2) to i64), ; # [4736] caddr i64 7860969150002, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_caddr to i8*), i32 2) to i64), ; # [4752] cdaar i64 7860160710194, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cdaar to i8*), i32 2) to i64), ; # [4768] cdadr i64 7860966016562, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cdadr to i8*), i32 2) to i64), ; # [4784] cddar i64 7860163855922, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cddar to i8*), i32 2) to i64), ; # [4800] cdddr i64 7860969162290, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cdddr to i8*), i32 2) to i64), ; # [4816] caaaar i64 2012201138656818, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_caaaar to i8*), i32 2) to i64), ; # [4832] caaadr i64 2012407297087026, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_caaadr to i8*), i32 2) to i64), ; # [4848] caadar i64 2012201943963186, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_caadar to i8*), i32 2) to i64), ; # [4864] caaddr i64 2012408102393394, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_caaddr to i8*), i32 2) to i64), ; # [4880] cadaar i64 2012201141802546, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cadaar to i8*), i32 2) to i64), ; # [4896] cadadr i64 2012407300232754, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cadadr to i8*), i32 2) to i64), ; # [4912] caddar i64 2012201947108914, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_caddar to i8*), i32 2) to i64), ; # [4928] cadddr i64 2012408105539122, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cadddr to i8*), i32 2) to i64), ; # [4944] cdaaar i64 2012201138669106, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cdaaar to i8*), i32 2) to i64), ; # [4960] cdaadr i64 2012407297099314, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cdaadr to i8*), i32 2) to i64), ; # [4976] cdadar i64 2012201943975474, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cdadar to i8*), i32 2) to i64), ; # [4992] cdaddr i64 2012408102405682, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cdaddr to i8*), i32 2) to i64), ; # [5008] cddaar i64 2012201141814834, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cddaar to i8*), i32 2) to i64), ; # [5024] cddadr i64 2012407300245042, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cddadr to i8*), i32 2) to i64), ; # [5040] cdddar i64 2012201947121202, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cdddar to i8*), i32 2) to i64), ; # [5056] cddddr i64 2012408105551410, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cddddr to i8*), i32 2) to i64), ; # [5072] nth i64 109528802, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_nth to i8*), i32 2) to i64), ; # [5088] con i64 115799602, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_con to i8*), i32 2) to i64), ; # [5104] cons i64 30985877042, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cons to i8*), i32 2) to i64), ; # [5120] conc i64 26690909746, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_conc to i8*), i32 2) to i64), ; # [5136] circ i64 26695079474, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_circ to i8*), i32 2) to i64), ; # [5152] rot i64 122091298, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rot to i8*), i32 2) to i64), ; # [5168] list i64 31259530946, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_list to i8*), i32 2) to i64), ; # [5184] need i64 26949867234, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_need to i8*), i32 2) to i64), ; # [5200] range i64 6968431744802, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_range to i8*), i32 2) to i64), ; # [5216] full i64 29104756322, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_full to i8*), i32 2) to i64), ; # [5232] make i64 27224577746, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_make to i8*), i32 2) to i64), ; # [5248] made i64 27217237714, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_made to i8*), i32 2) to i64), ; # [5264] chain i64 7587430303282, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_chain to i8*), i32 2) to i64), ; # [5280] link i64 28838368962, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_link to i8*), i32 2) to i64), ; # [5296] yoke i64 27224635282, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_yoke to i8*), i32 2) to i64), ; # [5312] copy i64 32598586930, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_copy to i8*), i32 2) to i64), ; # [5328] mix i64 126260946, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_mix to i8*), i32 2) to i64), ; # [5344] append i64 1766804976764434, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_append to i8*), i32 2) to i64), ; # [5360] delete i64 1784809475429954, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_delete to i8*), i32 2) to i64), ; # [5376] delq i64 30446868034, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_delq to i8*), i32 2) to i64), ; # [5392] replace i64 456611883680945954, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_replace to i8*), i32 2) to i64), ; # [5408] insert i64 2048554834519698, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_insert to i8*), i32 2) to i64), ; # [5424] remove i64 1784949599786786, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_remove to i8*), i32 2) to i64), ; # [5440] place i64 6967344416514, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_place to i8*), i32 2) to i64), ; # [5456] strip i64 7724887131954, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_strip to i8*), i32 2) to i64), ; # [5472] split i64 7999758731058, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_split to i8*), i32 2) to i64), ; # [5488] reverse i64 456894525016004386, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_reverse to i8*), i32 2) to i64), ; # [5504] flip i64 30175315554, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_flip to i8*), i32 2) to i64), ; # [5520] trim i64 29370033986, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_trim to i8*), i32 2) to i64), ; # [5536] clip i64 30175315506, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_clip to i8*), i32 2) to i64), ; # [5552] head i64 26945672834, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_head to i8*), i32 2) to i64), ; # [5568] tail i64 29101528898, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_tail to i8*), i32 2) to i64), ; # [5584] stem i64 29365847858, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_stem to i8*), i32 2) to i64), ; # [5600] fin i64 115775074, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_fin to i8*), i32 2) to i64), ; # [5616] last i64 31259498178, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_last to i8*), i32 2) to i64), ; # [5632] == i64 250834, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_eq to i8*), i32 2) to i64), ; # [5648] n== i64 64214754, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_neq to i8*), i32 2) to i64), ; # [5664] = i64 978, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_equal to i8*), i32 2) to i64), ; # [5680] <> i64 254914, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_nequal to i8*), i32 2) to i64), ; # [5696] =0 i64 197586, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_eq0 to i8*), i32 2) to i64), ; # [5712] =1 i64 201682, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_eq1 to i8*), i32 2) to i64), ; # [5728] =T i64 345042, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_eqT to i8*), i32 2) to i64), ; # [5744] n0 i64 198370, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_neq0 to i8*), i32 2) to i64), ; # [5760] nT i64 345826, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_neqT to i8*), i32 2) to i64), ; # [5776] < i64 962, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_lt to i8*), i32 2) to i64), ; # [5792] <= i64 250818, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_le to i8*), i32 2) to i64), ; # [5808] > i64 994, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_gt to i8*), i32 2) to i64), ; # [5824] >= i64 250850, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_ge to i8*), i32 2) to i64), ; # [5840] max i64 126228178, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_max to i8*), i32 2) to i64), ; # [5856] min i64 115775186, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_min to i8*), i32 2) to i64), ; # [5872] atom i64 29376333330, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_atom to i8*), i32 2) to i64), ; # [5888] pair i64 30712141570, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_pair to i8*), i32 2) to i64), ; # [5904] circ? i64 4356022113842, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_circQ to i8*), i32 2) to i64), ; # [5920] lst? i64 17033541314, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_lstQ to i8*), i32 2) to i64), ; # [5936] num? i64 17026209506, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_numQ to i8*), i32 2) to i64), ; # [5952] sym? i64 17026225970, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_symQ to i8*), i32 2) to i64), ; # [5968] flg? i64 17019881058, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_flgQ to i8*), i32 2) to i64), ; # [5984] member i64 2012476297598674, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_member to i8*), i32 2) to i64), ; # [6000] memq i64 30447916754, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_memq to i8*), i32 2) to i64), ; # [6016] mmeq i64 30439560914, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_mmeq to i8*), i32 2) to i64), ; # [6032] sect i64 31242737458, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_sect to i8*), i32 2) to i64), ; # [6048] diff i64 27487802946, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_diff to i8*), i32 2) to i64), ; # [6064] index i64 8273554499218, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_index to i8*), i32 2) to i64), ; # [6080] offset i64 2047665225754354, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_offset to i8*), i32 2) to i64), ; # [6096] prior i64 7863927252738, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_prior to i8*), i32 2) to i64), ; # [6112] length i64 1837586572531394, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_length to i8*), i32 2) to i64), ; # [6128] size i64 27240339250, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_size to i8*), i32 2) to i64), ; # [6144] bytes i64 7929973937698, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_bytes to i8*), i32 2) to i64), ; # [6160] assoc i64 6833145591314, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_assoc to i8*), i32 2) to i64), ; # [6176] rassoc i64 1749285271377698, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rassoc to i8*), i32 2) to i64), ; # [6192] asoq i64 30450071058, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_asoq to i8*), i32 2) to i64), ; # [6208] rasoq i64 7795218192162, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rasoq to i8*), i32 2) to i64), ; # [6224] rank i64 28838336290, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rank to i8*), i32 2) to i64), ; # [6240] match i64 7173522724562, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_match to i8*), i32 2) to i64), ; # [6256] fill i64 29104707170, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_fill to i8*), i32 2) to i64), ; # [6272] prove i64 6972459394818, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_prove to i8*), i32 2) to i64), ; # [6288] -> i64 254674, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_arrow to i8*), i32 2) to i64), ; # [6304] unify i64 8342547654482, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_unify to i8*), i32 2) to i64), ; # [6320] group i64 7728105203314, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_group to i8*), i32 2) to i64), ; # [6336] sort i64 31258507058, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_sort to i8*), i32 2) to i64), ; # [6352] tty i64 127354690, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_tty to i8*), i32 2) to i64), ; # [6368] raw i64 125179682, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_raw to i8*), i32 2) to i64), ; # [6384] alarm i64 7521126762002, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_alarm to i8*), i32 2) to i64), ; # [6400] sigio i64 7656156075826, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_sigio to i8*), i32 2) to i64), ; # [6416] kids i64 30975366834, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_kids to i8*), i32 2) to i64), ; # [6432] protect i64 524166155115898626, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_protect to i8*), i32 2) to i64), ; # [6448] heap i64 30166898306, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_heap to i8*), i32 2) to i64), ; # [6464] stack i64 7379661309746, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_stack to i8*), i32 2) to i64), ; # [6480] byte i64 27234113058, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_byte to i8*), i32 2) to i64), ; # [6496] env i64 124184146, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_env to i8*), i32 2) to i64), ; # [6512] date i64 27234014786, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_date to i8*), i32 2) to i64), ; # [6528] time i64 27226707778, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_time to i8*), i32 2) to i64), ; # [6544] usec i64 26681489234, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_usec to i8*), i32 2) to i64), ; # [6560] quit i64 31249094418, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_quit to i8*), i32 2) to i64), ; # [6576] sys i64 121083698, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_sys to i8*), i32 2) to i64), ; # [6592] pwd i64 105346818, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_pwd to i8*), i32 2) to i64), ; # [6608] cd i64 411186, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cd to i8*), i32 2) to i64), ; # [6624] ctty i64 32602801714, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_ctty to i8*), i32 2) to i64), ; # [6640] cmd i64 105305650, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_cmd to i8*), i32 2) to i64), ; # [6656] dir i64 119969346, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_dir to i8*), i32 2) to i64), ; # [6672] info i64 29903742610, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_info to i8*), i32 2) to i64), ; # [6688] file i64 27225658978, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_file to i8*), i32 2) to i64), ; # [6704] argv i64 31783855634, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_argv to i8*), i32 2) to i64), ; # [6720] opt i64 122095346, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_opt to i8*), i32 2) to i64), ; # [6736] errno i64 7657509824082, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_errno to i8*), i32 2) to i64), ; # [6752] %@ i64 262738, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_nat to i8*), i32 2) to i64), ; # [6768] native i64 1784947996497634, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_native to i8*), i32 2) to i64), ; # [6784] struct i64 2047528336312114, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_struct to i8*), i32 2) to i64), ; # [6800] lisp i64 30185789122, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_lisp to i8*), i32 2) to i64), ; # [6816] args i64 30978549266, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_args to i8*), i32 2) to i64), ; # [6832] next i64 31264757474, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_next to i8*), i32 2) to i64), ; # [6848] arg i64 108471826, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_arg to i8*), i32 2) to i64), ; # [6864] rest i64 31259514658, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_rest to i8*), i32 2) to i64), ; # [6880] adr i64 119948818, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_adr to i8*), i32 2) to i64), ; # [6896] trail i64 7449991391042, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_trail to i8*), i32 2) to i64), ; # [6912] up i64 460626, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_up to i8*), i32 2) to i64), ; # [6928] history i64 546948723242342018, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_history to i8*), i32 2) to i64), ; # [6944] version i64 497355938196772706, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast (i64(i64)* @_version to i8*), i32 2) to i64) ], align 16 @gcData = global [52 x i64] [ i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 [17 x i64] [ 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 (i64* null to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 96) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 0, i64 0, i64 0, i64 0, i64 sext (i32 0 to i64), i64 sext (i32 0 to i64) ], align 8 @$Cell = global [2 x i64] [ i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) ] @$Version = global [3 x i64] [ i64 338, i64 194, i64 434 ], 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 @$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 @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 i8* @readline(i8*) 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 i32 @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 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 @sigUnblock(i32) declare void @iSignal(i32, i8*) 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, 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 @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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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** @$OutFile ; # (i8** $Put) %3 = bitcast void(i8)** @$Put 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** @$OutFile ; # (fun (void i8) _putStdout) store void(i8)* @_putStdout, void(i8)** @$Put ; # (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)** @$Put to i8** store i8* %4, i8** %9 store i8* %2, i8** @$OutFile ret i64 %1 } define void @stop(i8*) align 8 { $1: ; # ((coroutine Crt) tag 0) %1 = ptrtoint i8* %0 to i64 %2 = inttoptr i64 %1 to i64* store i64 0, i64* %2 ; # (while ((coroutine Crt) nxt) (setq Crt @)) br label %$2 $2: %3 = phi i8* [%0, %$1], [%6, %$3] ; # Crt ; # ((coroutine Crt) nxt) %4 = getelementptr i8, i8* %3, i32 16 %5 = bitcast i8* %4 to i8** %6 = load i8*, i8** %5 %7 = icmp ne i8* %6, null br i1 %7, label %$3, label %$4 $3: %8 = phi i8* [%3, %$2] ; # Crt br label %$2 $4: %9 = phi i8* [%3, %$2] ; # Crt ; # (until ((coroutine Crt) tag) (setq Crt ((coroutine Crt) prv)) ((c... br label %$5 $5: %10 = phi i8* [%9, %$4], [%18, %$6] ; # Crt ; # ((coroutine Crt) tag) %11 = ptrtoint i8* %10 to i64 %12 = inttoptr i64 %11 to i64* %13 = load i64, i64* %12 %14 = icmp ne i64 %13, 0 br i1 %14, label %$7, label %$6 $6: %15 = phi i8* [%10, %$5] ; # Crt ; # ((coroutine Crt) prv) %16 = getelementptr i8, i8* %15, i32 8 %17 = bitcast i8* %16 to i8** %18 = load i8*, i8** %17 ; # ((coroutine Crt) nxt null) %19 = getelementptr i8, i8* %18, i32 16 %20 = bitcast i8* %19 to i8** store i8* null, i8** %20 br label %$5 $7: %21 = phi i8* [%10, %$5] ; # Crt 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 ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (val $Bind) %2 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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], [%156, %$36] ; # Ca %5 = phi i64 [%3, %$1], [%154, %$36] ; # 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 32 %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 ; # (until (== (val $CtlFrames) (Ca: (env $CtlFrames i8*))) (popCtlFi... br label %$10 $10: %36 = phi i8* [%34, %$9], [%44, %$11] ; # Ca %37 = phi i64 [%35, %$9], [%45, %$11] ; # Bnd ; # (val $CtlFrames) %38 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 56) to i8**) ; # (Ca: (env $CtlFrames i8*)) %39 = getelementptr i8, i8* %7, i32 32 %40 = getelementptr i8, i8* %39, i32 56 %41 = bitcast i8* %40 to i8** %42 = load i8*, i8** %41 ; # (== (val $CtlFrames) (Ca: (env $CtlFrames i8*))) %43 = icmp eq i8* %38, %42 br i1 %43, label %$12, label %$11 $11: %44 = phi i8* [%36, %$10] ; # Ca %45 = phi i64 [%37, %$10] ; # Bnd ; # (popCtlFiles) call void @popCtlFiles() br label %$10 $12: %46 = phi i8* [%36, %$10] ; # Ca %47 = phi i64 [%37, %$10] ; # Bnd ; # (until (== (val $ErrFrames) (Ca: (env $ErrFrames i8*))) (popErrFi... br label %$13 $13: %48 = phi i8* [%46, %$12], [%56, %$14] ; # Ca %49 = phi i64 [%47, %$12], [%57, %$14] ; # Bnd ; # (val $ErrFrames) %50 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 48) to i8**) ; # (Ca: (env $ErrFrames i8*)) %51 = getelementptr i8, i8* %7, i32 32 %52 = getelementptr i8, i8* %51, i32 48 %53 = bitcast i8* %52 to i8** %54 = load i8*, i8** %53 ; # (== (val $ErrFrames) (Ca: (env $ErrFrames i8*))) %55 = icmp eq i8* %50, %54 br i1 %55, label %$15, label %$14 $14: %56 = phi i8* [%48, %$13] ; # Ca %57 = phi i64 [%49, %$13] ; # Bnd ; # (popErrFiles) call void @popErrFiles() br label %$13 $15: %58 = phi i8* [%48, %$13] ; # Ca %59 = phi i64 [%49, %$13] ; # Bnd ; # (unless (== (val $OutFrames) (Ca: (env $OutFrames i8*))) (loop (p... ; # (val $OutFrames) %60 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (Ca: (env $OutFrames i8*)) %61 = getelementptr i8, i8* %7, i32 32 %62 = getelementptr i8, i8* %61, i32 40 %63 = bitcast i8* %62 to i8** %64 = load i8*, i8** %63 ; # (== (val $OutFrames) (Ca: (env $OutFrames i8*))) %65 = icmp eq i8* %60, %64 br i1 %65, label %$17, label %$16 $16: %66 = phi i8* [%58, %$15] ; # Ca %67 = phi i64 [%59, %$15] ; # Bnd ; # (loop (popOutFiles) (? (== (val $OutFrames) (Ca: (env $OutFrames ... br label %$18 $18: %68 = phi i8* [%66, %$16], [%76, %$19] ; # Ca %69 = phi i64 [%67, %$16], [%77, %$19] ; # Bnd ; # (popOutFiles) call void @popOutFiles() ; # (? (== (val $OutFrames) (Ca: (env $OutFrames i8*)))) ; # (val $OutFrames) %70 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (Ca: (env $OutFrames i8*)) %71 = getelementptr i8, i8* %7, i32 32 %72 = getelementptr i8, i8* %71, i32 40 %73 = bitcast i8* %72 to i8** %74 = load i8*, i8** %73 ; # (== (val $OutFrames) (Ca: (env $OutFrames i8*))) %75 = icmp eq i8* %70, %74 br i1 %75, label %$20, label %$19 $19: %76 = phi i8* [%68, %$18] ; # Ca %77 = phi i64 [%69, %$18] ; # Bnd br label %$18 $20: %78 = phi i8* [%68, %$18] ; # Ca %79 = phi i64 [%69, %$18] ; # Bnd %80 = phi i64 [0, %$18] ; # -> ; # (tosOutFile) call void @tosOutFile() br label %$17 $17: %81 = phi i8* [%58, %$15], [%78, %$20] ; # Ca %82 = phi i64 [%59, %$15], [%79, %$20] ; # Bnd ; # (unless (== (val $InFrames) (Ca: (env $InFrames i8*))) (loop (pop... ; # (val $InFrames) %83 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (Ca: (env $InFrames i8*)) %84 = getelementptr i8, i8* %7, i32 32 %85 = getelementptr i8, i8* %84, i32 32 %86 = bitcast i8* %85 to i8** %87 = load i8*, i8** %86 ; # (== (val $InFrames) (Ca: (env $InFrames i8*))) %88 = icmp eq i8* %83, %87 br i1 %88, label %$22, label %$21 $21: %89 = phi i8* [%81, %$17] ; # Ca %90 = phi i64 [%82, %$17] ; # Bnd ; # (loop (popInFiles) (? (== (val $InFrames) (Ca: (env $InFrames i8*... br label %$23 $23: %91 = phi i8* [%89, %$21], [%99, %$24] ; # Ca %92 = phi i64 [%90, %$21], [%100, %$24] ; # Bnd ; # (popInFiles) call void @popInFiles() ; # (? (== (val $InFrames) (Ca: (env $InFrames i8*)))) ; # (val $InFrames) %93 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (Ca: (env $InFrames i8*)) %94 = getelementptr i8, i8* %7, i32 32 %95 = getelementptr i8, i8* %94, i32 32 %96 = bitcast i8* %95 to i8** %97 = load i8*, i8** %96 ; # (== (val $InFrames) (Ca: (env $InFrames i8*))) %98 = icmp eq i8* %93, %97 br i1 %98, label %$25, label %$24 $24: %99 = phi i8* [%91, %$23] ; # Ca %100 = phi i64 [%92, %$23] ; # Bnd br label %$23 $25: %101 = phi i8* [%91, %$23] ; # Ca %102 = phi i64 [%92, %$23] ; # Bnd %103 = phi i64 [0, %$23] ; # -> ; # (tosInFile) call void @tosInFile() br label %$22 $22: %104 = phi i8* [%81, %$17], [%101, %$25] ; # Ca %105 = phi i64 [%82, %$17], [%102, %$25] ; # Bnd ; # (let (Src (val $Current) Dst (Ca: co)) (unless Dst (setq Dst (val... ; # (val $Current) %106 = load i8*, i8** @$Current ; # (Ca: co) %107 = getelementptr i8, i8* %7, i32 24 %108 = bitcast i8* %107 to i8** %109 = load i8*, i8** %108 ; # (unless Dst (setq Dst (val $Coroutines))) %110 = icmp ne i8* %109, null br i1 %110, label %$27, label %$26 $26: %111 = phi i8* [%104, %$22] ; # Ca %112 = phi i64 [%105, %$22] ; # Bnd %113 = phi i8* [%109, %$22] ; # Dst ; # (val $Coroutines) %114 = load i8*, i8** @$Coroutines br label %$27 $27: %115 = phi i8* [%104, %$22], [%111, %$26] ; # Ca %116 = phi i64 [%105, %$22], [%112, %$26] ; # Bnd %117 = phi i8* [%109, %$22], [%114, %$26] ; # Dst ; # (unless (== Src Dst) (stop Src) (let Crt: (coroutine (set $Curren... ; # (== Src Dst) %118 = icmp eq i8* %106, %117 br i1 %118, label %$29, label %$28 $28: %119 = phi i8* [%115, %$27] ; # Ca %120 = phi i64 [%116, %$27] ; # Bnd %121 = phi i8* [%117, %$27] ; # Dst ; # (stop Src) call void @stop(i8* %106) ; # (let Crt: (coroutine (set $Current Dst)) (set $StkLimit (+ (Crt: ... ; # (set $Current Dst) store i8* %121, i8** @$Current ; # (set $StkLimit (+ (Crt: lim) 4096)) ; # (Crt: lim) %122 = getelementptr i8, i8* %121, i32 40 %123 = bitcast i8* %122 to i8** %124 = load i8*, i8** %123 ; # (+ (Crt: lim) 4096) %125 = getelementptr i8, i8* %124, i32 4096 store i8* %125, i8** @$StkLimit ; # (set $At (Crt: at)) ; # (Crt: at) %126 = getelementptr i8, i8* %121, i32 48 %127 = ptrtoint i8* %126 to i64 %128 = inttoptr i64 %127 to i64* %129 = load i64, i64* %128 %130 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 %129, i64* %130 br label %$29 $29: %131 = phi i8* [%115, %$27], [%119, %$28] ; # Ca %132 = phi i64 [%116, %$27], [%120, %$28] ; # Bnd %133 = phi i8* [%117, %$27], [%121, %$28] ; # Dst ; # (i8* $Link) %134 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i8* ; # (Ca: (env)) %135 = getelementptr i8, i8* %7, i32 32 ; # (memcpy (env) (Ca: (env)) (env T) T) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %134, i8* %135, i64 136, i1 0) ; # (Ca: fin) %136 = getelementptr i8, i8* %7, i32 16 %137 = ptrtoint i8* %136 to i64 %138 = inttoptr i64 %137 to i64* %139 = load i64, i64* %138 ; # (eval (Ca: fin)) %140 = and i64 %139, 6 %141 = icmp ne i64 %140, 0 br i1 %141, label %$32, label %$31 $32: br label %$30 $31: %142 = and i64 %139, 8 %143 = icmp ne i64 %142, 0 br i1 %143, label %$34, label %$33 $34: %144 = inttoptr i64 %139 to i64* %145 = load i64, i64* %144 br label %$30 $33: %146 = call i64 @evList(i64 %139) br label %$30 $30: %147 = phi i64 [%139, %$32], [%145, %$34], [%146, %$33] ; # -> ; # (set $Catch (Ca: link)) ; # (Ca: link) %148 = bitcast i8* %7 to i8** %149 = load i8*, i8** %148 store i8* %149, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (when (== Ca Catch) (ret)) ; # (== Ca Catch) %150 = icmp eq i8* %131, %0 br i1 %150, label %$35, label %$36 $35: %151 = phi i8* [%131, %$30] ; # Ca %152 = phi i64 [%132, %$30] ; # Bnd ; # (ret) ret void $36: %153 = phi i8* [%131, %$30] ; # Ca %154 = phi i64 [%132, %$30] ; # Bnd ; # (Ca: link) %155 = bitcast i8* %7 to i8** %156 = load i8*, i8** %155 br label %$2 $4: %157 = phi i8* [%4, %$2] ; # Ca %158 = phi i64 [%5, %$2] ; # Bnd ; # (while Bnd (set (val 2 Bnd) (val Bnd)) (setq Bnd (val 3 Bnd))) br label %$37 $37: %159 = phi i8* [%157, %$4], [%162, %$38] ; # Ca %160 = phi i64 [%158, %$4], [%172, %$38] ; # Bnd %161 = icmp ne i64 %160, 0 br i1 %161, label %$38, label %$39 $38: %162 = phi i8* [%159, %$37] ; # Ca %163 = phi i64 [%160, %$37] ; # Bnd ; # (set (val 2 Bnd) (val Bnd)) ; # (val 2 Bnd) %164 = inttoptr i64 %163 to i64* %165 = getelementptr i64, i64* %164, i32 1 %166 = load i64, i64* %165 ; # (val Bnd) %167 = inttoptr i64 %163 to i64* %168 = load i64, i64* %167 %169 = inttoptr i64 %166 to i64* store i64 %168, i64* %169 ; # (val 3 Bnd) %170 = inttoptr i64 %163 to i64* %171 = getelementptr i64, i64* %170, i32 2 %172 = load i64, i64* %171 br label %$37 $39: %173 = phi i8* [%159, %$37] ; # Ca %174 = phi i64 [%160, %$37] ; # Bnd ; # (set $Bind 0) %175 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 0, i64* %175 ; # (while (val $CtlFrames) (popCtlFiles)) br label %$40 $40: %176 = phi i8* [%173, %$39], [%180, %$41] ; # Ca %177 = phi i64 [%174, %$39], [%181, %$41] ; # Bnd ; # (val $CtlFrames) %178 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 56) to i8**) %179 = icmp ne i8* %178, null br i1 %179, label %$41, label %$42 $41: %180 = phi i8* [%176, %$40] ; # Ca %181 = phi i64 [%177, %$40] ; # Bnd ; # (popCtlFiles) call void @popCtlFiles() br label %$40 $42: %182 = phi i8* [%176, %$40] ; # Ca %183 = phi i64 [%177, %$40] ; # Bnd ; # (while (val $ErrFrames) (popErrFiles)) br label %$43 $43: %184 = phi i8* [%182, %$42], [%188, %$44] ; # Ca %185 = phi i64 [%183, %$42], [%189, %$44] ; # Bnd ; # (val $ErrFrames) %186 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 48) to i8**) %187 = icmp ne i8* %186, null br i1 %187, label %$44, label %$45 $44: %188 = phi i8* [%184, %$43] ; # Ca %189 = phi i64 [%185, %$43] ; # Bnd ; # (popErrFiles) call void @popErrFiles() br label %$43 $45: %190 = phi i8* [%184, %$43] ; # Ca %191 = phi i64 [%185, %$43] ; # Bnd ; # (unless (== (val $OutFrames) (val $Stdout)) (loop (popOutFiles) (... ; # (val $OutFrames) %192 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (val $Stdout) %193 = load i8*, i8** @$Stdout ; # (== (val $OutFrames) (val $Stdout)) %194 = icmp eq i8* %192, %193 br i1 %194, label %$47, label %$46 $46: %195 = phi i8* [%190, %$45] ; # Ca %196 = phi i64 [%191, %$45] ; # Bnd ; # (loop (popOutFiles) (? (== (val $OutFrames) (val $Stdout)))) br label %$48 $48: %197 = phi i8* [%195, %$46], [%202, %$49] ; # Ca %198 = phi i64 [%196, %$46], [%203, %$49] ; # Bnd ; # (popOutFiles) call void @popOutFiles() ; # (? (== (val $OutFrames) (val $Stdout))) ; # (val $OutFrames) %199 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (val $Stdout) %200 = load i8*, i8** @$Stdout ; # (== (val $OutFrames) (val $Stdout)) %201 = icmp eq i8* %199, %200 br i1 %201, label %$50, label %$49 $49: %202 = phi i8* [%197, %$48] ; # Ca %203 = phi i64 [%198, %$48] ; # Bnd br label %$48 $50: %204 = phi i8* [%197, %$48] ; # Ca %205 = phi i64 [%198, %$48] ; # Bnd %206 = phi i64 [0, %$48] ; # -> ; # (tosOutFile) call void @tosOutFile() br label %$47 $47: %207 = phi i8* [%190, %$45], [%204, %$50] ; # Ca %208 = phi i64 [%191, %$45], [%205, %$50] ; # Bnd ; # (unless (== (val $InFrames) (val $Stdin)) (loop (popInFiles) (? (... ; # (val $InFrames) %209 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (val $Stdin) %210 = load i8*, i8** @$Stdin ; # (== (val $InFrames) (val $Stdin)) %211 = icmp eq i8* %209, %210 br i1 %211, label %$52, label %$51 $51: %212 = phi i8* [%207, %$47] ; # Ca %213 = phi i64 [%208, %$47] ; # Bnd ; # (loop (popInFiles) (? (== (val $InFrames) (val $Stdin)))) br label %$53 $53: %214 = phi i8* [%212, %$51], [%219, %$54] ; # Ca %215 = phi i64 [%213, %$51], [%220, %$54] ; # Bnd ; # (popInFiles) call void @popInFiles() ; # (? (== (val $InFrames) (val $Stdin))) ; # (val $InFrames) %216 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (val $Stdin) %217 = load i8*, i8** @$Stdin ; # (== (val $InFrames) (val $Stdin)) %218 = icmp eq i8* %216, %217 br i1 %218, label %$55, label %$54 $54: %219 = phi i8* [%214, %$53] ; # Ca %220 = phi i64 [%215, %$53] ; # Bnd br label %$53 $55: %221 = phi i8* [%214, %$53] ; # Ca %222 = phi i64 [%215, %$53] ; # Bnd %223 = phi i64 [0, %$53] ; # -> ; # (tosInFile) call void @tosInFile() br label %$52 $52: %224 = phi i8* [%207, %$47], [%221, %$55] ; # Ca %225 = phi i64 [%208, %$47], [%222, %$55] ; # Bnd ret void } define void @finish(i32) align 8 { $1: ; # (setCooked) call void @setCooked() ; # (exit N) call void @exit(i32 %0) unreachable } define void @giveup(i8*, i8*) align 8 { $1: ; # (stderrMsg Fmt Msg) %2 = call i8* @stderrMsg(i8* %0, i8* %1) ; # (finish 1) call void @finish(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 ([870 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: ; # (flushAll) call void @flushAll() ; # (finish N) call void @finish(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]* @$2 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") null)) ; # (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") null) call void @giveup(i8* bitcast ([10 x i8]* @$3 to i8*), i8* null) 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 ([17 x i64]* @env to i8*), i32 120) 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 ([17 x i64]* @env to i8*), i32 120) 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 ([52 x i64]* @gcData to i8*), i32 24) 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 ([870 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 ([870 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 ([52 x i64]* @gcData to i8*), i32 16) 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 28 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 ([17 x i64]* @env to i8*), i32 120) 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # -> %6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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) %17 = call i32 @gPrintf(i8* %16, i32 240, i8* %2, i8* %3) ; # (when (val Msg) (set $Msg (mkStr Msg)) (let Ca (val $Catch) (whil... ; # (val Msg) %18 = load i8, i8* %16 %19 = icmp ne i8 %18, 0 br i1 %19, label %$7, label %$8 $7: ; # (set $Msg (mkStr Msg)) ; # (mkStr Msg) %20 = call i64 @mkStr(i8* %16) %21 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 760) to i64) to i64* store i64 %20, i64* %21 ; # (let Ca (val $Catch) (while Ca (let Ca: (caFrame Ca) (let Tag (Ca... ; # (val $Catch) %22 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (while Ca (let Ca: (caFrame Ca) (let Tag (Ca: tag) (when Tag (whi... br label %$9 $9: %23 = phi i8* [%22, %$7], [%69, %$13] ; # Ca %24 = icmp ne i8* %23, null br i1 %24, label %$10, label %$11 $10: %25 = phi i8* [%23, %$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) %26 = getelementptr i8, i8* %25, i32 8 %27 = ptrtoint i8* %26 to i64 %28 = inttoptr i64 %27 to i64* %29 = load i64, i64* %28 ; # (when Tag (while (pair Tag) (when (subStr (car Tag) (val $Msg)) (... %30 = icmp ne i64 %29, 0 br i1 %30, label %$12, label %$13 $12: %31 = phi i8* [%25, %$10] ; # Ca %32 = phi i64 [%29, %$10] ; # Tag ; # (while (pair Tag) (when (subStr (car Tag) (val $Msg)) (unwind (Ca... br label %$14 $14: %33 = phi i8* [%31, %$12], [%59, %$18] ; # Ca %34 = phi i64 [%32, %$12], [%63, %$18] ; # Tag ; # (pair Tag) %35 = and i64 %34, 15 %36 = icmp eq i64 %35, 0 br i1 %36, label %$15, label %$16 $15: %37 = phi i8* [%33, %$14] ; # Ca %38 = phi i64 [%34, %$14] ; # Tag ; # (when (subStr (car Tag) (val $Msg)) (unwind (Ca:)) (set $Ret (if ... ; # (car Tag) %39 = inttoptr i64 %38 to i64* %40 = load i64, i64* %39 ; # (val $Msg) %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 760) to i64) to i64* %42 = load i64, i64* %41 ; # (subStr (car Tag) (val $Msg)) %43 = call i1 @subStr(i64 %40, i64 %42) br i1 %43, label %$17, label %$18 $17: %44 = phi i8* [%37, %$15] ; # Ca %45 = phi i64 [%38, %$15] ; # Tag ; # (Ca:) ; # (unwind (Ca:)) call void @unwind(i8* %25) ; # (set $Ret (if (nil? (car Tag)) (val $Msg) @)) ; # (if (nil? (car Tag)) (val $Msg) @) ; # (car Tag) %46 = inttoptr i64 %45 to i64* %47 = load i64, i64* %46 ; # (nil? (car Tag)) %48 = icmp eq i64 %47, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %48, label %$19, label %$20 $19: %49 = phi i8* [%44, %$17] ; # Ca %50 = phi i64 [%45, %$17] ; # Tag ; # (val $Msg) %51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 760) to i64) to i64* %52 = load i64, i64* %51 br label %$21 $20: %53 = phi i8* [%44, %$17] ; # Ca %54 = phi i64 [%45, %$17] ; # Tag br label %$21 $21: %55 = phi i8* [%49, %$19], [%53, %$20] ; # Ca %56 = phi i64 [%50, %$19], [%54, %$20] ; # Tag %57 = phi i64 [%52, %$19], [%47, %$20] ; # -> store i64 %57, i64* @$Ret ; # (Ca: (rst)) %58 = getelementptr i8, i8* %25, i32 168 ; # (longjmp (Ca: (rst)) 1) call void @longjmp(i8* %58, i32 1) unreachable $18: %59 = phi i8* [%37, %$15] ; # Ca %60 = phi i64 [%38, %$15] ; # Tag ; # (shift Tag) %61 = inttoptr i64 %60 to i64* %62 = getelementptr i64, i64* %61, i32 1 %63 = load i64, i64* %62 br label %$14 $16: %64 = phi i8* [%33, %$14] ; # Ca %65 = phi i64 [%34, %$14] ; # Tag br label %$13 $13: %66 = phi i8* [%25, %$10], [%64, %$16] ; # Ca %67 = phi i64 [%29, %$10], [%65, %$16] ; # Tag ; # (Ca: link) %68 = bitcast i8* %25 to i8** %69 = load i8*, i8** %68 br label %$9 $11: %70 = phi i8* [%23, %$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* @$Chr ; # (set $Break 0) %71 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 16) to i64) to i64* store i64 0, i64* %71 ; # (set $LinePtr null) store i8* null, i8** @$LinePtr ; # (set $Alarm (set $Sigio $Nil)) ; # (set $Sigio $Nil) %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 24) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %72 %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 16) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %73 ; # (b8 (ioFrame T)) %74 = alloca i8, i64 28 ; # (val $OutFiles) %75 = load i8**, i8*** @$OutFiles ; # (val 3 (val $OutFiles)) %76 = getelementptr i8*, i8** %75, i32 2 %77 = load i8*, i8** %76 ; # (pushOutFile (b8 (ioFrame T)) (val 3 (val $OutFiles)) 0) call void @pushOutFile(i8* %74, i8* %77, i32 0) ; # (let In: (inFile (val $InFile)) (when (and (In:) (In: name)) (cal... ; # (val $InFile) %78 = load i8*, i8** @$InFile ; # (when (and (In:) (In: name)) (call $Put (char "[")) (outString (I... ; # (and (In:) (In: name)) ; # (In:) %79 = icmp ne i8* %78, null br i1 %79, label %$23, label %$22 $23: ; # (In: name) %80 = bitcast i8* %78 to i8** %81 = load i8*, i8** %80 %82 = icmp ne i8* %81, null br label %$22 $22: %83 = phi i1 [0, %$8], [%82, %$23] ; # -> br i1 %83, label %$24, label %$25 $24: ; # (call $Put (char "[")) %84 = load void(i8)*, void(i8)** @$Put call void %84(i8 91) ; # (In: name) %85 = bitcast i8* %78 to i8** %86 = load i8*, i8** %85 ; # (outString (In: name)) call void @outString(i8* %86) ; # (call $Put (char ":")) %87 = load void(i8)*, void(i8)** @$Put call void %87(i8 58) ; # (In: src) %88 = getelementptr i8, i8* %78, i32 20 %89 = bitcast i8* %88 to i32* %90 = load i32, i32* %89 ; # (i64 (In: src)) %91 = sext i32 %90 to i64 ; # (outWord (i64 (In: src))) call void @outWord(i64 %91) ; # (call $Put (char "]")) %92 = load void(i8)*, void(i8)** @$Put call void %92(i8 93) ; # (space) call void @space() br label %$25 $25: ; # (when Exe (outString ($ "!? ")) (print Exe) (newline)) %93 = icmp ne i64 %0, 0 br i1 %93, label %$26, label %$27 $26: ; # (outString ($ "!? ")) call void @outString(i8* bitcast ([4 x i8]* @$4 to i8*)) ; # (print Exe) call void @print(i64 %0) ; # (newline) call void @newline() br label %$27 $27: ; # (when X (print X) (outString ($ " -- "))) %94 = icmp ne i64 %1, 0 br i1 %94, label %$28, label %$29 $28: ; # (print X) call void @print(i64 %1) ; # (outString ($ " -- ")) call void @outString(i8* bitcast ([5 x i8]* @$5 to i8*)) br label %$29 $29: ; # (when (val Msg) (outString Msg) (newline) (unless (or (nil? (val ... ; # (val Msg) %95 = load i8, i8* %16 %96 = icmp ne i8 %95, 0 br i1 %96, 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) %97 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 744) to i64) to i64* %98 = load i64, i64* %97 ; # (nil? (val $Err)) %99 = icmp eq i64 %98, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %99, label %$32, label %$33 $33: ; # (val $Jam) %100 = load i1, i1* @$Jam br label %$32 $32: %101 = phi i1 [1, %$30], [%100, %$33] ; # -> br i1 %101, label %$35, label %$34 $34: ; # (set $Jam YES) store i1 1, i1* @$Jam ; # (val $Err) %102 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 744) to i64) to i64* %103 = load i64, i64* %102 ; # (execAt (val $Err)) %104 = call i64 @execAt(i64 %103) ; # (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) %105 = load i8**, i8*** @$InFiles ; # (val (val $InFiles)) %106 = load i8*, i8** %105 ; # ((inFile (val (val $InFiles))) tty) %107 = getelementptr i8, i8* %106, i32 4128 %108 = bitcast i8* %107 to i1* %109 = load i1, i1* %108 br i1 %109, label %$37, label %$36 $37: ; # (val $OutFiles) %110 = load i8**, i8*** @$OutFiles ; # (val 2 (val $OutFiles)) %111 = getelementptr i8*, i8** %110, i32 1 %112 = load i8*, i8** %111 ; # ((outFile (val 2 (val $OutFiles))) tty) %113 = getelementptr i8, i8* %112, i32 4104 %114 = bitcast i8* %113 to i1* %115 = load i1, i1* %114 br label %$36 $36: %116 = phi i1 [0, %$35], [%115, %$37] ; # -> br i1 %116, label %$39, label %$38 $38: ; # (bye 1) call void @bye(i32 1) unreachable $39: ; # (repl 0 ($ "? ") $Nil) %117 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$6 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) br label %$31 $31: ; # (unwind null) call void @unwind(i8* null) ; # (unless (val $StkLimit) (set $StkLimit (val $StkBrk))) ; # (val $StkLimit) %118 = load i8*, i8** @$StkLimit %119 = icmp ne i8* %118, null br i1 %119, label %$41, label %$40 $40: ; # (set $StkLimit (val $StkBrk)) ; # (val $StkBrk) %120 = load i8*, i8** @$StkBrk store i8* %120, i8** @$StkLimit br label %$41 $41: ; # (set $Link 0 $Protect 0 $Next $Nil $Make 0 $Yoke 0 $Trace 0 $Put ... %121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 0, i64* %121 store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 120) to i32*) %122 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 80) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %122 %123 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 104) to i64) to i64* store i64 0, i64* %123 %124 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 112) to i64) to i64* store i64 0, i64* %124 store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 128) to i32*) ; # (fun (void i8) _putStdout) store void(i8)* @_putStdout, void(i8)** @$Put ; # (fun (i32) _getStdin) store i32()* @_getStdin, i32()** @$Get ; # (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 ; # (err Exe 0 ($ "Stack overflow") null) call void @err(i64 %0, i64 0, i8* bitcast ([15 x i8]* @$7 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]* @$8 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]* @$9 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]* @$10 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]* @$11 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]* @$12 to i8*), i8* null) unreachable } define void @nameErr(i64, i64) align 8 { $1: ; # (err Exe X ($ "Name expected") null) call void @err(i64 %0, i64 %1, i8* bitcast ([14 x i8]* @$13 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]* @$14 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]* @$15 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]* @$16 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]* @$17 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]* @$18 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]* @$19 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]* @$20 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]* @$21 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]* @$22 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 ([870 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 ([17 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 ([17 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 ([17 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, i64) align 8 { $1: ; # (cond ((nil? Sym) ZERO) ((sym? (val (tail Sym))) (nameErr Exe Sym... ; # (nil? Sym) %2 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %2, label %$4, label %$3 $4: br label %$2 $3: ; # (tail Sym) %3 = add i64 %1, -8 ; # (val (tail Sym)) %4 = inttoptr i64 %3 to i64* %5 = load i64, i64* %4 ; # (sym? (val (tail Sym))) %6 = and i64 %5, 8 %7 = icmp ne i64 %6, 0 br i1 %7, label %$6, label %$5 $6: ; # (nameErr Exe Sym) call void @nameErr(i64 %0, i64 %1) unreachable $5: ; # (name @) br label %$7 $7: %8 = phi i64 [%5, %$5], [%14, %$8] ; # Tail %9 = and i64 %8, 6 %10 = icmp ne i64 %9, 0 br i1 %10, label %$9, label %$8 $8: %11 = phi i64 [%8, %$7] ; # Tail %12 = inttoptr i64 %11 to i64* %13 = getelementptr i64, i64* %12, i32 1 %14 = load i64, i64* %13 br label %$7 $9: %15 = phi i64 [%8, %$7] ; # Tail br label %$2 $2: %16 = phi i64 [2, %$4], [%15, %$9] ; # -> ret i64 %16 } 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], [%71, %$12] ; # X %6 = phi i64 [%4, %$3], [%72, %$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)) (? (atom (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)) (? (atom (shift X)))) br label %$9 $9: %18 = phi i64 [%16, %$8], [%29, %$10] ; # X %19 = phi i64 [%17, %$8], [%30, %$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 ; # (? (atom (shift X))) ; # (shift X) %24 = inttoptr i64 %18 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 %$11, label %$10 $10: %29 = phi i64 [%26, %$9] ; # X %30 = phi i64 [%19, %$9] ; # Y br label %$9 $11: %31 = phi i64 [%26, %$9] ; # X %32 = phi i64 [%19, %$9] ; # Y %33 = phi i64 [0, %$9] ; # -> br label %$7 $6: %34 = phi i64 [%5, %$5] ; # X %35 = phi i64 [%13, %$5] ; # Y ; # (? (& (val Y) 1) (until (== X Y) (set X (& (val X) -2)) (shift X)... ; # (val Y) %36 = inttoptr i64 %35 to i64* %37 = load i64, i64* %36 ; # (& (val Y) 1) %38 = and i64 %37, 1 %39 = icmp ne i64 %38, 0 br i1 %39, label %$13, label %$12 $13: %40 = phi i64 [%34, %$6] ; # X %41 = phi i64 [%35, %$6] ; # Y ; # (until (== X Y) (set X (& (val X) -2)) (shift X)) br label %$14 $14: %42 = phi i64 [%40, %$13], [%53, %$15] ; # X %43 = phi i64 [%41, %$13], [%46, %$15] ; # Y ; # (== X Y) %44 = icmp eq i64 %42, %43 br i1 %44, label %$16, label %$15 $15: %45 = phi i64 [%42, %$14] ; # X %46 = phi i64 [%43, %$14] ; # Y ; # (set X (& (val X) -2)) ; # (val X) %47 = inttoptr i64 %45 to i64* %48 = load i64, i64* %47 ; # (& (val X) -2) %49 = and i64 %48, -2 %50 = inttoptr i64 %45 to i64* store i64 %49, i64* %50 ; # (shift X) %51 = inttoptr i64 %45 to i64* %52 = getelementptr i64, i64* %51, i32 1 %53 = load i64, i64* %52 br label %$14 $16: %54 = phi i64 [%42, %$14] ; # X %55 = phi i64 [%43, %$14] ; # Y ; # (loop (set X (& (val X) -2)) (? (== Y (shift X)))) br label %$17 $17: %56 = phi i64 [%54, %$16], [%66, %$18] ; # X %57 = phi i64 [%55, %$16], [%67, %$18] ; # Y ; # (set X (& (val X) -2)) ; # (val X) %58 = inttoptr i64 %56 to i64* %59 = load i64, i64* %58 ; # (& (val X) -2) %60 = and i64 %59, -2 %61 = inttoptr i64 %56 to i64* store i64 %60, i64* %61 ; # (? (== Y (shift X))) ; # (shift X) %62 = inttoptr i64 %56 to i64* %63 = getelementptr i64, i64* %62, i32 1 %64 = load i64, i64* %63 ; # (== Y (shift X)) %65 = icmp eq i64 %57, %64 br i1 %65, label %$19, label %$18 $18: %66 = phi i64 [%64, %$17] ; # X %67 = phi i64 [%57, %$17] ; # Y br label %$17 $19: %68 = phi i64 [%64, %$17] ; # X %69 = phi i64 [%57, %$17] ; # Y %70 = phi i64 [0, %$17] ; # -> br label %$7 $12: %71 = phi i64 [%34, %$6] ; # X %72 = phi i64 [%35, %$6] ; # Y br label %$5 $7: %73 = phi i64 [%31, %$11], [%68, %$19] ; # X %74 = phi i64 [%32, %$11], [%69, %$19] ; # Y %75 = phi i64 [0, %$11], [%69, %$19] ; # -> br label %$4 $4: %76 = phi i64 [%3, %$2], [%73, %$7] ; # X %77 = phi i64 [0, %$2], [%75, %$7] ; # -> ret i64 %77 } 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], [%150, %$40] ; # X %22 = phi i64 [%20, %$9], [%151, %$40] ; # 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 ([870 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 ([870 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 ([870 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 (not (sym... br label %$24 $24: %51 = phi i64 [%49, %$22], [%93, %$36] ; # X %52 = phi i64 [%50, %$22], [%94, %$36] ; # 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 ([870 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 (not (symb? (++ Y))) (nil? @) (t? @)) 0) ; # (or (not (symb? (++ Y))) (nil? @) (t? @)) ; # (++ Y) %74 = inttoptr i64 %73 to i64* %75 = load i64, i64* %74 %76 = getelementptr i64, i64* %74, i32 1 %77 = load i64, i64* %76 ; # (symb? (++ Y)) %78 = xor i64 %75, 8 %79 = and i64 %78, 14 %80 = icmp eq i64 %79, 0 ; # (not (symb? (++ Y))) %81 = icmp eq i1 %80, 0 br i1 %81, label %$33, label %$34 $34: %82 = phi i64 [%72, %$25] ; # X %83 = phi i64 [%77, %$25] ; # Y ; # (nil? @) %84 = icmp eq i64 %75, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %84, label %$33, label %$35 $35: %85 = phi i64 [%82, %$34] ; # X %86 = phi i64 [%83, %$34] ; # Y ; # (t? @) %87 = icmp eq i64 %75, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br label %$33 $33: %88 = phi i64 [%72, %$25], [%82, %$34], [%85, %$35] ; # X %89 = phi i64 [%77, %$25], [%83, %$34], [%86, %$35] ; # Y %90 = phi i1 [1, %$25], [1, %$34], [%87, %$35] ; # -> br i1 %90, label %$37, label %$36 $37: %91 = phi i64 [%88, %$33] ; # X %92 = phi i64 [%89, %$33] ; # Y br label %$26 $36: %93 = phi i64 [%88, %$33] ; # X %94 = phi i64 [%89, %$33] ; # Y br label %$24 $26: %95 = phi i64 [%69, %$32], [%91, %$37] ; # X %96 = phi i64 [%70, %$32], [%92, %$37] ; # Y %97 = phi i64 [%71, %$32], [0, %$37] ; # -> br label %$15 $15: %98 = phi i64 [%29, %$17], [%36, %$19], [%41, %$21], [%47, %$23], [%95, %$26] ; # X %99 = phi i64 [%30, %$17], [%37, %$19], [%42, %$21], [%48, %$23], [%96, %$26] ; # Y %100 = phi i64 [0, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$19], [0, %$21], [0, %$23], [%97, %$26] ; # -> br label %$13 $12: %101 = phi i64 [%21, %$11] ; # X %102 = phi i64 [%22, %$11] ; # Y ; # (let Z (++ Y) (if (pair Z) (if (num? (car Z)) (? (pair Y) 0) (? (... ; # (++ Y) %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 Z) (if (num? (car Z)) (? (pair Y) 0) (? (or (nil? (car ... ; # (pair Z) %107 = and i64 %104, 15 %108 = icmp eq i64 %107, 0 br i1 %108, label %$38, label %$39 $38: %109 = phi i64 [%101, %$12] ; # X %110 = phi i64 [%106, %$12] ; # Y ; # (if (num? (car Z)) (? (pair Y) 0) (? (or (nil? (car Z)) (t? (car ... ; # (car Z) %111 = inttoptr i64 %104 to i64* %112 = load i64, i64* %111 ; # (num? (car Z)) %113 = and i64 %112, 6 %114 = icmp ne i64 %113, 0 br i1 %114, label %$41, label %$42 $41: %115 = phi i64 [%109, %$38] ; # X %116 = phi i64 [%110, %$38] ; # Y ; # (? (pair Y) 0) ; # (pair Y) %117 = and i64 %116, 15 %118 = icmp eq i64 %117, 0 br i1 %118, label %$45, label %$44 $45: %119 = phi i64 [%115, %$41] ; # X %120 = phi i64 [%116, %$41] ; # Y br label %$13 $44: %121 = phi i64 [%115, %$41] ; # X %122 = phi i64 [%116, %$41] ; # Y br label %$43 $42: %123 = phi i64 [%109, %$38] ; # X %124 = phi i64 [%110, %$38] ; # Y ; # (? (or (nil? (car Z)) (t? (car Z))) 0) ; # (or (nil? (car Z)) (t? (car Z))) ; # (car Z) %125 = inttoptr i64 %104 to i64* %126 = load i64, i64* %125 ; # (nil? (car Z)) %127 = icmp eq i64 %126, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %127, label %$46, label %$47 $47: %128 = phi i64 [%123, %$42] ; # X %129 = phi i64 [%124, %$42] ; # Y ; # (car Z) %130 = inttoptr i64 %104 to i64* %131 = load i64, i64* %130 ; # (t? (car Z)) %132 = icmp eq i64 %131, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br label %$46 $46: %133 = phi i64 [%123, %$42], [%128, %$47] ; # X %134 = phi i64 [%124, %$42], [%129, %$47] ; # Y %135 = phi i1 [1, %$42], [%132, %$47] ; # -> br i1 %135, label %$49, label %$48 $49: %136 = phi i64 [%133, %$46] ; # X %137 = phi i64 [%134, %$46] ; # Y br label %$13 $48: %138 = phi i64 [%133, %$46] ; # X %139 = phi i64 [%134, %$46] ; # Y br label %$43 $43: %140 = phi i64 [%121, %$44], [%138, %$48] ; # X %141 = phi i64 [%122, %$44], [%139, %$48] ; # Y br label %$40 $39: %142 = phi i64 [%101, %$12] ; # X %143 = phi i64 [%106, %$12] ; # Y ; # (? (not (nil? Y)) 0) ; # (nil? Y) %144 = icmp eq i64 %143, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) ; # (not (nil? Y)) %145 = icmp eq i1 %144, 0 br i1 %145, label %$51, label %$50 $51: %146 = phi i64 [%142, %$39] ; # X %147 = phi i64 [%143, %$39] ; # Y br label %$13 $50: %148 = phi i64 [%142, %$39] ; # X %149 = phi i64 [%143, %$39] ; # Y br label %$40 $40: %150 = phi i64 [%140, %$43], [%148, %$50] ; # X %151 = phi i64 [%141, %$43], [%149, %$50] ; # Y br label %$11 $13: %152 = phi i64 [%98, %$15], [%119, %$45], [%136, %$49], [%146, %$51] ; # X %153 = phi i64 [%99, %$15], [%120, %$45], [%137, %$49], [%147, %$51] ; # Y %154 = phi i64 [%100, %$15], [0, %$45], [0, %$49], [0, %$51] ; # -> br label %$2 $2: %155 = phi i64 [%3, %$4], [%12, %$8], [%16, %$10], [%152, %$13] ; # X %156 = phi i64 [%3, %$4], [0, %$8], [0, %$10], [%154, %$13] ; # -> ret i64 %156 } define i64 @_tty(i64) align 8 { $1: ; # (let (Out (val $OutFile) Put (val (i8** $Put))) (set $OutFile (va... ; # (val $OutFile) %1 = load i8*, i8** @$OutFile ; # (i8** $Put) %2 = bitcast void(i8)** @$Put to i8** ; # (val (i8** $Put)) %3 = load i8*, i8** %2 ; # (set $OutFile (val 3 (val $OutFiles)) $Put (fun (void i8) _putStd... ; # (val $OutFiles) %4 = load i8**, i8*** @$OutFiles ; # (val 3 (val $OutFiles)) %5 = getelementptr i8*, i8** %4, i32 2 %6 = load i8*, i8** %5 store i8* %6, i8** @$OutFile ; # (fun (void i8) _putStdout) store void(i8)* @_putStdout, void(i8)** @$Put ; # (rlHide) call void @rlHide() ; # (prog1 (run (cdr Exe)) (rlShow) (set (i8** $Put) Put $OutFile Out... ; # (cdr Exe) %7 = inttoptr i64 %0 to i64* %8 = getelementptr i64, i64* %7, i32 1 %9 = load i64, i64* %8 ; # (run (cdr Exe)) 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] ; # -> ; # (rlShow) call void @rlShow() ; # (set (i8** $Put) Put $OutFile Out) ; # (i8** $Put) %36 = bitcast void(i8)** @$Put to i8** store i8* %3, i8** %36 store i8* %1, i8** @$OutFile ret i64 %35 } 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([52 x i64]* @gcData to i8*), i32 16) 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 ([52 x i64]* @gcData to i8*), i32 24) 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 ([870 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 ([17 x i64]* @env to i8*), i32 120) to i32*) ; # (- (val $Protect) 1) %33 = sub i32 %32, 1 store i32 %33, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 120) 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 ([870 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 16 %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 16 %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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 i1 @sharedLib(i64) align 8 { $1: ; # (let (Nm (xName 0 Sym) S (bufString Nm (b8 (bufSize Nm))) P (strc... ; # (xName 0 Sym) %1 = call i64 @xName(i64 0, 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]* @$23 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]* @$24 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 -ZERO) %0 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 232) to i64) to i64* store i64 10, 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 6952) 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* $Transient) %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 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 ([52 x i64]* @gcData to i8*), i32 408) 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] ; # -> ; # (val $Intern) %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %51 = load i64, i64* %50 ; # (mark (val $Intern)) call void @mark(i64 %51) ; # (let P (val $Link) (while P (mark (val P)) (shift P))) ; # (val $Link) %52 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %53 = load i64, i64* %52 ; # (while P (mark (val P)) (shift P)) br label %$14 $14: %54 = phi i64 [%53, %$13], [%61, %$15] ; # P %55 = icmp ne i64 %54, 0 br i1 %55, label %$15, label %$16 $15: %56 = phi i64 [%54, %$14] ; # P ; # (val P) %57 = inttoptr i64 %56 to i64* %58 = load i64, i64* %57 ; # (mark (val P)) call void @mark(i64 %58) ; # (shift P) %59 = inttoptr i64 %56 to i64* %60 = getelementptr i64, i64* %59, i32 1 %61 = load i64, i64* %60 br label %$14 $16: %62 = phi i64 [%54, %$14] ; # P ; # (let P (val $Bind) (while P (mark (val P)) (mark (val 2 P)) (setq... ; # (val $Bind) %63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* %64 = load i64, i64* %63 ; # (while P (mark (val P)) (mark (val 2 P)) (setq P (val 3 P))) br label %$17 $17: %65 = phi i64 [%64, %$16], [%75, %$18] ; # P %66 = icmp ne i64 %65, 0 br i1 %66, label %$18, label %$19 $18: %67 = phi i64 [%65, %$17] ; # P ; # (val P) %68 = inttoptr i64 %67 to i64* %69 = load i64, i64* %68 ; # (mark (val P)) call void @mark(i64 %69) ; # (val 2 P) %70 = inttoptr i64 %67 to i64* %71 = getelementptr i64, i64* %70, i32 1 %72 = load i64, i64* %71 ; # (mark (val 2 P)) call void @mark(i64 %72) ; # (val 3 P) %73 = inttoptr i64 %67 to i64* %74 = getelementptr i64, i64* %73, i32 2 %75 = load i64, i64* %74 br label %$17 $19: %76 = phi i64 [%65, %$17] ; # P ; # (let Ca (val $Catch) (while Ca (let Ca: (caFrame Ca) (when (Ca: t... ; # (val $Catch) %77 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (while Ca (let Ca: (caFrame Ca) (when (Ca: tag) (mark (Ca: tag)))... br label %$20 $20: %78 = phi i8* [%77, %$19], [%102, %$24] ; # Ca %79 = icmp ne i8* %78, null br i1 %79, label %$21, label %$22 $21: %80 = phi i8* [%78, %$20] ; # Ca ; # (let Ca: (caFrame Ca) (when (Ca: tag) (mark (Ca: tag))) (mark (Ca... ; # (when (Ca: tag) (mark (Ca: tag))) ; # (Ca: tag) %81 = getelementptr i8, i8* %80, i32 8 %82 = ptrtoint i8* %81 to i64 %83 = inttoptr i64 %82 to i64* %84 = load i64, i64* %83 %85 = icmp ne i64 %84, 0 br i1 %85, label %$23, label %$24 $23: %86 = phi i8* [%80, %$21] ; # Ca ; # (Ca: tag) %87 = getelementptr i8, i8* %80, i32 8 %88 = ptrtoint i8* %87 to i64 %89 = inttoptr i64 %88 to i64* %90 = load i64, i64* %89 ; # (mark (Ca: tag)) call void @mark(i64 %90) br label %$24 $24: %91 = phi i8* [%80, %$21], [%86, %$23] ; # Ca ; # (Ca: fin) %92 = getelementptr i8, i8* %80, i32 16 %93 = ptrtoint i8* %92 to i64 %94 = inttoptr i64 %93 to i64* %95 = load i64, i64* %94 ; # (mark (Ca: fin)) call void @mark(i64 %95) ; # (Ca: (env $Intern any)) %96 = getelementptr i8, i8* %80, i32 32 %97 = getelementptr i8, i8* %96, i32 72 %98 = ptrtoint i8* %97 to i64 %99 = inttoptr i64 %98 to i64* %100 = load i64, i64* %99 ; # (mark (Ca: (env $Intern any))) call void @mark(i64 %100) ; # (Ca: link) %101 = bitcast i8* %80 to i8** %102 = load i8*, i8** %101 br label %$20 $22: %103 = phi i8* [%78, %$20] ; # Ca ; # (let Crt (val $Coroutines) (while Crt (let Crt: (coroutine Crt) (... ; # (val $Coroutines) %104 = load i8*, i8** @$Coroutines ; # (while Crt (let Crt: (coroutine Crt) (when (and (Crt: tag) (Crt: ... br label %$25 $25: %105 = phi i8* [%104, %$22], [%211, %$31] ; # Crt %106 = icmp ne i8* %105, null br i1 %106, label %$26, label %$27 $26: %107 = phi i8* [%105, %$25] ; # Crt ; # (let Crt: (coroutine Crt) (when (and (Crt: tag) (Crt: at)) (mark ... ; # (when (and (Crt: tag) (Crt: at)) (mark (Crt: tag)) (mark (Crt: pr... ; # (and (Crt: tag) (Crt: at)) ; # (Crt: tag) %108 = ptrtoint i8* %107 to i64 %109 = inttoptr i64 %108 to i64* %110 = load i64, i64* %109 %111 = icmp ne i64 %110, 0 br i1 %111, label %$29, label %$28 $29: %112 = phi i8* [%107, %$26] ; # Crt ; # (Crt: at) %113 = getelementptr i8, i8* %107, i32 48 %114 = ptrtoint i8* %113 to i64 %115 = inttoptr i64 %114 to i64* %116 = load i64, i64* %115 %117 = icmp ne i64 %116, 0 br label %$28 $28: %118 = phi i8* [%107, %$26], [%112, %$29] ; # Crt %119 = phi i1 [0, %$26], [%117, %$29] ; # -> br i1 %119, label %$30, label %$31 $30: %120 = phi i8* [%118, %$28] ; # Crt ; # (Crt: tag) %121 = ptrtoint i8* %107 to i64 %122 = inttoptr i64 %121 to i64* %123 = load i64, i64* %122 ; # (mark (Crt: tag)) call void @mark(i64 %123) ; # (Crt: prg) %124 = getelementptr i8, i8* %107, i32 32 %125 = ptrtoint i8* %124 to i64 %126 = inttoptr i64 %125 to i64* %127 = load i64, i64* %126 ; # (mark (Crt: prg)) call void @mark(i64 %127) ; # (Crt: at) %128 = getelementptr i8, i8* %107, i32 48 %129 = ptrtoint i8* %128 to i64 %130 = inttoptr i64 %129 to i64* %131 = load i64, i64* %130 ; # (mark (Crt: at)) call void @mark(i64 %131) ; # (Crt: (env $Intern any)) %132 = getelementptr i8, i8* %107, i32 112 %133 = getelementptr i8, i8* %132, i32 72 %134 = ptrtoint i8* %133 to i64 %135 = inttoptr i64 %134 to i64* %136 = load i64, i64* %135 ; # (mark (Crt: (env $Intern any))) call void @mark(i64 %136) ; # (let P (Crt: (env $Link any)) (while P (mark (val P)) (shift P)))... ; # (Crt: (env $Link any)) %137 = getelementptr i8, i8* %107, i32 112 %138 = ptrtoint i8* %137 to i64 %139 = inttoptr i64 %138 to i64* %140 = load i64, i64* %139 ; # (while P (mark (val P)) (shift P)) br label %$32 $32: %141 = phi i8* [%120, %$30], [%144, %$33] ; # Crt %142 = phi i64 [%140, %$30], [%150, %$33] ; # P %143 = icmp ne i64 %142, 0 br i1 %143, label %$33, label %$34 $33: %144 = phi i8* [%141, %$32] ; # Crt %145 = phi i64 [%142, %$32] ; # P ; # (val P) %146 = inttoptr i64 %145 to i64* %147 = load i64, i64* %146 ; # (mark (val P)) call void @mark(i64 %147) ; # (shift P) %148 = inttoptr i64 %145 to i64* %149 = getelementptr i64, i64* %148, i32 1 %150 = load i64, i64* %149 br label %$32 $34: %151 = phi i8* [%141, %$32] ; # Crt %152 = phi i64 [%142, %$32] ; # P ; # (let P (Crt: (env $Bind any)) (while P (mark (val P)) (mark (val ... ; # (Crt: (env $Bind any)) %153 = getelementptr i8, i8* %107, i32 112 %154 = getelementptr i8, i8* %153, i32 8 %155 = ptrtoint i8* %154 to i64 %156 = inttoptr i64 %155 to i64* %157 = load i64, i64* %156 ; # (while P (mark (val P)) (mark (val 2 P)) (setq P (val 3 P))) br label %$35 $35: %158 = phi i8* [%151, %$34], [%161, %$36] ; # Crt %159 = phi i64 [%157, %$34], [%170, %$36] ; # P %160 = icmp ne i64 %159, 0 br i1 %160, label %$36, label %$37 $36: %161 = phi i8* [%158, %$35] ; # Crt %162 = phi i64 [%159, %$35] ; # P ; # (val P) %163 = inttoptr i64 %162 to i64* %164 = load i64, i64* %163 ; # (mark (val P)) call void @mark(i64 %164) ; # (val 2 P) %165 = inttoptr i64 %162 to i64* %166 = getelementptr i64, i64* %165, i32 1 %167 = load i64, i64* %166 ; # (mark (val 2 P)) call void @mark(i64 %167) ; # (val 3 P) %168 = inttoptr i64 %162 to i64* %169 = getelementptr i64, i64* %168, i32 2 %170 = load i64, i64* %169 br label %$35 $37: %171 = phi i8* [%158, %$35] ; # Crt %172 = phi i64 [%159, %$35] ; # P ; # (let Ca (Crt: (env $Catch i8*)) (while Ca (let Ca: (caFrame Ca) (... ; # (Crt: (env $Catch i8*)) %173 = getelementptr i8, i8* %107, i32 112 %174 = getelementptr i8, i8* %173, i32 24 %175 = bitcast i8* %174 to i8** %176 = load i8*, i8** %175 ; # (while Ca (let Ca: (caFrame Ca) (when (Ca: tag) (mark (Ca: tag)))... br label %$38 $38: %177 = phi i8* [%171, %$37], [%193, %$42] ; # Crt %178 = phi i8* [%176, %$37], [%205, %$42] ; # Ca %179 = icmp ne i8* %178, null br i1 %179, label %$39, label %$40 $39: %180 = phi i8* [%177, %$38] ; # Crt %181 = phi i8* [%178, %$38] ; # Ca ; # (let Ca: (caFrame Ca) (when (Ca: tag) (mark (Ca: tag))) (mark (Ca... ; # (when (Ca: tag) (mark (Ca: tag))) ; # (Ca: tag) %182 = getelementptr i8, i8* %181, i32 8 %183 = ptrtoint i8* %182 to i64 %184 = inttoptr i64 %183 to i64* %185 = load i64, i64* %184 %186 = icmp ne i64 %185, 0 br i1 %186, label %$41, label %$42 $41: %187 = phi i8* [%180, %$39] ; # Crt %188 = phi i8* [%181, %$39] ; # Ca ; # (Ca: tag) %189 = getelementptr i8, i8* %181, i32 8 %190 = ptrtoint i8* %189 to i64 %191 = inttoptr i64 %190 to i64* %192 = load i64, i64* %191 ; # (mark (Ca: tag)) call void @mark(i64 %192) br label %$42 $42: %193 = phi i8* [%180, %$39], [%187, %$41] ; # Crt %194 = phi i8* [%181, %$39], [%188, %$41] ; # Ca ; # (Ca: fin) %195 = getelementptr i8, i8* %181, i32 16 %196 = ptrtoint i8* %195 to i64 %197 = inttoptr i64 %196 to i64* %198 = load i64, i64* %197 ; # (mark (Ca: fin)) call void @mark(i64 %198) ; # (Ca: (env $Intern any)) %199 = getelementptr i8, i8* %181, i32 32 %200 = getelementptr i8, i8* %199, i32 72 %201 = ptrtoint i8* %200 to i64 %202 = inttoptr i64 %201 to i64* %203 = load i64, i64* %202 ; # (mark (Ca: (env $Intern any))) call void @mark(i64 %203) ; # (Ca: link) %204 = bitcast i8* %181 to i8** %205 = load i8*, i8** %204 br label %$38 $40: %206 = phi i8* [%177, %$38] ; # Crt %207 = phi i8* [%178, %$38] ; # Ca br label %$31 $31: %208 = phi i8* [%118, %$28], [%206, %$40] ; # Crt ; # (Crt: nxt) %209 = getelementptr i8, i8* %107, i32 16 %210 = bitcast i8* %209 to i8** %211 = load i8*, i8** %210 br label %$25 $27: %212 = phi i8* [%105, %$25] ; # Crt ; # (let (Tos 0 P (val $Extern)) (loop (loop (let X (any (& (cdr P) -... ; # (val $Extern) %213 = load i64, i64* @$Extern ; # (loop (loop (let X (any (& (cdr P) -2)) (set 2 P X) (let Y (any (... br label %$43 $43: %214 = phi i64 [0, %$27], [%331, %$58] ; # Tos %215 = phi i64 [%213, %$27], [%332, %$58] ; # P ; # (loop (let X (any (& (cdr P) -2)) (set 2 P X) (let Y (any (& (cdr... br label %$44 $44: %216 = phi i64 [%214, %$43], [%233, %$45] ; # Tos %217 = phi i64 [%215, %$43], [%227, %$45] ; # P ; # (let X (any (& (cdr P) -2)) (set 2 P X) (let Y (any (& (cdr X) -2... ; # (cdr P) %218 = inttoptr i64 %217 to i64* %219 = getelementptr i64, i64* %218, i32 1 %220 = load i64, i64* %219 ; # (& (cdr P) -2) %221 = and i64 %220, -2 ; # (any (& (cdr P) -2)) ; # (set 2 P X) %222 = inttoptr i64 %217 to i64* %223 = getelementptr i64, i64* %222, i32 1 store i64 %221, i64* %223 ; # (let Y (any (& (cdr X) -2)) (set 2 X Y) (? (atom Y)) (let Z P (se... ; # (cdr X) %224 = inttoptr i64 %221 to i64* %225 = getelementptr i64, i64* %224, i32 1 %226 = load i64, i64* %225 ; # (& (cdr X) -2) %227 = and i64 %226, -2 ; # (any (& (cdr X) -2)) ; # (set 2 X Y) %228 = inttoptr i64 %221 to i64* %229 = getelementptr i64, i64* %228, i32 1 store i64 %227, i64* %229 ; # (? (atom Y)) ; # (atom Y) %230 = and i64 %227, 15 %231 = icmp ne i64 %230, 0 br i1 %231, label %$46, label %$45 $45: %232 = phi i64 [%216, %$44] ; # Tos %233 = phi i64 [%217, %$44] ; # P ; # (let Z P (setq P Y) (set 2 X Tos) (setq Tos Z)) ; # (set 2 X Tos) %234 = inttoptr i64 %221 to i64* %235 = getelementptr i64, i64* %234, i32 1 store i64 %232, i64* %235 br label %$44 $46: %236 = phi i64 [%216, %$44] ; # Tos %237 = phi i64 [%217, %$44] ; # P %238 = phi i64 [0, %$44] ; # -> ; # (loop (let S (val P) (when (& (val S) 1) (let Tail (val (tail S))... br label %$47 $47: %239 = phi i64 [%236, %$46], [%328, %$64] ; # Tos %240 = phi i64 [%237, %$46], [%329, %$64] ; # P ; # (let S (val P) (when (& (val S) 1) (let Tail (val (tail S)) (unle... ; # (val P) %241 = inttoptr i64 %240 to i64* %242 = load i64, i64* %241 ; # (when (& (val S) 1) (let Tail (val (tail S)) (unless (num? Tail) ... ; # (val S) %243 = inttoptr i64 %242 to i64* %244 = load i64, i64* %243 ; # (& (val S) 1) %245 = and i64 %244, 1 %246 = icmp ne i64 %245, 0 br i1 %246, label %$48, label %$49 $48: %247 = phi i64 [%239, %$47] ; # Tos %248 = phi i64 [%240, %$47] ; # P ; # (let Tail (val (tail S)) (unless (num? Tail) (setq Tail (& Tail -... ; # (tail S) %249 = add i64 %242, -8 ; # (val (tail S)) %250 = inttoptr i64 %249 to i64* %251 = load i64, i64* %250 ; # (unless (num? Tail) (setq Tail (& Tail -10)) (until (num? (shift ... ; # (num? Tail) %252 = and i64 %251, 6 %253 = icmp ne i64 %252, 0 br i1 %253, label %$51, label %$50 $50: %254 = phi i64 [%247, %$48] ; # Tos %255 = phi i64 [%248, %$48] ; # P %256 = phi i64 [%251, %$48] ; # Tail ; # (& Tail -10) %257 = and i64 %256, -10 ; # (until (num? (shift Tail)) (setq Tail (& Tail -2))) br label %$52 $52: %258 = phi i64 [%254, %$50], [%266, %$53] ; # Tos %259 = phi i64 [%255, %$50], [%267, %$53] ; # P %260 = phi i64 [%257, %$50], [%269, %$53] ; # Tail ; # (shift Tail) %261 = inttoptr i64 %260 to i64* %262 = getelementptr i64, i64* %261, i32 1 %263 = load i64, i64* %262 ; # (num? (shift Tail)) %264 = and i64 %263, 6 %265 = icmp ne i64 %264, 0 br i1 %265, label %$54, label %$53 $53: %266 = phi i64 [%258, %$52] ; # Tos %267 = phi i64 [%259, %$52] ; # P %268 = phi i64 [%263, %$52] ; # Tail ; # (& Tail -2) %269 = and i64 %268, -2 br label %$52 $54: %270 = phi i64 [%258, %$52] ; # Tos %271 = phi i64 [%259, %$52] ; # P %272 = phi i64 [%263, %$52] ; # Tail br label %$51 $51: %273 = phi i64 [%247, %$48], [%270, %$54] ; # Tos %274 = phi i64 [%248, %$48], [%271, %$54] ; # P %275 = phi i64 [%251, %$48], [%272, %$54] ; # Tail ; # (add Tail Tail) %276 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %275, i64 %275) %277 = extractvalue {i64, i1} %276, 1 %278 = extractvalue {i64, i1} %276, 0 ; # (when @@ (mark S)) br i1 %277, label %$55, label %$56 $55: %279 = phi i64 [%273, %$51] ; # Tos %280 = phi i64 [%274, %$51] ; # P %281 = phi i64 [%275, %$51] ; # Tail ; # (mark S) call void @mark(i64 %242) br label %$56 $56: %282 = phi i64 [%273, %$51], [%279, %$55] ; # Tos %283 = phi i64 [%274, %$51], [%280, %$55] ; # P %284 = phi i64 [%275, %$51], [%281, %$55] ; # Tail br label %$49 $49: %285 = phi i64 [%239, %$47], [%282, %$56] ; # Tos %286 = phi i64 [%240, %$47], [%283, %$56] ; # P ; # (let X (cdr P) (? (pair (car X)) (let Z P (setq P @) (set X Tos) ... ; # (cdr P) %287 = inttoptr i64 %286 to i64* %288 = getelementptr i64, i64* %287, i32 1 %289 = load i64, i64* %288 ; # (? (pair (car X)) (let Z P (setq P @) (set X Tos) (setq Tos (| Z ... ; # (car X) %290 = inttoptr i64 %289 to i64* %291 = load i64, i64* %290 ; # (pair (car X)) %292 = and i64 %291, 15 %293 = icmp eq i64 %292, 0 br i1 %293, label %$59, label %$57 $59: %294 = phi i64 [%285, %$49] ; # Tos %295 = phi i64 [%286, %$49] ; # P ; # (let Z P (setq P @) (set X Tos) (setq Tos (| Z 8))) ; # (set X Tos) %296 = inttoptr i64 %289 to i64* store i64 %294, i64* %296 ; # (| Z 8) %297 = or i64 %295, 8 br label %$58 $57: %298 = phi i64 [%285, %$49] ; # Tos %299 = phi i64 [%286, %$49] ; # P ; # (loop (unless Tos (goto 1)) (? (=0 (& Tos 8)) (let (X Tos Y (cdr ... br label %$60 $60: %300 = phi i64 [%298, %$57], [%326, %$63] ; # Tos %301 = phi i64 [%299, %$57], [%321, %$63] ; # P ; # (unless Tos (goto 1)) %302 = icmp ne i64 %300, 0 br i1 %302, label %$62, label %$61 $61: %303 = phi i64 [%300, %$60] ; # Tos %304 = phi i64 [%301, %$60] ; # P ; # (goto 1) br label %$-1 $62: %305 = phi i64 [%300, %$60] ; # Tos %306 = phi i64 [%301, %$60] ; # P ; # (? (=0 (& Tos 8)) (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set ... ; # (& Tos 8) %307 = and i64 %305, 8 ; # (=0 (& Tos 8)) %308 = icmp eq i64 %307, 0 br i1 %308, label %$65, label %$63 $65: %309 = phi i64 [%305, %$62] ; # Tos %310 = phi i64 [%306, %$62] ; # P ; # (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set 2 Y P) (setq P X))... ; # (cdr X) %311 = inttoptr i64 %309 to i64* %312 = getelementptr i64, i64* %311, i32 1 %313 = load i64, i64* %312 ; # (cdr Y) %314 = inttoptr i64 %313 to i64* %315 = getelementptr i64, i64* %314, i32 1 %316 = load i64, i64* %315 ; # (set 2 Y P) %317 = inttoptr i64 %313 to i64* %318 = getelementptr i64, i64* %317, i32 1 store i64 %310, i64* %318 br label %$64 $63: %319 = phi i64 [%305, %$62] ; # Tos %320 = phi i64 [%306, %$62] ; # P ; # (& Tos -9) %321 = and i64 %319, -9 ; # (let (X Tos Y (cdr X)) (setq Tos (car Y)) (set Y P) (setq P X)) ; # (cdr X) %322 = inttoptr i64 %321 to i64* %323 = getelementptr i64, i64* %322, i32 1 %324 = load i64, i64* %323 ; # (car Y) %325 = inttoptr i64 %324 to i64* %326 = load i64, i64* %325 ; # (set Y P) %327 = inttoptr i64 %324 to i64* store i64 %320, i64* %327 br label %$60 $64: %328 = phi i64 [%316, %$65] ; # Tos %329 = phi i64 [%309, %$65] ; # P %330 = phi i64 [%309, %$65] ; # -> br label %$47 $58: %331 = phi i64 [%297, %$59] ; # Tos %332 = phi i64 [%291, %$59] ; # P %333 = phi i64 [%297, %$59] ; # -> br label %$43 $66: ; # (: 1 (set $DB $Db1) (when (& (val $Db1) 1) (set $Db1 $Nil (tail $... br label %$-1 $-1: ; # (set $DB $Db1) %334 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 232) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 408) to i64), i64* %334 ; # (when (& (val $Db1) 1) (set $Db1 $Nil (tail $Db1) DB1)) ; # (val $Db1) %335 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 408) to i64) to i64* %336 = load i64, i64* %335 ; # (& (val $Db1) 1) %337 = and i64 %336, 1 %338 = icmp ne i64 %337, 0 br i1 %338, label %$67, label %$68 $67: ; # (set $Db1 $Nil (tail $Db1) DB1) %339 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 408) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %339 ; # (tail $Db1) %340 = add i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 408) to i64), -8 %341 = inttoptr i64 %340 to i64* store i64 26, i64* %341 br label %$68 $68: ; # (let (Tos 0 P (val $Extern)) (: 2 (loop (loop (let X (cdr P) (? (... ; # (val $Extern) %342 = load i64, i64* @$Extern ; # (: 2 (loop (loop (let X (cdr P) (? (atom (cdr X))) (let Z P (setq... br label %$-2 $-2: %343 = phi i64 [0, %$68], [%414, %$80] ; # Tos %344 = phi i64 [%342, %$68], [%421, %$80] ; # P ; # (loop (loop (let X (cdr P) (? (atom (cdr X))) (let Z P (setq P @)... br label %$69 $69: %345 = phi i64 [%343, %$-2], [%549, %$89] ; # Tos %346 = phi i64 [%344, %$-2], [%550, %$89] ; # P ; # (loop (let X (cdr P) (? (atom (cdr X))) (let Z P (setq P @) (set ... br label %$70 $70: %347 = phi i64 [%345, %$69], [%358, %$71] ; # Tos %348 = phi i64 [%346, %$69], [%354, %$71] ; # P ; # (let X (cdr P) (? (atom (cdr X))) (let Z P (setq P @) (set 2 X To... ; # (cdr P) %349 = inttoptr i64 %348 to i64* %350 = getelementptr i64, i64* %349, i32 1 %351 = load i64, i64* %350 ; # (? (atom (cdr X))) ; # (cdr X) %352 = inttoptr i64 %351 to i64* %353 = getelementptr i64, i64* %352, i32 1 %354 = load i64, i64* %353 ; # (atom (cdr X)) %355 = and i64 %354, 15 %356 = icmp ne i64 %355, 0 br i1 %356, label %$72, label %$71 $71: %357 = phi i64 [%347, %$70] ; # Tos %358 = phi i64 [%348, %$70] ; # P ; # (let Z P (setq P @) (set 2 X Tos) (setq Tos Z)) ; # (set 2 X Tos) %359 = inttoptr i64 %351 to i64* %360 = getelementptr i64, i64* %359, i32 1 store i64 %357, i64* %360 br label %$70 $72: %361 = phi i64 [%347, %$70] ; # Tos %362 = phi i64 [%348, %$70] ; # P %363 = phi i64 [0, %$70] ; # -> ; # (loop (when (& (val (val P)) 1) (set $ExtCnt (- (val $ExtCnt) 1))... br label %$73 $73: %364 = phi i64 [%361, %$72], [%546, %$95] ; # Tos %365 = phi i64 [%362, %$72], [%547, %$95] ; # P ; # (when (& (val (val P)) 1) (set $ExtCnt (- (val $ExtCnt) 1)) (let ... ; # (val P) %366 = inttoptr i64 %365 to i64* %367 = load i64, i64* %366 ; # (val (val P)) %368 = inttoptr i64 %367 to i64* %369 = load i64, i64* %368 ; # (& (val (val P)) 1) %370 = and i64 %369, 1 %371 = icmp ne i64 %370, 0 br i1 %371, label %$74, label %$75 $74: %372 = phi i64 [%364, %$73] ; # Tos %373 = phi i64 [%365, %$73] ; # P ; # (set $ExtCnt (- (val $ExtCnt) 1)) ; # (val $ExtCnt) %374 = load i64, i64* @$ExtCnt ; # (- (val $ExtCnt) 1) %375 = sub i64 %374, 1 store i64 %375, i64* @$ExtCnt ; # (let X (cdr P) (when (atom X) (set 2 P (| X 1)) (setq P X) (goto ... ; # (cdr P) %376 = inttoptr i64 %373 to i64* %377 = getelementptr i64, i64* %376, i32 1 %378 = load i64, i64* %377 ; # (when (atom X) (set 2 P (| X 1)) (setq P X) (goto 4)) ; # (atom X) %379 = and i64 %378, 15 %380 = icmp ne i64 %379, 0 br i1 %380, label %$76, label %$77 $76: %381 = phi i64 [%372, %$74] ; # Tos %382 = phi i64 [%373, %$74] ; # P %383 = phi i64 [%378, %$74] ; # X ; # (set 2 P (| X 1)) ; # (| X 1) %384 = or i64 %383, 1 %385 = inttoptr i64 %382 to i64* %386 = getelementptr i64, i64* %385, i32 1 store i64 %384, i64* %386 ; # (goto 4) br label %$-4 $77: %387 = phi i64 [%372, %$74] ; # Tos %388 = phi i64 [%373, %$74] ; # P %389 = phi i64 [%378, %$74] ; # X ; # (when (atom (car X)) (set 2 P (| X 1)) (setq P (cdr X)) (set 2 X ... ; # (car X) %390 = inttoptr i64 %389 to i64* %391 = load i64, i64* %390 ; # (atom (car X)) %392 = and i64 %391, 15 %393 = icmp ne i64 %392, 0 br i1 %393, label %$78, label %$79 $78: %394 = phi i64 [%387, %$77] ; # Tos %395 = phi i64 [%388, %$77] ; # P %396 = phi i64 [%389, %$77] ; # X ; # (set 2 P (| X 1)) ; # (| X 1) %397 = or i64 %396, 1 %398 = inttoptr i64 %395 to i64* %399 = getelementptr i64, i64* %398, i32 1 store i64 %397, i64* %399 ; # (cdr X) %400 = inttoptr i64 %396 to i64* %401 = getelementptr i64, i64* %400, i32 1 %402 = load i64, i64* %401 ; # (set 2 X (| P 1)) ; # (| P 1) %403 = or i64 %402, 1 %404 = inttoptr i64 %396 to i64* %405 = getelementptr i64, i64* %404, i32 1 store i64 %403, i64* %405 ; # (goto 4) br label %$-4 $79: %406 = phi i64 [%387, %$77] ; # Tos %407 = phi i64 [%388, %$77] ; # P %408 = phi i64 [%389, %$77] ; # X ; # (when (atom (cdr X)) (set 2 P (| X 1)) (setq P (car X)) (set 2 X ... ; # (cdr X) %409 = inttoptr i64 %408 to i64* %410 = getelementptr i64, i64* %409, i32 1 %411 = load i64, i64* %410 ; # (atom (cdr X)) %412 = and i64 %411, 15 %413 = icmp ne i64 %412, 0 br i1 %413, label %$80, label %$81 $80: %414 = phi i64 [%406, %$79] ; # Tos %415 = phi i64 [%407, %$79] ; # P %416 = phi i64 [%408, %$79] ; # X ; # (set 2 P (| X 1)) ; # (| X 1) %417 = or i64 %416, 1 %418 = inttoptr i64 %415 to i64* %419 = getelementptr i64, i64* %418, i32 1 store i64 %417, i64* %419 ; # (car X) %420 = inttoptr i64 %416 to i64* %421 = load i64, i64* %420 ; # (set 2 X (| (cdr X) 1)) ; # (cdr X) %422 = inttoptr i64 %416 to i64* %423 = getelementptr i64, i64* %422, i32 1 %424 = load i64, i64* %423 ; # (| (cdr X) 1) %425 = or i64 %424, 1 %426 = inttoptr i64 %416 to i64* %427 = getelementptr i64, i64* %426, i32 1 store i64 %425, i64* %427 ; # (goto 2) br label %$-2 $81: %428 = phi i64 [%406, %$79] ; # Tos %429 = phi i64 [%407, %$79] ; # P %430 = phi i64 [%408, %$79] ; # X ; # (let Y (cdr (shift X)) (when (atom (car Y)) (set P (car X) 2 (cdr... ; # (shift X) %431 = inttoptr i64 %430 to i64* %432 = getelementptr i64, i64* %431, i32 1 %433 = load i64, i64* %432 ; # (cdr (shift X)) %434 = inttoptr i64 %433 to i64* %435 = getelementptr i64, i64* %434, i32 1 %436 = load i64, i64* %435 ; # (when (atom (car Y)) (set P (car X) 2 (cdr P) (cdr Y)) (goto 3)) ; # (car Y) %437 = inttoptr i64 %436 to i64* %438 = load i64, i64* %437 ; # (atom (car Y)) %439 = and i64 %438, 15 %440 = icmp ne i64 %439, 0 br i1 %440, label %$82, label %$83 $82: %441 = phi i64 [%428, %$81] ; # Tos %442 = phi i64 [%429, %$81] ; # P %443 = phi i64 [%433, %$81] ; # X %444 = phi i64 [%436, %$81] ; # Y ; # (set P (car X) 2 (cdr P) (cdr Y)) ; # (car X) %445 = inttoptr i64 %443 to i64* %446 = load i64, i64* %445 %447 = inttoptr i64 %442 to i64* store i64 %446, i64* %447 ; # (cdr P) %448 = inttoptr i64 %442 to i64* %449 = getelementptr i64, i64* %448, i32 1 %450 = load i64, i64* %449 ; # (cdr Y) %451 = inttoptr i64 %444 to i64* %452 = getelementptr i64, i64* %451, i32 1 %453 = load i64, i64* %452 %454 = inttoptr i64 %450 to i64* %455 = getelementptr i64, i64* %454, i32 1 store i64 %453, i64* %455 ; # (goto 3) br label %$-3 $83: %456 = phi i64 [%428, %$81] ; # Tos %457 = phi i64 [%429, %$81] ; # P %458 = phi i64 [%433, %$81] ; # X %459 = phi i64 [%436, %$81] ; # Y ; # (car Y) %460 = inttoptr i64 %459 to i64* %461 = load i64, i64* %460 ; # (loop (? (atom (cadr Y)) (set P (car Y) (cdr X) (cddr Y))) (setq ... br label %$84 $84: %462 = phi i64 [%456, %$83], [%490, %$85] ; # Tos %463 = phi i64 [%457, %$83], [%491, %$85] ; # P %464 = phi i64 [%458, %$83], [%493, %$85] ; # X %465 = phi i64 [%461, %$83], [%470, %$85] ; # Y ; # (? (atom (cadr Y)) (set P (car Y) (cdr X) (cddr Y))) ; # (cadr Y) %466 = inttoptr i64 %465 to i64* %467 = getelementptr i64, i64* %466, i32 1 %468 = load i64, i64* %467 %469 = inttoptr i64 %468 to i64* %470 = load i64, i64* %469 ; # (atom (cadr Y)) %471 = and i64 %470, 15 %472 = icmp ne i64 %471, 0 br i1 %472, label %$87, label %$85 $87: %473 = phi i64 [%462, %$84] ; # Tos %474 = phi i64 [%463, %$84] ; # P %475 = phi i64 [%464, %$84] ; # X %476 = phi i64 [%465, %$84] ; # Y ; # (set P (car Y) (cdr X) (cddr Y)) ; # (car Y) %477 = inttoptr i64 %476 to i64* %478 = load i64, i64* %477 %479 = inttoptr i64 %474 to i64* store i64 %478, i64* %479 ; # (cdr X) %480 = inttoptr i64 %475 to i64* %481 = getelementptr i64, i64* %480, i32 1 %482 = load i64, i64* %481 ; # (cddr Y) %483 = inttoptr i64 %476 to i64* %484 = getelementptr i64, i64* %483, i32 1 %485 = load i64, i64* %484 %486 = inttoptr i64 %485 to i64* %487 = getelementptr i64, i64* %486, i32 1 %488 = load i64, i64* %487 %489 = inttoptr i64 %482 to i64* store i64 %488, i64* %489 br label %$86 $85: %490 = phi i64 [%462, %$84] ; # Tos %491 = phi i64 [%463, %$84] ; # P %492 = phi i64 [%464, %$84] ; # X %493 = phi i64 [%465, %$84] ; # Y br label %$84 $86: %494 = phi i64 [%473, %$87] ; # Tos %495 = phi i64 [%474, %$87] ; # P %496 = phi i64 [%475, %$87] ; # X %497 = phi i64 [%476, %$87] ; # Y %498 = phi i64 [%488, %$87] ; # -> br label %$75 $75: %499 = phi i64 [%364, %$73], [%494, %$86] ; # Tos %500 = phi i64 [%365, %$73], [%495, %$86] ; # P ; # (: 3 (let X (cdr P) (? (pair (car X)) (let Z P (setq P @) (set X ... br label %$-3 $-3: %501 = phi i64 [%441, %$82], [%499, %$75] ; # Tos %502 = phi i64 [%442, %$82], [%500, %$75] ; # P ; # (let X (cdr P) (? (pair (car X)) (let Z P (setq P @) (set X Tos) ... ; # (cdr P) %503 = inttoptr i64 %502 to i64* %504 = getelementptr i64, i64* %503, i32 1 %505 = load i64, i64* %504 ; # (? (pair (car X)) (let Z P (setq P @) (set X Tos) (setq Tos (| Z ... ; # (car X) %506 = inttoptr i64 %505 to i64* %507 = load i64, i64* %506 ; # (pair (car X)) %508 = and i64 %507, 15 %509 = icmp eq i64 %508, 0 br i1 %509, label %$90, label %$88 $90: %510 = phi i64 [%501, %$-3] ; # Tos %511 = phi i64 [%502, %$-3] ; # P ; # (let Z P (setq P @) (set X Tos) (setq Tos (| Z 8))) ; # (set X Tos) %512 = inttoptr i64 %505 to i64* store i64 %510, i64* %512 ; # (| Z 8) %513 = or i64 %511, 8 br label %$89 $88: %514 = phi i64 [%501, %$-3] ; # Tos %515 = phi i64 [%502, %$-3] ; # P ; # (: 4 (loop (unless Tos (goto 5)) (? (=0 (& Tos 8)) (let (X Tos Y ... br label %$-4 $-4: %516 = phi i64 [%381, %$76], [%394, %$78], [%514, %$88] ; # Tos %517 = phi i64 [%383, %$76], [%402, %$78], [%515, %$88] ; # P ; # (loop (unless Tos (goto 5)) (? (=0 (& Tos 8)) (let (X Tos Y (cdr ... br label %$91 $91: %518 = phi i64 [%516, %$-4], [%544, %$94] ; # Tos %519 = phi i64 [%517, %$-4], [%539, %$94] ; # P ; # (unless Tos (goto 5)) %520 = icmp ne i64 %518, 0 br i1 %520, label %$93, label %$92 $92: %521 = phi i64 [%518, %$91] ; # Tos %522 = phi i64 [%519, %$91] ; # P ; # (goto 5) br label %$-5 $93: %523 = phi i64 [%518, %$91] ; # Tos %524 = phi i64 [%519, %$91] ; # P ; # (? (=0 (& Tos 8)) (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set ... ; # (& Tos 8) %525 = and i64 %523, 8 ; # (=0 (& Tos 8)) %526 = icmp eq i64 %525, 0 br i1 %526, label %$96, label %$94 $96: %527 = phi i64 [%523, %$93] ; # Tos %528 = phi i64 [%524, %$93] ; # P ; # (let (X Tos Y (cdr X)) (setq Tos (cdr Y)) (set 2 Y P) (setq P X))... ; # (cdr X) %529 = inttoptr i64 %527 to i64* %530 = getelementptr i64, i64* %529, i32 1 %531 = load i64, i64* %530 ; # (cdr Y) %532 = inttoptr i64 %531 to i64* %533 = getelementptr i64, i64* %532, i32 1 %534 = load i64, i64* %533 ; # (set 2 Y P) %535 = inttoptr i64 %531 to i64* %536 = getelementptr i64, i64* %535, i32 1 store i64 %528, i64* %536 br label %$95 $94: %537 = phi i64 [%523, %$93] ; # Tos %538 = phi i64 [%524, %$93] ; # P ; # (let (X (& Tos -9) Y (cdr X)) (setq Tos (car Y)) (set Y P) (setq ... ; # (& Tos -9) %539 = and i64 %537, -9 ; # (cdr X) %540 = inttoptr i64 %539 to i64* %541 = getelementptr i64, i64* %540, i32 1 %542 = load i64, i64* %541 ; # (car Y) %543 = inttoptr i64 %542 to i64* %544 = load i64, i64* %543 ; # (set Y P) %545 = inttoptr i64 %542 to i64* store i64 %538, i64* %545 br label %$91 $95: %546 = phi i64 [%534, %$96] ; # Tos %547 = phi i64 [%527, %$96] ; # P %548 = phi i64 [%527, %$96] ; # -> br label %$73 $89: %549 = phi i64 [%513, %$90] ; # Tos %550 = phi i64 [%507, %$90] ; # P %551 = phi i64 [%513, %$90] ; # -> br label %$69 $97: ; # (: 5 (set $Extern P)) br label %$-5 $-5: %552 = phi i64 [%521, %$92], [%549, %$97] ; # Tos %553 = phi i64 [%522, %$92], [%550, %$97] ; # P ; # (set $Extern P) store i64 %553, i64* @$Extern ; # (let (Avail 0 Heap (val $Heaps) Cnt (val $GcCount)) (ifn Cnt (let... ; # (val $Heaps) %554 = load i64, i64* @$Heaps ; # (val $GcCount) %555 = load i64, i64* @$GcCount ; # (ifn Cnt (let H (any $Heaps) (loop (let (A Avail P (ofs Heap (- H... %556 = icmp ne i64 %555, 0 br i1 %556, label %$99, label %$98 $98: %557 = phi i64 [0, %$-5] ; # Avail %558 = phi i64 [%554, %$-5] ; # Heap %559 = phi i64 [%555, %$-5] ; # Cnt ; # (let H (any $Heaps) (loop (let (A Avail P (ofs Heap (- HEAP 2))) ... ; # (any $Heaps) %560 = ptrtoint i64* @$Heaps to i64 ; # (loop (let (A Avail P (ofs Heap (- HEAP 2))) (setq Cnt CELLS) (lo... br label %$101 $101: %561 = phi i64 [%557, %$98], [%629, %$110] ; # Avail %562 = phi i64 [%558, %$98], [%630, %$110] ; # Heap %563 = phi i64 [%559, %$98], [%631, %$110] ; # Cnt %564 = phi i64 [%560, %$98], [%632, %$110] ; # H ; # (let (A Avail P (ofs Heap (- HEAP 2))) (setq Cnt CELLS) (loop (wh... ; # (- HEAP 2) ; # (ofs Heap (- HEAP 2)) %565 = add i64 %562, 1048560 ; # (loop (when (& (cdr P) 1) (set P Avail) (setq Avail P) (dec 'Cnt)... br label %$102 $102: %566 = phi i64 [%561, %$101], [%589, %$105] ; # Avail %567 = phi i64 [%562, %$101], [%590, %$105] ; # Heap %568 = phi i64 [65536, %$101], [%591, %$105] ; # Cnt %569 = phi i64 [%564, %$101], [%592, %$105] ; # H %570 = phi i64 [%565, %$101], [%594, %$105] ; # P ; # (when (& (cdr P) 1) (set P Avail) (setq Avail P) (dec 'Cnt)) ; # (cdr P) %571 = inttoptr i64 %570 to i64* %572 = getelementptr i64, i64* %571, i32 1 %573 = load i64, i64* %572 ; # (& (cdr P) 1) %574 = and i64 %573, 1 %575 = icmp ne i64 %574, 0 br i1 %575, label %$103, label %$104 $103: %576 = phi i64 [%566, %$102] ; # Avail %577 = phi i64 [%567, %$102] ; # Heap %578 = phi i64 [%568, %$102] ; # Cnt %579 = phi i64 [%569, %$102] ; # H %580 = phi i64 [%570, %$102] ; # P ; # (set P Avail) %581 = inttoptr i64 %580 to i64* store i64 %576, i64* %581 ; # (dec 'Cnt) %582 = sub i64 %578, 1 br label %$104 $104: %583 = phi i64 [%566, %$102], [%580, %$103] ; # Avail %584 = phi i64 [%567, %$102], [%577, %$103] ; # Heap %585 = phi i64 [%568, %$102], [%582, %$103] ; # Cnt %586 = phi i64 [%569, %$102], [%579, %$103] ; # H %587 = phi i64 [%570, %$102], [%580, %$103] ; # P ; # (? (== P Heap)) ; # (== P Heap) %588 = icmp eq i64 %587, %584 br i1 %588, label %$106, label %$105 $105: %589 = phi i64 [%583, %$104] ; # Avail %590 = phi i64 [%584, %$104] ; # Heap %591 = phi i64 [%585, %$104] ; # Cnt %592 = phi i64 [%586, %$104] ; # H %593 = phi i64 [%587, %$104] ; # P ; # (ofs P -2) %594 = add i64 %593, -16 br label %$102 $106: %595 = phi i64 [%583, %$104] ; # Avail %596 = phi i64 [%584, %$104] ; # Heap %597 = phi i64 [%585, %$104] ; # Cnt %598 = phi i64 [%586, %$104] ; # H %599 = phi i64 [%587, %$104] ; # P %600 = phi i64 [0, %$104] ; # -> ; # (if Cnt (setq Heap (val (setq H (ofs Heap HEAP)))) (setq Avail A ... %601 = icmp ne i64 %597, 0 br i1 %601, label %$107, label %$108 $107: %602 = phi i64 [%595, %$106] ; # Avail %603 = phi i64 [%596, %$106] ; # Heap %604 = phi i64 [%597, %$106] ; # Cnt %605 = phi i64 [%598, %$106] ; # H %606 = phi i64 [%599, %$106] ; # P ; # (ofs Heap HEAP) %607 = add i64 %603, 1048576 ; # (val (setq H (ofs Heap HEAP))) %608 = inttoptr i64 %607 to i64* %609 = load i64, i64* %608 br label %$109 $108: %610 = phi i64 [%595, %$106] ; # Avail %611 = phi i64 [%596, %$106] ; # Heap %612 = phi i64 [%597, %$106] ; # Cnt %613 = phi i64 [%598, %$106] ; # H %614 = phi i64 [%599, %$106] ; # P ; # (inc HEAP) ; # (val (inc HEAP) Heap) %615 = inttoptr i64 %611 to i64* %616 = getelementptr i64, i64* %615, i32 131072 %617 = load i64, i64* %616 ; # (val H) %618 = inttoptr i64 %613 to i64* %619 = load i64, i64* %618 ; # (i8* (val H)) %620 = inttoptr i64 %619 to i8* ; # (free (i8* (val H))) call void @free(i8* %620) ; # (set H Heap) %621 = inttoptr i64 %613 to i64* store i64 %617, i64* %621 br label %$109 $109: %622 = phi i64 [%602, %$107], [%561, %$108] ; # Avail %623 = phi i64 [%609, %$107], [%617, %$108] ; # Heap %624 = phi i64 [%604, %$107], [%612, %$108] ; # Cnt %625 = phi i64 [%607, %$107], [%613, %$108] ; # H %626 = phi i64 [%606, %$107], [%614, %$108] ; # P %627 = phi i64 [%609, %$107], [%617, %$108] ; # -> ; # (? (=0 Heap)) ; # (=0 Heap) %628 = icmp eq i64 %623, 0 br i1 %628, label %$111, label %$110 $110: %629 = phi i64 [%622, %$109] ; # Avail %630 = phi i64 [%623, %$109] ; # Heap %631 = phi i64 [%624, %$109] ; # Cnt %632 = phi i64 [%625, %$109] ; # H br label %$101 $111: %633 = phi i64 [%622, %$109] ; # Avail %634 = phi i64 [%623, %$109] ; # Heap %635 = phi i64 [%624, %$109] ; # Cnt %636 = phi i64 [%625, %$109] ; # H %637 = phi i64 [0, %$109] ; # -> ; # (set $Avail Avail) store i64 %633, i64* @$Avail br label %$100 $99: %638 = phi i64 [0, %$-5] ; # Avail %639 = phi i64 [%554, %$-5] ; # Heap %640 = phi i64 [%555, %$-5] ; # Cnt ; # (loop (let P (ofs Heap (- HEAP 2)) (loop (when (& (cdr P) 1) (set... br label %$112 $112: %641 = phi i64 [%638, %$99], [%679, %$118] ; # Avail %642 = phi i64 [%639, %$99], [%680, %$118] ; # Heap %643 = phi i64 [%640, %$99], [%681, %$118] ; # Cnt ; # (let P (ofs Heap (- HEAP 2)) (loop (when (& (cdr P) 1) (set P Ava... ; # (- HEAP 2) ; # (ofs Heap (- HEAP 2)) %644 = add i64 %642, 1048560 ; # (loop (when (& (cdr P) 1) (set P Avail) (setq Avail P) (dec 'Cnt)... br label %$113 $113: %645 = phi i64 [%641, %$112], [%665, %$116] ; # Avail %646 = phi i64 [%642, %$112], [%666, %$116] ; # Heap %647 = phi i64 [%643, %$112], [%667, %$116] ; # Cnt %648 = phi i64 [%644, %$112], [%669, %$116] ; # P ; # (when (& (cdr P) 1) (set P Avail) (setq Avail P) (dec 'Cnt)) ; # (cdr P) %649 = inttoptr i64 %648 to i64* %650 = getelementptr i64, i64* %649, i32 1 %651 = load i64, i64* %650 ; # (& (cdr P) 1) %652 = and i64 %651, 1 %653 = icmp ne i64 %652, 0 br i1 %653, label %$114, label %$115 $114: %654 = phi i64 [%645, %$113] ; # Avail %655 = phi i64 [%646, %$113] ; # Heap %656 = phi i64 [%647, %$113] ; # Cnt %657 = phi i64 [%648, %$113] ; # P ; # (set P Avail) %658 = inttoptr i64 %657 to i64* store i64 %654, i64* %658 ; # (dec 'Cnt) %659 = sub i64 %656, 1 br label %$115 $115: %660 = phi i64 [%645, %$113], [%657, %$114] ; # Avail %661 = phi i64 [%646, %$113], [%655, %$114] ; # Heap %662 = phi i64 [%647, %$113], [%659, %$114] ; # Cnt %663 = phi i64 [%648, %$113], [%657, %$114] ; # P ; # (? (== P Heap)) ; # (== P Heap) %664 = icmp eq i64 %663, %661 br i1 %664, label %$117, label %$116 $116: %665 = phi i64 [%660, %$115] ; # Avail %666 = phi i64 [%661, %$115] ; # Heap %667 = phi i64 [%662, %$115] ; # Cnt %668 = phi i64 [%663, %$115] ; # P ; # (ofs P -2) %669 = add i64 %668, -16 br label %$113 $117: %670 = phi i64 [%660, %$115] ; # Avail %671 = phi i64 [%661, %$115] ; # Heap %672 = phi i64 [%662, %$115] ; # Cnt %673 = phi i64 [%663, %$115] ; # P %674 = phi i64 [0, %$115] ; # -> ; # (? (=0 (setq Heap (val (inc HEAP) Heap)))) ; # (inc HEAP) ; # (val (inc HEAP) Heap) %675 = inttoptr i64 %671 to i64* %676 = getelementptr i64, i64* %675, i32 131072 %677 = load i64, i64* %676 ; # (=0 (setq Heap (val (inc HEAP) Heap))) %678 = icmp eq i64 %677, 0 br i1 %678, label %$119, label %$118 $118: %679 = phi i64 [%670, %$117] ; # Avail %680 = phi i64 [%677, %$117] ; # Heap %681 = phi i64 [%672, %$117] ; # Cnt br label %$112 $119: %682 = phi i64 [%670, %$117] ; # Avail %683 = phi i64 [%677, %$117] ; # Heap %684 = phi i64 [%672, %$117] ; # Cnt %685 = phi i64 [0, %$117] ; # -> ; # (set $Avail Avail) store i64 %682, i64* @$Avail ; # (while (ge0 Cnt) (heapAlloc) (dec 'Cnt CELLS)) br label %$120 $120: %686 = phi i64 [%682, %$119], [%690, %$121] ; # Avail %687 = phi i64 [%683, %$119], [%691, %$121] ; # Heap %688 = phi i64 [%684, %$119], [%693, %$121] ; # Cnt ; # (ge0 Cnt) %689 = icmp sge i64 %688, 0 br i1 %689, label %$121, label %$122 $121: %690 = phi i64 [%686, %$120] ; # Avail %691 = phi i64 [%687, %$120] ; # Heap %692 = phi i64 [%688, %$120] ; # Cnt ; # (heapAlloc) call void @heapAlloc() ; # (dec 'Cnt CELLS) %693 = sub i64 %692, 65536 br label %$120 $122: %694 = phi i64 [%686, %$120] ; # Avail %695 = phi i64 [%687, %$120] ; # Heap %696 = phi i64 [%688, %$120] ; # Cnt br label %$100 $100: %697 = phi i64 [%633, %$111], [%694, %$122] ; # Avail %698 = phi i64 [%634, %$111], [%695, %$122] ; # Heap %699 = phi i64 [%635, %$111], [%696, %$122] ; # 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))) (set $At $Nil $At2 $Nil) (if ... ; # (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] ; # -> ; # (set $At $Nil $At2 $Nil) %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %14 %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 456) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %15 ; # (if (nil? Y) (gc) (set $GcCount (shl (xCnt Exe Y) 16)) (gc) (set ... ; # (nil? Y) %16 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %16, label %$7, label %$8 $7: %17 = phi i64 [%3, %$2] ; # X ; # (gc) call void @gc() br label %$9 $8: %18 = phi i64 [%3, %$2] ; # X ; # (set $GcCount (shl (xCnt Exe Y) 16)) ; # (xCnt Exe Y) %19 = call i64 @xCnt(i64 %0, i64 %13) ; # (shl (xCnt Exe Y) 16) %20 = shl i64 %19, 16 store i64 %20, 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) %21 = inttoptr i64 %18 to i64* %22 = getelementptr i64, i64* %21, i32 1 %23 = load i64, i64* %22 ; # (atom (shift X)) %24 = and i64 %23, 15 %25 = icmp ne i64 %24, 0 br i1 %25, label %$10, label %$11 $10: %26 = phi i64 [%23, %$8] ; # X br label %$12 $11: %27 = phi i64 [%23, %$8] ; # X ; # (evCnt Exe X) %28 = call i64 @evCnt(i64 %0, i64 %27) ; # (shl (evCnt Exe X) 16) %29 = shl i64 %28, 16 br label %$12 $12: %30 = phi i64 [%26, %$10], [%27, %$11] ; # X %31 = phi i64 [65536, %$10], [%29, %$11] ; # -> store i64 %31, i64* @$GcCount br label %$9 $9: %32 = phi i64 [%17, %$7], [%30, %$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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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]* @$25 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %334, i64* %335 ret i64 %331 } define i64 @fmtWord(i64, i64, i8, i8, i64*) align 8 { $1: ; # (when (> N 9) (setq Scl (fmtWord (/ 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 ; # (fmtWord (/ N 10) Scl Sep Ign P) %9 = call i64 @fmtWord(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 @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] ; # -> ; # (cond ((ge0 Scl) (when Sign (byteSym (char "-") P)) (let N (* (sh... ; # (ge0 Scl) %313 = icmp sge i64 %308, 0 br i1 %313, label %$35, label %$34 $35: %314 = phi i64 [%307, %$32] ; # Num %315 = phi i64 [%308, %$32] ; # Scl %316 = phi i64 [%309, %$32] ; # Len %317 = phi i64* [%310, %$32] ; # TopA ; # (when Sign (byteSym (char "-") P)) br i1 %6, label %$36, label %$37 $36: %318 = phi i64 [%314, %$35] ; # Num %319 = phi i64 [%315, %$35] ; # Scl %320 = phi i64 [%316, %$35] ; # Len %321 = phi i64* [%317, %$35] ; # TopA ; # (byteSym (char "-") P) call void @byteSym(i8 45, i64* %4) br label %$37 $37: %322 = phi i64 [%314, %$35], [%318, %$36] ; # Num %323 = phi i64 [%315, %$35], [%319, %$36] ; # Scl %324 = phi i64 [%316, %$35], [%320, %$36] ; # Len %325 = phi i64* [%317, %$35], [%321, %$36] ; # TopA ; # (let N (* (shr (- TopA Acc) 3) 18) (let D (val TopA) (while (setq... ; # (- TopA Acc) %326 = ptrtoint i64* %325 to i64 %327 = ptrtoint i64* %27 to i64 %328 = sub i64 %326, %327 ; # (shr (- TopA Acc) 3) %329 = lshr i64 %328, 3 ; # (* (shr (- TopA Acc) 3) 18) %330 = mul i64 %329, 18 ; # (let D (val TopA) (while (setq D (/ D 10)) (inc 'N))) ; # (val TopA) %331 = load i64, i64* %325 ; # (while (setq D (/ D 10)) (inc 'N)) br label %$38 $38: %332 = phi i64 [%322, %$37], [%340, %$39] ; # Num %333 = phi i64 [%323, %$37], [%341, %$39] ; # Scl %334 = phi i64 [%324, %$37], [%342, %$39] ; # Len %335 = phi i64* [%325, %$37], [%343, %$39] ; # TopA %336 = phi i64 [%330, %$37], [%346, %$39] ; # N %337 = phi i64 [%331, %$37], [%345, %$39] ; # D ; # (/ D 10) %338 = udiv i64 %337, 10 %339 = icmp ne i64 %338, 0 br i1 %339, label %$39, label %$40 $39: %340 = phi i64 [%332, %$38] ; # Num %341 = phi i64 [%333, %$38] ; # Scl %342 = phi i64 [%334, %$38] ; # Len %343 = phi i64* [%335, %$38] ; # TopA %344 = phi i64 [%336, %$38] ; # N %345 = phi i64 [%338, %$38] ; # D ; # (inc 'N) %346 = add i64 %344, 1 br label %$38 $40: %347 = phi i64 [%332, %$38] ; # Num %348 = phi i64 [%333, %$38] ; # Scl %349 = phi i64 [%334, %$38] ; # Len %350 = phi i64* [%335, %$38] ; # TopA %351 = phi i64 [%336, %$38] ; # N %352 = phi i64 [%338, %$38] ; # D ; # (when (lt0 (setq Scl (- N Scl))) (byteSym (char "0") P) (byteSym ... ; # (- N Scl) %353 = sub i64 %351, %348 ; # (lt0 (setq Scl (- N Scl))) %354 = icmp slt i64 %353, 0 br i1 %354, label %$41, label %$42 $41: %355 = phi i64 [%347, %$40] ; # Num %356 = phi i64 [%353, %$40] ; # Scl %357 = phi i64 [%349, %$40] ; # Len %358 = phi i64* [%350, %$40] ; # TopA %359 = phi i64 [%351, %$40] ; # N ; # (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: %360 = phi i64 [%355, %$41], [%366, %$44] ; # Num %361 = phi i64 [%356, %$41], [%371, %$44] ; # Scl %362 = phi i64 [%357, %$41], [%368, %$44] ; # Len %363 = phi i64* [%358, %$41], [%369, %$44] ; # TopA %364 = phi i64 [%359, %$41], [%370, %$44] ; # N ; # (> -1 Scl) %365 = icmp ugt i64 -1, %361 br i1 %365, label %$44, label %$45 $44: %366 = phi i64 [%360, %$43] ; # Num %367 = phi i64 [%361, %$43] ; # Scl %368 = phi i64 [%362, %$43] ; # Len %369 = phi i64* [%363, %$43] ; # TopA %370 = phi i64 [%364, %$43] ; # N ; # (inc 'Scl) %371 = add i64 %367, 1 ; # (byteSym (char "0") P) call void @byteSym(i8 48, i64* %4) br label %$43 $45: %372 = phi i64 [%360, %$43] ; # Num %373 = phi i64 [%361, %$43] ; # Scl %374 = phi i64 [%362, %$43] ; # Len %375 = phi i64* [%363, %$43] ; # TopA %376 = phi i64 [%364, %$43] ; # N br label %$42 $42: %377 = phi i64 [%347, %$40], [%372, %$45] ; # Num %378 = phi i64 [%353, %$40], [%373, %$45] ; # Scl %379 = phi i64 [%349, %$40], [%374, %$45] ; # Len %380 = phi i64* [%350, %$40], [%375, %$45] ; # TopA %381 = phi i64 [%351, %$40], [%376, %$45] ; # N ; # (val TopA) %382 = load i64, i64* %380 ; # (fmtWord (val TopA) Scl Sep Ign P) %383 = call i64 @fmtWord(i64 %382, i64 %378, i8 %2, i8 %3, i64* %4) ; # (while (>= (dec 'TopA) Acc) (let (N (val TopA) D 1000000000000000... br label %$46 $46: %384 = phi i64 [%377, %$42], [%468, %$59] ; # Num %385 = phi i64 [%383, %$42], [%469, %$59] ; # Scl %386 = phi i64 [%379, %$42], [%470, %$59] ; # Len %387 = phi i64* [%380, %$42], [%471, %$59] ; # TopA ; # (dec 'TopA) %388 = getelementptr i64, i64* %387, i32 -1 ; # (>= (dec 'TopA) Acc) %389 = icmp uge i64* %388, %27 br i1 %389, label %$47, label %$48 $47: %390 = phi i64 [%384, %$46] ; # Num %391 = phi i64 [%385, %$46] ; # Scl %392 = phi i64 [%386, %$46] ; # Len %393 = phi i64* [%388, %$46] ; # TopA ; # (let (N (val TopA) D 100000000000000000) (loop (cond ((=0 Scl) (b... ; # (val TopA) %394 = load i64, i64* %393 ; # (loop (cond ((=0 Scl) (byteSym Sep P)) ((and Ign (gt0 Scl) (=0 (%... br label %$49 $49: %395 = phi i64 [%390, %$47], [%457, %$58] ; # Num %396 = phi i64 [%391, %$47], [%458, %$58] ; # Scl %397 = phi i64 [%392, %$47], [%459, %$58] ; # Len %398 = phi i64* [%393, %$47], [%460, %$58] ; # TopA %399 = phi i64 [%394, %$47], [%466, %$58] ; # N %400 = phi i64 [100000000000000000, %$47], [%467, %$58] ; # D ; # (cond ((=0 Scl) (byteSym Sep P)) ((and Ign (gt0 Scl) (=0 (% Scl 3... ; # (=0 Scl) %401 = icmp eq i64 %396, 0 br i1 %401, label %$52, label %$51 $52: %402 = phi i64 [%395, %$49] ; # Num %403 = phi i64 [%396, %$49] ; # Scl %404 = phi i64 [%397, %$49] ; # Len %405 = phi i64* [%398, %$49] ; # TopA %406 = phi i64 [%399, %$49] ; # N %407 = phi i64 [%400, %$49] ; # D ; # (byteSym Sep P) call void @byteSym(i8 %2, i64* %4) br label %$50 $51: %408 = phi i64 [%395, %$49] ; # Num %409 = phi i64 [%396, %$49] ; # Scl %410 = phi i64 [%397, %$49] ; # Len %411 = phi i64* [%398, %$49] ; # TopA %412 = phi i64 [%399, %$49] ; # N %413 = phi i64 [%400, %$49] ; # D ; # (and Ign (gt0 Scl) (=0 (% Scl 3))) %414 = icmp ne i8 %3, 0 br i1 %414, label %$54, label %$53 $54: %415 = phi i64 [%408, %$51] ; # Num %416 = phi i64 [%409, %$51] ; # Scl %417 = phi i64 [%410, %$51] ; # Len %418 = phi i64* [%411, %$51] ; # TopA %419 = phi i64 [%412, %$51] ; # N %420 = phi i64 [%413, %$51] ; # D ; # (gt0 Scl) %421 = icmp sgt i64 %416, 0 br i1 %421, label %$55, label %$53 $55: %422 = phi i64 [%415, %$54] ; # Num %423 = phi i64 [%416, %$54] ; # Scl %424 = phi i64 [%417, %$54] ; # Len %425 = phi i64* [%418, %$54] ; # TopA %426 = phi i64 [%419, %$54] ; # N %427 = phi i64 [%420, %$54] ; # D ; # (% Scl 3) %428 = urem i64 %423, 3 ; # (=0 (% Scl 3)) %429 = icmp eq i64 %428, 0 br label %$53 $53: %430 = phi i64 [%408, %$51], [%415, %$54], [%422, %$55] ; # Num %431 = phi i64 [%409, %$51], [%416, %$54], [%423, %$55] ; # Scl %432 = phi i64 [%410, %$51], [%417, %$54], [%424, %$55] ; # Len %433 = phi i64* [%411, %$51], [%418, %$54], [%425, %$55] ; # TopA %434 = phi i64 [%412, %$51], [%419, %$54], [%426, %$55] ; # N %435 = phi i64 [%413, %$51], [%420, %$54], [%427, %$55] ; # D %436 = phi i1 [0, %$51], [0, %$54], [%429, %$55] ; # -> br i1 %436, label %$57, label %$56 $57: %437 = phi i64 [%430, %$53] ; # Num %438 = phi i64 [%431, %$53] ; # Scl %439 = phi i64 [%432, %$53] ; # Len %440 = phi i64* [%433, %$53] ; # TopA %441 = phi i64 [%434, %$53] ; # N %442 = phi i64 [%435, %$53] ; # D ; # (byteSym Ign P) call void @byteSym(i8 %3, i64* %4) br label %$50 $56: %443 = phi i64 [%430, %$53] ; # Num %444 = phi i64 [%431, %$53] ; # Scl %445 = phi i64 [%432, %$53] ; # Len %446 = phi i64* [%433, %$53] ; # TopA %447 = phi i64 [%434, %$53] ; # N %448 = phi i64 [%435, %$53] ; # D br label %$50 $50: %449 = phi i64 [%402, %$52], [%437, %$57], [%443, %$56] ; # Num %450 = phi i64 [%403, %$52], [%438, %$57], [%444, %$56] ; # Scl %451 = phi i64 [%404, %$52], [%439, %$57], [%445, %$56] ; # Len %452 = phi i64* [%405, %$52], [%440, %$57], [%446, %$56] ; # TopA %453 = phi i64 [%406, %$52], [%441, %$57], [%447, %$56] ; # N %454 = phi i64 [%407, %$52], [%442, %$57], [%448, %$56] ; # D ; # (dec 'Scl) %455 = sub i64 %450, 1 ; # (? (== 1 D)) ; # (== 1 D) %456 = icmp eq i64 1, %454 br i1 %456, label %$59, label %$58 $58: %457 = phi i64 [%449, %$50] ; # Num %458 = phi i64 [%455, %$50] ; # Scl %459 = phi i64 [%451, %$50] ; # Len %460 = phi i64* [%452, %$50] ; # TopA %461 = phi i64 [%453, %$50] ; # N %462 = phi i64 [%454, %$50] ; # D ; # (/ N D) %463 = udiv i64 %461, %462 ; # (i8 (/ N D)) %464 = trunc i64 %463 to i8 ; # (+ (i8 (/ N D)) (char "0")) %465 = add i8 %464, 48 ; # (byteSym (+ (i8 (/ N D)) (char "0")) P) call void @byteSym(i8 %465, i64* %4) ; # (% N D) %466 = urem i64 %461, %462 ; # (/ D 10) %467 = udiv i64 %462, 10 br label %$49 $59: %468 = phi i64 [%449, %$50] ; # Num %469 = phi i64 [%455, %$50] ; # Scl %470 = phi i64 [%451, %$50] ; # Len %471 = phi i64* [%452, %$50] ; # TopA %472 = phi i64 [%453, %$50] ; # N %473 = phi i64 [%454, %$50] ; # D %474 = phi i64 [0, %$50] ; # -> ; # (i8 N) %475 = trunc i64 %472 to i8 ; # (+ (i8 N) (char "0")) %476 = add i8 %475, 48 ; # (byteSym (+ (i8 N) (char "0")) P) call void @byteSym(i8 %476, i64* %4) br label %$46 $48: %477 = phi i64 [%384, %$46] ; # Num %478 = phi i64 [%385, %$46] ; # Scl %479 = phi i64 [%386, %$46] ; # Len %480 = phi i64* [%388, %$46] ; # TopA br label %$33 $34: %481 = phi i64 [%307, %$32] ; # Num %482 = phi i64 [%308, %$32] ; # Scl %483 = phi i64 [%309, %$32] ; # Len %484 = phi i64* [%310, %$32] ; # TopA ; # (== Scl -1) %485 = icmp eq i64 %482, -1 br i1 %485, label %$61, label %$60 $61: %486 = phi i64 [%481, %$34] ; # Num %487 = phi i64 [%482, %$34] ; # Scl %488 = phi i64 [%483, %$34] ; # Len %489 = phi i64* [%484, %$34] ; # TopA ; # (when Sign (call $Put (char "-"))) br i1 %6, label %$62, label %$63 $62: %490 = phi i64 [%486, %$61] ; # Num %491 = phi i64 [%487, %$61] ; # Scl %492 = phi i64 [%488, %$61] ; # Len %493 = phi i64* [%489, %$61] ; # TopA ; # (call $Put (char "-")) %494 = load void(i8)*, void(i8)** @$Put call void %494(i8 45) br label %$63 $63: %495 = phi i64 [%486, %$61], [%490, %$62] ; # Num %496 = phi i64 [%487, %$61], [%491, %$62] ; # Scl %497 = phi i64 [%488, %$61], [%492, %$62] ; # Len %498 = phi i64* [%489, %$61], [%493, %$62] ; # TopA ; # (val TopA) %499 = load i64, i64* %498 ; # (outWord (val TopA)) call void @outWord(i64 %499) ; # (while (>= (dec 'TopA) Acc) (let (N (val TopA) D 1000000000000000... br label %$64 $64: %500 = phi i64 [%495, %$63], [%530, %$69] ; # Num %501 = phi i64 [%496, %$63], [%531, %$69] ; # Scl %502 = phi i64 [%497, %$63], [%532, %$69] ; # Len %503 = phi i64* [%498, %$63], [%533, %$69] ; # TopA ; # (dec 'TopA) %504 = getelementptr i64, i64* %503, i32 -1 ; # (>= (dec 'TopA) Acc) %505 = icmp uge i64* %504, %27 br i1 %505, label %$65, label %$66 $65: %506 = phi i64 [%500, %$64] ; # Num %507 = phi i64 [%501, %$64] ; # Scl %508 = phi i64 [%502, %$64] ; # Len %509 = phi i64* [%504, %$64] ; # TopA ; # (let (N (val TopA) D 100000000000000000) (loop (call $Put (+ (i8 ... ; # (val TopA) %510 = load i64, i64* %509 ; # (loop (call $Put (+ (i8 (/ N D)) (char "0"))) (setq N (% N D)) (?... br label %$67 $67: %511 = phi i64 [%506, %$65], [%524, %$68] ; # Num %512 = phi i64 [%507, %$65], [%525, %$68] ; # Scl %513 = phi i64 [%508, %$65], [%526, %$68] ; # Len %514 = phi i64* [%509, %$65], [%527, %$68] ; # TopA %515 = phi i64 [%510, %$65], [%528, %$68] ; # N %516 = phi i64 [100000000000000000, %$65], [%529, %$68] ; # D ; # (/ N D) %517 = udiv i64 %515, %516 ; # (i8 (/ N D)) %518 = trunc i64 %517 to i8 ; # (+ (i8 (/ N D)) (char "0")) %519 = add i8 %518, 48 ; # (call $Put (+ (i8 (/ N D)) (char "0"))) %520 = load void(i8)*, void(i8)** @$Put call void %520(i8 %519) ; # (% N D) %521 = urem i64 %515, %516 ; # (? (== 1 (setq D (/ D 10)))) ; # (/ D 10) %522 = udiv i64 %516, 10 ; # (== 1 (setq D (/ D 10))) %523 = icmp eq i64 1, %522 br i1 %523, label %$69, label %$68 $68: %524 = phi i64 [%511, %$67] ; # Num %525 = phi i64 [%512, %$67] ; # Scl %526 = phi i64 [%513, %$67] ; # Len %527 = phi i64* [%514, %$67] ; # TopA %528 = phi i64 [%521, %$67] ; # N %529 = phi i64 [%522, %$67] ; # D br label %$67 $69: %530 = phi i64 [%511, %$67] ; # Num %531 = phi i64 [%512, %$67] ; # Scl %532 = phi i64 [%513, %$67] ; # Len %533 = phi i64* [%514, %$67] ; # TopA %534 = phi i64 [%521, %$67] ; # N %535 = phi i64 [%522, %$67] ; # D %536 = phi i64 [0, %$67] ; # -> ; # (i8 N) %537 = trunc i64 %534 to i8 ; # (+ (i8 N) (char "0")) %538 = add i8 %537, 48 ; # (call $Put (+ (i8 N) (char "0"))) %539 = load void(i8)*, void(i8)** @$Put call void %539(i8 %538) br label %$64 $66: %540 = phi i64 [%500, %$64] ; # Num %541 = phi i64 [%501, %$64] ; # Scl %542 = phi i64 [%502, %$64] ; # Len %543 = phi i64* [%504, %$64] ; # TopA br label %$33 $60: %544 = phi i64 [%481, %$34] ; # Num %545 = phi i64 [%482, %$34] ; # Scl %546 = phi i64 [%483, %$34] ; # Len %547 = phi i64* [%484, %$34] ; # TopA ; # (let (N (* (shr (- TopA Acc) 3) 18) D (val TopA)) (loop (inc 'N) ... ; # (- TopA Acc) %548 = ptrtoint i64* %547 to i64 %549 = ptrtoint i64* %27 to i64 %550 = sub i64 %548, %549 ; # (shr (- TopA Acc) 3) %551 = lshr i64 %550, 3 ; # (* (shr (- TopA Acc) 3) 18) %552 = mul i64 %551, 18 ; # (val TopA) %553 = load i64, i64* %547 ; # (loop (inc 'N) (? (=0 (setq D (/ D 10))))) br label %$70 $70: %554 = phi i64 [%544, %$60], [%563, %$71] ; # Num %555 = phi i64 [%545, %$60], [%564, %$71] ; # Scl %556 = phi i64 [%546, %$60], [%565, %$71] ; # Len %557 = phi i64* [%547, %$60], [%566, %$71] ; # TopA %558 = phi i64 [%552, %$60], [%567, %$71] ; # N %559 = phi i64 [%553, %$60], [%568, %$71] ; # D ; # (inc 'N) %560 = add i64 %558, 1 ; # (? (=0 (setq D (/ D 10)))) ; # (/ D 10) %561 = udiv i64 %559, 10 ; # (=0 (setq D (/ D 10))) %562 = icmp eq i64 %561, 0 br i1 %562, label %$72, label %$71 $71: %563 = phi i64 [%554, %$70] ; # Num %564 = phi i64 [%555, %$70] ; # Scl %565 = phi i64 [%556, %$70] ; # Len %566 = phi i64* [%557, %$70] ; # TopA %567 = phi i64 [%560, %$70] ; # N %568 = phi i64 [%561, %$70] ; # D br label %$70 $72: %569 = phi i64 [%554, %$70] ; # Num %570 = phi i64 [%555, %$70] ; # Scl %571 = phi i64 [%556, %$70] ; # Len %572 = phi i64* [%557, %$70] ; # TopA %573 = phi i64 [%560, %$70] ; # N %574 = phi i64 [%561, %$70] ; # D %575 = phi i64 [0, %$70] ; # -> ; # (when Sign (inc 'N)) br i1 %6, label %$73, label %$74 $73: %576 = phi i64 [%569, %$72] ; # Num %577 = phi i64 [%570, %$72] ; # Scl %578 = phi i64 [%571, %$72] ; # Len %579 = phi i64* [%572, %$72] ; # TopA %580 = phi i64 [%573, %$72] ; # N %581 = phi i64 [%574, %$72] ; # D ; # (inc 'N) %582 = add i64 %580, 1 br label %$74 $74: %583 = phi i64 [%569, %$72], [%576, %$73] ; # Num %584 = phi i64 [%570, %$72], [%577, %$73] ; # Scl %585 = phi i64 [%571, %$72], [%578, %$73] ; # Len %586 = phi i64* [%572, %$72], [%579, %$73] ; # TopA %587 = phi i64 [%573, %$72], [%582, %$73] ; # N %588 = phi i64 [%574, %$72], [%581, %$73] ; # D ; # (cnt N) %589 = shl i64 %587, 4 %590 = or i64 %589, 2 br label %$33 $33: %591 = phi i64 [%477, %$48], [%540, %$66], [%583, %$74] ; # Num %592 = phi i64 [%478, %$48], [%541, %$66], [%584, %$74] ; # Scl %593 = phi i64 [%479, %$48], [%542, %$66], [%585, %$74] ; # Len %594 = phi i64* [%480, %$48], [%543, %$66], [%586, %$74] ; # TopA %595 = phi i64 [0, %$48], [0, %$66], [%590, %$74] ; # -> ret i64 %595 } 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$40], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %67, i64* %68 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %85, i64* %86 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ; # (& (name (& @ -9)) -9) %41 = and i64 %40, -9 ; # (packExtNm (& (name (& @ -9)) -9) P) call void @packExtNm(i64 %41, i64* %1) ; # (byteSym (char "}") P) call void @byteSym(i8 125, i64* %1) br label %$9 $13: %42 = phi i64 [%25, %$11] ; # X ; # (let Q (push 0 (name @)) (while (symByte Q) (byteSym @ P))) ; # (name @) br label %$18 $18: %43 = phi i64 [%28, %$13], [%49, %$19] ; # Tail %44 = and i64 %43, 6 %45 = icmp ne i64 %44, 0 br i1 %45, label %$20, label %$19 $19: %46 = phi i64 [%43, %$18] ; # Tail %47 = inttoptr i64 %46 to i64* %48 = getelementptr i64, i64* %47, i32 1 %49 = load i64, i64* %48 br label %$18 $20: %50 = phi i64 [%43, %$18] ; # Tail ; # (push 0 (name @)) %51 = alloca i64, i64 2, align 16 store i64 0, i64* %51 %52 = getelementptr i64, i64* %51, i32 1 store i64 %50, i64* %52 ; # (while (symByte Q) (byteSym @ P)) br label %$21 $21: %53 = phi i64 [%42, %$20], [%56, %$22] ; # X ; # (symByte Q) %54 = call i8 @symByte(i64* %51) %55 = icmp ne i8 %54, 0 br i1 %55, label %$22, label %$23 $22: %56 = phi i64 [%53, %$21] ; # X ; # (byteSym @ P) call void @byteSym(i8 %54, i64* %1) br label %$21 $23: %57 = phi i64 [%53, %$21] ; # X br label %$9 $9: %58 = phi i64 [%18, %$3], [%23, %$12], [%31, %$17], [%57, %$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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %3 ; # (link (push $Nil NIL)) %4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %54 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %98 = call i64 @cons(i64 %97, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %192 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %236 = call i64 @cons(i64 %235, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 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 ([17 x i64]* @env to i8*), i32 72) 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 (& (na... ; # (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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %25, i64* %30 ; # (name Tail) br label %$12 $12: %31 = phi i64 [%19, %$9], [%37, %$13] ; # Tail %32 = and i64 %31, 6 %33 = icmp ne i64 %32, 0 br i1 %33, label %$14, label %$13 $13: %34 = phi i64 [%31, %$12] ; # Tail %35 = inttoptr i64 %34 to i64* %36 = getelementptr i64, i64* %35, i32 1 %37 = load i64, i64* %36 br label %$12 $14: %38 = phi i64 [%31, %$12] ; # Tail ; # (& (name Tail) -9) %39 = and i64 %38, -9 ; # (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 ([17 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 @) Lst (val $Inte... ; # (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 @) Lst (val $Intern)) (loop (? (atom Lst) $Nil) (l... ; # (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 ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %31 = load i64, i64* %30 ; # (loop (? (atom Lst) $Nil) (let Nsp (car Lst) (? (== Sym (isIntern... br label %$15 $15: %32 = phi i64 [%31, %$14], [%50, %$19] ; # Lst ; # (? (atom Lst) $Nil) ; # (atom Lst) %33 = and i64 %32, 15 %34 = icmp ne i64 %33, 0 br i1 %34, label %$18, label %$16 $18: %35 = phi i64 [%32, %$15] ; # Lst br label %$17 $16: %36 = phi i64 [%32, %$15] ; # Lst ; # (let Nsp (car Lst) (? (== Sym (isIntern Nm (cdar Nsp))) Nsp)) ; # (car Lst) %37 = inttoptr i64 %36 to i64* %38 = load i64, i64* %37 ; # (? (== Sym (isIntern Nm (cdar Nsp))) Nsp) ; # (cdar Nsp) %39 = inttoptr i64 %38 to i64* %40 = load i64, i64* %39 %41 = inttoptr i64 %40 to i64* %42 = getelementptr i64, i64* %41, i32 1 %43 = load i64, i64* %42 ; # (isIntern Nm (cdar Nsp)) %44 = call i64 @isIntern(i64 %29, i64 %43) ; # (== Sym (isIntern Nm (cdar Nsp))) %45 = icmp eq i64 %13, %44 br i1 %45, label %$20, label %$19 $20: %46 = phi i64 [%36, %$16] ; # Lst br label %$17 $19: %47 = phi i64 [%36, %$16] ; # Lst ; # (shift Lst) %48 = inttoptr i64 %47 to i64* %49 = getelementptr i64, i64* %48, i32 1 %50 = load i64, i64* %49 br label %$15 $17: %51 = phi i64 [%35, %$18], [%46, %$20] ; # Lst %52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%38, %$20] ; # -> br label %$11 $11: %53 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%52, %$17] ; # -> ret i64 %53 } 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%22, %$11], [%31, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 x i64]* @env to i8*), i32 72) 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 ([870 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 ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* %49 = load i64, i64* %48 ; # (val 2 $Transient) %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 0) 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 x i64]* @env to i8*), i32 72) 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 ([870 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 ([870 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 ([870 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 ([52 x i64]* @gcData to i8*), i32 0) 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 ([52 x i64]* @gcData to i8*), i32 0) 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 ([17 x i64]* @env to i8*), i32 72) 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 ([870 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 ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %59 = load i64, i64* %58 ; # (set $Intern Y) %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) 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 ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %65 = load i64, i64* %64 ; # (save (val $Intern)) %66 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 72) 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 ([17 x i64]* @env to i8*), i32 72) 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 ([17 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 ; # (if (or (nil? (val (needSymb Exe Y))) (== @ Y)) (set (chkVar Exe ... ; # (or (nil? (val (needSymb Exe Y))) (== @ Y)) ; # (needSymb Exe Y) %112 = xor i64 %111, 8 %113 = and i64 %112, 14 %114 = icmp eq i64 %113, 0 br i1 %114, label %$38, label %$37 $37: call void @symErr(i64 %0, i64 %111) unreachable $38: ; # (val (needSymb Exe Y)) %115 = inttoptr i64 %111 to i64* %116 = load i64, i64* %115 ; # (nil? (val (needSymb Exe Y))) %117 = icmp eq i64 %116, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %117, label %$36, label %$39 $39: %118 = phi i64 [%110, %$38] ; # X %119 = phi i64 [%111, %$38] ; # Y ; # (== @ Y) %120 = icmp eq i64 %116, %119 br label %$36 $36: %121 = phi i64 [%110, %$38], [%118, %$39] ; # X %122 = phi i64 [%111, %$38], [%119, %$39] ; # Y %123 = phi i1 [1, %$38], [%120, %$39] ; # -> br i1 %123, label %$40, label %$41 $40: %124 = phi i64 [%121, %$36] ; # X %125 = phi i64 [%122, %$36] ; # Y ; # (set (chkVar Exe Y) (cons $Tilde (cons $Nil $Nil))) ; # (chkVar Exe Y) %126 = icmp uge i64 %125, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %126, label %$44, label %$43 $44: %127 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %125 br label %$43 $43: %128 = phi i1 [0, %$40], [%127, %$44] ; # -> br i1 %128, label %$45, label %$46 $45: call void @protErr(i64 %0, i64 %125) unreachable $46: ; # (cons $Nil $Nil) %129 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (cons $Tilde (cons $Nil $Nil)) %130 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 40) to i64), i64 %129) %131 = inttoptr i64 %125 to i64* store i64 %130, i64* %131 br label %$42 $41: %132 = phi i64 [%121, %$36] ; # X %133 = phi i64 [%122, %$36] ; # Y ; # (needNsp Exe Y) %134 = inttoptr i64 %133 to i64* %135 = load i64, i64* %134 %136 = and i64 %135, 15 %137 = icmp eq i64 %136, 0 br i1 %137, label %$48, label %$47 $48: %138 = inttoptr i64 %135 to i64* %139 = load i64, i64* %138 %140 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 40) to i64), %139 br label %$47 $47: %141 = phi i1 [0, %$41], [%140, %$48] ; # -> br i1 %141, label %$50, label %$49 $49: call void @symNspErr(i64 %0, i64 %133) unreachable $50: br label %$42 $42: %142 = phi i64 [%124, %$46], [%132, %$50] ; # X %143 = phi i64 [%125, %$46], [%133, %$50] ; # Y %144 = phi i64 [%130, %$46], [%133, %$50] ; # -> ; # (let R (setq Y (save (cons Y $Nil))) (while (pair X) (setq Y (set... ; # (cons Y $Nil) %145 = call i64 @cons(i64 %143, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save (cons Y $Nil)) %146 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %147 = load i64, i64* %146 %148 = alloca i64, i64 2, align 16 %149 = ptrtoint i64* %148 to i64 %150 = inttoptr i64 %149 to i64* store i64 %145, i64* %150 %151 = add i64 %149, 8 %152 = inttoptr i64 %151 to i64* store i64 %147, i64* %152 %153 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %149, i64* %153 ; # (while (pair X) (setq Y (set 2 Y (cons (needNsp Exe (needSymb Exe... br label %$51 $51: %154 = phi i64 [%142, %$42], [%163, %$64] ; # X %155 = phi i64 [%145, %$42], [%183, %$64] ; # Y ; # (pair X) %156 = and i64 %154, 15 %157 = icmp eq i64 %156, 0 br i1 %157, label %$52, label %$53 $52: %158 = phi i64 [%154, %$51] ; # X %159 = phi i64 [%155, %$51] ; # Y ; # (set 2 Y (cons (needNsp Exe (needSymb Exe (eval (++ X)))) $Nil)) ; # (++ X) %160 = inttoptr i64 %158 to i64* %161 = load i64, i64* %160 %162 = getelementptr i64, i64* %160, i32 1 %163 = load i64, i64* %162 ; # (eval (++ X)) %164 = and i64 %161, 6 %165 = icmp ne i64 %164, 0 br i1 %165, label %$56, label %$55 $56: br label %$54 $55: %166 = and i64 %161, 8 %167 = icmp ne i64 %166, 0 br i1 %167, label %$58, label %$57 $58: %168 = inttoptr i64 %161 to i64* %169 = load i64, i64* %168 br label %$54 $57: %170 = call i64 @evList(i64 %161) br label %$54 $54: %171 = phi i64 [%161, %$56], [%169, %$58], [%170, %$57] ; # -> ; # (needSymb Exe (eval (++ X))) %172 = xor i64 %171, 8 %173 = and i64 %172, 14 %174 = icmp eq i64 %173, 0 br i1 %174, label %$60, label %$59 $59: call void @symErr(i64 %0, i64 %171) unreachable $60: ; # (needNsp Exe (needSymb Exe (eval (++ X)))) %175 = inttoptr i64 %171 to i64* %176 = load i64, i64* %175 %177 = and i64 %176, 15 %178 = icmp eq i64 %177, 0 br i1 %178, label %$62, label %$61 $62: %179 = inttoptr i64 %176 to i64* %180 = load i64, i64* %179 %181 = icmp eq i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 40) to i64), %180 br label %$61 $61: %182 = phi i1 [0, %$60], [%181, %$62] ; # -> br i1 %182, label %$64, label %$63 $63: call void @symNspErr(i64 %0, i64 %171) unreachable $64: ; # (cons (needNsp Exe (needSymb Exe (eval (++ X)))) $Nil) %183 = call i64 @cons(i64 %171, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %184 = inttoptr i64 %159 to i64* %185 = getelementptr i64, i64* %184, i32 1 store i64 %183, i64* %185 br label %$51 $53: %186 = phi i64 [%154, %$51] ; # X %187 = phi i64 [%155, %$51] ; # Y ; # (prog1 (val $Intern) (set $Intern R)) ; # (val $Intern) %188 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %189 = load i64, i64* %188 ; # (set $Intern R) %190 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) to i64) to i64* store i64 %145, i64* %190 ; # (drop *Safe) %191 = inttoptr i64 %149 to i64* %192 = getelementptr i64, i64* %191, i32 1 %193 = load i64, i64* %192 %194 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %193, i64* %194 br label %$12 $12: %195 = phi i64 [%106, %$24], [%186, %$53] ; # X %196 = phi i64 [%107, %$24], [%187, %$53] ; # Y %197 = phi i64 [%109, %$24], [%189, %$53] ; # -> br label %$4 $4: %198 = phi i64 [%6, %$2], [%195, %$12] ; # X %199 = phi i64 [%8, %$2], [%197, %$12] ; # -> ret i64 %199 } define i64 @_intern(i64) align 8 { $1: ; # (let (X (cdr Exe) Sym (save (needSymb Exe (eval (++ X))))) (cond ... ; # (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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %22, i64* %26 ; # (cond ((sym? (val (tail Sym))) $Nil) ((== (name @) ZERO) $Nil) (T... ; # (tail Sym) %27 = add i64 %15, -8 ; # (val (tail Sym)) %28 = inttoptr i64 %27 to i64* %29 = load i64, i64* %28 ; # (sym? (val (tail Sym))) %30 = and i64 %29, 8 %31 = icmp ne i64 %30, 0 br i1 %31, label %$11, label %$10 $11: br label %$9 $10: ; # (name @) br label %$12 $12: %32 = phi i64 [%29, %$10], [%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 ; # (== (name @) ZERO) %40 = icmp eq i64 %39, 2 br i1 %40, label %$16, label %$15 $16: br label %$9 $15: ; # (let Nm @ (if (nil? (eval (car X))) (let L (val $Intern) (intern ... ; # (if (nil? (eval (car X))) (let L (val $Intern) (intern Sym 0 Nm (... ; # (car X) %41 = inttoptr i64 %7 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] ; # -> ; # (nil? (eval (car X))) %51 = icmp eq i64 %50, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %51, label %$22, label %$23 $22: ; # (let L (val $Intern) (intern Sym 0 Nm (cdar (car L)) (cdr L) NO))... ; # (val $Intern) %52 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %53 = load i64, i64* %52 ; # (car L) %54 = inttoptr i64 %53 to i64* %55 = load i64, i64* %54 ; # (cdar (car L)) %56 = inttoptr i64 %55 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 ; # (cdr L) %61 = inttoptr i64 %53 to i64* %62 = getelementptr i64, i64* %61, i32 1 %63 = load i64, i64* %62 ; # (intern Sym 0 Nm (cdar (car L)) (cdr L) NO) %64 = call i64 @intern(i64 %15, i64 0, i64 %39, i64 %60, i64 %63, i1 0) br label %$24 $23: ; # (if (t? @) (cdar (car (val $Intern))) (cdar @)) ; # (t? @) %65 = icmp eq i64 %50, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br i1 %65, label %$25, label %$26 $25: ; # (val $Intern) %66 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %67 = load i64, i64* %66 ; # (car (val $Intern)) %68 = inttoptr i64 %67 to i64* %69 = load i64, i64* %68 ; # (cdar (car (val $Intern))) %70 = inttoptr i64 %69 to i64* %71 = load i64, i64* %70 %72 = inttoptr i64 %71 to i64* %73 = getelementptr i64, i64* %72, i32 1 %74 = load i64, i64* %73 br label %$27 $26: ; # (cdar @) %75 = inttoptr i64 %50 to i64* %76 = load i64, i64* %75 %77 = inttoptr i64 %76 to i64* %78 = getelementptr i64, i64* %77, i32 1 %79 = load i64, i64* %78 br label %$27 $27: %80 = phi i64 [%74, %$25], [%79, %$26] ; # -> ; # (intern Sym 0 Nm (if (t? @) (cdar (car (val $Intern))) (cdar @)) ... %81 = call i64 @intern(i64 %15, i64 0, i64 %39, i64 %80, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i1 0) br label %$24 $24: %82 = phi i64 [%64, %$22], [%81, %$27] ; # -> br label %$9 $9: %83 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%82, %$24] ; # -> ; # (drop *Safe) %84 = inttoptr i64 %22 to i64* %85 = getelementptr i64, i64* %84, i32 1 %86 = load i64, i64* %85 %87 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %86, i64* %87 ret i64 %83 } 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 ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* %2 = getelementptr i64, i64* %1, i32 1 store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %2 %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %3 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([17 x i64]* @env to i8*), i32 72) 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 x i64]* @env to i8*), i32 72) 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 Exe Y) NIL) Q (link (ofs P ... ; # (nil? Y) %5 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 Exe Y) NIL) Q (link (ofs P 1) T) R (push 4... ; # (xName Exe Y) %8 = call i64 @xName(i64 %0, i64 %4) ; # (push 0 (xName Exe 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 0 X))) (let (P (push 0 (xNam... ; # (nil? X) %2 = icmp eq i64 %0, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %2, label %$2, label %$3 $3: %3 = phi i64 [%0, %$1] ; # X ; # (xName 0 X) %4 = call i64 @xName(i64 0, i64 %3) ; # (== ZERO (setq X (xName 0 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 0 Y)) B T) (loop (? (=0 (setq B (symByte P... ; # (xName 0 Y) %7 = call i64 @xName(i64 0, i64 %1) ; # (push 0 (xName 0 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 ([17 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 ([17 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 Exe Y))) Z) (T (let P... ; # (nil? Y) %17 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 Exe Y) %20 = call i64 @xName(i64 %0, i64 %19) ; # (== ZERO (setq Y (xName Exe 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 Exe Z)) (cond ((=0 (symByte P)) $Nil) ((pre... ; # (xName Exe Z) %24 = call i64 @xName(i64 %0, i64 %16) ; # (push 0 (xName Exe 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%16, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Z) %57 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$32], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$37], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %205 ; # (link (push $Nil NIL)) %206 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %72, i64* %73 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %100, i64* %101 ret i64 %97 } define i64 @idxPut(i64, i64) align 8 { $1: ; # (let X (val Var) (if (pair X) (loop (? (=0 (compare (car X) Key))... ; # (val Var) %2 = inttoptr i64 %0 to i64* %3 = load i64, i64* %2 ; # (if (pair X) (loop (? (=0 (compare (car X) Key)) X) (let Y (cdr X... ; # (pair X) %4 = and i64 %3, 15 %5 = icmp eq i64 %4, 0 br i1 %5, label %$2, label %$3 $2: %6 = phi i64 [%3, %$1] ; # X ; # (loop (? (=0 (compare (car X) Key)) X) (let Y (cdr X) (cond ((lt0... br label %$5 $5: %7 = phi i64 [%6, %$2], [%65, %$9] ; # X ; # (? (=0 (compare (car X) Key)) X) ; # (car X) %8 = inttoptr i64 %7 to i64* %9 = load i64, i64* %8 ; # (compare (car X) Key) %10 = call i64 @compare(i64 %9, i64 %1) ; # (=0 (compare (car X) Key)) %11 = icmp eq i64 %10, 0 br i1 %11, label %$8, label %$6 $8: %12 = phi i64 [%7, %$5] ; # X br label %$7 $6: %13 = phi i64 [%7, %$5] ; # X ; # (let Y (cdr X) (cond ((lt0 @) (? (atom Y) (set 2 X (cons $Nil (co... ; # (cdr X) %14 = inttoptr i64 %13 to i64* %15 = getelementptr i64, i64* %14, i32 1 %16 = load i64, i64* %15 ; # (cond ((lt0 @) (? (atom Y) (set 2 X (cons $Nil (cons Key $Nil))) ... ; # (lt0 @) %17 = icmp slt i64 %10, 0 br i1 %17, label %$11, label %$10 $11: %18 = phi i64 [%13, %$6] ; # X %19 = phi i64 [%16, %$6] ; # Y ; # (? (atom Y) (set 2 X (cons $Nil (cons Key $Nil))) $Nil) ; # (atom Y) %20 = and i64 %19, 15 %21 = icmp ne i64 %20, 0 br i1 %21, label %$13, label %$12 $13: %22 = phi i64 [%18, %$11] ; # X %23 = phi i64 [%19, %$11] ; # Y ; # (set 2 X (cons $Nil (cons Key $Nil))) ; # (cons Key $Nil) %24 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (cons $Nil (cons Key $Nil)) %25 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 %24) %26 = inttoptr i64 %22 to i64* %27 = getelementptr i64, i64* %26, i32 1 store i64 %25, i64* %27 br label %$7 $12: %28 = phi i64 [%18, %$11] ; # X %29 = phi i64 [%19, %$11] ; # Y ; # (? (atom (setq Y (cdr (setq X Y)))) (set 2 X (cons Key $Nil)) $Ni... ; # (cdr (setq X Y)) %30 = inttoptr i64 %29 to i64* %31 = getelementptr i64, i64* %30, i32 1 %32 = load i64, i64* %31 ; # (atom (setq Y (cdr (setq X Y)))) %33 = and i64 %32, 15 %34 = icmp ne i64 %33, 0 br i1 %34, label %$15, label %$14 $15: %35 = phi i64 [%29, %$12] ; # X %36 = phi i64 [%32, %$12] ; # Y ; # (set 2 X (cons Key $Nil)) ; # (cons Key $Nil) %37 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %38 = inttoptr i64 %35 to i64* %39 = getelementptr i64, i64* %38, i32 1 store i64 %37, i64* %39 br label %$7 $14: %40 = phi i64 [%29, %$12] ; # X %41 = phi i64 [%32, %$12] ; # Y br label %$9 $10: %42 = phi i64 [%13, %$6] ; # X %43 = phi i64 [%16, %$6] ; # Y ; # (? (atom Y) (set 2 X (cons (cons Key $Nil) $Nil)) $Nil) ; # (atom Y) %44 = and i64 %43, 15 %45 = icmp ne i64 %44, 0 br i1 %45, label %$17, label %$16 $17: %46 = phi i64 [%42, %$10] ; # X %47 = phi i64 [%43, %$10] ; # Y ; # (set 2 X (cons (cons Key $Nil) $Nil)) ; # (cons Key $Nil) %48 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (cons (cons Key $Nil) $Nil) %49 = call i64 @cons(i64 %48, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %50 = inttoptr i64 %46 to i64* %51 = getelementptr i64, i64* %50, i32 1 store i64 %49, i64* %51 br label %$7 $16: %52 = phi i64 [%42, %$10] ; # X %53 = phi i64 [%43, %$10] ; # Y ; # (? (atom (setq Y (car (setq X Y)))) (set X (cons Key $Nil)) $Nil)... ; # (car (setq X Y)) %54 = inttoptr i64 %53 to i64* %55 = load i64, i64* %54 ; # (atom (setq Y (car (setq X Y)))) %56 = and i64 %55, 15 %57 = icmp ne i64 %56, 0 br i1 %57, label %$19, label %$18 $19: %58 = phi i64 [%53, %$16] ; # X %59 = phi i64 [%55, %$16] ; # Y ; # (set X (cons Key $Nil)) ; # (cons Key $Nil) %60 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %61 = inttoptr i64 %58 to i64* store i64 %60, i64* %61 br label %$7 $18: %62 = phi i64 [%53, %$16] ; # X %63 = phi i64 [%55, %$16] ; # Y br label %$9 $9: %64 = phi i64 [%40, %$14], [%62, %$18] ; # X %65 = phi i64 [%41, %$14], [%63, %$18] ; # Y br label %$5 $7: %66 = phi i64 [%12, %$8], [%22, %$13], [%35, %$15], [%46, %$17], [%58, %$19] ; # X %67 = phi i64 [%12, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$19] ; # -> br label %$4 $3: %68 = phi i64 [%3, %$1] ; # X ; # (set Var (cons Key $Nil)) ; # (cons Key $Nil) %69 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %70 = inttoptr i64 %0 to i64* store i64 %69, i64* %70 br label %$4 $4: %71 = phi i64 [%66, %$7], [%68, %$3] ; # X %72 = phi i64 [%67, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # -> ret i64 %72 } define i64 @idxGet(i64, i64) align 8 { $1: ; # (let X (val Var) (loop (? (atom X) $Nil) (? (=0 (compare (car X) ... ; # (val Var) %2 = inttoptr i64 %0 to i64* %3 = load i64, i64* %2 ; # (loop (? (atom X) $Nil) (? (=0 (compare (car X) Key)) X) (let Y (... br label %$2 $2: %4 = phi i64 [%3, %$1], [%27, %$10] ; # X ; # (? (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 [%4, %$2] ; # X br label %$4 $3: %8 = phi i64 [%4, %$2] ; # 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 %$7, label %$6 $7: %13 = phi i64 [%8, %$3] ; # X br label %$4 $6: %14 = phi i64 [%8, %$3] ; # X ; # (let Y (cdr X) (setq X (if (lt0 @) (cdr Y) (car Y)))) ; # (cdr X) %15 = inttoptr i64 %14 to i64* %16 = getelementptr i64, i64* %15, i32 1 %17 = load i64, i64* %16 ; # (if (lt0 @) (cdr Y) (car Y)) ; # (lt0 @) %18 = icmp slt i64 %11, 0 br i1 %18, label %$8, label %$9 $8: %19 = phi i64 [%14, %$6] ; # X ; # (cdr Y) %20 = inttoptr i64 %17 to i64* %21 = getelementptr i64, i64* %20, i32 1 %22 = load i64, i64* %21 br label %$10 $9: %23 = phi i64 [%14, %$6] ; # X ; # (car Y) %24 = inttoptr i64 %17 to i64* %25 = load i64, i64* %24 br label %$10 $10: %26 = phi i64 [%19, %$8], [%23, %$9] ; # X %27 = phi i64 [%22, %$8], [%25, %$9] ; # -> br label %$2 $4: %28 = phi i64 [%7, %$5], [%13, %$7] ; # X %29 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%13, %$7] ; # -> ret i64 %29 } 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%4, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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) 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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: ; # (if (== Key ZERO) (val Sym) (let Tail (val (tail Sym)) (unless (n... ; # (== Key ZERO) %2 = icmp eq i64 %1, 2 br i1 %2, label %$2, label %$3 $2: ; # (val Sym) %3 = inttoptr i64 %0 to i64* %4 = load i64, i64* %3 br label %$4 $3: ; # (let Tail (val (tail Sym)) (unless (num? Tail) (let (L (any (& Ta... ; # (tail Sym) %5 = add i64 %0, -8 ; # (val (tail Sym)) %6 = inttoptr i64 %5 to i64* %7 = load i64, i64* %6 ; # (unless (num? Tail) (let (L (any (& Tail -9)) X (car L)) (if (ato... ; # (num? Tail) %8 = and i64 %7, 6 %9 = icmp ne i64 %8, 0 br i1 %9, label %$6, label %$5 $5: ; # (let (L (any (& Tail -9)) X (car L)) (if (atom X) (when (== Key X... ; # (& Tail -9) %10 = and i64 %7, -9 ; # (any (& Tail -9)) ; # (car L) %11 = inttoptr i64 %10 to i64* %12 = load i64, i64* %11 ; # (if (atom X) (when (== Key X) (ret $T)) (when (== Key (cdr X)) (r... ; # (atom X) %13 = and i64 %12, 15 %14 = icmp ne i64 %13, 0 br i1 %14, label %$7, label %$8 $7: %15 = phi i64 [%10, %$5] ; # L %16 = phi i64 [%12, %$5] ; # X ; # (when (== Key X) (ret $T)) ; # (== Key X) %17 = icmp eq i64 %1, %16 br i1 %17, label %$10, label %$11 $10: %18 = phi i64 [%15, %$7] ; # L %19 = phi i64 [%16, %$7] ; # X ; # (ret $T) ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) $11: %20 = phi i64 [%15, %$7] ; # L %21 = phi i64 [%16, %$7] ; # X br label %$9 $8: %22 = phi i64 [%10, %$5] ; # L %23 = phi i64 [%12, %$5] ; # X ; # (when (== Key (cdr X)) (ret (car X))) ; # (cdr X) %24 = inttoptr i64 %23 to i64* %25 = getelementptr i64, i64* %24, i32 1 %26 = load i64, i64* %25 ; # (== Key (cdr X)) %27 = icmp eq i64 %1, %26 br i1 %27, label %$12, label %$13 $12: %28 = phi i64 [%22, %$8] ; # L %29 = phi i64 [%23, %$8] ; # X ; # (car X) %30 = inttoptr i64 %29 to i64* %31 = load i64, i64* %30 ; # (ret (car X)) ret i64 %31 $13: %32 = phi i64 [%22, %$8] ; # L %33 = phi i64 [%23, %$8] ; # X br label %$9 $9: %34 = phi i64 [%20, %$11], [%32, %$13] ; # L %35 = phi i64 [%21, %$11], [%33, %$13] ; # X ; # (while (pair (setq X (cdr L))) (let Y (car X) (if (atom Y) (when ... br label %$14 $14: %36 = phi i64 [%34, %$9], [%113, %$19] ; # L %37 = phi i64 [%35, %$9], [%113, %$19] ; # X ; # (cdr L) %38 = inttoptr i64 %36 to i64* %39 = getelementptr i64, i64* %38, i32 1 %40 = load i64, i64* %39 ; # (pair (setq X (cdr L))) %41 = and i64 %40, 15 %42 = icmp eq i64 %41, 0 br i1 %42, label %$15, label %$16 $15: %43 = phi i64 [%36, %$14] ; # L %44 = phi i64 [%40, %$14] ; # X ; # (let Y (car X) (if (atom Y) (when (== Key Y) (set 2 L (cdr X)) (i... ; # (car X) %45 = inttoptr i64 %44 to i64* %46 = load i64, i64* %45 ; # (if (atom Y) (when (== Key Y) (set 2 L (cdr X)) (ifn (sym? Tail) ... ; # (atom Y) %47 = and i64 %46, 15 %48 = icmp ne i64 %47, 0 br i1 %48, label %$17, label %$18 $17: %49 = phi i64 [%43, %$15] ; # L %50 = phi i64 [%44, %$15] ; # X ; # (when (== Key Y) (set 2 L (cdr X)) (ifn (sym? Tail) (set 2 X Tail... ; # (== Key Y) %51 = icmp eq i64 %1, %46 br i1 %51, label %$20, label %$21 $20: %52 = phi i64 [%49, %$17] ; # L %53 = phi i64 [%50, %$17] ; # X ; # (set 2 L (cdr X)) ; # (cdr X) %54 = inttoptr i64 %53 to i64* %55 = getelementptr i64, i64* %54, i32 1 %56 = load i64, i64* %55 %57 = inttoptr i64 %52 to i64* %58 = getelementptr i64, i64* %57, i32 1 store i64 %56, i64* %58 ; # (ifn (sym? Tail) (set 2 X Tail) (set 2 X (& Tail -9)) (setq X (sy... ; # (sym? Tail) %59 = and i64 %7, 8 %60 = icmp ne i64 %59, 0 br i1 %60, label %$23, label %$22 $22: %61 = phi i64 [%52, %$20] ; # L %62 = phi i64 [%53, %$20] ; # X ; # (set 2 X Tail) %63 = inttoptr i64 %62 to i64* %64 = getelementptr i64, i64* %63, i32 1 store i64 %7, i64* %64 br label %$24 $23: %65 = phi i64 [%52, %$20] ; # L %66 = phi i64 [%53, %$20] ; # X ; # (set 2 X (& Tail -9)) ; # (& Tail -9) %67 = and i64 %7, -9 %68 = inttoptr i64 %66 to i64* %69 = getelementptr i64, i64* %68, i32 1 store i64 %67, i64* %69 ; # (sym X) %70 = or i64 %66, 8 br label %$24 $24: %71 = phi i64 [%61, %$22], [%65, %$23] ; # L %72 = phi i64 [%62, %$22], [%70, %$23] ; # X %73 = phi i64 [%7, %$22], [%70, %$23] ; # -> ; # (set (tail Sym) X) ; # (tail Sym) %74 = add i64 %0, -8 %75 = inttoptr i64 %74 to i64* store i64 %72, i64* %75 ; # (ret $T) ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) $21: %76 = phi i64 [%49, %$17] ; # L %77 = phi i64 [%50, %$17] ; # X br label %$19 $18: %78 = phi i64 [%43, %$15] ; # L %79 = phi i64 [%44, %$15] ; # X ; # (when (== Key (cdr Y)) (set 2 L (cdr X)) (ifn (sym? Tail) (set 2 ... ; # (cdr Y) %80 = inttoptr i64 %46 to i64* %81 = getelementptr i64, i64* %80, i32 1 %82 = load i64, i64* %81 ; # (== Key (cdr Y)) %83 = icmp eq i64 %1, %82 br i1 %83, label %$25, label %$26 $25: %84 = phi i64 [%78, %$18] ; # L %85 = phi i64 [%79, %$18] ; # X ; # (set 2 L (cdr X)) ; # (cdr X) %86 = inttoptr i64 %85 to i64* %87 = getelementptr i64, i64* %86, i32 1 %88 = load i64, i64* %87 %89 = inttoptr i64 %84 to i64* %90 = getelementptr i64, i64* %89, i32 1 store i64 %88, i64* %90 ; # (ifn (sym? Tail) (set 2 X Tail) (set 2 X (& Tail -9)) (setq X (sy... ; # (sym? Tail) %91 = and i64 %7, 8 %92 = icmp ne i64 %91, 0 br i1 %92, label %$28, label %$27 $27: %93 = phi i64 [%84, %$25] ; # L %94 = phi i64 [%85, %$25] ; # X ; # (set 2 X Tail) %95 = inttoptr i64 %94 to i64* %96 = getelementptr i64, i64* %95, i32 1 store i64 %7, i64* %96 br label %$29 $28: %97 = phi i64 [%84, %$25] ; # L %98 = phi i64 [%85, %$25] ; # X ; # (set 2 X (& Tail -9)) ; # (& Tail -9) %99 = and i64 %7, -9 %100 = inttoptr i64 %98 to i64* %101 = getelementptr i64, i64* %100, i32 1 store i64 %99, i64* %101 ; # (sym X) %102 = or i64 %98, 8 br label %$29 $29: %103 = phi i64 [%93, %$27], [%97, %$28] ; # L %104 = phi i64 [%94, %$27], [%102, %$28] ; # X %105 = phi i64 [%7, %$27], [%102, %$28] ; # -> ; # (set (tail Sym) X) ; # (tail Sym) %106 = add i64 %0, -8 %107 = inttoptr i64 %106 to i64* store i64 %104, i64* %107 ; # (car Y) %108 = inttoptr i64 %46 to i64* %109 = load i64, i64* %108 ; # (ret (car Y)) ret i64 %109 $26: %110 = phi i64 [%78, %$18] ; # L %111 = phi i64 [%79, %$18] ; # X br label %$19 $19: %112 = phi i64 [%76, %$21], [%110, %$26] ; # L %113 = phi i64 [%77, %$21], [%111, %$26] ; # X br label %$14 $16: %114 = phi i64 [%36, %$14] ; # L %115 = phi i64 [%40, %$14] ; # X br label %$6 $6: br label %$4 $4: %116 = phi i64 [%4, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$6] ; # -> ret i64 %116 } 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 ([870 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 ([870 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 ; # (get X Key) %78 = tail call i64 @get(i64 %77, i64 %2) br label %$6 $6: %79 = phi i64 [%68, %$7], [%77, %$27] ; # X %80 = phi i64 [%69, %$7], [%78, %$27] ; # -> ret i64 %80 } 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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], [%31, %$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? (get Y Key))) @) (st... ; # (car X) %7 = inttoptr i64 %6 to i64* %8 = load i64, i64* %7 ; # (when (symb? Y) (? (not (nil? (get Y Key))) @) (stkChk 0) (? (not... ; # (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? (get Y Key))) @) ; # (get Y Key) %13 = call i64 @get(i64 %8, i64 %1) ; # (nil? (get Y Key)) %14 = icmp eq i64 %13, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) ; # (not (nil? (get Y Key))) %15 = icmp eq i1 %14, 0 br i1 %15, label %$9, label %$8 $9: %16 = phi i64 [%12, %$6] ; # X br label %$4 $8: %17 = phi i64 [%12, %$6] ; # X ; # (stkChk 0) %18 = load i8*, i8** @$StkLimit %19 = call i8* @llvm.stacksave() %20 = icmp ugt i8* %18, %19 br i1 %20, label %$10, label %$11 $10: call void @stkErr(i64 0) unreachable $11: ; # (? (not (nil? (meta (car Y) Key))) @) ; # (car Y) %21 = inttoptr i64 %8 to i64* %22 = load i64, i64* %21 ; # (meta (car Y) Key) %23 = call i64 @meta(i64 %22, i64 %1) ; # (nil? (meta (car Y) Key)) %24 = icmp eq i64 %23, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) ; # (not (nil? (meta (car Y) Key))) %25 = icmp eq i1 %24, 0 br i1 %25, label %$13, label %$12 $13: %26 = phi i64 [%17, %$11] ; # X br label %$4 $12: %27 = phi i64 [%17, %$11] ; # X br label %$7 $7: %28 = phi i64 [%6, %$3], [%27, %$12] ; # X ; # (shift X) %29 = inttoptr i64 %28 to i64* %30 = getelementptr i64, i64* %29, i32 1 %31 = load i64, i64* %30 br label %$2 $4: %32 = phi i64 [%5, %$5], [%16, %$9], [%26, %$13] ; # X %33 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%13, %$9], [%23, %$13] ; # -> ret i64 %33 } 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 Exe X)... ; # (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 ([870 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 Exe X) NIL) Q (link (ofs P 1) T) R (push 4... ; # (xName Exe X) %20 = call i64 @xName(i64 %0, i64 %13) ; # (push 0 (xName Exe 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 Exe X)... ; # (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 ([870 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 Exe X) NIL) Q (link (ofs P 1) T) R (push 4... ; # (xName Exe X) %20 = call i64 @xName(i64 %0, i64 %13) ; # (push 0 (xName Exe 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 Exe Y) NIL... ; # (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 Exe Y) %26 = call i64 @xName(i64 %0, i64 %15) ; # (push 0 (xName Exe 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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) 0) ((> X ... ; # (== 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) 0) ((> 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 eq 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 ; # (> X Y) %113 = icmp ugt i64 %109, %110 br i1 %113, label %$41, label %$42 $42: %114 = phi i64 [%109, %$39] ; # X %115 = phi i64 [%110, %$39] ; # Y %116 = phi i64 [%111, %$39] ; # NmX %117 = phi i64 [%112, %$39] ; # NmY br label %$36 $41: %118 = phi i64 [%109, %$39] ; # X %119 = phi i64 [%110, %$39] ; # Y %120 = phi i64 [%111, %$39] ; # NmX %121 = phi i64 [%112, %$39] ; # NmY br label %$36 $36: %122 = phi i64 [%96, %$38], [%105, %$40], [%114, %$42], [%118, %$41] ; # X %123 = phi i64 [%97, %$38], [%106, %$40], [%115, %$42], [%119, %$41] ; # Y %124 = phi i64 [%98, %$38], [%107, %$40], [%116, %$42], [%120, %$41] ; # NmX %125 = phi i64 [%99, %$38], [%108, %$40], [%117, %$42], [%121, %$41] ; # NmY %126 = phi i64 [-1, %$38], [0, %$40], [1, %$42], [-1, %$41] ; # -> br label %$33 $34: %127 = phi i64 [%64, %$32] ; # X %128 = phi i64 [%65, %$32] ; # Y %129 = phi i64 [%77, %$32] ; # NmX %130 = phi i64 [%89, %$32] ; # NmY ; # (== ZERO NmY) %131 = icmp eq i64 2, %130 br i1 %131, label %$44, label %$43 $44: %132 = phi i64 [%127, %$34] ; # X %133 = phi i64 [%128, %$34] ; # Y %134 = phi i64 [%129, %$34] ; # NmX %135 = phi i64 [%130, %$34] ; # NmY br label %$33 $43: %136 = phi i64 [%127, %$34] ; # X %137 = phi i64 [%128, %$34] ; # Y %138 = phi i64 [%129, %$34] ; # NmX %139 = phi i64 [%130, %$34] ; # NmY ; # (loop (let (A (if (cnt? NmX) (prog1 (shr (shl (name NmX) 2) 6) (s... br label %$45 $45: %140 = phi i64 [%136, %$43], [%339, %$65] ; # X %141 = phi i64 [%137, %$43], [%340, %$65] ; # Y %142 = phi i64 [%138, %$43], [%341, %$65] ; # NmX %143 = phi i64 [%139, %$43], [%342, %$65] ; # 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) %144 = and i64 %142, 2 %145 = icmp ne i64 %144, 0 br i1 %145, label %$46, label %$47 $46: %146 = phi i64 [%140, %$45] ; # X %147 = phi i64 [%141, %$45] ; # Y %148 = phi i64 [%142, %$45] ; # NmX %149 = phi i64 [%143, %$45] ; # NmY ; # (prog1 (shr (shl (name NmX) 2) 6) (setq NmX 0)) ; # (name NmX) br label %$49 $49: %150 = phi i64 [%148, %$46], [%156, %$50] ; # Tail %151 = and i64 %150, 6 %152 = icmp ne i64 %151, 0 br i1 %152, label %$51, label %$50 $50: %153 = phi i64 [%150, %$49] ; # Tail %154 = inttoptr i64 %153 to i64* %155 = getelementptr i64, i64* %154, i32 1 %156 = load i64, i64* %155 br label %$49 $51: %157 = phi i64 [%150, %$49] ; # Tail ; # (shl (name NmX) 2) %158 = shl i64 %157, 2 ; # (shr (shl (name NmX) 2) 6) %159 = lshr i64 %158, 6 br label %$48 $47: %160 = phi i64 [%140, %$45] ; # X %161 = phi i64 [%141, %$45] ; # Y %162 = phi i64 [%142, %$45] ; # NmX %163 = phi i64 [%143, %$45] ; # NmY ; # (prog1 (val (dig NmX)) (setq NmX (val (big NmX)))) ; # (dig NmX) %164 = add i64 %162, -4 ; # (val (dig NmX)) %165 = inttoptr i64 %164 to i64* %166 = load i64, i64* %165 ; # (big NmX) %167 = add i64 %162, 4 ; # (val (big NmX)) %168 = inttoptr i64 %167 to i64* %169 = load i64, i64* %168 br label %$48 $48: %170 = phi i64 [%146, %$51], [%160, %$47] ; # X %171 = phi i64 [%147, %$51], [%161, %$47] ; # Y %172 = phi i64 [0, %$51], [%169, %$47] ; # NmX %173 = phi i64 [%149, %$51], [%163, %$47] ; # NmY %174 = phi i64 [%159, %$51], [%166, %$47] ; # -> ; # (if (cnt? NmY) (prog1 (shr (shl (name NmY) 2) 6) (setq NmY 0)) (p... ; # (cnt? NmY) %175 = and i64 %173, 2 %176 = icmp ne i64 %175, 0 br i1 %176, label %$52, label %$53 $52: %177 = phi i64 [%170, %$48] ; # X %178 = phi i64 [%171, %$48] ; # Y %179 = phi i64 [%172, %$48] ; # NmX %180 = phi i64 [%173, %$48] ; # NmY %181 = phi i64 [%174, %$48] ; # A ; # (prog1 (shr (shl (name NmY) 2) 6) (setq NmY 0)) ; # (name NmY) br label %$55 $55: %182 = phi i64 [%180, %$52], [%188, %$56] ; # Tail %183 = and i64 %182, 6 %184 = icmp ne i64 %183, 0 br i1 %184, label %$57, label %$56 $56: %185 = phi i64 [%182, %$55] ; # Tail %186 = inttoptr i64 %185 to i64* %187 = getelementptr i64, i64* %186, i32 1 %188 = load i64, i64* %187 br label %$55 $57: %189 = phi i64 [%182, %$55] ; # Tail ; # (shl (name NmY) 2) %190 = shl i64 %189, 2 ; # (shr (shl (name NmY) 2) 6) %191 = lshr i64 %190, 6 br label %$54 $53: %192 = phi i64 [%170, %$48] ; # X %193 = phi i64 [%171, %$48] ; # Y %194 = phi i64 [%172, %$48] ; # NmX %195 = phi i64 [%173, %$48] ; # NmY %196 = phi i64 [%174, %$48] ; # A ; # (prog1 (val (dig NmY)) (setq NmY (val (big NmY)))) ; # (dig NmY) %197 = add i64 %195, -4 ; # (val (dig NmY)) %198 = inttoptr i64 %197 to i64* %199 = load i64, i64* %198 ; # (big NmY) %200 = add i64 %195, 4 ; # (val (big NmY)) %201 = inttoptr i64 %200 to i64* %202 = load i64, i64* %201 br label %$54 $54: %203 = phi i64 [%177, %$57], [%192, %$53] ; # X %204 = phi i64 [%178, %$57], [%193, %$53] ; # Y %205 = phi i64 [%179, %$57], [%194, %$53] ; # NmX %206 = phi i64 [0, %$57], [%202, %$53] ; # NmY %207 = phi i64 [%181, %$57], [%196, %$53] ; # A %208 = phi i64 [%191, %$57], [%199, %$53] ; # -> ; # (loop (when (- (& A 255) (& B 255)) (ret (if (gt0 @) 1 -1))) (? (... br label %$58 $58: %209 = phi i64 [%203, %$54], [%333, %$77] ; # X %210 = phi i64 [%204, %$54], [%334, %$77] ; # Y %211 = phi i64 [%205, %$54], [%335, %$77] ; # NmX %212 = phi i64 [%206, %$54], [%336, %$77] ; # NmY %213 = phi i64 [%207, %$54], [%337, %$77] ; # A %214 = phi i64 [%208, %$54], [%338, %$77] ; # B ; # (when (- (& A 255) (& B 255)) (ret (if (gt0 @) 1 -1))) ; # (& A 255) %215 = and i64 %213, 255 ; # (& B 255) %216 = and i64 %214, 255 ; # (- (& A 255) (& B 255)) %217 = sub i64 %215, %216 %218 = icmp ne i64 %217, 0 br i1 %218, label %$59, label %$60 $59: %219 = phi i64 [%209, %$58] ; # X %220 = phi i64 [%210, %$58] ; # Y %221 = phi i64 [%211, %$58] ; # NmX %222 = phi i64 [%212, %$58] ; # NmY %223 = phi i64 [%213, %$58] ; # A %224 = phi i64 [%214, %$58] ; # B ; # (if (gt0 @) 1 -1) ; # (gt0 @) %225 = icmp sgt i64 %217, 0 br i1 %225, label %$61, label %$62 $61: %226 = phi i64 [%219, %$59] ; # X %227 = phi i64 [%220, %$59] ; # Y %228 = phi i64 [%221, %$59] ; # NmX %229 = phi i64 [%222, %$59] ; # NmY %230 = phi i64 [%223, %$59] ; # A %231 = phi i64 [%224, %$59] ; # B br label %$63 $62: %232 = phi i64 [%219, %$59] ; # X %233 = phi i64 [%220, %$59] ; # Y %234 = phi i64 [%221, %$59] ; # NmX %235 = phi i64 [%222, %$59] ; # NmY %236 = phi i64 [%223, %$59] ; # A %237 = phi i64 [%224, %$59] ; # B br label %$63 $63: %238 = phi i64 [%226, %$61], [%232, %$62] ; # X %239 = phi i64 [%227, %$61], [%233, %$62] ; # Y %240 = phi i64 [%228, %$61], [%234, %$62] ; # NmX %241 = phi i64 [%229, %$61], [%235, %$62] ; # NmY %242 = phi i64 [%230, %$61], [%236, %$62] ; # A %243 = phi i64 [%231, %$61], [%237, %$62] ; # B %244 = phi i64 [1, %$61], [-1, %$62] ; # -> ; # (ret (if (gt0 @) 1 -1)) ret i64 %244 $60: %245 = phi i64 [%209, %$58] ; # X %246 = phi i64 [%210, %$58] ; # Y %247 = phi i64 [%211, %$58] ; # NmX %248 = phi i64 [%212, %$58] ; # NmY %249 = phi i64 [%213, %$58] ; # A %250 = phi i64 [%214, %$58] ; # B ; # (? (=0 (setq A (shr A 8))) (when (setq B (shr B 8)) (ret -1)) (un... ; # (shr A 8) %251 = lshr i64 %249, 8 ; # (=0 (setq A (shr A 8))) %252 = icmp eq i64 %251, 0 br i1 %252, label %$66, label %$64 $66: %253 = phi i64 [%245, %$60] ; # X %254 = phi i64 [%246, %$60] ; # Y %255 = phi i64 [%247, %$60] ; # NmX %256 = phi i64 [%248, %$60] ; # NmY %257 = phi i64 [%251, %$60] ; # A %258 = phi i64 [%250, %$60] ; # B ; # (when (setq B (shr B 8)) (ret -1)) ; # (shr B 8) %259 = lshr i64 %258, 8 %260 = icmp ne i64 %259, 0 br i1 %260, label %$67, label %$68 $67: %261 = phi i64 [%253, %$66] ; # X %262 = phi i64 [%254, %$66] ; # Y %263 = phi i64 [%255, %$66] ; # NmX %264 = phi i64 [%256, %$66] ; # NmY %265 = phi i64 [%257, %$66] ; # A %266 = phi i64 [%259, %$66] ; # B ; # (ret -1) ret i64 -1 $68: %267 = phi i64 [%253, %$66] ; # X %268 = phi i64 [%254, %$66] ; # Y %269 = phi i64 [%255, %$66] ; # NmX %270 = phi i64 [%256, %$66] ; # NmY %271 = phi i64 [%257, %$66] ; # A %272 = phi i64 [%259, %$66] ; # B ; # (unless NmX (ret (if NmY -1 0))) %273 = icmp ne i64 %269, 0 br i1 %273, label %$70, label %$69 $69: %274 = phi i64 [%267, %$68] ; # X %275 = phi i64 [%268, %$68] ; # Y %276 = phi i64 [%269, %$68] ; # NmX %277 = phi i64 [%270, %$68] ; # NmY %278 = phi i64 [%271, %$68] ; # A %279 = phi i64 [%272, %$68] ; # B ; # (if NmY -1 0) %280 = icmp ne i64 %277, 0 br i1 %280, label %$71, label %$72 $71: %281 = phi i64 [%274, %$69] ; # X %282 = phi i64 [%275, %$69] ; # Y %283 = phi i64 [%276, %$69] ; # NmX %284 = phi i64 [%277, %$69] ; # NmY %285 = phi i64 [%278, %$69] ; # A %286 = phi i64 [%279, %$69] ; # B br label %$73 $72: %287 = phi i64 [%274, %$69] ; # X %288 = phi i64 [%275, %$69] ; # Y %289 = phi i64 [%276, %$69] ; # NmX %290 = phi i64 [%277, %$69] ; # NmY %291 = phi i64 [%278, %$69] ; # A %292 = phi i64 [%279, %$69] ; # B br label %$73 $73: %293 = phi i64 [%281, %$71], [%287, %$72] ; # X %294 = phi i64 [%282, %$71], [%288, %$72] ; # Y %295 = phi i64 [%283, %$71], [%289, %$72] ; # NmX %296 = phi i64 [%284, %$71], [%290, %$72] ; # NmY %297 = phi i64 [%285, %$71], [%291, %$72] ; # A %298 = phi i64 [%286, %$71], [%292, %$72] ; # B %299 = phi i64 [-1, %$71], [0, %$72] ; # -> ; # (ret (if NmY -1 0)) ret i64 %299 $70: %300 = phi i64 [%267, %$68] ; # X %301 = phi i64 [%268, %$68] ; # Y %302 = phi i64 [%269, %$68] ; # NmX %303 = phi i64 [%270, %$68] ; # NmY %304 = phi i64 [%271, %$68] ; # A %305 = phi i64 [%272, %$68] ; # B ; # (unless NmY (ret 1)) %306 = icmp ne i64 %303, 0 br i1 %306, label %$75, label %$74 $74: %307 = phi i64 [%300, %$70] ; # X %308 = phi i64 [%301, %$70] ; # Y %309 = phi i64 [%302, %$70] ; # NmX %310 = phi i64 [%303, %$70] ; # NmY %311 = phi i64 [%304, %$70] ; # A %312 = phi i64 [%305, %$70] ; # B ; # (ret 1) ret i64 1 $75: %313 = phi i64 [%300, %$70] ; # X %314 = phi i64 [%301, %$70] ; # Y %315 = phi i64 [%302, %$70] ; # NmX %316 = phi i64 [%303, %$70] ; # NmY %317 = phi i64 [%304, %$70] ; # A %318 = phi i64 [%305, %$70] ; # B br label %$65 $64: %319 = phi i64 [%245, %$60] ; # X %320 = phi i64 [%246, %$60] ; # Y %321 = phi i64 [%247, %$60] ; # NmX %322 = phi i64 [%248, %$60] ; # NmY %323 = phi i64 [%251, %$60] ; # A %324 = phi i64 [%250, %$60] ; # B ; # (unless (setq B (shr B 8)) (ret 1)) ; # (shr B 8) %325 = lshr i64 %324, 8 %326 = icmp ne i64 %325, 0 br i1 %326, label %$77, label %$76 $76: %327 = phi i64 [%319, %$64] ; # X %328 = phi i64 [%320, %$64] ; # Y %329 = phi i64 [%321, %$64] ; # NmX %330 = phi i64 [%322, %$64] ; # NmY %331 = phi i64 [%323, %$64] ; # A %332 = phi i64 [%325, %$64] ; # B ; # (ret 1) ret i64 1 $77: %333 = phi i64 [%319, %$64] ; # X %334 = phi i64 [%320, %$64] ; # Y %335 = phi i64 [%321, %$64] ; # NmX %336 = phi i64 [%322, %$64] ; # NmY %337 = phi i64 [%323, %$64] ; # A %338 = phi i64 [%325, %$64] ; # B br label %$58 $65: %339 = phi i64 [%313, %$75] ; # X %340 = phi i64 [%314, %$75] ; # Y %341 = phi i64 [%315, %$75] ; # NmX %342 = phi i64 [%316, %$75] ; # NmY %343 = phi i64 [%317, %$75] ; # A %344 = phi i64 [%318, %$75] ; # B br label %$45 $33: %345 = phi i64 [%122, %$36], [%132, %$44] ; # X %346 = phi i64 [%123, %$36], [%133, %$44] ; # Y %347 = phi i64 [%124, %$36], [%134, %$44] ; # NmX %348 = phi i64 [%125, %$36], [%135, %$44] ; # NmY %349 = phi i64 [%126, %$36], [1, %$44] ; # -> br label %$18 $18: %350 = phi i64 [%50, %$22], [%62, %$26], [%345, %$33] ; # X %351 = phi i64 [%51, %$22], [%63, %$26], [%346, %$33] ; # Y %352 = phi i64 [1, %$22], [-1, %$26], [%349, %$33] ; # -> br label %$2 $16: %353 = phi i64 [%36, %$9] ; # X %354 = phi i64 [%37, %$9] ; # Y ; # (atom Y) %355 = and i64 %354, 15 %356 = icmp ne i64 %355, 0 br i1 %356, label %$79, label %$78 $79: %357 = phi i64 [%353, %$16] ; # X %358 = phi i64 [%354, %$16] ; # Y ; # (if (t? Y) -1 1) ; # (t? Y) %359 = icmp eq i64 %358, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br i1 %359, label %$80, label %$81 $80: %360 = phi i64 [%357, %$79] ; # X %361 = phi i64 [%358, %$79] ; # Y br label %$82 $81: %362 = phi i64 [%357, %$79] ; # X %363 = phi i64 [%358, %$79] ; # Y br label %$82 $82: %364 = phi i64 [%360, %$80], [%362, %$81] ; # X %365 = phi i64 [%361, %$80], [%363, %$81] ; # Y %366 = phi i64 [-1, %$80], [1, %$81] ; # -> br label %$2 $78: %367 = phi i64 [%353, %$16] ; # X %368 = phi i64 [%354, %$16] ; # Y ; # (stkChk 0) %369 = load i8*, i8** @$StkLimit %370 = call i8* @llvm.stacksave() %371 = icmp ugt i8* %369, %370 br i1 %371, label %$83, label %$84 $83: call void @stkErr(i64 0) unreachable $84: ; # (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 %$85 $85: %372 = phi i64 [%367, %$84], [%423, %$101] ; # X %373 = phi i64 [%368, %$84], [%424, %$101] ; # Y ; # (? (compare (car X) (car Y)) @) ; # (car X) %374 = inttoptr i64 %372 to i64* %375 = load i64, i64* %374 ; # (car Y) %376 = inttoptr i64 %373 to i64* %377 = load i64, i64* %376 ; # (compare (car X) (car Y)) %378 = call i64 @compare(i64 %375, i64 %377) %379 = icmp ne i64 %378, 0 br i1 %379, label %$88, label %$86 $88: %380 = phi i64 [%372, %$85] ; # X %381 = phi i64 [%373, %$85] ; # Y br label %$87 $86: %382 = phi i64 [%372, %$85] ; # X %383 = phi i64 [%373, %$85] ; # Y ; # (? (atom (shift X)) (compare X (cdr Y))) ; # (shift X) %384 = inttoptr i64 %382 to i64* %385 = getelementptr i64, i64* %384, i32 1 %386 = load i64, i64* %385 ; # (atom (shift X)) %387 = and i64 %386, 15 %388 = icmp ne i64 %387, 0 br i1 %388, label %$90, label %$89 $90: %389 = phi i64 [%386, %$86] ; # X %390 = phi i64 [%383, %$86] ; # Y ; # (cdr Y) %391 = inttoptr i64 %390 to i64* %392 = getelementptr i64, i64* %391, i32 1 %393 = load i64, i64* %392 ; # (compare X (cdr Y)) %394 = call i64 @compare(i64 %389, i64 %393) br label %$87 $89: %395 = phi i64 [%386, %$86] ; # X %396 = phi i64 [%383, %$86] ; # Y ; # (? (atom (shift Y)) (if (t? Y) -1 1)) ; # (shift Y) %397 = inttoptr i64 %396 to i64* %398 = getelementptr i64, i64* %397, i32 1 %399 = load i64, i64* %398 ; # (atom (shift Y)) %400 = and i64 %399, 15 %401 = icmp ne i64 %400, 0 br i1 %401, label %$92, label %$91 $92: %402 = phi i64 [%395, %$89] ; # X %403 = phi i64 [%399, %$89] ; # Y ; # (if (t? Y) -1 1) ; # (t? Y) %404 = icmp eq i64 %403, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br i1 %404, label %$93, label %$94 $93: %405 = phi i64 [%402, %$92] ; # X %406 = phi i64 [%403, %$92] ; # Y br label %$95 $94: %407 = phi i64 [%402, %$92] ; # X %408 = phi i64 [%403, %$92] ; # Y br label %$95 $95: %409 = phi i64 [%405, %$93], [%407, %$94] ; # X %410 = phi i64 [%406, %$93], [%408, %$94] ; # Y %411 = phi i64 [-1, %$93], [1, %$94] ; # -> br label %$87 $91: %412 = phi i64 [%395, %$89] ; # X %413 = phi i64 [%399, %$89] ; # Y ; # (? (and (== X A) (== Y B)) 0) ; # (and (== X A) (== Y B)) ; # (== X A) %414 = icmp eq i64 %412, %367 br i1 %414, label %$97, label %$96 $97: %415 = phi i64 [%412, %$91] ; # X %416 = phi i64 [%413, %$91] ; # Y ; # (== Y B) %417 = icmp eq i64 %416, %368 br label %$96 $96: %418 = phi i64 [%412, %$91], [%415, %$97] ; # X %419 = phi i64 [%413, %$91], [%416, %$97] ; # Y %420 = phi i1 [0, %$91], [%417, %$97] ; # -> br i1 %420, label %$99, label %$98 $99: %421 = phi i64 [%418, %$96] ; # X %422 = phi i64 [%419, %$96] ; # Y br label %$87 $98: %423 = phi i64 [%418, %$96] ; # X %424 = phi i64 [%419, %$96] ; # Y ; # (sigChk 0) %425 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*) %426 = icmp ne i32 %425, 0 br i1 %426, label %$100, label %$101 $100: call void @sighandler(i64 0) br label %$101 $101: br label %$85 $87: %427 = phi i64 [%380, %$88], [%389, %$90], [%409, %$95], [%421, %$99] ; # X %428 = phi i64 [%381, %$88], [%390, %$90], [%410, %$95], [%422, %$99] ; # Y %429 = phi i64 [%378, %$88], [%394, %$90], [%411, %$95], [0, %$99] ; # -> br label %$2 $2: %430 = phi i64 [%3, %$4], [%8, %$6], [%13, %$8], [%33, %$11], [%350, %$18], [%364, %$82], [%427, %$87] ; # X %431 = phi i64 [%4, %$4], [%9, %$6], [%14, %$8], [%34, %$11], [%351, %$18], [%365, %$82], [%428, %$87] ; # Y %432 = phi i64 [0, %$4], [-1, %$6], [1, %$8], [%35, %$11], [%352, %$18], [%366, %$82], [%429, %$87] ; # -> ret i64 %432 } 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]* @$26 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 ([870 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 80) 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %231 %232 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 80) 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 ([870 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 ([17 x i64]* @env to i8*), i32 80) 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 ([17 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 ([17 x i64]* @env to i8*), i32 80) to i64) to i64* %296 = load i64, i64* %295 ; # (set $Next $Nil) %297 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 80) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([17 x i64]* @env to i8*), i32 80) 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 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 ([17 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 ([17 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 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 ([17 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]* @$27 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]* @$28 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]* @$29 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]* @$30 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]* @$31 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* @$Chr ; # (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]* @$32 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]* @$33 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]* @$34 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]* @$35 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) In (val... ; # (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) In (val P)) (when (== In (val $In... ; # (val $InFiles) %3 = load i8**, i8*** @$InFiles ; # (ofs (val $InFiles) Fd) %4 = getelementptr i8*, i8** %3, i32 %0 ; # (val P) %5 = load i8*, i8** %4 ; # (when (== In (val $InFile)) (set $Chr ((inFile (set $InFile (val ... ; # (val $InFile) %6 = load i8*, i8** @$InFile ; # (== In (val $InFile)) %7 = icmp eq i8* %5, %6 br i1 %7, label %$4, label %$5 $4: ; # (set $Chr ((inFile (set $InFile (val (val $InFiles)))) chr)) ; # (set $InFile (val (val $InFiles))) ; # (val $InFiles) %8 = load i8**, i8*** @$InFiles ; # (val (val $InFiles)) %9 = load i8*, i8** %8 store i8* %9, i8** @$InFile ; # ((inFile (set $InFile (val (val $InFiles)))) chr) %10 = getelementptr i8, i8* %9, i32 12 %11 = bitcast i8* %10 to i32* %12 = load i32, i32* %11 store i32 %12, i32* @$Chr br label %$5 $5: ; # (when In (let In: (inFile @) (free (In: name)) (In: name null) (I... %13 = icmp ne i8* %5, null br i1 %13, label %$6, label %$7 $6: ; # (let In: (inFile @) (free (In: name)) (In: name null) (In: fd -1)... ; # (In: name) %14 = bitcast i8* %5 to i8** %15 = load i8*, i8** %14 ; # (free (In: name)) call void @free(i8* %15) ; # (In: name null) %16 = bitcast i8* %5 to i8** store i8* null, i8** %16 ; # (In: fd -1) %17 = getelementptr i8, i8* %5, i32 8 %18 = bitcast i8* %17 to i32* store i32 -1, i32* %18 br label %$7 $7: br label %$3 $3: ret void } define void @closeOutFile(i32) align 8 { $1: ; # (when (> (val $OutFDs) Fd) (let (P (ofs (val $OutFiles) Fd) Out (... ; # (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) Out (val P)) (when (== Out (val ... ; # (val $OutFiles) %3 = load i8**, i8*** @$OutFiles ; # (ofs (val $OutFiles) Fd) %4 = getelementptr i8*, i8** %3, i32 %0 ; # (val P) %5 = load i8*, i8** %4 ; # (when (== Out (val $OutFile)) (set $OutFile (val 2 (val $OutFiles... ; # (val $OutFile) %6 = load i8*, i8** @$OutFile ; # (== Out (val $OutFile)) %7 = icmp eq i8* %5, %6 br i1 %7, label %$4, label %$5 $4: ; # (set $OutFile (val 2 (val $OutFiles))) ; # (val $OutFiles) %8 = load i8**, i8*** @$OutFiles ; # (val 2 (val $OutFiles)) %9 = getelementptr i8*, i8** %8, i32 1 %10 = load i8*, i8** %9 store i8* %10, i8** @$OutFile br label %$5 $5: ; # (when Out ((outFile @) fd -1)) %11 = icmp ne i8* %5, null br i1 %11, label %$6, label %$7 $6: ; # ((outFile @) fd -1) %12 = bitcast i8* %5 to i32* store i32 -1, i32* %12 br label %$7 $7: 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 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 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 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 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 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 (let N (i32 (write Fd P (i64 Cnt))) (if (lt0 N) (let E (gEr... br label %$2 $2: %3 = phi i8* [%1, %$1], [%48, %$5] ; # P %4 = phi i32 [%2, %$1], [%49, %$5] ; # Cnt ; # (let N (i32 (write Fd P (i64 Cnt))) (if (lt0 N) (let E (gErrno) (... ; # (i64 Cnt) %5 = sext i32 %4 to i64 ; # (write Fd P (i64 Cnt)) %6 = call i64 @write(i32 %0, i8* %3, i64 %5) ; # (i32 (write Fd P (i64 Cnt))) %7 = trunc i64 %6 to i32 ; # (if (lt0 N) (let E (gErrno) (? (== E EBADF) NO) (? (== E EPIPE) N... ; # (lt0 N) %8 = icmp slt i32 %7, 0 br i1 %8, label %$3, label %$4 $3: %9 = phi i8* [%3, %$2] ; # P %10 = phi i32 [%4, %$2] ; # Cnt ; # (let E (gErrno) (? (== E EBADF) NO) (? (== E EPIPE) NO) (? (== E ... ; # (gErrno) %11 = call i32 @gErrno() ; # (? (== E EBADF) NO) ; # (== E EBADF) %12 = icmp eq i32 %11, 3 br i1 %12, label %$8, label %$6 $8: %13 = phi i8* [%9, %$3] ; # P %14 = phi i32 [%10, %$3] ; # Cnt br label %$7 $6: %15 = phi i8* [%9, %$3] ; # P %16 = phi i32 [%10, %$3] ; # Cnt ; # (? (== E EPIPE) NO) ; # (== E EPIPE) %17 = icmp eq i32 %11, 6 br i1 %17, label %$10, label %$9 $10: %18 = phi i8* [%15, %$6] ; # P %19 = phi i32 [%16, %$6] ; # Cnt br label %$7 $9: %20 = phi i8* [%15, %$6] ; # P %21 = phi i32 [%16, %$6] ; # Cnt ; # (? (== E ECONNRESET) NO) ; # (== E ECONNRESET) %22 = icmp eq i32 %11, 7 br i1 %22, label %$12, label %$11 $12: %23 = phi i8* [%20, %$9] ; # P %24 = phi i32 [%21, %$9] ; # Cnt br label %$7 $11: %25 = phi i8* [%20, %$9] ; # P %26 = phi i32 [%21, %$9] ; # Cnt ; # (unless (== E EINTR) (when (== Fd 2) (bye 2)) (writeErr ($ "bytes... ; # (== E EINTR) %27 = icmp eq i32 %11, 2 br i1 %27, label %$14, label %$13 $13: %28 = phi i8* [%25, %$11] ; # P %29 = phi i32 [%26, %$11] ; # Cnt ; # (when (== Fd 2) (bye 2)) ; # (== Fd 2) %30 = icmp eq i32 %0, 2 br i1 %30, label %$15, label %$16 $15: %31 = phi i8* [%28, %$13] ; # P %32 = phi i32 [%29, %$13] ; # Cnt ; # (bye 2) call void @bye(i32 2) unreachable $16: %33 = phi i8* [%28, %$13] ; # P %34 = phi i32 [%29, %$13] ; # Cnt ; # (writeErr ($ "bytes write: %s")) call void @writeErr(i8* bitcast ([16 x i8]* @$36 to i8*)) unreachable $14: %35 = phi i8* [%25, %$11] ; # P %36 = phi i32 [%26, %$11] ; # Cnt ; # (sigChk 0) %37 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*) %38 = icmp ne i32 %37, 0 br i1 %38, label %$17, label %$18 $17: call void @sighandler(i64 0) br label %$18 $18: br label %$5 $4: %39 = phi i8* [%3, %$2] ; # P %40 = phi i32 [%4, %$2] ; # Cnt ; # (? (=0 (dec 'Cnt N)) YES) ; # (dec 'Cnt N) %41 = sub i32 %40, %7 ; # (=0 (dec 'Cnt N)) %42 = icmp eq i32 %41, 0 br i1 %42, label %$20, label %$19 $20: %43 = phi i8* [%39, %$4] ; # P %44 = phi i32 [%41, %$4] ; # Cnt br label %$7 $19: %45 = phi i8* [%39, %$4] ; # P %46 = phi i32 [%41, %$4] ; # Cnt ; # (inc 'P N) %47 = getelementptr i8, i8* %45, i32 %7 br label %$5 $5: %48 = phi i8* [%35, %$18], [%47, %$19] ; # P %49 = phi i32 [%36, %$18], [%46, %$19] ; # Cnt br label %$2 $7: %50 = phi i8* [%13, %$8], [%18, %$10], [%23, %$12], [%43, %$20] ; # P %51 = phi i32 [%14, %$8], [%19, %$10], [%24, %$12], [%44, %$20] ; # Cnt %52 = phi i1 [0, %$8], [0, %$10], [0, %$12], [1, %$20] ; # -> ret i1 %52 } 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]* @$37 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** @$InFile ; # (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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save X) %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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) (ifn P (loop (binPrint (car X)) (? (nil? (shift X... ; # (circ X) %280 = call i64 @circ(i64 %278) ; # (ifn P (loop (binPrint (car X)) (? (nil? (shift X)) (call $PutBin... %281 = icmp ne i64 %280, 0 br i1 %281, label %$39, label %$38 $38: %282 = phi i64 [%278, %$37] ; # X ; # (loop (binPrint (car X)) (? (nil? (shift X)) (call $PutBin END)) ... br label %$41 $41: %283 = phi i64 [%282, %$38], [%297, %$45] ; # X ; # (car X) %284 = inttoptr i64 %283 to i64* %285 = load i64, i64* %284 ; # (binPrint (car X)) call void @binPrint(i64 %285) ; # (? (nil? (shift X)) (call $PutBin END)) ; # (shift X) %286 = inttoptr i64 %283 to i64* %287 = getelementptr i64, i64* %286, i32 1 %288 = load i64, i64* %287 ; # (nil? (shift X)) %289 = icmp eq i64 %288, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %289, label %$44, label %$42 $44: %290 = phi i64 [%288, %$41] ; # X ; # (call $PutBin END) %291 = load void(i8)*, void(i8)** @$PutBin call void %291(i8 3) br label %$43 $42: %292 = phi i64 [%288, %$41] ; # X ; # (? (atom X) (call $PutBin DOT) (binPrint X)) ; # (atom X) %293 = and i64 %292, 15 %294 = icmp ne i64 %293, 0 br i1 %294, label %$46, label %$45 $46: %295 = phi i64 [%292, %$42] ; # X ; # (call $PutBin DOT) %296 = load void(i8)*, void(i8)** @$PutBin call void %296(i8 2) ; # (binPrint X) call void @binPrint(i64 %295) br label %$43 $45: %297 = phi i64 [%292, %$42] ; # X br label %$41 $43: %298 = phi i64 [%290, %$44], [%295, %$46] ; # X br label %$40 $39: %299 = phi i64 [%278, %$37] ; # X ; # (let Flg (== P X) (loop (binPrint (car X)) (? (== P (shift X)))) ... ; # (== P X) %300 = icmp eq i64 %280, %299 ; # (loop (binPrint (car X)) (? (== P (shift X)))) br label %$47 $47: %301 = phi i64 [%299, %$39], [%308, %$48] ; # X ; # (car X) %302 = inttoptr i64 %301 to i64* %303 = load i64, i64* %302 ; # (binPrint (car X)) call void @binPrint(i64 %303) ; # (? (== P (shift X))) ; # (shift X) %304 = inttoptr i64 %301 to i64* %305 = getelementptr i64, i64* %304, i32 1 %306 = load i64, i64* %305 ; # (== P (shift X)) %307 = icmp eq i64 %280, %306 br i1 %307, label %$49, label %$48 $48: %308 = phi i64 [%306, %$47] ; # X br label %$47 $49: %309 = phi i64 [%306, %$47] ; # X %310 = phi i64 [0, %$47] ; # -> ; # (call $PutBin DOT) %311 = load void(i8)*, void(i8)** @$PutBin call void %311(i8 2) ; # (unless Flg (call $PutBin BEG) (loop (binPrint (car X)) (? (== P ... br i1 %300, label %$51, label %$50 $50: %312 = phi i64 [%309, %$49] ; # X ; # (call $PutBin BEG) %313 = load void(i8)*, void(i8)** @$PutBin call void %313(i8 1) ; # (loop (binPrint (car X)) (? (== P (shift X)))) br label %$52 $52: %314 = phi i64 [%312, %$50], [%321, %$53] ; # X ; # (car X) %315 = inttoptr i64 %314 to i64* %316 = load i64, i64* %315 ; # (binPrint (car X)) call void @binPrint(i64 %316) ; # (? (== P (shift X))) ; # (shift X) %317 = inttoptr i64 %314 to i64* %318 = getelementptr i64, i64* %317, i32 1 %319 = load i64, i64* %318 ; # (== P (shift X)) %320 = icmp eq i64 %280, %319 br i1 %320, label %$54, label %$53 $53: %321 = phi i64 [%319, %$52] ; # X br label %$52 $54: %322 = phi i64 [%319, %$52] ; # X %323 = phi i64 [0, %$52] ; # -> ; # (call $PutBin DOT) %324 = load void(i8)*, void(i8)** @$PutBin call void %324(i8 2) br label %$51 $51: %325 = phi i64 [%309, %$49], [%322, %$54] ; # X ; # (call $PutBin END) %326 = load void(i8)*, void(i8)** @$PutBin call void %326(i8 3) br label %$40 $40: %327 = phi i64 [%298, %$43], [%325, %$51] ; # X br label %$2 $36: %328 = phi i64 [%275, %$34] ; # X ; # (tail X) %329 = add i64 %328, -8 ; # (val (tail X)) %330 = inttoptr i64 %329 to i64* %331 = load i64, i64* %330 ; # (sym? (val (tail X))) %332 = and i64 %331, 8 %333 = icmp ne i64 %332, 0 br i1 %333, label %$56, label %$55 $56: %334 = phi i64 [%328, %$36] ; # X ; # (let Nm (name (& @ -9)) (when (val $Extn) (let N (shl (& (i64 (- ... ; # (& @ -9) %335 = and i64 %331, -9 ; # (name (& @ -9)) br label %$57 $57: %336 = phi i64 [%335, %$56], [%342, %$58] ; # Tail %337 = and i64 %336, 6 %338 = icmp ne i64 %337, 0 br i1 %338, label %$59, label %$58 $58: %339 = phi i64 [%336, %$57] ; # Tail %340 = inttoptr i64 %339 to i64* %341 = getelementptr i64, i64* %340, i32 1 %342 = load i64, i64* %341 br label %$57 $59: %343 = phi i64 [%336, %$57] ; # Tail ; # (when (val $Extn) (let N (shl (& (i64 (- (objFile Nm) @)) (hex "F... ; # (val $Extn) %344 = load i32, i32* @$Extn %345 = icmp ne i32 %344, 0 br i1 %345, label %$60, label %$61 $60: %346 = phi i64 [%334, %$59] ; # X %347 = phi i64 [%343, %$59] ; # Nm ; # (let N (shl (& (i64 (- (objFile Nm) @)) (hex "FFFF")) 24) (setq N... ; # (objFile Nm) %348 = call i32 @objFile(i64 %347) ; # (- (objFile Nm) @) %349 = sub i32 %348, %344 ; # (i64 (- (objFile Nm) @)) %350 = sext i32 %349 to i64 ; # (& (i64 (- (objFile Nm) @)) (hex "FFFF")) %351 = and i64 %350, 65535 ; # (shl (& (i64 (- (objFile Nm) @)) (hex "FFFF")) 24) %352 = shl i64 %351, 24 ; # (& Nm (hex "FFF00FFF00FFFFFF")) %353 = and i64 %347, 18442258061990035455 ; # (shl N 12) %354 = shl i64 %352, 12 ; # (| N (shl N 12)) %355 = or i64 %352, %354 ; # (& (| N (shl N 12)) (hex "000FF000FF000000")) %356 = and i64 %355, 4486011719516160 ; # (| (& Nm (hex "FFF00FFF00FFFFFF")) (& (| N (shl N 12)) (hex "000F... %357 = or i64 %353, %356 br label %$61 $61: %358 = phi i64 [%334, %$59], [%346, %$60] ; # X %359 = phi i64 [%343, %$59], [%357, %$60] ; # Nm ; # (+ EXTERN 4) ; # (shl Nm 2) %360 = shl i64 %359, 2 ; # (shr (shl Nm 2) 6) %361 = lshr i64 %360, 6 ; # (prCnt (+ EXTERN 4) (shr (shl Nm 2) 6)) tail call void @prCnt(i8 7, i64 %361) br label %$2 $55: %362 = phi i64 [%328, %$36] ; # X ; # (name @) br label %$62 $62: %363 = phi i64 [%331, %$55], [%369, %$63] ; # Tail %364 = and i64 %363, 6 %365 = icmp ne i64 %364, 0 br i1 %365, label %$64, label %$63 $63: %366 = phi i64 [%363, %$62] ; # Tail %367 = inttoptr i64 %366 to i64* %368 = getelementptr i64, i64* %367, i32 1 %369 = load i64, i64* %368 br label %$62 $64: %370 = phi i64 [%363, %$62] ; # Tail ; # (== (name @) ZERO) %371 = icmp eq i64 %370, 2 br i1 %371, label %$66, label %$65 $66: %372 = phi i64 [%362, %$64] ; # X ; # (call $PutBin NIX) %373 = load void(i8)*, void(i8)** @$PutBin call void %373(i8 0) br label %$2 $65: %374 = phi i64 [%362, %$64] ; # 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) %375 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %376 = load i64, i64* %375 ; # (findSym X Nm (val $Intern)) %377 = call i1 @findSym(i64 %374, i64 %370, i64 %376) br i1 %377, label %$67, label %$68 $67: %378 = phi i64 [%374, %$65] ; # X ; # (i8 INTERN) br label %$69 $68: %379 = phi i64 [%374, %$65] ; # X ; # (i8 TRANSIENT) br label %$69 $69: %380 = phi i64 [%378, %$67], [%379, %$68] ; # X %381 = phi i8 [1, %$67], [2, %$68] ; # -> ; # (if (cnt? Nm) (prCnt (+ Tag 4) (int Nm)) (let (Y Nm N 8) (while (... ; # (cnt? Nm) %382 = and i64 %370, 2 %383 = icmp ne i64 %382, 0 br i1 %383, label %$70, label %$71 $70: %384 = phi i64 [%380, %$69] ; # X ; # (+ Tag 4) %385 = add i8 %381, 4 ; # (int Nm) %386 = lshr i64 %370, 4 ; # (prCnt (+ Tag 4) (int Nm)) call void @prCnt(i8 %385, i64 %386) br label %$72 $71: %387 = phi i64 [%380, %$69] ; # 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 %$73 $73: %388 = phi i64 [%387, %$71], [%396, %$74] ; # X %389 = phi i64 [%370, %$71], [%397, %$74] ; # Y %390 = phi i64 [8, %$71], [%399, %$74] ; # N ; # (big Y) %391 = add i64 %389, 4 ; # (val (big Y)) %392 = inttoptr i64 %391 to i64* %393 = load i64, i64* %392 ; # (big? (setq Y (val (big Y)))) %394 = and i64 %393, 4 %395 = icmp ne i64 %394, 0 br i1 %395, label %$74, label %$75 $74: %396 = phi i64 [%388, %$73] ; # X %397 = phi i64 [%393, %$73] ; # Y %398 = phi i64 [%390, %$73] ; # N ; # (inc 'N 8) %399 = add i64 %398, 8 br label %$73 $75: %400 = phi i64 [%388, %$73] ; # X %401 = phi i64 [%393, %$73] ; # Y %402 = phi i64 [%390, %$73] ; # N ; # (int Y) %403 = lshr i64 %401, 4 ; # (while Y (inc 'N) (setq Y (shr Y 8))) br label %$76 $76: %404 = phi i64 [%400, %$75], [%408, %$77] ; # X %405 = phi i64 [%403, %$75], [%412, %$77] ; # Y %406 = phi i64 [%402, %$75], [%411, %$77] ; # N %407 = icmp ne i64 %405, 0 br i1 %407, label %$77, label %$78 $77: %408 = phi i64 [%404, %$76] ; # X %409 = phi i64 [%405, %$76] ; # Y %410 = phi i64 [%406, %$76] ; # N ; # (inc 'N) %411 = add i64 %410, 1 ; # (shr Y 8) %412 = lshr i64 %409, 8 br label %$76 $78: %413 = phi i64 [%404, %$76] ; # X %414 = phi i64 [%405, %$76] ; # Y %415 = phi i64 [%406, %$76] ; # N ; # (let (P (push 0 Nm) M (- N 63) C 8) (when (ge0 M) (setq N 63)) (c... ; # (push 0 Nm) %416 = alloca i64, i64 2, align 16 store i64 0, i64* %416 %417 = getelementptr i64, i64* %416, i32 1 store i64 %370, i64* %417 ; # (- N 63) %418 = sub i64 %415, 63 ; # (when (ge0 M) (setq N 63)) ; # (ge0 M) %419 = icmp sge i64 %418, 0 br i1 %419, label %$79, label %$80 $79: %420 = phi i64 [%413, %$78] ; # X %421 = phi i64 [%414, %$78] ; # Y %422 = phi i64 [%415, %$78] ; # N %423 = phi i64 [%418, %$78] ; # M br label %$80 $80: %424 = phi i64 [%413, %$78], [%420, %$79] ; # X %425 = phi i64 [%414, %$78], [%421, %$79] ; # Y %426 = phi i64 [%415, %$78], [63, %$79] ; # N %427 = phi i64 [%418, %$78], [%423, %$79] ; # M ; # (shl N 2) %428 = shl i64 %426, 2 ; # (i8 (shl N 2)) %429 = trunc i64 %428 to i8 ; # (+ Tag (i8 (shl N 2))) %430 = add i8 %381, %429 ; # (call $PutBin (+ Tag (i8 (shl N 2)))) %431 = load void(i8)*, void(i8)** @$PutBin call void %431(i8 %430) ; # (loop (loop (call $PutBin (symByte P)) (? (=0 (dec 'N)))) (? (lt0... br label %$81 $81: %432 = phi i64 [%424, %$80], [%474, %$90] ; # X %433 = phi i64 [%425, %$80], [%475, %$90] ; # Y %434 = phi i64 [%426, %$80], [%476, %$90] ; # N %435 = phi i64 [%427, %$80], [%477, %$90] ; # M ; # (loop (call $PutBin (symByte P)) (? (=0 (dec 'N)))) br label %$82 $82: %436 = phi i64 [%432, %$81], [%444, %$83] ; # X %437 = phi i64 [%433, %$81], [%445, %$83] ; # Y %438 = phi i64 [%434, %$81], [%446, %$83] ; # N %439 = phi i64 [%435, %$81], [%447, %$83] ; # M ; # (symByte P) %440 = call i8 @symByte(i64* %416) ; # (call $PutBin (symByte P)) %441 = load void(i8)*, void(i8)** @$PutBin call void %441(i8 %440) ; # (? (=0 (dec 'N))) ; # (dec 'N) %442 = sub i64 %438, 1 ; # (=0 (dec 'N)) %443 = icmp eq i64 %442, 0 br i1 %443, label %$84, label %$83 $83: %444 = phi i64 [%436, %$82] ; # X %445 = phi i64 [%437, %$82] ; # Y %446 = phi i64 [%442, %$82] ; # N %447 = phi i64 [%439, %$82] ; # M br label %$82 $84: %448 = phi i64 [%436, %$82] ; # X %449 = phi i64 [%437, %$82] ; # Y %450 = phi i64 [%442, %$82] ; # N %451 = phi i64 [%439, %$82] ; # M %452 = phi i64 [0, %$82] ; # -> ; # (? (lt0 M)) ; # (lt0 M) %453 = icmp slt i64 %451, 0 br i1 %453, label %$86, label %$85 $85: %454 = phi i64 [%448, %$84] ; # X %455 = phi i64 [%449, %$84] ; # Y %456 = phi i64 [%450, %$84] ; # N %457 = phi i64 [%451, %$84] ; # M ; # (? (=0 M) (call $PutBin 0)) ; # (=0 M) %458 = icmp eq i64 %457, 0 br i1 %458, label %$88, label %$87 $88: %459 = phi i64 [%454, %$85] ; # X %460 = phi i64 [%455, %$85] ; # Y %461 = phi i64 [%456, %$85] ; # N %462 = phi i64 [%457, %$85] ; # M ; # (call $PutBin 0) %463 = load void(i8)*, void(i8)** @$PutBin call void %463(i8 0) br label %$86 $87: %464 = phi i64 [%454, %$85] ; # X %465 = phi i64 [%455, %$85] ; # Y %466 = phi i64 [%456, %$85] ; # N %467 = phi i64 [%457, %$85] ; # M ; # (when (ge0 (setq M (- (setq N M) 255))) (setq N 255)) ; # (- (setq N M) 255) %468 = sub i64 %467, 255 ; # (ge0 (setq M (- (setq N M) 255))) %469 = icmp sge i64 %468, 0 br i1 %469, label %$89, label %$90 $89: %470 = phi i64 [%464, %$87] ; # X %471 = phi i64 [%465, %$87] ; # Y %472 = phi i64 [%467, %$87] ; # N %473 = phi i64 [%468, %$87] ; # M br label %$90 $90: %474 = phi i64 [%464, %$87], [%470, %$89] ; # X %475 = phi i64 [%465, %$87], [%471, %$89] ; # Y %476 = phi i64 [%467, %$87], [255, %$89] ; # N %477 = phi i64 [%468, %$87], [%473, %$89] ; # M ; # (i8 N) %478 = trunc i64 %476 to i8 ; # (call $PutBin (i8 N)) %479 = load void(i8)*, void(i8)** @$PutBin call void %479(i8 %478) br label %$81 $86: %480 = phi i64 [%448, %$84], [%459, %$88] ; # X %481 = phi i64 [%449, %$84], [%460, %$88] ; # Y %482 = phi i64 [%450, %$84], [%461, %$88] ; # N %483 = phi i64 [%451, %$84], [%462, %$88] ; # M br label %$72 $72: %484 = phi i64 [%384, %$70], [%480, %$86] ; # X br label %$2 $2: %485 = phi i64 [%3, %$4], [%263, %$29], [%273, %$35], [%327, %$40], [%358, %$61], [%372, %$66], [%484, %$72] ; # 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]* @$38 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 28 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 0)) 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 0)) 8) (close Fd) (set $... ; # (unless (wrBytes Fd (i8* (push 0)) 8) (close Fd) (set $Tell 0)) ; # (push 0) %2 = alloca i64, i64 1 store i64 0, i64* %2 ; # (i8* (push 0)) %3 = bitcast i64* %2 to i8* ; # (wrBytes Fd (i8* (push 0)) 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 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: ; # (getpgrp) %8 = call i32 @getpgrp() ; # (tcsetpgrp 0 (getpgrp)) %9 = call i32 @tcsetpgrp(i32 0, i32 %8) ; # (set $At2 (cnt (i64 (val Res)))) ; # (val Res) %10 = load i32, i32* %1 ; # (i64 (val Res)) %11 = sext i32 %10 to i64 ; # (cnt (i64 (val Res))) %12 = shl i64 %11, 4 %13 = or i64 %12, 2 %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 456) to i64) to i64* store i64 %13, i64* %14 ret void } define i32 @currFd(i64) align 8 { $1: ; # (let (In (val $InFrames) Out (val $OutFrames)) (nond ((or In Out)... ; # (val $InFrames) %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (val $OutFrames) %2 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (nond ((or In Out) (err 0 0 ($ "No current fd") null)) (Out ((inF... ; # (or In Out) %3 = icmp ne i8* %1, null br i1 %3, label %$3, label %$4 $4: %4 = icmp ne i8* %2, null br label %$3 $3: %5 = phi i1 [1, %$1], [%4, %$4] ; # -> br i1 %5, label %$5, label %$6 $6: ; # (err 0 0 ($ "No current fd") null) call void @err(i64 0, i64 0, i8* bitcast ([14 x i8]* @$39 to i8*), i8* null) unreachable $5: %6 = icmp ne i8* %2, null br i1 %6, label %$7, label %$8 $8: ; # ((ioFrame In) file) %7 = getelementptr i8, i8* %1, i32 8 %8 = bitcast i8* %7 to i8** %9 = load i8*, i8** %8 ; # ((inFile ((ioFrame In) file)) fd) %10 = getelementptr i8, i8* %9, i32 8 %11 = bitcast i8* %10 to i32* %12 = load i32, i32* %11 br label %$2 $7: %13 = icmp ne i8* %1, null br i1 %13, label %$9, label %$10 $10: ; # ((ioFrame Out) file) %14 = getelementptr i8, i8* %2, i32 8 %15 = bitcast i8* %14 to i8** %16 = load i8*, i8** %15 ; # ((outFile ((ioFrame Out) file)) fd) %17 = bitcast i8* %16 to i32* %18 = load i32, i32* %17 br label %$2 $9: ; # (if (if (> In (stack)) (> Out In) (> In Out)) ((inFile ((ioFrame ... ; # (if (> In (stack)) (> Out In) (> In Out)) ; # (stack) %19 = call i8* @llvm.stacksave() ; # (> In (stack)) %20 = icmp ugt i8* %1, %19 br i1 %20, label %$11, label %$12 $11: ; # (> Out In) %21 = icmp ugt i8* %2, %1 br label %$13 $12: ; # (> In Out) %22 = icmp ugt i8* %1, %2 br label %$13 $13: %23 = phi i1 [%21, %$11], [%22, %$12] ; # -> br i1 %23, label %$14, label %$15 $14: ; # ((ioFrame In) file) %24 = getelementptr i8, i8* %1, i32 8 %25 = bitcast i8* %24 to i8** %26 = load i8*, i8** %25 ; # ((inFile ((ioFrame In) file)) fd) %27 = getelementptr i8, i8* %26, i32 8 %28 = bitcast i8* %27 to i32* %29 = load i32, i32* %28 br label %$16 $15: ; # ((ioFrame Out) file) %30 = getelementptr i8, i8* %2, i32 8 %31 = bitcast i8* %30 to i8** %32 = load i8*, i8** %31 ; # ((outFile ((ioFrame Out) file)) fd) %33 = bitcast i8* %32 to i32* %34 = load i32, i32* %33 br label %$16 $16: %35 = phi i32 [%29, %$14], [%34, %$15] ; # -> br label %$2 $2: %36 = phi i32 [%12, %$8], [%18, %$10], [%35, %$16] ; # -> ret i32 %36 } define void @pushInFile(i8*, i8*, i32) align 8 { $1: ; # (let Io: (ioFrame Io) (when (val $InFile) ((inFile @) chr (val $C... ; # (when (val $InFile) ((inFile @) chr (val $Chr))) ; # (val $InFile) %3 = load i8*, i8** @$InFile %4 = icmp ne i8* %3, null br i1 %4, label %$2, label %$3 $2: ; # ((inFile @) chr (val $Chr)) %5 = getelementptr i8, i8* %3, i32 12 %6 = bitcast i8* %5 to i32* %7 = load i32, i32* @$Chr store i32 %7, i32* %6 br label %$3 $3: ; # (when (Io: link (val $InFrames)) ((ioFrame @) fun (val (i8** $Get... ; # (Io: link (val $InFrames)) %8 = bitcast i8* %0 to i8** %9 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) store i8* %9, i8** %8 %10 = icmp ne i8* %9, null br i1 %10, label %$4, label %$5 $4: ; # ((ioFrame @) fun (val (i8** $Get))) %11 = getelementptr i8, i8* %9, i32 16 %12 = bitcast i8* %11 to i8** %13 = bitcast i32()** @$Get to i8** %14 = load i8*, i8** %13 store i8* %14, i8** %12 br label %$5 $5: ; # (set $Get (fun (i32) _getStdin)) ; # (fun (i32) _getStdin) store i32()* @_getStdin, i32()** @$Get ; # (set $Chr ((inFile (Io: file (set $InFile In))) chr)) ; # (Io: file (set $InFile In)) %15 = getelementptr i8, i8* %0, i32 8 %16 = bitcast i8* %15 to i8** store i8* %1, i8** @$InFile store i8* %1, i8** %16 ; # ((inFile (Io: file (set $InFile In))) chr) %17 = getelementptr i8, i8* %1, i32 12 %18 = bitcast i8* %17 to i32* %19 = load i32, i32* %18 store i32 %19, i32* @$Chr ; # (Io: pid Pid) %20 = getelementptr i8, i8* %0, i32 24 %21 = bitcast i8* %20 to i32* store i32 %2, i32* %21 ; # (set $InFrames (Io:)) ; # (Io:) store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ret void } define void @pushOutFile(i8*, i8*, i32) align 8 { $1: ; # (let Io: (ioFrame Io) (when (Io: link (val $OutFrames)) ((ioFrame... ; # (when (Io: link (val $OutFrames)) ((ioFrame @) fun (val (i8** $Pu... ; # (Io: link (val $OutFrames)) %3 = bitcast i8* %0 to i8** %4 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) store i8* %4, i8** %3 %5 = icmp ne i8* %4, null br i1 %5, label %$2, label %$3 $2: ; # ((ioFrame @) fun (val (i8** $Put))) %6 = getelementptr i8, i8* %4, i32 16 %7 = bitcast i8* %6 to i8** %8 = bitcast void(i8)** @$Put to i8** %9 = load i8*, i8** %8 store i8* %9, i8** %7 br label %$3 $3: ; # (set $Put (fun (void i8) _putStdout)) ; # (fun (void i8) _putStdout) store void(i8)* @_putStdout, void(i8)** @$Put ; # (Io: file (set $OutFile Out)) %10 = getelementptr i8, i8* %0, i32 8 %11 = bitcast i8* %10 to i8** store i8* %1, i8** @$OutFile store i8* %1, i8** %11 ; # (Io: pid Pid) %12 = getelementptr i8, i8* %0, i32 24 %13 = bitcast i8* %12 to i32* store i32 %2, i32* %13 ; # (set $OutFrames (Io:)) ; # (Io:) store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to 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 ([17 x i64]* @env to i8*), i32 48) to i8**) store i8* %2, i8** %1 ; # (set $ErrFrames Ct) store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 48) 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 ([17 x i64]* @env to i8*), i32 56) to i8**) store i8* %2, i8** %1 ; # (set $CtlFrames Ct) store i8* %0, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 56) to i8**) ret void } define void @popInFiles() align 8 { $1: ; # (let (Io: (ioFrame (val $InFrames)) In: (inFile (Io: file))) (whe... ; # (val $InFrames) %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (Io: file) %1 = getelementptr i8, i8* %0, i32 8 %2 = bitcast i8* %1 to i8** %3 = load i8*, i8** %2 ; # (when (ge0 (In: fd)) (ifn (Io: pid) (In: chr (val $Chr)) (close (... ; # (In: fd) %4 = getelementptr i8, i8* %3, i32 8 %5 = bitcast i8* %4 to i32* %6 = load i32, i32* %5 ; # (ge0 (In: fd)) %7 = icmp sge i32 %6, 0 br i1 %7, label %$2, label %$3 $2: ; # (ifn (Io: pid) (In: chr (val $Chr)) (close (In: fd)) (closeInFile... ; # (Io: pid) %8 = getelementptr i8, i8* %0, i32 24 %9 = bitcast i8* %8 to i32* %10 = load i32, i32* %9 %11 = icmp ne i32 %10, 0 br i1 %11, label %$5, label %$4 $4: ; # (In: chr (val $Chr)) %12 = getelementptr i8, i8* %3, i32 12 %13 = bitcast i8* %12 to i32* %14 = load i32, i32* @$Chr store i32 %14, i32* %13 br label %$6 $5: ; # (In: fd) %15 = getelementptr i8, i8* %3, i32 8 %16 = bitcast i8* %15 to i32* %17 = load i32, i32* %16 ; # (close (In: fd)) %18 = call i32 @close(i32 %17) ; # (In: fd) %19 = getelementptr i8, i8* %3, i32 8 %20 = bitcast i8* %19 to i32* %21 = load i32, i32* %20 ; # (closeInFile (In: fd)) call void @closeInFile(i32 %21) ; # (when (> (Io: pid) 1) (waitFile @)) ; # (Io: pid) %22 = getelementptr i8, i8* %0, i32 24 %23 = bitcast i8* %22 to i32* %24 = load i32, i32* %23 ; # (> (Io: pid) 1) %25 = icmp sgt i32 %24, 1 br i1 %25, label %$7, label %$8 $7: ; # (waitFile @) call void @waitFile(i32 %24) br label %$8 $8: br label %$6 $6: br label %$3 $3: ; # (set $InFrames (Io: link)) ; # (Io: link) %26 = bitcast i8* %0 to i8** %27 = load i8*, i8** %26 store i8* %27, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ret void } define void @tosInFile() align 8 { $1: ; # (let Io: (ioFrame (val $InFrames)) (set $Chr ((inFile (set $InFil... ; # (val $InFrames) %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (set $Chr ((inFile (set $InFile (Io: file))) chr) (i8** $Get) (Io... ; # (set $InFile (Io: file)) ; # (Io: file) %1 = getelementptr i8, i8* %0, i32 8 %2 = bitcast i8* %1 to i8** %3 = load i8*, i8** %2 store i8* %3, i8** @$InFile ; # ((inFile (set $InFile (Io: file))) chr) %4 = getelementptr i8, i8* %3, i32 12 %5 = bitcast i8* %4 to i32* %6 = load i32, i32* %5 store i32 %6, i32* @$Chr ; # (i8** $Get) %7 = bitcast i32()** @$Get to i8** ; # (Io: fun) %8 = getelementptr i8, i8* %0, i32 16 %9 = bitcast i8* %8 to i8** %10 = load i8*, i8** %9 store i8* %10, i8** %7 ret void } define void @popOutFiles() align 8 { $1: ; # (val $OutFile) %0 = load i8*, i8** @$OutFile ; # (flush (val $OutFile)) %1 = call i1 @flush(i8* %0) ; # (let (Io: (ioFrame (val $OutFrames)) Out: (outFile (Io: file))) (... ; # (val $OutFrames) %2 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (Io: file) %3 = getelementptr i8, i8* %2, i32 8 %4 = bitcast i8* %3 to i8** %5 = load i8*, i8** %4 ; # (when (ge0 (Out: fd)) (when (Io: pid) (close (Out: fd)) (closeOut... ; # (Out: fd) %6 = bitcast i8* %5 to i32* %7 = load i32, i32* %6 ; # (ge0 (Out: fd)) %8 = icmp sge i32 %7, 0 br i1 %8, label %$2, label %$3 $2: ; # (when (Io: pid) (close (Out: fd)) (closeOutFile (Out: fd)) (when ... ; # (Io: pid) %9 = getelementptr i8, i8* %2, i32 24 %10 = bitcast i8* %9 to i32* %11 = load i32, i32* %10 %12 = icmp ne i32 %11, 0 br i1 %12, label %$4, label %$5 $4: ; # (Out: fd) %13 = bitcast i8* %5 to i32* %14 = load i32, i32* %13 ; # (close (Out: fd)) %15 = call i32 @close(i32 %14) ; # (Out: fd) %16 = bitcast i8* %5 to i32* %17 = load i32, i32* %16 ; # (closeOutFile (Out: fd)) call void @closeOutFile(i32 %17) ; # (when (> (Io: pid) 1) (waitFile @)) ; # (Io: pid) %18 = getelementptr i8, i8* %2, i32 24 %19 = bitcast i8* %18 to i32* %20 = load i32, i32* %19 ; # (> (Io: pid) 1) %21 = icmp sgt i32 %20, 1 br i1 %21, label %$6, label %$7 $6: ; # (waitFile @) call void @waitFile(i32 %20) br label %$7 $7: br label %$5 $5: br label %$3 $3: ; # (set $OutFrames (Io: link)) ; # (Io: link) %22 = bitcast i8* %2 to i8** %23 = load i8*, i8** %22 store i8* %23, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ret void } define void @tosOutFile() align 8 { $1: ; # (let Io: (ioFrame (val $OutFrames)) (set $OutFile (Io: file) (i8*... ; # (val $OutFrames) %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (set $OutFile (Io: file) (i8** $Put) (Io: fun)) ; # (Io: file) %1 = getelementptr i8, i8* %0, i32 8 %2 = bitcast i8* %1 to i8** %3 = load i8*, i8** %2 store i8* %3, i8** @$OutFile ; # (i8** $Put) %4 = bitcast void(i8)** @$Put to i8** ; # (Io: fun) %5 = getelementptr i8, i8* %0, i32 16 %6 = bitcast i8* %5 to i8** %7 = load i8*, i8** %6 store i8* %7, i8** %4 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 ([17 x i64]* @env to i8*), i32 48) 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 ([17 x i64]* @env to i8*), i32 48) 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 ([17 x i64]* @env to i8*), i32 56) 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 ([17 x i64]* @env to i8*), i32 56) to i8**) ret void } define i64 @_path(i64) align 8 { $1: ; # (let Nm (xName Exe (evSym (cdr Exe))) (mkStr (pathString Nm (b8 (... ; # (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 Exe (evSym (cdr Exe))) %5 = call i64 @xName(i64 %0, 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 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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], [%859, %$148] ; # Ms %31 = phi i64 [%4, %$3], [%863, %$148] ; # Run %32 = phi i64 [%26, %$3], [%861, %$148] ; # 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 ; # (let (Cld2 (val $Child) Cld... br label %$69 $69: %386 = phi i64 [%378, %$68], [%442, %$78] ; # Ms %387 = phi i64 [%379, %$68], [%443, %$78] ; # Run %388 = phi i64 [%380, %$68], [%444, %$78] ; # Tim %389 = phi i8* [%381, %$68], [%445, %$78] ; # Cld %390 = phi i8* [%382, %$68], [%447, %$78] ; # Cld2 ; # (== Cld2 Cld Cld2) (Cld2: pid) (or ... ; # (when (and (<> Cld Cld2) (Cld2: pid) (or (=0 (val Pn)) (== @ (Cld... ; # (and (<> Cld Cld2) (Cld2: pid) (or (=0 (val Pn)) (== @ (Cld2: pid... ; # (<> Cld Cld2) %397 = icmp ne i8* %395, %396 br i1 %397, label %$73, label %$72 $73: %398 = phi i64 [%392, %$70] ; # Ms %399 = phi i64 [%393, %$70] ; # Run %400 = phi i64 [%394, %$70] ; # Tim %401 = phi i8* [%395, %$70] ; # Cld %402 = phi i8* [%396, %$70] ; # Cld2 ; # (Cld2: pid) %403 = getelementptr i8, i8* %396, i32 16 %404 = bitcast i8* %403 to i32* %405 = load i32, i32* %404 %406 = icmp ne i32 %405, 0 br i1 %406, label %$74, label %$72 $74: %407 = phi i64 [%398, %$73] ; # Ms %408 = phi i64 [%399, %$73] ; # Run %409 = phi i64 [%400, %$73] ; # Tim %410 = phi i8* [%401, %$73] ; # Cld %411 = phi i8* [%402, %$73] ; # Cld2 ; # (or (=0 (val Pn)) (== @ (Cld2: pid))) ; # (val Pn) %412 = load i32, i32* %25 ; # (=0 (val Pn)) %413 = icmp eq i32 %412, 0 br i1 %413, label %$75, label %$76 $76: %414 = phi i64 [%407, %$74] ; # Ms %415 = phi i64 [%408, %$74] ; # Run %416 = phi i64 [%409, %$74] ; # Tim %417 = phi i8* [%410, %$74] ; # Cld %418 = phi i8* [%411, %$74] ; # Cld2 ; # (Cld2: pid) %419 = getelementptr i8, i8* %396, i32 16 %420 = bitcast i8* %419 to i32* %421 = load i32, i32* %420 ; # (== @ (Cld2: pid)) %422 = icmp eq i32 %412, %421 br label %$75 $75: %423 = phi i64 [%407, %$74], [%414, %$76] ; # Ms %424 = phi i64 [%408, %$74], [%415, %$76] ; # Run %425 = phi i64 [%409, %$74], [%416, %$76] ; # Tim %426 = phi i8* [%410, %$74], [%417, %$76] ; # Cld %427 = phi i8* [%411, %$74], [%418, %$76] ; # Cld2 %428 = phi i1 [1, %$74], [%422, %$76] ; # -> br label %$72 $72: %429 = phi i64 [%392, %$70], [%398, %$73], [%423, %$75] ; # Ms %430 = phi i64 [%393, %$70], [%399, %$73], [%424, %$75] ; # Run %431 = phi i64 [%394, %$70], [%400, %$73], [%425, %$75] ; # Tim %432 = phi i8* [%395, %$70], [%401, %$73], [%426, %$75] ; # Cld %433 = phi i8* [%396, %$70], [%402, %$73], [%427, %$75] ; # Cld2 %434 = phi i1 [0, %$70], [0, %$73], [%428, %$75] ; # -> br i1 %434, label %$77, label %$78 $77: %435 = phi i64 [%429, %$72] ; # Ms %436 = phi i64 [%430, %$72] ; # Run %437 = phi i64 [%431, %$72] ; # Tim %438 = phi i8* [%432, %$72] ; # Cld %439 = phi i8* [%433, %$72] ; # Cld2 ; # (val 2 Pn) %440 = getelementptr i32, i32* %25, i32 1 %441 = load i32, i32* %440 ; # (wrChild Cld2 Buf (val 2 Pn)) call void @wrChild(i8* %439, i8* %24, i32 %441) br label %$78 $78: %442 = phi i64 [%429, %$72], [%435, %$77] ; # Ms %443 = phi i64 [%430, %$72], [%436, %$77] ; # Run %444 = phi i64 [%431, %$72], [%437, %$77] ; # Tim %445 = phi i8* [%432, %$72], [%438, %$77] ; # Cld %446 = phi i8* [%433, %$72], [%439, %$77] ; # Cld2 ; # (ofs Cld2 (child T)) %447 = getelementptr i8, i8* %446, i32 28 br label %$69 $71: %448 = phi i64 [%386, %$69] ; # Ms %449 = phi i64 [%387, %$69] ; # Run %450 = phi i64 [%388, %$69] ; # Tim %451 = phi i8* [%389, %$69] ; # Cld %452 = phi i8* [%390, %$69] ; # Cld2 br label %$60 $67: %453 = phi i64 [%370, %$65] ; # Ms %454 = phi i64 [%371, %$65] ; # Run %455 = phi i64 [%372, %$65] ; # Tim %456 = phi i8* [%373, %$65] ; # Cld ; # (clsChild Cld) call void @clsChild(i8* %456) ; # (goto 1) br label %$-1 $60: %457 = phi i64 [%354, %$64], [%448, %$71] ; # Ms %458 = phi i64 [%355, %$64], [%449, %$71] ; # Run %459 = phi i64 [%356, %$64], [%450, %$71] ; # Tim %460 = phi i8* [%357, %$64], [%451, %$71] ; # Cld br label %$55 $58: %461 = phi i64 [%329, %$56] ; # Ms %462 = phi i64 [%330, %$56] ; # Run %463 = phi i64 [%331, %$56] ; # Tim %464 = phi i8* [%332, %$56] ; # Cld br label %$55 $55: %465 = phi i64 [%457, %$60], [%461, %$58] ; # Ms %466 = phi i64 [%458, %$60], [%462, %$58] ; # Run %467 = phi i64 [%459, %$60], [%463, %$58] ; # Tim %468 = phi i8* [%460, %$60], [%464, %$58] ; # Cld br label %$54 $54: %469 = phi i64 [%306, %$51], [%465, %$55] ; # Ms %470 = phi i64 [%307, %$51], [%466, %$55] ; # Run %471 = phi i64 [%308, %$51], [%467, %$55] ; # Tim %472 = phi i8* [%309, %$51], [%468, %$55] ; # Cld ; # (when (readyOut (pollfd (Cld: tell))) (let (P (ofs (Cld: buf) (Cl... ; # (Cld: tell) %473 = getelementptr i8, i8* %301, i32 24 %474 = bitcast i8* %473 to i32* %475 = load i32, i32* %474 ; # (pollfd (Cld: tell)) %476 = call i64* @pollfd(i32 %475) ; # (readyOut (pollfd (Cld: tell))) %477 = call i1 @readyOut(i64* %476) br i1 %477, label %$79, label %$80 $79: %478 = phi i64 [%469, %$54] ; # Ms %479 = phi i64 [%470, %$54] ; # Run %480 = phi i64 [%471, %$54] ; # Tim %481 = phi i8* [%472, %$54] ; # Cld ; # (let (P (ofs (Cld: buf) (Cld: ofs)) N (val (i32* P))) (ifn (wrByt... ; # (Cld: buf) %482 = bitcast i8* %301 to i8** %483 = load i8*, i8** %482 ; # (Cld: ofs) %484 = getelementptr i8, i8* %301, i32 8 %485 = bitcast i8* %484 to i32* %486 = load i32, i32* %485 ; # (ofs (Cld: buf) (Cld: ofs)) %487 = getelementptr i8, i8* %483, i32 %486 ; # (i32* P) %488 = bitcast i8* %487 to i32* ; # (val (i32* P)) %489 = load i32, i32* %488 ; # (ifn (wrBytes (Cld: tell) (ofs P 4) N) (clsChild Cld) (setq N (Cl... ; # (Cld: tell) %490 = getelementptr i8, i8* %301, i32 24 %491 = bitcast i8* %490 to i32* %492 = load i32, i32* %491 ; # (ofs P 4) %493 = getelementptr i8, i8* %487, i32 4 ; # (wrBytes (Cld: tell) (ofs P 4) N) %494 = call i1 @wrBytes(i32 %492, i8* %493, i32 %489) br i1 %494, label %$82, label %$81 $81: %495 = phi i64 [%478, %$79] ; # Ms %496 = phi i64 [%479, %$79] ; # Run %497 = phi i64 [%480, %$79] ; # Tim %498 = phi i8* [%481, %$79] ; # Cld %499 = phi i32 [%489, %$79] ; # N ; # (clsChild Cld) call void @clsChild(i8* %498) br label %$83 $82: %500 = phi i64 [%478, %$79] ; # Ms %501 = phi i64 [%479, %$79] ; # Run %502 = phi i64 [%480, %$79] ; # Tim %503 = phi i8* [%481, %$79] ; # Cld %504 = phi i32 [%489, %$79] ; # N ; # (Cld: ofs (+ (Cld: ofs) N 4)) %505 = getelementptr i8, i8* %301, i32 8 %506 = bitcast i8* %505 to i32* %507 = getelementptr i8, i8* %301, i32 8 %508 = bitcast i8* %507 to i32* %509 = load i32, i32* %508 %510 = add i32 %509, %504 %511 = add i32 %510, 4 store i32 %511, i32* %506 ; # (when (>= (* 2 N) (Cld: cnt)) (when (Cld: cnt (- (Cld: cnt) N)) (... ; # (* 2 N) %512 = mul i32 2, %511 ; # (Cld: cnt) %513 = getelementptr i8, i8* %301, i32 12 %514 = bitcast i8* %513 to i32* %515 = load i32, i32* %514 ; # (>= (* 2 N) (Cld: cnt)) %516 = icmp sge i32 %512, %515 br i1 %516, label %$84, label %$85 $84: %517 = phi i64 [%500, %$82] ; # Ms %518 = phi i64 [%501, %$82] ; # Run %519 = phi i64 [%502, %$82] ; # Tim %520 = phi i8* [%503, %$82] ; # Cld %521 = phi i32 [%511, %$82] ; # N ; # (when (Cld: cnt (- (Cld: cnt) N)) (memcpy (Cld: buf) (ofs (Cld: b... ; # (Cld: cnt (- (Cld: cnt) N)) %522 = getelementptr i8, i8* %301, i32 12 %523 = bitcast i8* %522 to i32* %524 = getelementptr i8, i8* %301, i32 12 %525 = bitcast i8* %524 to i32* %526 = load i32, i32* %525 %527 = sub i32 %526, %521 store i32 %527, i32* %523 %528 = icmp ne i32 %527, 0 br i1 %528, label %$86, label %$87 $86: %529 = phi i64 [%517, %$84] ; # Ms %530 = phi i64 [%518, %$84] ; # Run %531 = phi i64 [%519, %$84] ; # Tim %532 = phi i8* [%520, %$84] ; # Cld %533 = phi i32 [%521, %$84] ; # N ; # (Cld: buf) %534 = bitcast i8* %301 to i8** %535 = load i8*, i8** %534 ; # (Cld: buf) %536 = bitcast i8* %301 to i8** %537 = load i8*, i8** %536 ; # (ofs (Cld: buf) N) %538 = getelementptr i8, i8* %537, i32 %533 ; # (Cld: cnt) %539 = getelementptr i8, i8* %301, i32 12 %540 = bitcast i8* %539 to i32* %541 = load i32, i32* %540 ; # (i64 (Cld: cnt)) %542 = sext i32 %541 to i64 ; # (memcpy (Cld: buf) (ofs (Cld: buf) N) (i64 (Cld: cnt))) call void @llvm.memcpy.p0i8.p0i8.i64(i8* %535, i8* %538, i64 %542, i1 0) ; # (Cld: buf (alloc (Cld: buf) (i64 (Cld: cnt)))) %543 = bitcast i8* %301 to i8** %544 = bitcast i8* %301 to i8** %545 = load i8*, i8** %544 %546 = getelementptr i8, i8* %301, i32 12 %547 = bitcast i8* %546 to i32* %548 = load i32, i32* %547 %549 = sext i32 %548 to i64 %550 = call i8* @alloc(i8* %545, i64 %549) store i8* %550, i8** %543 br label %$87 $87: %551 = phi i64 [%517, %$84], [%529, %$86] ; # Ms %552 = phi i64 [%518, %$84], [%530, %$86] ; # Run %553 = phi i64 [%519, %$84], [%531, %$86] ; # Tim %554 = phi i8* [%520, %$84], [%532, %$86] ; # Cld %555 = phi i32 [%521, %$84], [%533, %$86] ; # N ; # (Cld: ofs 0) %556 = getelementptr i8, i8* %301, i32 8 %557 = bitcast i8* %556 to i32* store i32 0, i32* %557 br label %$85 $85: %558 = phi i64 [%500, %$82], [%551, %$87] ; # Ms %559 = phi i64 [%501, %$82], [%552, %$87] ; # Run %560 = phi i64 [%502, %$82], [%553, %$87] ; # Tim %561 = phi i8* [%503, %$82], [%554, %$87] ; # Cld %562 = phi i32 [%511, %$82], [%555, %$87] ; # N br label %$83 $83: %563 = phi i64 [%495, %$81], [%558, %$85] ; # Ms %564 = phi i64 [%496, %$81], [%559, %$85] ; # Run %565 = phi i64 [%497, %$81], [%560, %$85] ; # Tim %566 = phi i8* [%498, %$81], [%561, %$85] ; # Cld %567 = phi i32 [%499, %$81], [%562, %$85] ; # N br label %$80 $80: %568 = phi i64 [%469, %$54], [%563, %$83] ; # Ms %569 = phi i64 [%470, %$54], [%564, %$83] ; # Run %570 = phi i64 [%471, %$54], [%565, %$83] ; # Tim %571 = phi i8* [%472, %$54], [%566, %$83] ; # Cld br label %$52 $52: %572 = phi i64 [%298, %$49], [%568, %$80] ; # Ms %573 = phi i64 [%299, %$49], [%569, %$80] ; # Run %574 = phi i64 [%300, %$49], [%570, %$80] ; # Tim %575 = phi i8* [%301, %$49], [%571, %$80] ; # Cld ; # (: 1 (setq Cld (ofs Cld (child T)))) br label %$-1 $-1: %576 = phi i64 [%325, %$57], [%453, %$67], [%572, %$52] ; # Ms %577 = phi i64 [%326, %$57], [%454, %$67], [%573, %$52] ; # Run %578 = phi i64 [%327, %$57], [%455, %$67], [%574, %$52] ; # Tim %579 = phi i8* [%328, %$57], [%456, %$67], [%575, %$52] ; # Cld ; # (ofs Cld (child T)) %580 = getelementptr i8, i8* %579, i32 28 br label %$48 $50: %581 = phi i64 [%293, %$48] ; # Ms %582 = phi i64 [%294, %$48] ; # Run %583 = phi i64 [%295, %$48] ; # Tim %584 = 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) %585 = load i32, i32* @$Talking ; # (=0 (val $Talking)) %586 = icmp eq i32 %585, 0 br i1 %586, label %$89, label %$88 $89: %587 = phi i64 [%581, %$50] ; # Ms %588 = phi i64 [%582, %$50] ; # Run %589 = phi i64 [%583, %$50] ; # Tim ; # (val $Spkr) %590 = load i32, i32* @$Spkr ; # (pollfd (val $Spkr)) %591 = call i64* @pollfd(i32 %590) ; # (readyIn (pollfd (val $Spkr))) %592 = call i1 @readyIn(i64* %591) br i1 %592, label %$90, label %$88 $90: %593 = phi i64 [%587, %$89] ; # Ms %594 = phi i64 [%588, %$89] ; # Run %595 = phi i64 [%589, %$89] ; # Tim ; # (val $Spkr) %596 = load i32, i32* @$Spkr ; # (i8* Pn) %597 = bitcast i32* %25 to i8* ; # (rdBytesNb (val $Spkr) (i8* Pn) 4) %598 = call i64 @rdBytesNb(i32 %596, i8* %597, i32 4) ; # (gt0 (rdBytesNb (val $Spkr) (i8* Pn) 4)) %599 = icmp sgt i64 %598, 0 br label %$88 $88: %600 = phi i64 [%581, %$50], [%587, %$89], [%593, %$90] ; # Ms %601 = phi i64 [%582, %$50], [%588, %$89], [%594, %$90] ; # Run %602 = phi i64 [%583, %$50], [%589, %$89], [%595, %$90] ; # Tim %603 = phi i1 [0, %$50], [0, %$89], [%599, %$90] ; # -> br i1 %603, label %$91, label %$92 $91: %604 = phi i64 [%600, %$88] ; # Ms %605 = phi i64 [%601, %$88] ; # Run %606 = phi i64 [%602, %$88] ; # Tim ; # (let Cld (ofs (val $Child) (* (val Pn) (child T))) (when ((child ... ; # (val $Child) %607 = load i8*, i8** @$Child ; # (val Pn) %608 = load i32, i32* %25 ; # (* (val Pn) (child T)) %609 = mul i32 %608, 28 ; # (ofs (val $Child) (* (val Pn) (child T))) %610 = getelementptr i8, i8* %607, i32 %609 ; # (when ((child Cld) pid) (set $Talking @) (wrChild Cld $TBuf 2)) ; # ((child Cld) pid) %611 = getelementptr i8, i8* %610, i32 16 %612 = bitcast i8* %611 to i32* %613 = load i32, i32* %612 %614 = icmp ne i32 %613, 0 br i1 %614, label %$93, label %$94 $93: %615 = phi i64 [%604, %$91] ; # Ms %616 = phi i64 [%605, %$91] ; # Run %617 = phi i64 [%606, %$91] ; # Tim ; # (set $Talking @) store i32 %613, i32* @$Talking ; # (wrChild Cld $TBuf 2) call void @wrChild(i8* %610, i8* bitcast ([2 x i8]* @$TBuf to i8*), i32 2) br label %$94 $94: %618 = phi i64 [%604, %$91], [%615, %$93] ; # Ms %619 = phi i64 [%605, %$91], [%616, %$93] ; # Run %620 = phi i64 [%606, %$91], [%617, %$93] ; # Tim br label %$92 $92: %621 = phi i64 [%600, %$88], [%618, %$94] ; # Ms %622 = phi i64 [%601, %$88], [%619, %$94] ; # Run %623 = phi i64 [%602, %$88], [%620, %$94] ; # Tim ; # (set $Protect (dec (val $Protect))) ; # (val $Protect) %624 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 120) to i32*) ; # (dec (val $Protect)) %625 = sub i32 %624, 1 store i32 %625, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 120) to i32*) br label %$47 $47: %626 = phi i64 [%276, %$41], [%621, %$92] ; # Ms %627 = phi i64 [%277, %$41], [%622, %$92] ; # Run %628 = phi i64 [%278, %$41], [%623, %$92] ; # Tim ; # (let N (val $Hear) (when (and N (<> N Fd) (inReady N NO)) (let In... ; # (val $Hear) %629 = load i32, i32* @$Hear ; # (when (and N (<> N Fd) (inReady N NO)) (let In (val $InFile) (set... ; # (and N (<> N Fd) (inReady N NO)) %630 = icmp ne i32 %629, 0 br i1 %630, label %$96, label %$95 $96: %631 = phi i64 [%626, %$47] ; # Ms %632 = phi i64 [%627, %$47] ; # Run %633 = phi i64 [%628, %$47] ; # Tim ; # (<> N Fd) %634 = icmp ne i32 %629, %1 br i1 %634, label %$97, label %$95 $97: %635 = phi i64 [%631, %$96] ; # Ms %636 = phi i64 [%632, %$96] ; # Run %637 = phi i64 [%633, %$96] ; # Tim ; # (inReady N NO) %638 = call i1 @inReady(i32 %629, i1 0) br label %$95 $95: %639 = phi i64 [%626, %$47], [%631, %$96], [%635, %$97] ; # Ms %640 = phi i64 [%627, %$47], [%632, %$96], [%636, %$97] ; # Run %641 = phi i64 [%628, %$47], [%633, %$96], [%637, %$97] ; # Tim %642 = phi i1 [0, %$47], [0, %$96], [%638, %$97] ; # -> br i1 %642, label %$98, label %$99 $98: %643 = phi i64 [%639, %$95] ; # Ms %644 = phi i64 [%640, %$95] ; # Run %645 = phi i64 [%641, %$95] ; # Tim ; # (let In (val $InFile) (set $InFile (val (ofs (val $InFiles) (val ... ; # (val $InFile) %646 = load i8*, i8** @$InFile ; # (set $InFile (val (ofs (val $InFiles) (val $Hear))) $GetBin (fun ... ; # (val $InFiles) %647 = load i8**, i8*** @$InFiles ; # (val $Hear) %648 = load i32, i32* @$Hear ; # (ofs (val $InFiles) (val $Hear)) %649 = getelementptr i8*, i8** %647, i32 %648 ; # (val (ofs (val $InFiles) (val $Hear))) %650 = load i8*, i8** %649 store i8* %650, i8** @$InFile ; # (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) %651 = call i64 @binRead() ; # (cond ((=0 E) (close N) (closeInFile N) (closeOutFile N) (set $He... ; # (=0 E) %652 = icmp eq i64 %651, 0 br i1 %652, label %$102, label %$101 $102: %653 = phi i64 [%643, %$98] ; # Ms %654 = phi i64 [%644, %$98] ; # Run %655 = phi i64 [%645, %$98] ; # Tim ; # (close N) %656 = call i32 @close(i32 %629) ; # (closeInFile N) call void @closeInFile(i32 %629) ; # (closeOutFile N) call void @closeOutFile(i32 %629) ; # (set $Hear 0) store i32 0, i32* @$Hear br label %$100 $101: %657 = phi i64 [%643, %$98] ; # Ms %658 = phi i64 [%644, %$98] ; # Run %659 = phi i64 [%645, %$98] ; # Tim ; # (t? E) %660 = icmp eq i64 %651, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br i1 %660, label %$104, label %$103 $104: %661 = phi i64 [%657, %$101] ; # Ms %662 = phi i64 [%658, %$101] ; # Run %663 = phi i64 [%659, %$101] ; # Tim ; # (set $Sync YES) store i1 1, i1* @$Sync br label %$100 $103: %664 = phi i64 [%657, %$101] ; # Ms %665 = phi i64 [%658, %$101] ; # Run %666 = phi i64 [%659, %$101] ; # Tim ; # (save E (evList E)) %667 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %668 = load i64, i64* %667 %669 = alloca i64, i64 2, align 16 %670 = ptrtoint i64* %669 to i64 %671 = inttoptr i64 %670 to i64* store i64 %651, i64* %671 %672 = add i64 %670, 8 %673 = inttoptr i64 %672 to i64* store i64 %668, i64* %673 %674 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %670, i64* %674 ; # (evList E) %675 = call i64 @evList(i64 %651) ; # drop %676 = inttoptr i64 %670 to i64* %677 = getelementptr i64, i64* %676, i32 1 %678 = load i64, i64* %677 %679 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %678, i64* %679 br label %$100 $100: %680 = phi i64 [%653, %$102], [%661, %$104], [%664, %$103] ; # Ms %681 = phi i64 [%654, %$102], [%662, %$104], [%665, %$103] ; # Run %682 = phi i64 [%655, %$102], [%663, %$104], [%666, %$103] ; # Tim ; # (set $InFile In) store i8* %646, i8** @$InFile br label %$99 $99: %683 = phi i64 [%639, %$95], [%680, %$100] ; # Ms %684 = phi i64 [%640, %$95], [%681, %$100] ; # Run %685 = phi i64 [%641, %$95], [%682, %$100] ; # 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 %$105 $105: %686 = phi i64 [%683, %$99], [%823, %$108] ; # Ms %687 = phi i64 [%684, %$99], [%824, %$108] ; # Run %688 = phi i64 [%685, %$99], [%825, %$108] ; # Tim %689 = phi i64 [%684, %$99], [%826, %$108] ; # R ; # (pair R) %690 = and i64 %689, 15 %691 = icmp eq i64 %690, 0 br i1 %691, label %$106, label %$107 $106: %692 = phi i64 [%686, %$105] ; # Ms %693 = phi i64 [%687, %$105] ; # Run %694 = phi i64 [%688, %$105] ; # Tim %695 = phi i64 [%689, %$105] ; # R ; # (let X (++ R) (cond ((sign? (car X)) (let Y (cdr X) (if (gt0 (- (... ; # (++ R) %696 = inttoptr i64 %695 to i64* %697 = load i64, i64* %696 %698 = getelementptr i64, i64* %696, i32 1 %699 = load i64, i64* %698 ; # (cond ((sign? (car X)) (let Y (cdr X) (if (gt0 (- (int (car Y)) D... ; # (car X) %700 = inttoptr i64 %697 to i64* %701 = load i64, i64* %700 ; # (sign? (car X)) %702 = and i64 %701, 8 %703 = icmp ne i64 %702, 0 br i1 %703, label %$110, label %$109 $110: %704 = phi i64 [%692, %$106] ; # Ms %705 = phi i64 [%693, %$106] ; # Run %706 = phi i64 [%694, %$106] ; # Tim %707 = phi i64 [%699, %$106] ; # R ; # (let Y (cdr X) (if (gt0 (- (int (car Y)) Dif)) (set Y (sign (cnt ... ; # (cdr X) %708 = inttoptr i64 %697 to i64* %709 = getelementptr i64, i64* %708, i32 1 %710 = load i64, i64* %709 ; # (if (gt0 (- (int (car Y)) Dif)) (set Y (sign (cnt @))) (let V (ca... ; # (car Y) %711 = inttoptr i64 %710 to i64* %712 = load i64, i64* %711 ; # (int (car Y)) %713 = lshr i64 %712, 4 ; # (- (int (car Y)) Dif) %714 = sub i64 %713, %281 ; # (gt0 (- (int (car Y)) Dif)) %715 = icmp sgt i64 %714, 0 br i1 %715, label %$111, label %$112 $111: %716 = phi i64 [%704, %$110] ; # Ms %717 = phi i64 [%705, %$110] ; # Run %718 = phi i64 [%706, %$110] ; # Tim %719 = phi i64 [%707, %$110] ; # R ; # (set Y (sign (cnt @))) ; # (cnt @) %720 = shl i64 %714, 4 %721 = or i64 %720, 2 ; # (sign (cnt @)) %722 = or i64 %721, 8 %723 = inttoptr i64 %710 to i64* store i64 %722, i64* %723 br label %$113 $112: %724 = phi i64 [%704, %$110] ; # Ms %725 = phi i64 [%705, %$110] ; # Run %726 = phi i64 [%706, %$110] ; # Tim %727 = phi i64 [%707, %$110] ; # R ; # (let V (car X) (set Y (pos V) $At V) (run (cdr Y))) ; # (car X) %728 = inttoptr i64 %697 to i64* %729 = load i64, i64* %728 ; # (set Y (pos V) $At V) ; # (pos V) %730 = and i64 %729, -9 %731 = inttoptr i64 %710 to i64* store i64 %730, i64* %731 %732 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 %729, i64* %732 ; # (cdr Y) %733 = inttoptr i64 %710 to i64* %734 = getelementptr i64, i64* %733, i32 1 %735 = load i64, i64* %734 ; # (run (cdr Y)) br label %$114 $114: %736 = phi i64 [%735, %$112], [%758, %$123] ; # Prg %737 = inttoptr i64 %736 to i64* %738 = load i64, i64* %737 %739 = getelementptr i64, i64* %737, i32 1 %740 = load i64, i64* %739 %741 = and i64 %740, 15 %742 = icmp ne i64 %741, 0 br i1 %742, label %$117, label %$115 $117: %743 = phi i64 [%740, %$114] ; # Prg %744 = and i64 %738, 6 %745 = icmp ne i64 %744, 0 br i1 %745, label %$120, label %$119 $120: br label %$118 $119: %746 = and i64 %738, 8 %747 = icmp ne i64 %746, 0 br i1 %747, label %$122, label %$121 $122: %748 = inttoptr i64 %738 to i64* %749 = load i64, i64* %748 br label %$118 $121: %750 = call i64 @evList(i64 %738) br label %$118 $118: %751 = phi i64 [%738, %$120], [%749, %$122], [%750, %$121] ; # -> br label %$116 $115: %752 = phi i64 [%740, %$114] ; # Prg %753 = and i64 %738, 15 %754 = icmp eq i64 %753, 0 br i1 %754, label %$124, label %$123 $124: %755 = phi i64 [%752, %$115] ; # Prg %756 = call i64 @evList(i64 %738) %757 = icmp ne i64 %756, 0 br label %$123 $123: %758 = phi i64 [%752, %$115], [%755, %$124] ; # Prg %759 = phi i1 [0, %$115], [%757, %$124] ; # -> br label %$114 $116: %760 = phi i64 [%743, %$118] ; # Prg %761 = phi i64 [%751, %$118] ; # -> br label %$113 $113: %762 = phi i64 [%716, %$111], [%724, %$116] ; # Ms %763 = phi i64 [%717, %$111], [%725, %$116] ; # Run %764 = phi i64 [%718, %$111], [%726, %$116] ; # Tim %765 = phi i64 [%719, %$111], [%727, %$116] ; # R %766 = phi i64 [%722, %$111], [%761, %$116] ; # -> br label %$108 $109: %767 = phi i64 [%692, %$106] ; # Ms %768 = phi i64 [%693, %$106] ; # Run %769 = phi i64 [%694, %$106] ; # Tim %770 = phi i64 [%699, %$106] ; # R ; # (int @) %771 = lshr i64 %701, 4 ; # (i32 (int @)) %772 = trunc i64 %771 to i32 ; # (<> (i32 (int @)) Fd) %773 = icmp ne i32 %772, %1 br i1 %773, label %$126, label %$125 $126: %774 = phi i64 [%767, %$109] ; # Ms %775 = phi i64 [%768, %$109] ; # Run %776 = phi i64 [%769, %$109] ; # Tim %777 = phi i64 [%770, %$109] ; # R ; # (when (inReady @ NO) (set $At (car X)) (run (cdr X))) ; # (inReady @ NO) %778 = call i1 @inReady(i32 %772, i1 0) br i1 %778, label %$127, label %$128 $127: %779 = phi i64 [%774, %$126] ; # Ms %780 = phi i64 [%775, %$126] ; # Run %781 = phi i64 [%776, %$126] ; # Tim %782 = phi i64 [%777, %$126] ; # R ; # (set $At (car X)) ; # (car X) %783 = inttoptr i64 %697 to i64* %784 = load i64, i64* %783 %785 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 %784, i64* %785 ; # (cdr X) %786 = inttoptr i64 %697 to i64* %787 = getelementptr i64, i64* %786, i32 1 %788 = load i64, i64* %787 ; # (run (cdr X)) br label %$129 $129: %789 = phi i64 [%788, %$127], [%811, %$138] ; # Prg %790 = inttoptr i64 %789 to i64* %791 = load i64, i64* %790 %792 = getelementptr i64, i64* %790, i32 1 %793 = load i64, i64* %792 %794 = and i64 %793, 15 %795 = icmp ne i64 %794, 0 br i1 %795, label %$132, label %$130 $132: %796 = phi i64 [%793, %$129] ; # Prg %797 = and i64 %791, 6 %798 = icmp ne i64 %797, 0 br i1 %798, label %$135, label %$134 $135: br label %$133 $134: %799 = and i64 %791, 8 %800 = icmp ne i64 %799, 0 br i1 %800, label %$137, label %$136 $137: %801 = inttoptr i64 %791 to i64* %802 = load i64, i64* %801 br label %$133 $136: %803 = call i64 @evList(i64 %791) br label %$133 $133: %804 = phi i64 [%791, %$135], [%802, %$137], [%803, %$136] ; # -> br label %$131 $130: %805 = phi i64 [%793, %$129] ; # Prg %806 = and i64 %791, 15 %807 = icmp eq i64 %806, 0 br i1 %807, label %$139, label %$138 $139: %808 = phi i64 [%805, %$130] ; # Prg %809 = call i64 @evList(i64 %791) %810 = icmp ne i64 %809, 0 br label %$138 $138: %811 = phi i64 [%805, %$130], [%808, %$139] ; # Prg %812 = phi i1 [0, %$130], [%810, %$139] ; # -> br label %$129 $131: %813 = phi i64 [%796, %$133] ; # Prg %814 = phi i64 [%804, %$133] ; # -> br label %$128 $128: %815 = phi i64 [%774, %$126], [%779, %$131] ; # Ms %816 = phi i64 [%775, %$126], [%780, %$131] ; # Run %817 = phi i64 [%776, %$126], [%781, %$131] ; # Tim %818 = phi i64 [%777, %$126], [%782, %$131] ; # R br label %$108 $125: %819 = phi i64 [%767, %$109] ; # Ms %820 = phi i64 [%768, %$109] ; # Run %821 = phi i64 [%769, %$109] ; # Tim %822 = phi i64 [%770, %$109] ; # R br label %$108 $108: %823 = phi i64 [%762, %$113], [%815, %$128], [%819, %$125] ; # Ms %824 = phi i64 [%763, %$113], [%816, %$128], [%820, %$125] ; # Run %825 = phi i64 [%764, %$113], [%817, %$128], [%821, %$125] ; # Tim %826 = phi i64 [%765, %$113], [%818, %$128], [%822, %$125] ; # R br label %$105 $107: %827 = phi i64 [%686, %$105] ; # Ms %828 = phi i64 [%687, %$105] ; # Run %829 = phi i64 [%688, %$105] ; # Tim %830 = phi i64 [%689, %$105] ; # R ; # (and (gt0 Ms) (lt0 (dec 'Ms Dif)) (setq Ms 0)) ; # (gt0 Ms) %831 = icmp sgt i64 %827, 0 br i1 %831, label %$141, label %$140 $141: %832 = phi i64 [%827, %$107] ; # Ms %833 = phi i64 [%828, %$107] ; # Run %834 = phi i64 [%829, %$107] ; # Tim ; # (dec 'Ms Dif) %835 = sub i64 %832, %281 ; # (lt0 (dec 'Ms Dif)) %836 = icmp slt i64 %835, 0 br i1 %836, label %$142, label %$140 $142: %837 = phi i64 [%835, %$141] ; # Ms %838 = phi i64 [%833, %$141] ; # Run %839 = phi i64 [%834, %$141] ; # Tim br label %$140 $140: %840 = phi i64 [%827, %$107], [%835, %$141], [0, %$142] ; # Ms %841 = phi i64 [%828, %$107], [%833, %$141], [%838, %$142] ; # Run %842 = phi i64 [%829, %$107], [%834, %$141], [%839, %$142] ; # Tim %843 = phi i1 [0, %$107], [0, %$141], [0, %$142] ; # -> ; # (sigChk Exe) %844 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*) %845 = icmp ne i32 %844, 0 br i1 %845, label %$143, label %$144 $143: call void @sighandler(i64 %0) br label %$144 $144: ; # (? (or (=0 Ms) (lt0 Fd) (inReady Fd YES))) ; # (or (=0 Ms) (lt0 Fd) (inReady Fd YES)) ; # (=0 Ms) %846 = icmp eq i64 %840, 0 br i1 %846, label %$145, label %$146 $146: %847 = phi i64 [%840, %$144] ; # Ms %848 = phi i64 [%841, %$144] ; # Run %849 = phi i64 [%280, %$144] ; # Tim ; # (lt0 Fd) %850 = icmp slt i32 %1, 0 br i1 %850, label %$145, label %$147 $147: %851 = phi i64 [%847, %$146] ; # Ms %852 = phi i64 [%848, %$146] ; # Run %853 = phi i64 [%849, %$146] ; # Tim ; # (inReady Fd YES) %854 = call i1 @inReady(i32 %1, i1 1) br label %$145 $145: %855 = phi i64 [%840, %$144], [%847, %$146], [%851, %$147] ; # Ms %856 = phi i64 [%841, %$144], [%848, %$146], [%852, %$147] ; # Run %857 = phi i64 [%280, %$144], [%849, %$146], [%853, %$147] ; # Tim %858 = phi i1 [1, %$144], [1, %$146], [%854, %$147] ; # -> br i1 %858, label %$149, label %$148 $148: %859 = phi i64 [%855, %$145] ; # Ms %860 = phi i64 [%856, %$145] ; # Run %861 = phi i64 [%857, %$145] ; # Tim ; # (val $Run) %862 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 600) to i64) to i64* %863 = load i64, i64* %862 ; # (safe (val $Run)) %864 = inttoptr i64 %8 to i64* store i64 %863, i64* %864 br label %$4 $149: %865 = phi i64 [%855, %$145] ; # Ms %866 = phi i64 [%856, %$145] ; # Run %867 = phi i64 [%857, %$145] ; # Tim %868 = phi i64 [0, %$145] ; # -> ; # (set $At At) %869 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 %14, i64* %869 ; # (drop *Safe) %870 = inttoptr i64 %8 to i64* %871 = getelementptr i64, i64* %870, i32 1 %872 = load i64, i64* %871 %873 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %872, i64* %873 ret i64 %865 } 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 ([870 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 ([870 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 ([870 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 ([870 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 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]* @$40 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 0)) (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 0) ; # (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 [0, %$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 [0, %$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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%45, %$18] ; # -> ret i64 %46 } define void @rdOpen(i64, i64, i8*) align 8 { $1: ; # (let Io: (ioFrame Io) (cond ((nil? X) (pushInFile Io (val (val $I... ; # (cond ((nil? X) (pushInFile Io (val (val $InFiles)) 0)) ((num? X)... ; # (nil? X) %3 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 x i64]* @env to i8*), i32 32) 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 Exe X) S (pathString Nm (b8 (pathSize Nm))) Flg (... ; # (xName Exe X) %65 = call i64 @xName(i64 %0, 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) ; # (val S) %69 = load i8, i8* %68 ; # (== (val S) (char "+")) %70 = icmp eq i8 %69, 43 ; # (when Flg (setq S (ofs S 1))) br i1 %70, label %$21, label %$22 $21: %71 = phi i64 [%64, %$20] ; # X %72 = phi i8* [%68, %$20] ; # S ; # (ofs S 1) %73 = getelementptr i8, i8* %72, i32 1 br label %$22 $22: %74 = phi i64 [%64, %$20], [%71, %$21] ; # X %75 = phi i8* [%68, %$20], [%73, %$21] ; # S ; # (while (lt0 (setq Fd (if Flg (openRdWrAppend S) (openRd S)))) (un... br label %$23 $23: %76 = phi i64 [%74, %$22], [%96, %$32] ; # X %77 = phi i8* [%75, %$22], [%97, %$32] ; # S ; # (if Flg (openRdWrAppend S) (openRd S)) br i1 %70, label %$24, label %$25 $24: %78 = phi i64 [%76, %$23] ; # X %79 = phi i8* [%77, %$23] ; # S ; # (openRdWrAppend S) %80 = call i32 @openRdWrAppend(i8* %79) br label %$26 $25: %81 = phi i64 [%76, %$23] ; # X %82 = phi i8* [%77, %$23] ; # S ; # (openRd S) %83 = call i32 @openRd(i8* %82) br label %$26 $26: %84 = phi i64 [%78, %$24], [%81, %$25] ; # X %85 = phi i8* [%79, %$24], [%82, %$25] ; # S %86 = phi i32 [%80, %$24], [%83, %$25] ; # -> ; # (lt0 (setq Fd (if Flg (openRdWrAppend S) (openRd S)))) %87 = icmp slt i32 %86, 0 br i1 %87, label %$27, label %$28 $27: %88 = phi i64 [%84, %$26] ; # X %89 = phi i8* [%85, %$26] ; # S %90 = phi i32 [%86, %$26] ; # Fd ; # (unless (== (gErrno) EINTR) (openErr Exe X)) ; # (gErrno) %91 = call i32 @gErrno() ; # (== (gErrno) EINTR) %92 = icmp eq i32 %91, 2 br i1 %92, label %$30, label %$29 $29: %93 = phi i64 [%88, %$27] ; # X %94 = phi i8* [%89, %$27] ; # S %95 = phi i32 [%90, %$27] ; # Fd ; # (openErr Exe X) call void @openErr(i64 %0, i64 %93) unreachable $30: %96 = phi i64 [%88, %$27] ; # X %97 = phi i8* [%89, %$27] ; # S %98 = phi i32 [%90, %$27] ; # Fd ; # (sigChk Exe) %99 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*) %100 = icmp ne i32 %99, 0 br i1 %100, label %$31, label %$32 $31: call void @sighandler(i64 %0) br label %$32 $32: br label %$23 $28: %101 = phi i64 [%84, %$26] ; # X %102 = phi i8* [%85, %$26] ; # S %103 = phi i32 [%86, %$26] ; # Fd ; # (closeOnExec Exe Fd) call void @closeOnExec(i64 %0, i32 %103) ; # (strdup S) %104 = call i8* @strdup(i8* %102) ; # (initInFile Fd (strdup S)) %105 = call i8* @initInFile(i32 %103, i8* %104) ; # (pushInFile Io (initInFile Fd (strdup S)) 1) call void @pushInFile(i8* %2, i8* %105, i32 1) br label %$2 $19: %106 = phi i64 [%61, %$5] ; # X ; # (let (Pfd (b32 2) Av (b8* (inc (length X))) Cmd (xName Exe (xSym ... ; # (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 Exe (xSym (car X))) %125 = call i64 @xName(i64 %0, 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 Exe (xSym (car X... ; # (while (pair (shift X)) (let Nm (xName Exe (xSym (car X))) (set (... 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 Exe (xSym (car X))) (set (inc 'A) (bufString Nm (b... ; # (car X) %142 = inttoptr i64 %140 to i64* %143 = load i64, i64* %142 ; # (xSym (car X)) %144 = call i64 @xSym(i64 %143) ; # (xName Exe (xSym (car X))) %145 = call i64 @xName(i64 %0, 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 Pfd) %160 = load i32, i32* %107 ; # (close (val Pfd)) %161 = call i32 @close(i32 %160) ; # (unless (== (val 2 Pfd) 1) (dup2 @ 1) (close @)) ; # (val 2 Pfd) %162 = getelementptr i32, i32* %107, i32 1 %163 = load i32, i32* %162 ; # (== (val 2 Pfd) 1) %164 = icmp eq i32 %163, 1 br i1 %164, label %$47, label %$46 $46: %165 = phi i64 [%158, %$45] ; # X ; # (dup2 @ 1) %166 = call i32 @dup2(i32 %163, i32 1) ; # (close @) %167 = call i32 @close(i32 %163) br label %$47 $47: %168 = phi i64 [%158, %$45], [%165, %$46] ; # X ; # (val SIGPIPE Sig) %169 = getelementptr i32, i32* @Sig, i32 4 %170 = load i32, i32* %169 ; # (val SigDfl) %171 = load i8*, i8** @SigDfl ; # (signal (val SIGPIPE Sig) (val SigDfl)) %172 = call i8* @signal(i32 %170, i8* %171) ; # (val Av) %173 = load i8*, i8** %121 ; # (execvp (val Av) Av) %174 = call i32 @execvp(i8* %173, i8** %121) ; # (val Av) %175 = load i8*, i8** %121 ; # (execErr (val Av)) call void @execErr(i8* %175) unreachable $44: %176 = phi i64 [%156, %$42] ; # X br label %$41 $41: %177 = phi i64 [%176, %$44] ; # X %178 = phi i64 [0, %$44] ; # -> ; # (let (Pid @ Fd (val Pfd)) (setpgid Pid 0) (close (val 2 Pfd)) (cl... ; # (val Pfd) %179 = load i32, i32* %107 ; # (setpgid Pid 0) %180 = call i32 @setpgid(i32 %153, i32 0) ; # (val 2 Pfd) %181 = getelementptr i32, i32* %107, i32 1 %182 = load i32, i32* %181 ; # (close (val 2 Pfd)) %183 = call i32 @close(i32 %182) ; # (closeOnExec Exe Fd) call void @closeOnExec(i64 %0, i32 %179) ; # (initInFile Fd null) %184 = call i8* @initInFile(i32 %179, i8* null) ; # (pushInFile Io (initInFile Fd null) Pid) call void @pushInFile(i8* %2, i8* %184, i32 %153) br label %$2 $2: %185 = phi i64 [%4, %$4], [%58, %$7], [%101, %$28], [%177, %$41] ; # X ret void } define void @wrOpen(i64, i64, i8*) align 8 { $1: ; # (let Io: (ioFrame Io) (cond ((nil? X) (pushOutFile Io (val 2 (val... ; # (cond ((nil? X) (pushOutFile Io (val 2 (val $OutFiles)) 0)) ((num... ; # (nil? X) %3 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 x i64]* @env to i8*), i32 40) 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 Exe X) S (pathString Nm (b8 (pathSize Nm))) Flg (... ; # (xName Exe X) %66 = call i64 @xName(i64 %0, 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 (openWrAppend S) (openWr S)))) (unle... br label %$23 $23: %77 = phi i64 [%75, %$22], [%97, %$32] ; # X %78 = phi i8* [%76, %$22], [%98, %$32] ; # S ; # (if Flg (openWrAppend S) (openWr S)) br i1 %71, label %$24, label %$25 $24: %79 = phi i64 [%77, %$23] ; # X %80 = phi i8* [%78, %$23] ; # S ; # (openWrAppend S) %81 = call i32 @openWrAppend(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 (openWrAppend 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 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 Exe (xSym ... ; # (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 Exe (xSym (car X))) %125 = call i64 @xName(i64 %0, 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 Exe (xSym (car X... ; # (while (pair (shift X)) (let Nm (xName Exe (xSym (car X))) (set (... 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 Exe (xSym (car X))) (set (inc 'A) (bufString Nm (b... ; # (car X) %142 = inttoptr i64 %140 to i64* %143 = load i64, i64* %142 ; # (xSym (car X)) %144 = call i64 @xSym(i64 %143) ; # (xName Exe (xSym (car X))) %145 = call i64 @xName(i64 %0, 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %9, label %$4, label %$5 $4: ; # (val $OutFile) %10 = load i8*, i8** @$OutFile ; # ((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 Exe X) S (pathString Nm (b8 (pathSize Nm))) Flg (... ; # (xName Exe X) %14 = call i64 @xName(i64 %0, 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 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 ([870 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 ([870 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 Exe X) S (pathString Nm (b8 (pathSize Nm))) Flg (... ; # (xName Exe X) %14 = call i64 @xName(i64 %0, 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 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** @$InFile ; # (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 (readline (val $LinePrmt)))) (wrnl)... ; # (set $LineBuf (readline (val $LinePrmt))) ; # (val $LinePrmt) %54 = load i8*, i8** @$LinePrmt ; # (readline (val $LinePrmt)) %55 = call i8* @readline(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 ([17 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* @$Chr 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()** @$Get %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()** @$Get %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()** @$Get %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* @$Chr ; # (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()** @$Get %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()** @$Get %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()** @$Get %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()** @$Get %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()** @$Get %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()** @$Get %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()** @$Get %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()** @$Get %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()** @$Get %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* @$Chr ; # (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()** @$Get %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 i1 @testEsc(i32) align 8 { $1: ; # (loop (? (lt0 Chr) NO) (? (== Chr (char "\^")) (when (== (setq Ch... br label %$2 $2: %1 = phi i32 [%0, %$1], [%72, %$39] ; # 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()** @$Get %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* @$Chr 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* @$Chr 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()** @$Get %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* @$Chr br label %$18 $20: %28 = phi i32 [%26, %$16] ; # Chr ; # (set $Chr (char "^[")) store i32 27, i32* @$Chr br label %$18 $21: %29 = phi i32 [%26, %$16] ; # Chr ; # (set $Chr (char "^J")) store i32 10, i32* @$Chr br label %$18 $22: %30 = phi i32 [%26, %$16] ; # Chr ; # (set $Chr (char "^M")) store i32 13, i32* @$Chr br label %$18 $23: %31 = phi i32 [%26, %$16] ; # Chr ; # (set $Chr (char "^I")) store i32 9, i32* @$Chr br label %$18 $17: %32 = phi i32 [%26, %$16] ; # Chr ; # (when (and (>= Chr (char "0")) (>= (char "9") Chr)) (dec 'Chr (ch... ; # (and (>= Chr (char "0")) (>= (char "9") Chr)) ; # (>= Chr (char "0")) %33 = icmp sge i32 %32, 48 br i1 %33, label %$25, label %$24 $25: %34 = phi i32 [%32, %$17] ; # Chr ; # (>= (char "9") Chr) %35 = icmp sge i32 57, %34 br label %$24 $24: %36 = phi i32 [%32, %$17], [%34, %$25] ; # Chr %37 = phi i1 [0, %$17], [%35, %$25] ; # -> br i1 %37, label %$26, label %$27 $26: %38 = phi i32 [%36, %$24] ; # Chr ; # (dec 'Chr (char "0")) %39 = sub i32 %38, 48 ; # (until (== (call $Get) (char "\\")) (unless (and (>= (val $Chr) (... br label %$28 $28: %40 = phi i32 [%39, %$26], [%57, %$34] ; # Chr ; # (call $Get) %41 = load i32()*, i32()** @$Get %42 = call i32 %41() ; # (== (call $Get) (char "\\")) %43 = icmp eq i32 %42, 92 br i1 %43, label %$30, label %$29 $29: %44 = phi i32 [%40, %$28] ; # Chr ; # (unless (and (>= (val $Chr) (char "0")) (>= (char "9") (val $Chr)... ; # (and (>= (val $Chr) (char "0")) (>= (char "9") (val $Chr))) ; # (val $Chr) %45 = load i32, i32* @$Chr ; # (>= (val $Chr) (char "0")) %46 = icmp sge i32 %45, 48 br i1 %46, label %$32, label %$31 $32: %47 = phi i32 [%44, %$29] ; # Chr ; # (val $Chr) %48 = load i32, i32* @$Chr ; # (>= (char "9") (val $Chr)) %49 = icmp sge i32 57, %48 br label %$31 $31: %50 = phi i32 [%44, %$29], [%47, %$32] ; # Chr %51 = phi i1 [0, %$29], [%49, %$32] ; # -> br i1 %51, label %$34, label %$33 $33: %52 = phi i32 [%50, %$31] ; # Chr ; # (badInput) call void @badInput() unreachable $34: %53 = phi i32 [%50, %$31] ; # Chr ; # (* Chr 10) %54 = mul i32 %53, 10 ; # (val $Chr) %55 = load i32, i32* @$Chr ; # (- (val $Chr) (char "0")) %56 = sub i32 %55, 48 ; # (+ (* Chr 10) (- (val $Chr) (char "0"))) %57 = add i32 %54, %56 br label %$28 $30: %58 = phi i32 [%40, %$28] ; # Chr br label %$27 $27: %59 = phi i32 [%36, %$24], [%58, %$30] ; # Chr ; # (set $Chr Chr) store i32 %59, i32* @$Chr br label %$18 $18: %60 = phi i32 [%27, %$19], [%28, %$20], [%29, %$21], [%30, %$22], [%31, %$23], [%59, %$27] ; # Chr %61 = phi i32 [8, %$19], [27, %$20], [10, %$21], [13, %$22], [9, %$23], [%59, %$27] ; # -> br label %$4 $15: %62 = phi i32 [%24, %$13] ; # Chr ; # (loop (setq Chr (call $Get)) (? (and (<> Chr (char " ")) (<> Chr ... br label %$35 $35: %63 = phi i32 [%62, %$15], [%71, %$38] ; # Chr ; # (call $Get) %64 = load i32()*, i32()** @$Get %65 = call i32 %64() ; # (? (and (<> Chr (char " ")) (<> Chr (char "^I")))) ; # (and (<> Chr (char " ")) (<> Chr (char "^I"))) ; # (<> Chr (char " ")) %66 = icmp ne i32 %65, 32 br i1 %66, label %$37, label %$36 $37: %67 = phi i32 [%65, %$35] ; # Chr ; # (<> Chr (char "^I")) %68 = icmp ne i32 %67, 9 br label %$36 $36: %69 = phi i32 [%65, %$35], [%67, %$37] ; # Chr %70 = phi i1 [0, %$35], [%68, %$37] ; # -> br i1 %70, label %$39, label %$38 $38: %71 = phi i32 [%69, %$36] ; # Chr br label %$35 $39: %72 = phi i32 [%69, %$36] ; # Chr %73 = phi i64 [0, %$36] ; # -> br label %$2 $4: %74 = phi i32 [%3, %$5], [%16, %$12], [%20, %$14], [%60, %$18] ; # Chr %75 = phi i1 [0, %$5], [1, %$12], [1, %$14], [1, %$18] ; # -> ret i1 %75 } 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 ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %2 = load i64, i64* %1 ; # (save (val $Intern)) %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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* @$Chr ; # (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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 1016) 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 ([17 x i64]* @env to i8*), i32 72) to i64) to i64* store i64 %25, i64* %31 ; # (call $Get) %32 = load i32()*, i32()** @$Get %33 = call i32 %32() ; # (call $Get) %34 = load i32()*, i32()** @$Get %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 ([17 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 ([17 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], [%86, %$13] ; # Chr %47 = phi i32 [%37, %$5], [%84, %$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 ([870 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 ([17 x i64]* @env to i8*), i32 72) 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 (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()** @$Get %79 = call i32 %78() br label %$20 $20: %80 = phi i32 [%73, %$18], [%79, %$19] ; # Chr %81 = phi i32 [%74, %$18], [%77, %$19] ; # C ; # (i8 Chr) %82 = trunc i32 %80 to i8 ; # (byteSym (i8 Chr) P) call void @byteSym(i8 %82, i64* %11) br label %$13 $13: %83 = phi i32 [%52, %$17], [%80, %$20] ; # Chr %84 = phi i32 [%53, %$17], [%81, %$20] ; # C ; # (call $Get) %85 = load i32()*, i32()** @$Get %86 = call i32 %85() br label %$8 $10: %87 = phi i32 [%46, %$8], [%69, %$12] ; # Chr %88 = 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) %89 = getelementptr i64, i64* %11, i32 2 %90 = load i64, i64* %89 ; # (val $Intern) %91 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %92 = load i64, i64* %91 ; # (cond ((== Nm ZERO) (badInput)) ((== L (any $Cell)) (intern 0 $Ni... ; # (== Nm ZERO) %93 = icmp eq i64 %90, 2 br i1 %93, label %$23, label %$22 $23: %94 = phi i32 [%87, %$10] ; # Chr %95 = phi i32 [%88, %$10] ; # C ; # (badInput) call void @badInput() unreachable $22: %96 = phi i32 [%87, %$10] ; # Chr %97 = phi i32 [%88, %$10] ; # C ; # (any $Cell) %98 = ptrtoint i64* bitcast ([2 x i64]* @$Cell to i64*) to i64 ; # (== L (any $Cell)) %99 = icmp eq i64 %92, %98 br i1 %99, label %$25, label %$24 $25: %100 = phi i32 [%96, %$22] ; # Chr %101 = phi i32 [%97, %$22] ; # C ; # (car @) %102 = inttoptr i64 %92 to i64* %103 = load i64, i64* %102 ; # (cdar (car @)) %104 = inttoptr i64 %103 to i64* %105 = load i64, i64* %104 %106 = inttoptr i64 %105 to i64* %107 = getelementptr i64, i64* %106, i32 1 %108 = load i64, i64* %107 ; # (intern 0 $Nil Nm (cdar (car @)) $Nil NO) %109 = call i64 @intern(i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64 %90, i64 %108, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i1 0) br label %$21 $24: %110 = phi i32 [%96, %$22] ; # Chr %111 = phi i32 [%97, %$22] ; # C ; # (val $Scl) %112 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 552) to i64) to i64* %113 = load i64, i64* %112 ; # (int (val $Scl)) %114 = lshr i64 %113, 4 ; # (symToNum Nm (int (val $Scl)) (char ".") 0) %115 = call i64 @symToNum(i64 %90, i64 %114, i8 46, i8 0) %116 = icmp ne i64 %115, 0 br i1 %116, label %$27, label %$26 $27: %117 = phi i32 [%110, %$24] ; # Chr %118 = phi i32 [%111, %$24] ; # C br label %$21 $26: %119 = phi i32 [%110, %$24] ; # Chr %120 = phi i32 [%111, %$24] ; # C ; # (anonymous Nm) %121 = call i64 @anonymous(i64 %90) %122 = icmp ne i64 %121, 0 br i1 %122, label %$29, label %$28 $29: %123 = phi i32 [%119, %$26] ; # Chr %124 = phi i32 [%120, %$26] ; # C br label %$21 $28: %125 = phi i32 [%119, %$26] ; # Chr %126 = phi i32 [%120, %$26] ; # C ; # (and (== (car L) $priv) (nil? (cdr L))) ; # (car L) %127 = inttoptr i64 %92 to i64* %128 = load i64, i64* %127 ; # (== (car L) $priv) %129 = icmp eq i64 %128, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 152) to i64) br i1 %129, label %$31, label %$30 $31: %130 = phi i32 [%125, %$28] ; # Chr %131 = phi i32 [%126, %$28] ; # C ; # (cdr L) %132 = inttoptr i64 %92 to i64* %133 = getelementptr i64, i64* %132, i32 1 %134 = load i64, i64* %133 ; # (nil? (cdr L)) %135 = icmp eq i64 %134, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br label %$30 $30: %136 = phi i32 [%125, %$28], [%130, %$31] ; # Chr %137 = phi i32 [%126, %$28], [%131, %$31] ; # C %138 = phi i1 [0, %$28], [%135, %$31] ; # -> br i1 %138, label %$33, label %$32 $33: %139 = phi i32 [%136, %$30] ; # Chr %140 = phi i32 [%137, %$30] ; # C ; # (consSym Nm $Nil) %141 = call i64 @consSym(i64 %90, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (intern (consSym Nm $Nil) 0 Nm $PrivT $Nil YES) %142 = call i64 @intern(i64 %141, i64 0, i64 %90, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 112) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i1 1) br label %$21 $32: %143 = phi i32 [%136, %$30] ; # Chr %144 = phi i32 [%137, %$30] ; # C ; # (requestSym Nm) %145 = call i64 @requestSym(i64 %90) br label %$21 $21: %146 = phi i32 [%100, %$25], [%117, %$27], [%123, %$29], [%139, %$33], [%143, %$32] ; # Chr %147 = phi i32 [%101, %$25], [%118, %$27], [%124, %$29], [%140, %$33], [%144, %$32] ; # C %148 = phi i64 [%109, %$25], [%115, %$27], [%121, %$29], [%142, %$33], [%145, %$32] ; # -> ; # (set $Intern Int) %149 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) to i64) to i64* store i64 %2, i64* %149 ; # (drop *Safe) %150 = inttoptr i64 %6 to i64* %151 = getelementptr i64, i64* %150, i32 1 %152 = load i64, i64* %151 %153 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %152, i64* %153 ret i64 %148 } 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()** @$Get %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()** @$Get %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()** @$Get %35 = call i32 %34() br label %$17 $18: %36 = phi i64 [%28, %$16] ; # P ; # (val $Chr) %37 = load i32, i32* @$Chr ; # (<> (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]* @$41 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 ([870 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()** @$Get %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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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()** @$Get %4 = call i32 %3() ; # (loop (? (== (skip) (char ")")) (call $Get) $Nil) (? (== @ (char ... br label %$4 $4: ; # (? (== (skip) (char ")")) (call $Get) $Nil) ; # (skip) %5 = call i32 @skip() ; # (== (skip) (char ")")) %6 = icmp eq i32 %5, 41 br i1 %6, label %$7, label %$5 $7: ; # (call $Get) %7 = load i32()*, i32()** @$Get %8 = call i32 %7() br label %$6 $5: ; # (? (== @ (char "]")) $Nil) ; # (== @ (char "]")) %9 = icmp eq i32 %5, 93 br i1 %9, label %$9, label %$8 $9: br label %$6 $8: ; # (? (<> @ (char "~")) (let R (save (cons (read0 NO) $Nil)) (rdl R ... ; # (<> @ (char "~")) %10 = icmp ne i32 %5, 126 br i1 %10, label %$11, label %$10 $11: ; # (let R (save (cons (read0 NO) $Nil)) (rdl R R) R) ; # (read0 NO) %11 = call i64 @read0(i1 0) ; # (cons (read0 NO) $Nil) %12 = call i64 @cons(i64 %11, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save (cons (read0 NO) $Nil)) %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %16, i64* %20 ; # (rdl R R) call void @rdl(i64 %12, i64 %12) ; # (drop *Safe) %21 = inttoptr i64 %16 to i64* %22 = getelementptr i64, i64* %21, i32 1 %23 = load i64, i64* %22 %24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %23, i64* %24 br label %$6 $10: ; # (call $Get) %25 = load i32()*, i32()** @$Get %26 = call i32 %25() ; # (let (X (save (read0 NO)) R (eval X)) (? (not (nil? R)) (if (atom... ; # (read0 NO) %27 = call i64 @read0(i1 0) ; # (save (read0 NO)) %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %31, i64* %35 ; # (eval X) %36 = and i64 %27, 6 %37 = icmp ne i64 %36, 0 br i1 %37, label %$14, label %$13 $14: br label %$12 $13: %38 = and i64 %27, 8 %39 = icmp ne i64 %38, 0 br i1 %39, label %$16, label %$15 $16: %40 = inttoptr i64 %27 to i64* %41 = load i64, i64* %40 br label %$12 $15: %42 = call i64 @evList(i64 %27) br label %$12 $12: %43 = phi i64 [%27, %$14], [%41, %$16], [%42, %$15] ; # -> ; # (? (not (nil? R)) (if (atom (safe R)) (rdl (safe (setq R (cons R ... ; # (nil? R) %44 = icmp eq i64 %43, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) ; # (not (nil? R)) %45 = icmp eq i1 %44, 0 br i1 %45, label %$18, label %$17 $18: %46 = phi i64 [%43, %$12] ; # R ; # (if (atom (safe R)) (rdl (safe (setq R (cons R $Nil))) R) (let L ... ; # (safe R) %47 = inttoptr i64 %31 to i64* store i64 %46, i64* %47 ; # (atom (safe R)) %48 = and i64 %46, 15 %49 = icmp ne i64 %48, 0 br i1 %49, label %$19, label %$20 $19: %50 = phi i64 [%46, %$18] ; # R ; # (cons R $Nil) %51 = call i64 @cons(i64 %50, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (safe (setq R (cons R $Nil))) %52 = inttoptr i64 %31 to i64* store i64 %51, i64* %52 ; # (rdl (safe (setq R (cons R $Nil))) R) call void @rdl(i64 %51, i64 %51) br label %$21 $20: %53 = phi i64 [%46, %$18] ; # R ; # (let L R (while (pair (cdr L)) (setq L @)) (rdl R L)) ; # (while (pair (cdr L)) (setq L @)) br label %$22 $22: %54 = phi i64 [%53, %$20], [%61, %$23] ; # R %55 = phi i64 [%53, %$20], [%58, %$23] ; # L ; # (cdr L) %56 = inttoptr i64 %55 to i64* %57 = getelementptr i64, i64* %56, i32 1 %58 = load i64, i64* %57 ; # (pair (cdr L)) %59 = and i64 %58, 15 %60 = icmp eq i64 %59, 0 br i1 %60, label %$23, label %$24 $23: %61 = phi i64 [%54, %$22] ; # R %62 = phi i64 [%55, %$22] ; # L br label %$22 $24: %63 = phi i64 [%54, %$22] ; # R %64 = phi i64 [%55, %$22] ; # L ; # (rdl R L) call void @rdl(i64 %63, i64 %64) br label %$21 $21: %65 = phi i64 [%51, %$19], [%63, %$24] ; # R br label %$6 $17: %66 = phi i64 [%43, %$12] ; # R ; # (drop *Safe) %67 = inttoptr i64 %31 to i64* %68 = getelementptr i64, i64* %67, i32 1 %69 = load i64, i64* %68 %70 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %69, i64* %70 br label %$4 $6: %71 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%12, %$11], [%65, %$21] ; # -> ret i64 %71 } 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** @$InFile ; # (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* @$Chr ; # (== (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()** @$Get %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* @$Chr ; # (== (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]* @$42 to i8*), i8* null) unreachable $17: %34 = phi i32 [%29, %$15] ; # C ; # (call $Get) %35 = load i32()*, i32()** @$Get %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()** @$Get %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 ([870 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()** @$Get %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 ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* %50 = load i64, i64* %49 ; # (save (val $Transient)) %51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([52 x i64]* @gcData to i8*), i32 0) 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 ([17 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 ([17 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 ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* %71 = getelementptr i64, i64* %70, i32 1 store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %71 %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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)) (car @) ... ; # (val $Uni) %74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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)) (car @) X)) %79 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %82, i64* %86 ; # (if (pair (idxPut $Uni X)) (car @) X) ; # (idxPut $Uni X) %87 = call i64 @idxPut(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 776) to i64), i64 %73) ; # (pair (idxPut $Uni X)) %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 ([17 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 ([52 x i64]* @gcData to i8*), i32 0) 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 ([52 x i64]* @gcData to i8*), i32 0) 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 ([17 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()** @$Get %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 ([17 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 ([17 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 ([17 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()** @$Get %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()** @$Get %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 ([17 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 ([17 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* @$Chr ; # (charSym (val $Chr) P) call void @charSym(i32 %158, i64* %148) ; # (? (== (setq C (call $Get)) (char "\""))) ; # (call $Get) %159 = load i32()*, i32()** @$Get %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()** @$Get %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 ([52 x i64]* @gcData to i8*), i32 0) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([870 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()** @$Get %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 ([870 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()** @$Get %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()** @$Get %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()** @$Get %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()** @$Get %256 = call i32 %255() br label %$70 $70: %257 = phi i32 [%252, %$67], [%254, %$69] ; # C ; # (val $Chr) %258 = load i32, i32* @$Chr ; # (call $Get) %259 = load i32()*, i32()** @$Get %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 ([870 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* @$Chr %2 = icmp ne i32 %1, 0 br i1 %2, label %$3, label %$2 $2: ; # (call $Get) %3 = load i32()*, i32()** @$Get %4 = call i32 %3() br label %$3 $3: ; # (if (== End (val $Chr)) $Nil (read0 YES)) ; # (val $Chr) %5 = load i32, i32* @$Chr ; # (== 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 ([870 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 (val $Chr) (unless C (setq C (call $Get))) (cond ((lt0 (sk... ; # (val $Chr) %2 = load i32, i32* @$Chr ; # (unless C (setq C (call $Get))) %3 = icmp ne i32 %2, 0 br i1 %3, label %$3, label %$2 $2: %4 = phi i32 [%2, %$1] ; # C ; # (call $Get) %5 = load i32()*, i32()** @$Get %6 = call i32 %5() br label %$3 $3: %7 = phi i32 [%2, %$1], [%6, %$2] ; # C ; # (cond ((lt0 (skipc Cmt)) 0) ((== (setq C @) (char "\"")) (cond ((... ; # (skipc Cmt) %8 = call i32 @skipc(i32 %1) ; # (lt0 (skipc Cmt)) %9 = icmp slt i32 %8, 0 br i1 %9, label %$6, label %$5 $6: %10 = phi i32 [%7, %$3] ; # C br label %$4 $5: %11 = phi i32 [%7, %$3] ; # C ; # (== (setq C @) (char "\"")) %12 = icmp eq i32 %8, 34 br i1 %12, label %$8, label %$7 $8: %13 = phi i32 [%8, %$5] ; # C ; # (cond ((== (setq C (call $Get)) (char "\"")) (call $Get) $Nil) ((... ; # (call $Get) %14 = load i32()*, i32()** @$Get %15 = call i32 %14() ; # (== (setq C (call $Get)) (char "\"")) %16 = icmp eq i32 %15, 34 br i1 %16, label %$11, label %$10 $11: %17 = phi i32 [%15, %$8] ; # C ; # (call $Get) %18 = load i32()*, i32()** @$Get %19 = call i32 %18() br label %$9 $10: %20 = phi i32 [%15, %$8] ; # C ; # (testEsc C) %21 = call i1 @testEsc(i32 %20) ; # (not (testEsc C)) %22 = icmp eq i1 %21, 0 br i1 %22, label %$13, label %$12 $13: %23 = phi i32 [%20, %$10] ; # C br label %$9 $12: %24 = phi i32 [%20, %$10] ; # C ; # (let (Y (cons (mkChar (val $Chr)) $Nil) R (save Y)) (loop (? (== ... ; # (val $Chr) %25 = load i32, i32* @$Chr ; # (mkChar (val $Chr)) %26 = call i64 @mkChar(i32 %25) ; # (cons (mkChar (val $Chr)) $Nil) %27 = call i64 @cons(i64 %26, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %31, i64* %35 ; # (loop (? (== (setq C (call $Get)) (char "\"")) (call $Get)) (? (n... br label %$14 $14: %36 = phi i32 [%24, %$12], [%49, %$18] ; # C %37 = phi i64 [%27, %$12], [%53, %$18] ; # Y ; # (? (== (setq C (call $Get)) (char "\"")) (call $Get)) ; # (call $Get) %38 = load i32()*, i32()** @$Get %39 = call i32 %38() ; # (== (setq C (call $Get)) (char "\"")) %40 = icmp eq i32 %39, 34 br i1 %40, label %$17, label %$15 $17: %41 = phi i32 [%39, %$14] ; # C %42 = phi i64 [%37, %$14] ; # Y ; # (call $Get) %43 = load i32()*, i32()** @$Get %44 = call i32 %43() br label %$16 $15: %45 = phi i32 [%39, %$14] ; # C %46 = phi i64 [%37, %$14] ; # Y ; # (? (not (testEsc C))) ; # (testEsc C) %47 = call i1 @testEsc(i32 %45) ; # (not (testEsc C)) %48 = icmp eq i1 %47, 0 br i1 %48, label %$16, label %$18 $18: %49 = phi i32 [%45, %$15] ; # C %50 = phi i64 [%46, %$15] ; # Y ; # (set 2 Y (cons (mkChar (val $Chr)) $Nil)) ; # (val $Chr) %51 = load i32, i32* @$Chr ; # (mkChar (val $Chr)) %52 = call i64 @mkChar(i32 %51) ; # (cons (mkChar (val $Chr)) $Nil) %53 = call i64 @cons(i64 %52, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %54 = inttoptr i64 %50 to i64* %55 = getelementptr i64, i64* %54, i32 1 store i64 %53, i64* %55 br label %$14 $16: %56 = phi i32 [%41, %$17], [%45, %$15] ; # C %57 = phi i64 [%42, %$17], [%46, %$15] ; # Y %58 = phi i32 [%44, %$17], [0, %$15] ; # -> ; # (drop *Safe) %59 = inttoptr i64 %31 to i64* %60 = getelementptr i64, i64* %59, i32 1 %61 = load i64, i64* %60 %62 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %61, i64* %62 br label %$9 $9: %63 = phi i32 [%17, %$11], [%23, %$13], [%56, %$16] ; # C %64 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%27, %$16] ; # -> br label %$4 $7: %65 = phi i32 [%8, %$5] ; # C ; # (and (>= (char "9") C) (>= C (char "0"))) ; # (>= (char "9") C) %66 = icmp sge i32 57, %65 br i1 %66, label %$20, label %$19 $20: %67 = phi i32 [%65, %$7] ; # C ; # (>= C (char "0")) %68 = icmp sge i32 %67, 48 br label %$19 $19: %69 = phi i32 [%65, %$7], [%67, %$20] ; # C %70 = phi i1 [0, %$7], [%68, %$20] ; # -> br i1 %70, label %$22, label %$21 $22: %71 = phi i32 [%69, %$19] ; # C ; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (loop (byteSym (i... ; # (push 4 NIL ZERO NIL) %72 = alloca i64, i64 4, align 16 store i64 4, i64* %72 %73 = getelementptr i64, i64* %72, i32 2 store i64 2, i64* %73 ; # (ofs P 2) %74 = getelementptr i64, i64* %72, i32 2 ; # (link (ofs P 2) T) %75 = ptrtoint i64* %74 to i64 %76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %77 = load i64, i64* %76 %78 = inttoptr i64 %75 to i64* %79 = getelementptr i64, i64* %78, i32 1 store i64 %77, i64* %79 %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %75, i64* %80 ; # (loop (byteSym (i8 C) P) (? (and (<> (setq C (call $Get)) (char "... br label %$23 $23: %81 = phi i32 [%71, %$22], [%94, %$28] ; # C ; # (i8 C) %82 = trunc i32 %81 to i8 ; # (byteSym (i8 C) P) call void @byteSym(i8 %82, i64* %72) ; # (? (and (<> (setq C (call $Get)) (char ".")) (or (> (char "0") C)... ; # (and (<> (setq C (call $Get)) (char ".")) (or (> (char "0") C) (>... ; # (call $Get) %83 = load i32()*, i32()** @$Get %84 = call i32 %83() ; # (<> (setq C (call $Get)) (char ".")) %85 = icmp ne i32 %84, 46 br i1 %85, label %$25, label %$24 $25: %86 = phi i32 [%84, %$23] ; # C ; # (or (> (char "0") C) (> C (char "9"))) ; # (> (char "0") C) %87 = icmp sgt i32 48, %86 br i1 %87, label %$26, label %$27 $27: %88 = phi i32 [%86, %$25] ; # C ; # (> C (char "9")) %89 = icmp sgt i32 %88, 57 br label %$26 $26: %90 = phi i32 [%86, %$25], [%88, %$27] ; # C %91 = phi i1 [1, %$25], [%89, %$27] ; # -> br label %$24 $24: %92 = phi i32 [%84, %$23], [%90, %$26] ; # C %93 = phi i1 [0, %$23], [%91, %$26] ; # -> br i1 %93, label %$29, label %$28 $28: %94 = phi i32 [%92, %$24] ; # C br label %$23 $29: %95 = phi i32 [%92, %$24] ; # C %96 = phi i64 [0, %$24] ; # -> ; # (val 3 P) %97 = getelementptr i64, i64* %72, i32 2 %98 = load i64, i64* %97 ; # (val $Scl) %99 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 552) to i64) to i64* %100 = load i64, i64* %99 ; # (int (val $Scl)) %101 = lshr i64 %100, 4 ; # (symToNum (val 3 P) (int (val $Scl)) (char ".") 0) %102 = call i64 @symToNum(i64 %98, i64 %101, i8 46, i8 0) ; # (drop *Safe) %103 = inttoptr i64 %75 to i64* %104 = getelementptr i64, i64* %103, i32 1 %105 = load i64, i64* %104 %106 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %105, i64* %106 br label %$4 $21: %107 = phi i32 [%69, %$19] ; # C ; # (let (Nm (xName 0 Set) S (bufString Nm (b8 (bufSize Nm)))) (if (o... ; # (xName 0 Set) %108 = call i64 @xName(i64 0, i64 %0) ; # (bufSize Nm) %109 = call i64 @bufSize(i64 %108) ; # (b8 (bufSize Nm)) %110 = alloca i8, i64 %109 ; # (bufString Nm (b8 (bufSize Nm))) %111 = call i8* @bufString(i64 %108, i8* %110) ; # (if (or (== C (char "+")) (== C (char "-")) (noToken C S)) (prog1... ; # (or (== C (char "+")) (== C (char "-")) (noToken C S)) ; # (== C (char "+")) %112 = icmp eq i32 %107, 43 br i1 %112, label %$30, label %$31 $31: %113 = phi i32 [%107, %$21] ; # C ; # (== C (char "-")) %114 = icmp eq i32 %113, 45 br i1 %114, label %$30, label %$32 $32: %115 = phi i32 [%113, %$31] ; # C ; # (noToken C S) %116 = icmp eq i32 %115, 92 br i1 %116, label %$33, label %$34 $34: %117 = icmp sge i32 122, %115 br i1 %117, label %$36, label %$35 $36: %118 = icmp sge i32 %115, 97 br label %$35 $35: %119 = phi i1 [0, %$34], [%118, %$36] ; # -> br i1 %119, label %$33, label %$37 $37: %120 = icmp sge i32 90, %115 br i1 %120, label %$39, label %$38 $39: %121 = icmp sge i32 %115, 65 br label %$38 $38: %122 = phi i1 [0, %$37], [%121, %$39] ; # -> br i1 %122, label %$33, label %$40 $40: %123 = call i8* @strchr(i8* %111, i32 %115) %124 = icmp ne i8* %123, null br label %$33 $33: %125 = phi i1 [1, %$32], [1, %$35], [1, %$38], [%124, %$40] ; # -> %126 = icmp eq i1 %125, 0 br label %$30 $30: %127 = phi i32 [%107, %$21], [%113, %$31], [%115, %$33] ; # C %128 = phi i1 [1, %$21], [1, %$31], [%126, %$33] ; # -> br i1 %128, label %$41, label %$42 $41: %129 = phi i32 [%127, %$30] ; # C ; # (prog1 (mkChar (getChar C)) (call $Get)) ; # (getChar C) %130 = call i32 @getChar(i32 %129) ; # (mkChar (getChar C)) %131 = call i64 @mkChar(i32 %130) ; # (call $Get) %132 = load i32()*, i32()** @$Get %133 = call i32 %132() br label %$43 $42: %134 = phi i32 [%127, %$30] ; # C ; # (when (== C (char "\\")) (call $Get)) ; # (== C (char "\\")) %135 = icmp eq i32 %134, 92 br i1 %135, label %$44, label %$45 $44: %136 = phi i32 [%134, %$42] ; # C ; # (call $Get) %137 = load i32()*, i32()** @$Get %138 = call i32 %137() br label %$45 $45: %139 = phi i32 [%134, %$42], [%136, %$44] ; # C ; # (let P (push 4 NIL ZERO NIL) (link (ofs P 2) T) (loop (byteSym (i... ; # (push 4 NIL ZERO NIL) %140 = alloca i64, i64 4, align 16 store i64 4, i64* %140 %141 = getelementptr i64, i64* %140, i32 2 store i64 2, i64* %141 ; # (ofs P 2) %142 = getelementptr i64, i64* %140, i32 2 ; # (link (ofs P 2) T) %143 = ptrtoint i64* %142 to i64 %144 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %145 = load i64, i64* %144 %146 = inttoptr i64 %143 to i64* %147 = getelementptr i64, i64* %146, i32 1 store i64 %145, i64* %147 %148 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %143, i64* %148 ; # (loop (byteSym (i8 C) P) (? (and (noToken (setq C (call $Get)) S)... br label %$46 $46: %149 = phi i32 [%139, %$45], [%177, %$62] ; # C ; # (i8 C) %150 = trunc i32 %149 to i8 ; # (byteSym (i8 C) P) call void @byteSym(i8 %150, i64* %140) ; # (? (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) %151 = load i32()*, i32()** @$Get %152 = call i32 %151() ; # (noToken (setq C (call $Get)) S) %153 = icmp eq i32 %152, 92 br i1 %153, label %$48, label %$49 $49: %154 = icmp sge i32 122, %152 br i1 %154, label %$51, label %$50 $51: %155 = icmp sge i32 %152, 97 br label %$50 $50: %156 = phi i1 [0, %$49], [%155, %$51] ; # -> br i1 %156, label %$48, label %$52 $52: %157 = icmp sge i32 90, %152 br i1 %157, label %$54, label %$53 $54: %158 = icmp sge i32 %152, 65 br label %$53 $53: %159 = phi i1 [0, %$52], [%158, %$54] ; # -> br i1 %159, label %$48, label %$55 $55: %160 = call i8* @strchr(i8* %111, i32 %152) %161 = icmp ne i8* %160, null br label %$48 $48: %162 = phi i1 [1, %$46], [1, %$50], [1, %$53], [%161, %$55] ; # -> %163 = icmp eq i1 %162, 0 br i1 %163, label %$56, label %$47 $56: %164 = phi i32 [%152, %$48] ; # C ; # (or (> (char "0") C) (> C (char "9"))) ; # (> (char "0") C) %165 = icmp sgt i32 48, %164 br i1 %165, label %$57, label %$58 $58: %166 = phi i32 [%164, %$56] ; # C ; # (> C (char "9")) %167 = icmp sgt i32 %166, 57 br label %$57 $57: %168 = phi i32 [%164, %$56], [%166, %$58] ; # C %169 = phi i1 [1, %$56], [%167, %$58] ; # -> br label %$47 $47: %170 = phi i32 [%152, %$48], [%168, %$57] ; # C %171 = phi i1 [0, %$48], [%169, %$57] ; # -> br i1 %171, label %$60, label %$59 $59: %172 = phi i32 [%170, %$47] ; # C ; # (when (== C (char "\\")) (call $Get)) ; # (== C (char "\\")) %173 = icmp eq i32 %172, 92 br i1 %173, label %$61, label %$62 $61: %174 = phi i32 [%172, %$59] ; # C ; # (call $Get) %175 = load i32()*, i32()** @$Get %176 = call i32 %175() br label %$62 $62: %177 = phi i32 [%172, %$59], [%174, %$61] ; # C br label %$46 $60: %178 = phi i32 [%170, %$47] ; # C %179 = phi i64 [0, %$47] ; # -> ; # (val 3 P) %180 = getelementptr i64, i64* %140, i32 2 %181 = load i64, i64* %180 ; # (requestSym (val 3 P)) %182 = call i64 @requestSym(i64 %181) ; # (drop *Safe) %183 = inttoptr i64 %143 to i64* %184 = getelementptr i64, i64* %183, i32 1 %185 = load i64, i64* %184 %186 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %185, i64* %186 br label %$43 $43: %187 = phi i32 [%129, %$41], [%178, %$60] ; # C %188 = phi i64 [%131, %$41], [%182, %$60] ; # -> br label %$4 $4: %189 = phi i32 [%10, %$6], [%63, %$9], [%95, %$29], [%187, %$43] ; # C %190 = phi i64 [0, %$6], [%64, %$9], [%102, %$29], [%188, %$43] ; # -> ret i64 %190 } 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 ([17 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 ([17 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 ([870 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 ([17 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* @$Chr ; # (== (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** @$InFile ; # (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* @$Chr %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 Raw (val Termio) (prog2 (setRaw) (if (waitFd Exe 0 (if (nil?... ; # (val Termio) %1 = load i8*, i8** @Termio ; # (prog2 (setRaw) (if (waitFd Exe 0 (if (nil? (eval (cadr Exe))) 29... ; # (setRaw) call void @setRaw() ; # (if (waitFd Exe 0 (if (nil? (eval (cadr Exe))) 292MY (xCnt Exe @)... ; # (if (nil? (eval (cadr Exe))) 292MY (xCnt Exe @)) ; # (cadr Exe) %2 = inttoptr i64 %0 to i64* %3 = getelementptr i64, i64* %2, i32 1 %4 = load i64, i64* %3 %5 = inttoptr i64 %4 to i64* %6 = load i64, i64* %5 ; # (eval (cadr Exe)) %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] ; # -> ; # (nil? (eval (cadr Exe))) %15 = icmp eq i64 %14, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %15, label %$7, label %$8 $7: br label %$9 $8: ; # (xCnt Exe @) %16 = call i64 @xCnt(i64 %0, i64 %14) br label %$9 $9: %17 = phi i64 [9223372036854775807, %$7], [%16, %$8] ; # -> ; # (waitFd Exe 0 (if (nil? (eval (cadr Exe))) 292MY (xCnt Exe @))) %18 = call i64 @waitFd(i64 %0, i32 0, i64 %17) %19 = icmp ne i64 %18, 0 br i1 %19, label %$10, label %$11 $10: ; # (let C (stdinByte) (mkChar (cond ((>= 127 C) C) ((== C (hex "FF")... ; # (stdinByte) %20 = call i32 @stdinByte() ; # (cond ((>= 127 C) C) ((== C (hex "FF")) (i32 TOP)) (T (let B (ifn... ; # (>= 127 C) %21 = icmp sge i32 127, %20 br i1 %21, label %$15, label %$14 $15: br label %$13 $14: ; # (== C (hex "FF")) %22 = icmp eq i32 %20, 255 br i1 %22, label %$17, label %$16 $17: ; # (i32 TOP) br label %$13 $16: ; # (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")) %23 = and i32 %20, 32 %24 = icmp ne i32 %23, 0 br i1 %24, label %$19, label %$18 $18: ; # (& C (hex "1F")) %25 = and i32 %20, 31 br label %$20 $19: ; # (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")) %26 = and i32 %20, 16 %27 = icmp ne i32 %26, 0 br i1 %27, label %$22, label %$21 $21: ; # (& C (hex "0F")) %28 = and i32 %20, 15 br label %$23 $22: ; # (& C 7) %29 = and i32 %20, 7 ; # (shl (& C 7) 6) %30 = shl i32 %29, 6 ; # (stdinByte) %31 = call i32 @stdinByte() ; # (& (stdinByte) (hex "3F")) %32 = and i32 %31, 63 ; # (| (shl (& C 7) 6) (& (stdinByte) (hex "3F"))) %33 = or i32 %30, %32 br label %$23 $23: %34 = phi i32 [%28, %$21], [%33, %$22] ; # -> ; # (shl A 6) %35 = shl i32 %34, 6 ; # (stdinByte) %36 = call i32 @stdinByte() ; # (& (stdinByte) (hex "3F")) %37 = and i32 %36, 63 ; # (| (shl A 6) (& (stdinByte) (hex "3F"))) %38 = or i32 %35, %37 br label %$20 $20: %39 = phi i32 [%25, %$18], [%38, %$23] ; # -> ; # (shl B 6) %40 = shl i32 %39, 6 ; # (stdinByte) %41 = call i32 @stdinByte() ; # (& (stdinByte) (hex "3F")) %42 = and i32 %41, 63 ; # (| (shl B 6) (& (stdinByte) (hex "3F"))) %43 = or i32 %40, %42 br label %$13 $13: %44 = phi i32 [%20, %$15], [1114112, %$17], [%43, %$20] ; # -> ; # (mkChar (cond ((>= 127 C) C) ((== C (hex "FF")) (i32 TOP)) (T (le... %45 = call i64 @mkChar(i32 %44) br label %$12 $11: br label %$12 $12: %46 = phi i64 [%45, %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # -> ; # (unless Raw (setCooked)) %47 = icmp ne i8* %1, null br i1 %47, label %$25, label %$24 $24: ; # (setCooked) call void @setCooked() br label %$25 $25: ret i64 %46 } define i64 @_peek(i64) align 8 { $1: ; # (let Chr (val $Chr) (unless Chr (setq Chr (call $Get))) (if (lt0 ... ; # (val $Chr) %1 = load i32, i32* @$Chr ; # (unless Chr (setq Chr (call $Get))) %2 = icmp ne i32 %1, 0 br i1 %2, label %$3, label %$2 $2: %3 = phi i32 [%1, %$1] ; # Chr ; # (call $Get) %4 = load i32()*, i32()** @$Get %5 = call i32 %4() br label %$3 $3: %6 = phi i32 [%1, %$1], [%5, %$2] ; # Chr ; # (if (lt0 Chr) $Nil (mkChar Chr)) ; # (lt0 Chr) %7 = icmp slt i32 %6, 0 br i1 %7, label %$4, label %$5 $4: %8 = phi i32 [%6, %$3] ; # Chr br label %$6 $5: %9 = phi i32 [%6, %$3] ; # Chr ; # (mkChar Chr) %10 = call i64 @mkChar(i32 %9) br label %$6 $6: %11 = phi i32 [%8, %$4], [%9, %$5] ; # Chr %12 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%10, %$5] ; # -> ret i64 %12 } define i64 @_char(i64) align 8 { $1: ; # (let X (cdr Exe) (cond ((atom X) (let Chr (val $Chr) (unless Chr ... ; # (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 (val $Chr) (unless Chr (setq Chr (call $... ; # (atom X) %4 = and i64 %3, 15 %5 = icmp ne i64 %4, 0 br i1 %5, label %$4, label %$3 $4: ; # (let Chr (val $Chr) (unless Chr (setq Chr (call $Get))) (prog1 (i... ; # (val $Chr) %6 = load i32, i32* @$Chr ; # (unless Chr (setq Chr (call $Get))) %7 = icmp ne i32 %6, 0 br i1 %7, label %$6, label %$5 $5: %8 = phi i32 [%6, %$4] ; # Chr ; # (call $Get) %9 = load i32()*, i32()** @$Get %10 = call i32 %9() br label %$6 $6: %11 = phi i32 [%6, %$4], [%10, %$5] ; # Chr ; # (prog1 (if (lt0 Chr) $Nil (mkChar (getChar Chr))) (call $Get)) ; # (if (lt0 Chr) $Nil (mkChar (getChar Chr))) ; # (lt0 Chr) %12 = icmp slt i32 %11, 0 br i1 %12, label %$7, label %$8 $7: %13 = phi i32 [%11, %$6] ; # Chr br label %$9 $8: %14 = phi i32 [%11, %$6] ; # Chr ; # (getChar Chr) %15 = call i32 @getChar(i32 %14) ; # (mkChar (getChar Chr)) %16 = call i64 @mkChar(i32 %15) br label %$9 $9: %17 = phi i32 [%13, %$7], [%14, %$8] ; # Chr %18 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%16, %$8] ; # -> ; # (call $Get) %19 = load i32()*, i32()** @$Get %20 = call i32 %19() br label %$2 $3: ; # (car X) %21 = inttoptr i64 %3 to i64* %22 = load i64, i64* %21 ; # (eval (car X)) %23 = and i64 %22, 6 %24 = icmp ne i64 %23, 0 br i1 %24, label %$12, label %$11 $12: br label %$10 $11: %25 = and i64 %22, 8 %26 = icmp ne i64 %25, 0 br i1 %26, label %$14, label %$13 $14: %27 = inttoptr i64 %22 to i64* %28 = load i64, i64* %27 br label %$10 $13: %29 = call i64 @evList(i64 %22) br label %$10 $10: %30 = phi i64 [%22, %$12], [%28, %$14], [%29, %$13] ; # -> ; # (cnt? (eval (car X))) %31 = and i64 %30, 2 %32 = icmp ne i64 %31, 0 br i1 %32, label %$16, label %$15 $16: ; # (if (int @) (mkChar (i32 @)) $Nil) ; # (int @) %33 = lshr i64 %30, 4 %34 = icmp ne i64 %33, 0 br i1 %34, label %$17, label %$18 $17: ; # (i32 @) %35 = trunc i64 %33 to i32 ; # (mkChar (i32 @)) %36 = call i64 @mkChar(i32 %35) br label %$19 $18: br label %$19 $19: %37 = phi i64 [%36, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$18] ; # -> br label %$2 $15: ; # (t? @) %38 = icmp eq i64 %30, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br i1 %38, label %$21, label %$20 $21: ; # (mkChar TOP) %39 = call i64 @mkChar(i32 1114112) br label %$2 $20: ; # (symb? @) %40 = xor i64 %30, 8 %41 = and i64 %40, 14 %42 = icmp eq i64 %41, 0 br i1 %42, label %$23, label %$22 $23: ; # (firstChar @) %43 = call i32 @firstChar(i64 %30) ; # (i64 (firstChar @)) %44 = sext i32 %43 to i64 ; # (cnt (i64 (firstChar @))) %45 = shl i64 %44, 4 %46 = or i64 %45, 2 br label %$2 $22: ; # (atomErr Exe @) call void @atomErr(i64 %0, i64 %30) unreachable $2: %47 = phi i64 [%18, %$9], [%37, %$19], [%39, %$21], [%46, %$23] ; # -> ret i64 %47 } 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 ([870 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* @$Chr %2 = icmp ne i32 %1, 0 br i1 %2, label %$2, label %$3 $2: br label %$4 $3: ; # (call $Get) %3 = load i32()*, i32()** @$Get %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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %14, label %$8, label %$9 $9: ; # (set $Chr -1) store i32 -1, i32* @$Chr br label %$2 $8: ; # (val $Chr) %15 = load i32, i32* @$Chr ; # (=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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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()** @$Get %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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$16] ; # -> br label %$2 $2: %23 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 Exe Y) L (link (push ... ; # (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 Exe Y) %5 = call i64 @xName(i64 %0, 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 ([17 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 ([17 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 Exe Y) L (lin... 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 Exe Y) %38 = call i64 @xName(i64 %0, 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 ([17 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 ([17 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* @$Chr %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()** @$Get %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* @$Chr ; # (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()** @$Get %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 ([17 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()** @$Get %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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %240, i64* %241 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) } define i64 @_till(i64) align 8 { $1: ; # (let (X (cdr Exe) Nm (xName Exe (evSym X)) S (bufString Nm (b8 (b... ; # (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 Exe (evSym X)) %5 = call i64 @xName(i64 %0, 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* @$Chr %10 = icmp ne i32 %9, 0 br i1 %10, label %$2, label %$3 $2: br label %$4 $3: ; # (call $Get) %11 = load i32()*, i32()** @$Get %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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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()** @$Get %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 ([870 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 ([17 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 ([17 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 ([17 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()** @$Get %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 ([17 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 ([870 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* @$Chr 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()** @$Get %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* @$Chr 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 (val $Chr) (unless C (setq C (call $Get))) (if (eol C) $Ni... ; # (val $Chr) %1 = load i32, i32* @$Chr ; # (unless C (setq C (call $Get))) %2 = icmp ne i32 %1, 0 br i1 %2, label %$3, label %$2 $2: %3 = phi i32 [%1, %$1] ; # C ; # (call $Get) %4 = load i32()*, i32()** @$Get %5 = call i32 %4() br label %$3 $3: %6 = phi i32 [%1, %$1], [%5, %$2] ; # C ; # (if (eol C) $Nil (let X (cdr Exe) (cond ((nil? (eval (++ X))) (le... ; # (eol C) %7 = call i1 @eol(i32 %6) br i1 %7, label %$4, label %$5 $4: %8 = phi i32 [%6, %$3] ; # C br label %$6 $5: %9 = phi i32 [%6, %$3] ; # C ; # (let X (cdr Exe) (cond ((nil? (eval (++ X))) (let (Y (cons (mkCha... ; # (cdr Exe) %10 = inttoptr i64 %0 to i64* %11 = getelementptr i64, i64* %10, i32 1 %12 = load i64, i64* %11 ; # (cond ((nil? (eval (++ X))) (let (Y (cons (mkChar (getChar C)) $N... ; # (++ 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 %$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] ; # -> ; # (nil? (eval (++ X))) %25 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %25, label %$14, label %$13 $14: %26 = phi i32 [%9, %$8] ; # C %27 = phi i64 [%16, %$8] ; # X ; # (let (Y (cons (mkChar (getChar C)) $Nil) R (save Y)) (when (pair ... ; # (getChar C) %28 = call i32 @getChar(i32 %26) ; # (mkChar (getChar C)) %29 = call i64 @mkChar(i32 %28) ; # (cons (mkChar (getChar C)) $Nil) %30 = call i64 @cons(i64 %29, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %32 = load i64, i64* %31 %33 = alloca i64, i64 2, align 16 %34 = ptrtoint i64* %33 to i64 %35 = inttoptr i64 %34 to i64* store i64 %30, i64* %35 %36 = add i64 %34, 8 %37 = inttoptr i64 %36 to i64* store i64 %32, i64* %37 %38 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %34, i64* %38 ; # (when (pair X) (let Z (set Y (cons (car Y) $Nil)) (loop (let N (e... ; # (pair X) %39 = and i64 %27, 15 %40 = icmp eq i64 %39, 0 br i1 %40, label %$15, label %$16 $15: %41 = phi i32 [%26, %$14] ; # C %42 = phi i64 [%27, %$14] ; # X %43 = phi i64 [%30, %$14] ; # Y ; # (let Z (set Y (cons (car Y) $Nil)) (loop (let N (evCnt Exe X) (wh... ; # (set Y (cons (car Y) $Nil)) ; # (car Y) %44 = inttoptr i64 %43 to i64* %45 = load i64, i64* %44 ; # (cons (car Y) $Nil) %46 = call i64 @cons(i64 %45, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %47 = inttoptr i64 %43 to i64* store i64 %46, i64* %47 ; # (loop (let N (evCnt Exe X) (while (gt0 (dec 'N)) (when (eol (setq... br label %$17 $17: %48 = phi i32 [%41, %$15], [%112, %$26] ; # C %49 = phi i64 [%42, %$15], [%113, %$26] ; # X %50 = phi i64 [%43, %$15], [%119, %$26] ; # Y %51 = phi i64 [%46, %$15], [%118, %$26] ; # Z ; # (let N (evCnt Exe X) (while (gt0 (dec 'N)) (when (eol (setq C (ca... ; # (evCnt Exe X) %52 = call i64 @evCnt(i64 %0, i64 %49) ; # (while (gt0 (dec 'N)) (when (eol (setq C (call $Get))) (ret R)) (... br label %$18 $18: %53 = phi i32 [%48, %$17], [%77, %$22] ; # C %54 = phi i64 [%49, %$17], [%78, %$22] ; # X %55 = phi i64 [%50, %$17], [%79, %$22] ; # Y %56 = phi i64 [%51, %$17], [%84, %$22] ; # Z %57 = phi i64 [%52, %$17], [%81, %$22] ; # N ; # (dec 'N) %58 = sub i64 %57, 1 ; # (gt0 (dec 'N)) %59 = icmp sgt i64 %58, 0 br i1 %59, label %$19, label %$20 $19: %60 = phi i32 [%53, %$18] ; # C %61 = phi i64 [%54, %$18] ; # X %62 = phi i64 [%55, %$18] ; # Y %63 = phi i64 [%56, %$18] ; # Z %64 = phi i64 [%58, %$18] ; # N ; # (when (eol (setq C (call $Get))) (ret R)) ; # (call $Get) %65 = load i32()*, i32()** @$Get %66 = call i32 %65() ; # (eol (setq C (call $Get))) %67 = call i1 @eol(i32 %66) br i1 %67, label %$21, label %$22 $21: %68 = phi i32 [%66, %$19] ; # C %69 = phi i64 [%61, %$19] ; # X %70 = phi i64 [%62, %$19] ; # Y %71 = phi i64 [%63, %$19] ; # Z %72 = phi i64 [%64, %$19] ; # N ; # (ret R) ; # (drop *Safe) %73 = inttoptr i64 %34 to i64* %74 = getelementptr i64, i64* %73, i32 1 %75 = load i64, i64* %74 %76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %75, i64* %76 ret i64 %30 $22: %77 = phi i32 [%66, %$19] ; # C %78 = phi i64 [%61, %$19] ; # X %79 = phi i64 [%62, %$19] ; # Y %80 = phi i64 [%63, %$19] ; # Z %81 = phi i64 [%64, %$19] ; # N ; # (set 2 Z (cons (mkChar (getChar C)) $Nil)) ; # (getChar C) %82 = call i32 @getChar(i32 %77) ; # (mkChar (getChar C)) %83 = call i64 @mkChar(i32 %82) ; # (cons (mkChar (getChar C)) $Nil) %84 = call i64 @cons(i64 %83, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %85 = inttoptr i64 %80 to i64* %86 = getelementptr i64, i64* %85, i32 1 store i64 %84, i64* %86 br label %$18 $20: %87 = phi i32 [%53, %$18] ; # C %88 = phi i64 [%54, %$18] ; # X %89 = phi i64 [%55, %$18] ; # Y %90 = phi i64 [%56, %$18] ; # Z %91 = phi i64 [%58, %$18] ; # N ; # (? (atom (shift X))) ; # (shift X) %92 = inttoptr i64 %88 to i64* %93 = getelementptr i64, i64* %92, i32 1 %94 = load i64, i64* %93 ; # (atom (shift X)) %95 = and i64 %94, 15 %96 = icmp ne i64 %95, 0 br i1 %96, label %$24, label %$23 $23: %97 = phi i32 [%87, %$20] ; # C %98 = phi i64 [%94, %$20] ; # X %99 = phi i64 [%89, %$20] ; # Y %100 = phi i64 [%90, %$20] ; # Z ; # (when (eol (setq C (call $Get))) (ret R)) ; # (call $Get) %101 = load i32()*, i32()** @$Get %102 = call i32 %101() ; # (eol (setq C (call $Get))) %103 = call i1 @eol(i32 %102) br i1 %103, label %$25, label %$26 $25: %104 = phi i32 [%102, %$23] ; # C %105 = phi i64 [%98, %$23] ; # X %106 = phi i64 [%99, %$23] ; # Y %107 = phi i64 [%100, %$23] ; # Z ; # (ret R) ; # (drop *Safe) %108 = inttoptr i64 %34 to i64* %109 = getelementptr i64, i64* %108, i32 1 %110 = load i64, i64* %109 %111 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %110, i64* %111 ret i64 %30 $26: %112 = phi i32 [%102, %$23] ; # C %113 = phi i64 [%98, %$23] ; # X %114 = phi i64 [%99, %$23] ; # Y %115 = phi i64 [%100, %$23] ; # Z ; # (set 2 Y (cons (setq Z (cons (mkChar (getChar C)) $Nil)) $Nil)) ; # (getChar C) %116 = call i32 @getChar(i32 %112) ; # (mkChar (getChar C)) %117 = call i64 @mkChar(i32 %116) ; # (cons (mkChar (getChar C)) $Nil) %118 = call i64 @cons(i64 %117, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (cons (setq Z (cons (mkChar (getChar C)) $Nil)) $Nil) %119 = call i64 @cons(i64 %118, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %120 = inttoptr i64 %114 to i64* %121 = getelementptr i64, i64* %120, i32 1 store i64 %119, i64* %121 br label %$17 $24: %122 = phi i32 [%87, %$20] ; # C %123 = phi i64 [%94, %$20] ; # X %124 = phi i64 [%89, %$20] ; # Y %125 = phi i64 [%90, %$20] ; # Z %126 = phi i64 [0, %$20] ; # -> br label %$16 $16: %127 = phi i32 [%26, %$14], [%122, %$24] ; # C %128 = phi i64 [%27, %$14], [%123, %$24] ; # X %129 = phi i64 [%30, %$14], [%124, %$24] ; # Y ; # (until (eol (setq C (call $Get))) (setq Y (set 2 Y (cons (mkChar ... br label %$27 $27: %130 = phi i32 [%127, %$16], [%136, %$28] ; # C %131 = phi i64 [%128, %$16], [%137, %$28] ; # X %132 = phi i64 [%129, %$16], [%141, %$28] ; # Y ; # (call $Get) %133 = load i32()*, i32()** @$Get %134 = call i32 %133() ; # (eol (setq C (call $Get))) %135 = call i1 @eol(i32 %134) br i1 %135, label %$29, label %$28 $28: %136 = phi i32 [%134, %$27] ; # C %137 = phi i64 [%131, %$27] ; # X %138 = phi i64 [%132, %$27] ; # Y ; # (set 2 Y (cons (mkChar (getChar C)) $Nil)) ; # (getChar C) %139 = call i32 @getChar(i32 %136) ; # (mkChar (getChar C)) %140 = call i64 @mkChar(i32 %139) ; # (cons (mkChar (getChar C)) $Nil) %141 = call i64 @cons(i64 %140, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %142 = inttoptr i64 %138 to i64* %143 = getelementptr i64, i64* %142, i32 1 store i64 %141, i64* %143 br label %$27 $29: %144 = phi i32 [%134, %$27] ; # C %145 = phi i64 [%131, %$27] ; # X %146 = phi i64 [%132, %$27] ; # Y ; # (drop *Safe) %147 = inttoptr i64 %34 to i64* %148 = getelementptr i64, i64* %147, i32 1 %149 = load i64, i64* %148 %150 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %149, i64* %150 br label %$7 $13: %151 = phi i32 [%9, %$8] ; # C %152 = phi i64 [%16, %$8] ; # X ; # (atom X) %153 = and i64 %152, 15 %154 = icmp ne i64 %153, 0 br i1 %154, label %$31, label %$30 $31: %155 = phi i32 [%151, %$13] ; # C %156 = phi i64 [%152, %$13] ; # X ; # (let (P (push 4 NIL ZERO NIL) Q (link (ofs P 2))) (loop (charSym ... ; # (push 4 NIL ZERO NIL) %157 = alloca i64, i64 4, align 16 store i64 4, i64* %157 %158 = getelementptr i64, i64* %157, i32 2 store i64 2, i64* %158 ; # (ofs P 2) %159 = getelementptr i64, i64* %157, i32 2 ; # (link (ofs P 2)) %160 = ptrtoint i64* %159 to i64 %161 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %162 = load i64, i64* %161 %163 = inttoptr i64 %160 to i64* %164 = getelementptr i64, i64* %163, i32 1 store i64 %162, i64* %164 %165 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %160, i64* %165 ; # (loop (charSym (getChar C) P) (? (eol (setq C (call $Get))))) br label %$32 $32: %166 = phi i32 [%155, %$31], [%172, %$33] ; # C %167 = phi i64 [%156, %$31], [%173, %$33] ; # X ; # (getChar C) %168 = call i32 @getChar(i32 %166) ; # (charSym (getChar C) P) call void @charSym(i32 %168, i64* %157) ; # (? (eol (setq C (call $Get)))) ; # (call $Get) %169 = load i32()*, i32()** @$Get %170 = call i32 %169() ; # (eol (setq C (call $Get))) %171 = call i1 @eol(i32 %170) br i1 %171, label %$34, label %$33 $33: %172 = phi i32 [%170, %$32] ; # C %173 = phi i64 [%167, %$32] ; # X br label %$32 $34: %174 = phi i32 [%170, %$32] ; # C %175 = phi i64 [%167, %$32] ; # X %176 = phi i64 [0, %$32] ; # -> ; # (drop Q (consStr (val 3 P))) ; # (val 3 P) %177 = getelementptr i64, i64* %157, i32 2 %178 = load i64, i64* %177 ; # (consStr (val 3 P)) %179 = call i64 @consStr(i64 %178) %180 = inttoptr i64 %160 to i64* %181 = getelementptr i64, i64* %180, i32 1 %182 = load i64, i64* %181 %183 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %182, i64* %183 br label %$7 $30: %184 = phi i32 [%151, %$13] ; # C %185 = phi i64 [%152, %$13] ; # X ; # (let (N (evCnt Exe X) P (push 4 NIL ZERO NIL) Q (link (ofs P 2) T... ; # (evCnt Exe X) %186 = call i64 @evCnt(i64 %0, i64 %185) ; # (push 4 NIL ZERO NIL) %187 = alloca i64, i64 4, align 16 store i64 4, i64* %187 %188 = getelementptr i64, i64* %187, i32 2 store i64 2, i64* %188 ; # (ofs P 2) %189 = getelementptr i64, i64* %187, i32 2 ; # (link (ofs P 2) T) %190 = ptrtoint i64* %189 to i64 %191 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %190, i64* %195 ; # (loop (charSym (getChar C) P) (when (eol (setq C (call $Get))) (r... br label %$35 $35: %196 = phi i32 [%184, %$30], [%219, %$38] ; # C %197 = phi i64 [%185, %$30], [%220, %$38] ; # X %198 = phi i64 [%186, %$30], [%221, %$38] ; # N ; # (getChar C) %199 = call i32 @getChar(i32 %196) ; # (charSym (getChar C) P) call void @charSym(i32 %199, i64* %187) ; # (when (eol (setq C (call $Get))) (ret (cons (consStr (val Q)) $Ni... ; # (call $Get) %200 = load i32()*, i32()** @$Get %201 = call i32 %200() ; # (eol (setq C (call $Get))) %202 = call i1 @eol(i32 %201) br i1 %202, label %$36, label %$37 $36: %203 = phi i32 [%201, %$35] ; # C %204 = phi i64 [%197, %$35] ; # X %205 = phi i64 [%198, %$35] ; # N ; # (val Q) %206 = inttoptr i64 %190 to i64* %207 = load i64, i64* %206 ; # (consStr (val Q)) %208 = call i64 @consStr(i64 %207) ; # (cons (consStr (val Q)) $Nil) %209 = call i64 @cons(i64 %208, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (ret (cons (consStr (val Q)) $Nil)) ; # (drop *Safe) %210 = inttoptr i64 %190 to i64* %211 = getelementptr i64, i64* %210, i32 1 %212 = load i64, i64* %211 %213 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %212, i64* %213 ret i64 %209 $37: %214 = phi i32 [%201, %$35] ; # C %215 = phi i64 [%197, %$35] ; # X %216 = phi i64 [%198, %$35] ; # N ; # (? (=0 (dec 'N))) ; # (dec 'N) %217 = sub i64 %216, 1 ; # (=0 (dec 'N)) %218 = icmp eq i64 %217, 0 br i1 %218, label %$39, label %$38 $38: %219 = phi i32 [%214, %$37] ; # C %220 = phi i64 [%215, %$37] ; # X %221 = phi i64 [%217, %$37] ; # N br label %$35 $39: %222 = phi i32 [%214, %$37] ; # C %223 = phi i64 [%215, %$37] ; # X %224 = phi i64 [%217, %$37] ; # N %225 = phi i64 [0, %$37] ; # -> ; # (let (Y (cons (consStr (val Q)) $Nil) R (save Y)) (while (pair (s... ; # (val Q) %226 = inttoptr i64 %190 to i64* %227 = load i64, i64* %226 ; # (consStr (val Q)) %228 = call i64 @consStr(i64 %227) ; # (cons (consStr (val Q)) $Nil) %229 = call i64 @cons(i64 %228, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %230 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %231 = load i64, i64* %230 %232 = alloca i64, i64 2, align 16 %233 = ptrtoint i64* %232 to i64 %234 = inttoptr i64 %233 to i64* store i64 %229, i64* %234 %235 = add i64 %233, 8 %236 = inttoptr i64 %235 to i64* store i64 %231, i64* %236 %237 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %233, i64* %237 ; # (while (pair (shift X)) (setq N (evCnt Exe X)) (set P 4 3 P ZERO)... br label %$40 $40: %238 = phi i32 [%222, %$39], [%285, %$47] ; # C %239 = phi i64 [%223, %$39], [%286, %$47] ; # X %240 = phi i64 [%224, %$39], [%287, %$47] ; # N %241 = phi i64 [%229, %$39], [%293, %$47] ; # Y ; # (shift X) %242 = inttoptr i64 %239 to i64* %243 = getelementptr i64, i64* %242, i32 1 %244 = load i64, i64* %243 ; # (pair (shift X)) %245 = and i64 %244, 15 %246 = icmp eq i64 %245, 0 br i1 %246, label %$41, label %$42 $41: %247 = phi i32 [%238, %$40] ; # C %248 = phi i64 [%244, %$40] ; # X %249 = phi i64 [%240, %$40] ; # N %250 = phi i64 [%241, %$40] ; # Y ; # (evCnt Exe X) %251 = call i64 @evCnt(i64 %0, i64 %248) ; # (set P 4 3 P ZERO) store i64 4, i64* %187 %252 = getelementptr i64, i64* %187, i32 2 store i64 2, i64* %252 ; # (loop (charSym (getChar C) P) (when (eol (setq C (call $Get))) (s... br label %$43 $43: %253 = phi i32 [%247, %$41], [%281, %$46] ; # C %254 = phi i64 [%248, %$41], [%282, %$46] ; # X %255 = phi i64 [%251, %$41], [%283, %$46] ; # N %256 = phi i64 [%250, %$41], [%284, %$46] ; # Y ; # (getChar C) %257 = call i32 @getChar(i32 %253) ; # (charSym (getChar C) P) call void @charSym(i32 %257, i64* %187) ; # (when (eol (setq C (call $Get))) (set 2 Y (cons (consStr (val Q))... ; # (call $Get) %258 = load i32()*, i32()** @$Get %259 = call i32 %258() ; # (eol (setq C (call $Get))) %260 = call i1 @eol(i32 %259) br i1 %260, label %$44, label %$45 $44: %261 = phi i32 [%259, %$43] ; # C %262 = phi i64 [%254, %$43] ; # X %263 = phi i64 [%255, %$43] ; # N %264 = phi i64 [%256, %$43] ; # Y ; # (set 2 Y (cons (consStr (val Q)) $Nil)) ; # (val Q) %265 = inttoptr i64 %190 to i64* %266 = load i64, i64* %265 ; # (consStr (val Q)) %267 = call i64 @consStr(i64 %266) ; # (cons (consStr (val Q)) $Nil) %268 = call i64 @cons(i64 %267, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %269 = inttoptr i64 %264 to i64* %270 = getelementptr i64, i64* %269, i32 1 store i64 %268, i64* %270 ; # (ret R) ; # (drop *Safe) %271 = inttoptr i64 %190 to i64* %272 = getelementptr i64, i64* %271, i32 1 %273 = load i64, i64* %272 %274 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %273, i64* %274 ret i64 %229 $45: %275 = phi i32 [%259, %$43] ; # C %276 = phi i64 [%254, %$43] ; # X %277 = phi i64 [%255, %$43] ; # N %278 = phi i64 [%256, %$43] ; # Y ; # (? (=0 (dec 'N))) ; # (dec 'N) %279 = sub i64 %277, 1 ; # (=0 (dec 'N)) %280 = icmp eq i64 %279, 0 br i1 %280, label %$47, label %$46 $46: %281 = phi i32 [%275, %$45] ; # C %282 = phi i64 [%276, %$45] ; # X %283 = phi i64 [%279, %$45] ; # N %284 = phi i64 [%278, %$45] ; # Y br label %$43 $47: %285 = phi i32 [%275, %$45] ; # C %286 = phi i64 [%276, %$45] ; # X %287 = phi i64 [%279, %$45] ; # N %288 = phi i64 [%278, %$45] ; # Y %289 = phi i64 [0, %$45] ; # -> ; # (set 2 Y (cons (consStr (val Q)) $Nil)) ; # (val Q) %290 = inttoptr i64 %190 to i64* %291 = load i64, i64* %290 ; # (consStr (val Q)) %292 = call i64 @consStr(i64 %291) ; # (cons (consStr (val Q)) $Nil) %293 = call i64 @cons(i64 %292, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %294 = inttoptr i64 %288 to i64* %295 = getelementptr i64, i64* %294, i32 1 store i64 %293, i64* %295 br label %$40 $42: %296 = phi i32 [%238, %$40] ; # C %297 = phi i64 [%244, %$40] ; # X %298 = phi i64 [%240, %$40] ; # N %299 = phi i64 [%241, %$40] ; # Y ; # (loop (setq Y (set 2 Y (cons (mkChar (getChar C)) $Nil))) (? (eol... br label %$48 $48: %300 = phi i32 [%296, %$42], [%312, %$49] ; # C %301 = phi i64 [%297, %$42], [%313, %$49] ; # X %302 = phi i64 [%298, %$42], [%314, %$49] ; # N %303 = phi i64 [%299, %$42], [%315, %$49] ; # Y ; # (set 2 Y (cons (mkChar (getChar C)) $Nil)) ; # (getChar C) %304 = call i32 @getChar(i32 %300) ; # (mkChar (getChar C)) %305 = call i64 @mkChar(i32 %304) ; # (cons (mkChar (getChar C)) $Nil) %306 = call i64 @cons(i64 %305, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %307 = inttoptr i64 %303 to i64* %308 = getelementptr i64, i64* %307, i32 1 store i64 %306, i64* %308 ; # (? (eol (setq C (call $Get)))) ; # (call $Get) %309 = load i32()*, i32()** @$Get %310 = call i32 %309() ; # (eol (setq C (call $Get))) %311 = call i1 @eol(i32 %310) br i1 %311, label %$50, label %$49 $49: %312 = phi i32 [%310, %$48] ; # C %313 = phi i64 [%301, %$48] ; # X %314 = phi i64 [%302, %$48] ; # N %315 = phi i64 [%306, %$48] ; # Y br label %$48 $50: %316 = phi i32 [%310, %$48] ; # C %317 = phi i64 [%301, %$48] ; # X %318 = phi i64 [%302, %$48] ; # N %319 = phi i64 [%306, %$48] ; # Y %320 = phi i64 [0, %$48] ; # -> ; # (drop *Safe) %321 = inttoptr i64 %190 to i64* %322 = getelementptr i64, i64* %321, i32 1 %323 = load i64, i64* %322 %324 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %323, i64* %324 br label %$7 $7: %325 = phi i32 [%144, %$29], [%174, %$34], [%316, %$50] ; # C %326 = phi i64 [%145, %$29], [%175, %$34], [%317, %$50] ; # X %327 = phi i64 [%30, %$29], [%179, %$34], [%229, %$50] ; # -> br label %$6 $6: %328 = phi i32 [%8, %$4], [%325, %$7] ; # C %329 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%327, %$7] ; # -> ret i64 %329 } define i64 @_in(i64) align 8 { $1: ; # (let X (cdr Exe) (rdOpen Exe (eval (++ X)) (b8 (ioFrame T))) (pro... ; # (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 ; # (rdOpen Exe (eval (++ X)) (b8 (ioFrame T))) call void @rdOpen(i64 %0, i64 %15, i8* %16) ; # (prog1 (run X) (popInFiles) (tosInFile)) ; # (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() ; # (tosInFile) call void @tosInFile() ret i64 %42 } define i64 @_out(i64) align 8 { $1: ; # (let X (cdr Exe) (wrOpen Exe (eval (++ X)) (b8 (ioFrame T))) (pro... ; # (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 ; # (wrOpen Exe (eval (++ X)) (b8 (ioFrame T))) call void @wrOpen(i64 %0, i64 %15, i8* %16) ; # (prog1 (run X) (popOutFiles) (tosOutFile)) ; # (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() ; # (tosOutFile) call void @tosOutFile() ret i64 %42 } define i64 @_err(i64) align 8 { $1: ; # (let X (cdr Exe) (erOpen Exe (eval (++ X)) (b8 (ctFrame T))) (pro... ; # (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 ; # (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))) (pro... ; # (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 ; # (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 i64 @_fd(i64) align 8 { $1: ; # (currFd Exe) %1 = call i32 @currFd(i64 %0) ; # (i64 (currFd Exe)) %2 = sext i32 %1 to i64 ; # (cnt (i64 (currFd Exe))) %3 = shl i64 %2, 4 %4 = or i64 %3, 2 ret i64 %4 } 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 28 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 28 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) (In: pid ... ; # (val $InFrames) %115 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (while In (let In: (ioFrame In) (In: pid 0) (setq In (In: link)))... br label %$28 $28: %116 = phi i32 [%111, %$25], [%120, %$29] ; # I %117 = phi i32 [%112, %$25], [%121, %$29] ; # N %118 = phi i8* [%115, %$25], [%126, %$29] ; # 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) (In: pid 0) (setq In (In: link))) ; # (In: pid 0) %123 = getelementptr i8, i8* %122, i32 24 %124 = bitcast i8* %123 to i32* store i32 0, i32* %124 ; # (In: link) %125 = bitcast i8* %122 to i8** %126 = load i8*, i8** %125 br label %$28 $30: %127 = phi i32 [%116, %$28] ; # I %128 = phi i32 [%117, %$28] ; # N %129 = phi i8* [%118, %$28] ; # In ; # (let Out (val $OutFrames) (while Out (let Out: (ioFrame Out) (Out... ; # (val $OutFrames) %130 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (while Out (let Out: (ioFrame Out) (Out: pid 0) (setq Out (Out: l... br label %$31 $31: %131 = phi i32 [%127, %$30], [%135, %$32] ; # I %132 = phi i32 [%128, %$30], [%136, %$32] ; # N %133 = phi i8* [%130, %$30], [%141, %$32] ; # Out %134 = icmp ne i8* %133, null br i1 %134, label %$32, label %$33 $32: %135 = phi i32 [%131, %$31] ; # I %136 = phi i32 [%132, %$31] ; # N %137 = phi i8* [%133, %$31] ; # Out ; # (let Out: (ioFrame Out) (Out: pid 0) (setq Out (Out: link))) ; # (Out: pid 0) %138 = getelementptr i8, i8* %137, i32 24 %139 = bitcast i8* %138 to i32* store i32 0, i32* %139 ; # (Out: link) %140 = bitcast i8* %137 to i8** %141 = load i8*, i8** %140 br label %$31 $33: %142 = phi i32 [%131, %$31] ; # I %143 = phi i32 [%132, %$31] ; # N %144 = phi i8* [%133, %$31] ; # Out ; # (let Ca (val $Catch) (while Ca (let Ca: (caFrame Ca) (Ca: fin ZER... ; # (val $Catch) %145 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (while Ca (let Ca: (caFrame Ca) (Ca: fin ZERO) (setq Ca (Ca: link... br label %$34 $34: %146 = phi i32 [%142, %$33], [%150, %$35] ; # I %147 = phi i32 [%143, %$33], [%151, %$35] ; # N %148 = phi i8* [%145, %$33], [%157, %$35] ; # Ca %149 = icmp ne i8* %148, null br i1 %149, label %$35, label %$36 $35: %150 = phi i32 [%146, %$34] ; # I %151 = phi i32 [%147, %$34] ; # N %152 = phi i8* [%148, %$34] ; # Ca ; # (let Ca: (caFrame Ca) (Ca: fin ZERO) (setq Ca (Ca: link))) ; # (Ca: fin ZERO) %153 = getelementptr i8, i8* %152, i32 16 %154 = ptrtoint i8* %153 to i64 %155 = inttoptr i64 %154 to i64* store i64 2, i64* %155 ; # (Ca: link) %156 = bitcast i8* %152 to i8** %157 = load i8*, i8** %156 br label %$34 $36: %158 = phi i32 [%146, %$34] ; # I %159 = phi i32 [%147, %$34] ; # N %160 = phi i8* [%148, %$34] ; # Ca ; # (let R (val $Run) (while (pair R) (let X (++ R) (unless (sign? (c... ; # (val $Run) %161 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 600) to i64) to i64* %162 = load i64, i64* %161 ; # (while (pair R) (let X (++ R) (unless (sign? (car X)) (let Fd (i3... br label %$37 $37: %163 = phi i32 [%158, %$36], [%185, %$41] ; # I %164 = phi i32 [%159, %$36], [%186, %$41] ; # N %165 = phi i64 [%162, %$36], [%187, %$41] ; # R ; # (pair R) %166 = and i64 %165, 15 %167 = icmp eq i64 %166, 0 br i1 %167, label %$38, label %$39 $38: %168 = phi i32 [%163, %$37] ; # I %169 = phi i32 [%164, %$37] ; # N %170 = phi i64 [%165, %$37] ; # R ; # (let X (++ R) (unless (sign? (car X)) (let Fd (i32 (int @)) (clos... ; # (++ R) %171 = inttoptr i64 %170 to i64* %172 = load i64, i64* %171 %173 = getelementptr i64, i64* %171, i32 1 %174 = load i64, i64* %173 ; # (unless (sign? (car X)) (let Fd (i32 (int @)) (close Fd) (closeIn... ; # (car X) %175 = inttoptr i64 %172 to i64* %176 = load i64, i64* %175 ; # (sign? (car X)) %177 = and i64 %176, 8 %178 = icmp ne i64 %177, 0 br i1 %178, label %$41, label %$40 $40: %179 = phi i32 [%168, %$38] ; # I %180 = phi i32 [%169, %$38] ; # N %181 = phi i64 [%174, %$38] ; # R ; # (let Fd (i32 (int @)) (close Fd) (closeInFile Fd) (closeOutFile F... ; # (int @) %182 = lshr i64 %176, 4 ; # (i32 (int @)) %183 = trunc i64 %182 to i32 ; # (close Fd) %184 = call i32 @close(i32 %183) ; # (closeInFile Fd) call void @closeInFile(i32 %183) ; # (closeOutFile Fd) call void @closeOutFile(i32 %183) br label %$41 $41: %185 = phi i32 [%168, %$38], [%179, %$40] ; # I %186 = phi i32 [%169, %$38], [%180, %$40] ; # N %187 = phi i64 [%174, %$38], [%181, %$40] ; # R br label %$37 $39: %188 = phi i32 [%163, %$37] ; # I %189 = phi i32 [%164, %$37] ; # N %190 = phi i64 [%165, %$37] ; # R ; # (set $Bye $Nil) %191 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 808) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %191 ; # (set $Run $Nil) %192 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 600) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %192 ; # (val Termio) %193 = load i8*, i8** @Termio ; # (free (val Termio)) call void @free(i8* %193) ; # (set Termio null) store i8* null, i8** @Termio ; # (set $PRepl (val $Repl) $PPid (val $Pid)) ; # (val $Repl) %194 = load i1, i1* @$Repl store i1 %194, i1* @$PRepl ; # (val $Pid) %195 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 200) to i64) to i64* %196 = load i64, i64* %195 %197 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 216) to i64) to i64* store i64 %196, i64* %197 ; # (set $Pid (cnt (i64 (getpid)))) ; # (getpid) %198 = call i32 @getpid() ; # (i64 (getpid)) %199 = sext i32 %198 to i64 ; # (cnt (i64 (getpid))) %200 = shl i64 %199, 4 %201 = or i64 %200, 2 %202 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 200) to i64) to i64* store i64 %201, i64* %202 ; # (val $Fork) %203 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 792) to i64) to i64* %204 = load i64, i64* %203 ; # (execAt (val $Fork)) %205 = call i64 @execAt(i64 %204) ; # (set $Fork $Nil) %206 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 792) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %206 br label %$14 $17: %207 = phi i32 [%46, %$15] ; # I %208 = 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) %209 = icmp eq i32 %207, %208 br i1 %209, label %$42, label %$43 $42: %210 = phi i32 [%207, %$17] ; # I %211 = phi i32 [%208, %$17] ; # N ; # (set $Children (inc 'N 8)) ; # (inc 'N 8) %212 = add i32 %211, 8 store i32 %212, 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) %213 = load i8*, i8** @$Child ; # (* N (child T)) %214 = mul i32 %212, 28 ; # (i64 (* N (child T))) %215 = sext i32 %214 to i64 ; # (alloc (val $Child) (i64 (* N (child T)))) %216 = call i8* @alloc(i8* %213, i64 %215) store i8* %216, i8** @$Child ; # (let Cld (ofs P (* I (child T))) (loop ((child Cld) pid 0) (? (==... ; # (* I (child T)) %217 = mul i32 %210, 28 ; # (ofs P (* I (child T))) %218 = getelementptr i8, i8* %216, i32 %217 ; # (loop ((child Cld) pid 0) (? (== I (dec 'N))) (setq Cld (ofs Cld ... br label %$44 $44: %219 = phi i32 [%210, %$42], [%226, %$45] ; # I %220 = phi i32 [%212, %$42], [%227, %$45] ; # N %221 = phi i8* [%218, %$42], [%229, %$45] ; # Cld ; # ((child Cld) pid 0) %222 = getelementptr i8, i8* %221, i32 16 %223 = bitcast i8* %222 to i32* store i32 0, i32* %223 ; # (? (== I (dec 'N))) ; # (dec 'N) %224 = sub i32 %220, 1 ; # (== I (dec 'N)) %225 = icmp eq i32 %219, %224 br i1 %225, label %$46, label %$45 $45: %226 = phi i32 [%219, %$44] ; # I %227 = phi i32 [%224, %$44] ; # N %228 = phi i8* [%221, %$44] ; # Cld ; # (ofs Cld (child T)) %229 = getelementptr i8, i8* %228, i32 28 br label %$44 $46: %230 = phi i32 [%219, %$44] ; # I %231 = phi i32 [%224, %$44] ; # N %232 = phi i8* [%221, %$44] ; # Cld %233 = phi i64 [0, %$44] ; # -> br label %$43 $43: %234 = phi i32 [%207, %$17], [%230, %$46] ; # I %235 = phi i32 [%208, %$17], [%231, %$46] ; # N ; # (val Hear) %236 = load i32, i32* %8 ; # (close (val Hear)) %237 = call i32 @close(i32 %236) ; # (val 2 Tell) %238 = getelementptr i32, i32* %9, i32 1 %239 = load i32, i32* %238 ; # (close (val 2 Tell)) %240 = call i32 @close(i32 %239) ; # (let Cld: (child (ofs (val $Child) (* I (child T)))) (Cld: buf nu... ; # (val $Child) %241 = load i8*, i8** @$Child ; # (* I (child T)) %242 = mul i32 %234, 28 ; # (ofs (val $Child) (* I (child T))) %243 = getelementptr i8, i8* %241, i32 %242 ; # (Cld: buf null) %244 = bitcast i8* %243 to i8** store i8* null, i8** %244 ; # (Cld: ofs (Cld: cnt 0)) %245 = getelementptr i8, i8* %243, i32 8 %246 = bitcast i8* %245 to i32* %247 = getelementptr i8, i8* %243, i32 12 %248 = bitcast i8* %247 to i32* store i32 0, i32* %248 store i32 0, i32* %246 ; # (Cld: pid Pid) %249 = getelementptr i8, i8* %243, i32 16 %250 = bitcast i8* %249 to i32* store i32 %42, i32* %250 ; # (Cld: hear (val Tell)) %251 = getelementptr i8, i8* %243, i32 20 %252 = bitcast i8* %251 to i32* %253 = load i32, i32* %9 store i32 %253, i32* %252 ; # (Cld: tell (val 2 Hear)) %254 = getelementptr i8, i8* %243, i32 24 %255 = bitcast i8* %254 to i32* %256 = getelementptr i32, i32* %8, i32 1 %257 = load i32, i32* %256 store i32 %257, i32* %255 ; # (nonBlocking (Cld: tell (val 2 Hear))) %258 = call i32 @nonBlocking(i32 %257) br label %$14 $14: %259 = phi i32 [%188, %$39], [%234, %$43] ; # I %260 = phi i32 [%189, %$39], [%235, %$43] ; # N %261 = phi i32 [0, %$39], [%42, %$43] ; # -> ret i32 %261 } 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 ; # (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) (tosInFile)) ; # (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() ; # (tosInFile) call void @tosInFile() 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)) (dup2... ; # (val 2 Pfd) %63 = getelementptr i32, i32* %8, i32 1 %64 = load i32, i32* %63 ; # (if (pair X) (setpgid 0 0) (dup2 Fd 0)) ; # (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) br label %$28 $28: %69 = phi i32 [%67, %$26], [%68, %$27] ; # -> ; # (dup2 Fd 1) %70 = call i32 @dup2(i32 %64, i32 1) ; # (close Fd) %71 = call i32 @close(i32 %64) ; # (val SIGPIPE Sig) %72 = getelementptr i32, i32* @Sig, i32 4 %73 = load i32, i32* %72 ; # (val SigDfl) %74 = load i8*, i8** @SigDfl ; # (signal (val SIGPIPE Sig) (val SigDfl)) %75 = call i8* @signal(i32 %73, i8* %74) ; # (val $OutFile) %76 = load i8*, i8** @$OutFile ; # ((outFile (val $OutFile)) tty NO) %77 = getelementptr i8, i8* %76, i32 4104 %78 = bitcast i8* %77 to i1* store i1 0, i1* %78 ; # (Io:) ; # (val $OutFiles) %79 = load i8**, i8*** @$OutFiles ; # (val 2 (val $OutFiles)) %80 = getelementptr i8*, i8** %79, i32 1 %81 = load i8*, i8** %80 ; # (pushOutFile (Io:) (val 2 (val $OutFiles)) 0) call void @pushOutFile(i8* %9, i8* %81, i32 0) ; # (set $LinePtr null) store i8* null, i8** @$LinePtr ; # (when (pair E) (evList E)) ; # (pair E) %82 = and i64 %5, 15 %83 = icmp eq i64 %82, 0 br i1 %83, label %$29, label %$30 $29: ; # (evList E) %84 = call i64 @evList(i64 %5) br label %$30 $30: ; # (bye 0) call void @bye(i32 0) unreachable $11: %85 = phi i64 [%60, %$12] ; # -> ret i64 %85 } define i64 @_open(i64) align 8 { $1: ; # (let (X (cdr Exe) Nm (xName Exe (evSym X)) S (pathString Nm (b8 (... ; # (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 Exe (evSym X)) %5 = call i64 @xName(i64 %0, 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 ([870 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 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 ([870 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 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 ([870 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 ([870 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* @$Chr %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()** @$Get %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)** @$Put call void %45(i8 %44) ; # (call $Get) %46 = load i32()*, i32()** @$Get %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()** @$Get %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 ([870 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()** @$Get %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 ([870 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)** @$Put 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* @$Chr 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 Exe Y) L (link (push Y NIL 0 (a... ; # (i64* null) %117 = inttoptr i64 0 to i64* ; # (xName Exe Y) %118 = call i64 @xName(i64 %0, 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 ([17 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 ([17 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 Exe Y) L (link (... 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 Exe Y) %154 = call i64 @xName(i64 %0, 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 ([17 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 ([17 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* @$Chr %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()** @$Get %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* @$Chr ; # (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)** @$Put 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* @$Chr ; # (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 ([17 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)** @$Put 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)** @$Put 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)** @$Put 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()** @$Get %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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$29], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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** @$OutFile ; # (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)** @$Put call void %0(i8 10) ret void } define void @space() align 8 { $1: ; # (call $Put (char " ")) %0 = load void(i8)*, void(i8)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put call void %7(i8 92) br label %$6 $6: %8 = phi i8 [%4, %$2], [%6, %$5] ; # B ; # (loop (when (or (== B (char "\\")) (strchr $Delim (i32 B))) (call... br label %$7 $7: %9 = phi i8 [%8, %$6], [%23, %$12] ; # B ; # (when (or (== B (char "\\")) (strchr $Delim (i32 B))) (call $Put ... ; # (or (== B (char "\\")) (strchr $Delim (i32 B))) ; # (== B (char "\\")) %10 = icmp eq i8 %9, 92 br i1 %10, label %$8, label %$9 $9: %11 = phi i8 [%9, %$7] ; # B ; # (i32 B) %12 = zext i8 %11 to i32 ; # (strchr $Delim (i32 B)) %13 = call i8* @strchr(i8* bitcast ([16 x i8]* @$Delim to i8*), i32 %12) %14 = icmp ne i8* %13, null br label %$8 $8: %15 = phi i8 [%9, %$7], [%11, %$9] ; # B %16 = phi i1 [1, %$7], [%14, %$9] ; # -> br i1 %16, label %$10, label %$11 $10: %17 = phi i8 [%15, %$8] ; # B ; # (call $Put (char "\\")) %18 = load void(i8)*, void(i8)** @$Put call void %18(i8 92) br label %$11 $11: %19 = phi i8 [%15, %$8], [%17, %$10] ; # B ; # (call $Put B) %20 = load void(i8)*, void(i8)** @$Put call void %20(i8 %19) ; # (? (=0 (setq B (symByte P)))) ; # (symByte P) %21 = call i8 @symByte(i64* %2) ; # (=0 (setq B (symByte P))) %22 = icmp eq i8 %21, 0 br i1 %22, label %$13, label %$12 $12: %23 = phi i8 [%21, %$11] ; # B br label %$7 $13: %24 = phi i8 [%21, %$11] ; # B %25 = phi i64 [0, %$11] ; # -> br label %$4 $3: ; # (call $Put (char "\\")) %26 = load void(i8)*, void(i8)** @$Put call void %26(i8 92) ; # (call $Put (char ".")) %27 = load void(i8)*, void(i8)** @$Put call void %27(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 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 -1 0 0 null)) ((s... ; # (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 -1 0 0 null) %10 = call i64 @fmtNum(i64 %9, i64 -1, 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)** @$Put 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)** @$Put 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)** @$Put 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 @ (ifn (== X (isIntern Nm $PrivT)) (let (Lst (val $Intern... ; # (ifn (== X (isIntern Nm $PrivT)) (let (Lst (val $Intern) F NO) (l... ; # (isIntern Nm $PrivT) %46 = call i64 @isIntern(i64 %40, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 112) to i64)) ; # (== X (isIntern Nm $PrivT)) %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 ([17 x i64]* @env to i8*), i32 72) 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], [%159, %$43] ; # X %52 = phi i64 [%50, %$22], [%164, %$43] ; # Lst %53 = phi i1 [0, %$22], [%161, %$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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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 F (printSym Nsp)... ; # (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 F (printSym Nsp) (call $Put (char "~"))) (print... ; # (== @ 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 F (printSym Nsp) (call $Put (char "~"))) br i1 %148, label %$46, label %$47 $46: %149 = phi i64 [%146, %$45] ; # X %150 = phi i64 [%147, %$45] ; # Lst %151 = phi i1 [%148, %$45] ; # F ; # (printSym Nsp) call void @printSym(i64 %134) ; # (call $Put (char "~")) %152 = load void(i8)*, void(i8)** @$Put call void %152(i8 126) br label %$47 $47: %153 = phi i64 [%146, %$45], [%149, %$46] ; # X %154 = phi i64 [%147, %$45], [%150, %$46] ; # Lst %155 = phi i1 [%148, %$45], [%151, %$46] ; # F ; # (printName Nm) call void @printName(i64 %40) br label %$27 $44: %156 = phi i64 [%142, %$42] ; # X %157 = phi i64 [%143, %$42] ; # Lst %158 = phi i1 [%144, %$42] ; # F br label %$43 $43: %159 = phi i64 [%130, %$26], [%156, %$44] ; # X %160 = phi i64 [%131, %$26], [%157, %$44] ; # Lst %161 = phi i1 [%132, %$26], [1, %$44] ; # F ; # (shift Lst) %162 = inttoptr i64 %160 to i64* %163 = getelementptr i64, i64* %162, i32 1 %164 = load i64, i64* %163 br label %$25 $27: %165 = phi i64 [%124, %$41], [%153, %$47] ; # X %166 = phi i64 [%125, %$41], [%154, %$47] ; # Lst %167 = phi i1 [%126, %$41], [%155, %$47] ; # F br label %$24 $23: %168 = phi i64 [%45, %$20] ; # X ; # (outString ($ "priv~")) call void @outString(i8* bitcast ([6 x i8]* @$43 to i8*)) ; # (printName Nm) call void @printName(i64 %40) br label %$24 $24: %169 = phi i64 [%165, %$27], [%168, %$23] ; # X br label %$11 $11: %170 = phi i64 [%20, %$16], [%42, %$21], [%169, %$24] ; # X br label %$4 $9: %171 = phi i64 [%11, %$7] ; # X ; # (and (== (car X) $Quote) (<> X (cdr X))) ; # (car X) %172 = inttoptr i64 %171 to i64* %173 = load i64, i64* %172 ; # (== (car X) $Quote) %174 = icmp eq i64 %173, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 264) to i64) br i1 %174, label %$49, label %$48 $49: %175 = phi i64 [%171, %$9] ; # X ; # (cdr X) %176 = inttoptr i64 %175 to i64* %177 = getelementptr i64, i64* %176, i32 1 %178 = load i64, i64* %177 ; # (<> X (cdr X)) %179 = icmp ne i64 %175, %178 br label %$48 $48: %180 = phi i64 [%171, %$9], [%175, %$49] ; # X %181 = phi i1 [0, %$9], [%179, %$49] ; # -> br i1 %181, label %$51, label %$50 $51: %182 = phi i64 [%180, %$48] ; # X ; # (call $Put (char "'")) %183 = load void(i8)*, void(i8)** @$Put call void %183(i8 39) ; # (cdr X) %184 = inttoptr i64 %182 to i64* %185 = getelementptr i64, i64* %184, i32 1 %186 = load i64, i64* %185 ; # (print (cdr X)) call void @print(i64 %186) br label %$4 $50: %187 = phi i64 [%180, %$48] ; # X ; # (stkChk 0) %188 = load i8*, i8** @$StkLimit %189 = call i8* @llvm.stacksave() %190 = icmp ugt i8* %188, %189 br i1 %190, label %$52, label %$53 $52: call void @stkErr(i64 0) unreachable $53: ; # (call $Put (char "(")) %191 = load void(i8)*, void(i8)** @$Put call void %191(i8 40) ; # (let P (circ X) (ifn P (loop (print (car X)) (? (nil? (shift X)))... ; # (circ X) %192 = call i64 @circ(i64 %187) ; # (ifn P (loop (print (car X)) (? (nil? (shift X))) (? (atom X) (ou... %193 = icmp ne i64 %192, 0 br i1 %193, label %$55, label %$54 $54: %194 = phi i64 [%187, %$53] ; # X ; # (loop (print (car X)) (? (nil? (shift X))) (? (atom X) (outString... br label %$57 $57: %195 = phi i64 [%194, %$54], [%206, %$60] ; # X ; # (car X) %196 = inttoptr i64 %195 to i64* %197 = load i64, i64* %196 ; # (print (car X)) call void @print(i64 %197) ; # (? (nil? (shift X))) ; # (shift X) %198 = inttoptr i64 %195 to i64* %199 = getelementptr i64, i64* %198, i32 1 %200 = load i64, i64* %199 ; # (nil? (shift X)) %201 = icmp eq i64 %200, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %201, label %$59, label %$58 $58: %202 = phi i64 [%200, %$57] ; # X ; # (? (atom X) (outString ($ " . ")) (print X)) ; # (atom X) %203 = and i64 %202, 15 %204 = icmp ne i64 %203, 0 br i1 %204, label %$61, label %$60 $61: %205 = phi i64 [%202, %$58] ; # X ; # (outString ($ " . ")) call void @outString(i8* bitcast ([4 x i8]* @$44 to i8*)) ; # (print X) call void @print(i64 %205) br label %$59 $60: %206 = phi i64 [%202, %$58] ; # X ; # (space) call void @space() br label %$57 $59: %207 = phi i64 [%200, %$57], [%205, %$61] ; # X br label %$56 $55: %208 = phi i64 [%187, %$53] ; # X ; # (let Flg (== P X) (loop (print (car X)) (space) (? (== P (shift X... ; # (== P X) %209 = icmp eq i64 %192, %208 ; # (loop (print (car X)) (space) (? (== P (shift X)))) br label %$62 $62: %210 = phi i64 [%208, %$55], [%217, %$63] ; # X ; # (car X) %211 = inttoptr i64 %210 to i64* %212 = load i64, i64* %211 ; # (print (car X)) call void @print(i64 %212) ; # (space) call void @space() ; # (? (== P (shift X))) ; # (shift X) %213 = inttoptr i64 %210 to i64* %214 = getelementptr i64, i64* %213, i32 1 %215 = load i64, i64* %214 ; # (== P (shift X)) %216 = icmp eq i64 %192, %215 br i1 %216, label %$64, label %$63 $63: %217 = phi i64 [%215, %$62] ; # X br label %$62 $64: %218 = phi i64 [%215, %$62] ; # X %219 = phi i64 [0, %$62] ; # -> ; # (call $Put (char ".")) %220 = load void(i8)*, void(i8)** @$Put call void %220(i8 46) ; # (unless Flg (space) (call $Put (char "(")) (loop (print (car X)) ... br i1 %209, label %$66, label %$65 $65: %221 = phi i64 [%218, %$64] ; # X ; # (space) call void @space() ; # (call $Put (char "(")) %222 = load void(i8)*, void(i8)** @$Put call void %222(i8 40) ; # (loop (print (car X)) (space) (? (== P (shift X)))) br label %$67 $67: %223 = phi i64 [%221, %$65], [%230, %$68] ; # X ; # (car X) %224 = inttoptr i64 %223 to i64* %225 = load i64, i64* %224 ; # (print (car X)) call void @print(i64 %225) ; # (space) call void @space() ; # (? (== P (shift X))) ; # (shift X) %226 = inttoptr i64 %223 to i64* %227 = getelementptr i64, i64* %226, i32 1 %228 = load i64, i64* %227 ; # (== P (shift X)) %229 = icmp eq i64 %192, %228 br i1 %229, label %$69, label %$68 $68: %230 = phi i64 [%228, %$67] ; # X br label %$67 $69: %231 = phi i64 [%228, %$67] ; # X %232 = phi i64 [0, %$67] ; # -> ; # (call $Put (char ".")) %233 = load void(i8)*, void(i8)** @$Put call void %233(i8 46) ; # (call $Put (char ")")) %234 = load void(i8)*, void(i8)** @$Put call void %234(i8 41) br label %$66 $66: %235 = phi i64 [%218, %$64], [%231, %$69] ; # X br label %$56 $56: %236 = phi i64 [%207, %$59], [%235, %$66] ; # X ; # (call $Put (char ")")) %237 = load void(i8)*, void(i8)** @$Put call void %237(i8 41) br label %$4 $4: %238 = phi i64 [%5, %$6], [%9, %$8], [%170, %$11], [%182, %$51], [%236, %$56] ; # X ret void } define void @prin(i64) align 8 { $1: ; # (sigChk 0) %1 = load 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 ([870 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 -1 0 0 null)) ((p... ; # (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 -1 0 0 null) %12 = call i64 @fmtNum(i64 %11, i64 -1, 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 ([870 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)** @$Put 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)** @$Put 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 ([870 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** @$OutFile ; # (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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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** @$OutFile ; # (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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([17 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 ([17 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** @$InFile ; # ((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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %52, i64* %53 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([17 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 ([17 x i64]* @env to i8*), i32 64) 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* @$Chr 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* @$Chr ; # (i8** $Get) %5 = bitcast i32()** @$Get to i8** ; # (val (i8** $Get)) %6 = load i8*, i8** %5 ; # (val $Parser) %7 = load i64*, i64** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 64) to i64**) ; # (set $Chr 0 $Get (fun (i32) getParse) $Parser (push 0 (save Nm) E... store i32 0, i32* @$Chr ; # (fun (i32) getParse) store i32()* @getParse, i32()** @$Get ; # (save Nm) %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 64) 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save (cons @ $Nil)) %27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([870 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 ([17 x i64]* @env to i8*), i32 64) to i64**) ; # (i8** $Get) %44 = bitcast i32()** @$Get to i8** store i8* %6, i8** %44 store i32 %4, i32* @$Chr ; # (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 ([17 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 ([17 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 ([17 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%71, %$23], [%99, %$26] ; # -> ret i64 %106 } define i64 @repl(i64, i8*, i64) align 8 { $1: ; # (when (num? X) (argErr Exe X)) ; # (num? X) %3 = and i64 %2, 6 %4 = icmp ne i64 %3, 0 br i1 %4, label %$2, label %$3 $2: %5 = phi i64 [%2, %$1] ; # X ; # (argErr Exe X) call void @argErr(i64 %0, i64 %5) unreachable $3: %6 = phi i64 [%2, %$1] ; # X ; # (if (and (sym? X) (== (firstByte X) (char "-"))) (let E (save (pa... ; # (and (sym? X) (== (firstByte X) (char "-"))) ; # (sym? X) %7 = and i64 %6, 8 %8 = icmp ne i64 %7, 0 br i1 %8, label %$5, label %$4 $5: %9 = phi i64 [%6, %$3] ; # X ; # (firstByte X) %10 = call i8 @firstByte(i64 %9) ; # (== (firstByte X) (char "-")) %11 = icmp eq i8 %10, 45 br label %$4 $4: %12 = phi i64 [%6, %$3], [%9, %$5] ; # X %13 = phi i1 [0, %$3], [%11, %$5] ; # -> br i1 %13, label %$6, label %$7 $6: %14 = phi i64 [%12, %$4] ; # X ; # (let E (save (parse (xName Exe X) YES (hex "5D0A") 0)) (evList E)... ; # (xName Exe X) %15 = call i64 @xName(i64 %0, i64 %14) ; # (parse (xName Exe X) YES (hex "5D0A") 0) %16 = call i64 @parse(i64 %15, i1 1, i64 23818, i64 0) ; # (save (parse (xName Exe X) YES (hex "5D0A") 0)) %17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %20, i64* %24 ; # (evList E) %25 = call i64 @evList(i64 %16) ; # (drop *Safe) %26 = inttoptr i64 %20 to i64* %27 = getelementptr i64, i64* %26, i32 1 %28 = load i64, i64* %27 %29 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %28, i64* %29 br label %$8 $7: %30 = phi i64 [%12, %$4] ; # X ; # (let (Int (save (val $Intern)) Pr1 (save (val $PrivT)) Pr2 (save ... ; # (val $Intern) %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) to i64) to i64* %32 = load i64, i64* %31 ; # (save (val $Intern)) %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %34 = load i64, i64* %33 %35 = alloca i64, i64 2, align 16 %36 = ptrtoint i64* %35 to i64 %37 = inttoptr i64 %36 to i64* store i64 %32, i64* %37 %38 = add i64 %36, 8 %39 = inttoptr i64 %38 to i64* store i64 %34, i64* %39 %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %36, i64* %40 ; # (val $PrivT) %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 112) to i64) to i64* %42 = load i64, i64* %41 ; # (save (val $PrivT)) %43 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %46, i64* %50 ; # (val 2 $PrivT) %51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 112) to i64) to i64* %52 = getelementptr i64, i64* %51, i32 1 %53 = load i64, i64* %52 ; # (save (val 2 $PrivT)) %54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %57, i64* %61 ; # (val $Transient) %62 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* %63 = load i64, i64* %62 ; # (save (val $Transient)) %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %67, i64* %71 ; # (val 2 $Transient) %72 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* %73 = getelementptr i64, i64* %72, i32 1 %74 = load i64, i64* %73 ; # (save (val 2 $Transient)) %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %76 = load i64, i64* %75 %77 = alloca i64, i64 2, align 16 %78 = ptrtoint i64* %77 to i64 %79 = inttoptr i64 %78 to i64* store i64 %74, i64* %79 %80 = add i64 %78, 8 %81 = inttoptr i64 %80 to i64* store i64 %76, i64* %81 %82 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %78, i64* %82 ; # (push -ZERO NIL) %83 = alloca i64, i64 2, align 16 %84 = ptrtoint i64* %83 to i64 %85 = inttoptr i64 %84 to i64* store i64 10, i64* %85 ; # (link (push -ZERO NIL)) %86 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %87 = load i64, i64* %86 %88 = inttoptr i64 %84 to i64* %89 = getelementptr i64, i64* %88, i32 1 store i64 %87, i64* %89 %90 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %84, i64* %90 ; # (push -ZERO NIL) %91 = alloca i64, i64 2, align 16 %92 = ptrtoint i64* %91 to i64 %93 = inttoptr i64 %92 to i64* store i64 10, i64* %93 ; # (link (push -ZERO NIL)) %94 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %95 = load i64, i64* %94 %96 = inttoptr i64 %92 to i64* %97 = getelementptr i64, i64* %96, i32 1 store i64 %95, i64* %97 %98 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %92, i64* %98 ; # (val Termio) %99 = load i8*, i8** @Termio ; # (when (nil? X) (setCooked) (unless (val $Repl) (set $Repl YES) (i... ; # (nil? X) %100 = icmp eq i64 %30, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %100, label %$9, label %$10 $9: %101 = phi i64 [%30, %$7] ; # X ; # (setCooked) call void @setCooked() ; # (unless (val $Repl) (set $Repl YES) (iSignal (val SIGINT Sig) (fu... ; # (val $Repl) %102 = load i1, i1* @$Repl br i1 %102, label %$12, label %$11 $11: %103 = phi i64 [%101, %$9] ; # X ; # (set $Repl YES) store i1 1, i1* @$Repl ; # (val SIGINT Sig) %104 = getelementptr i32, i32* @Sig, i32 1 %105 = load i32, i32* %104 ; # (fun sig) ; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar... %106 = bitcast void(i32)* @sig to i8* ; # (iSignal (val SIGINT Sig) (fun sig)) call void @iSignal(i32 %105, i8* %106) br label %$12 $12: %107 = phi i64 [%101, %$9], [%103, %$11] ; # X br label %$10 $10: %108 = phi i64 [%30, %$7], [%107, %$12] ; # X ; # (b8 (ioFrame T)) %109 = alloca i8, i64 28 ; # (rdOpen Exe X (b8 (ioFrame T))) call void @rdOpen(i64 %0, i64 %108, i8* %109) ; # (set $PrivT (set 2 $PrivT $Nil)) ; # (set 2 $PrivT $Nil) %110 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 112) to i64) to i64* %111 = getelementptr i64, i64* %110, i32 1 store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %111 %112 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 112) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %112 ; # (set $Rule (set $Transient (set 2 $Transient $Nil))) ; # (set $Transient (set 2 $Transient $Nil)) ; # (set 2 $Transient $Nil) %113 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* %114 = getelementptr i64, i64* %113, i32 1 store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %114 %115 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %115 %116 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 568) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %116 ; # (loop (let Y (ifn (== (val $InFile) (val (val $InFiles))) (read1 ... br label %$13 $13: %117 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%230, %$44] ; # X ; # (let Y (ifn (== (val $InFile) (val (val $InFiles))) (read1 0) (se... ; # (ifn (== (val $InFile) (val (val $InFiles))) (read1 0) (set $Line... ; # (val $InFile) %118 = load i8*, i8** @$InFile ; # (val $InFiles) %119 = load i8**, i8*** @$InFiles ; # (val (val $InFiles)) %120 = load i8*, i8** %119 ; # (== (val $InFile) (val (val $InFiles))) %121 = icmp eq i8* %118, %120 br i1 %121, label %$15, label %$14 $14: %122 = phi i64 [%117, %$13] ; # X ; # (read1 0) %123 = call i64 @read1(i32 0) br label %$16 $15: %124 = phi i64 [%117, %$13] ; # X ; # (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) %125 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 504) to i64) to i64* %126 = load i64, i64* %125 ; # (runAt (val $Prompt)) %127 = call i64 @runAt(i64 %126) ; # (nil? (runAt (val $Prompt))) %128 = icmp eq i64 %127, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %128, label %$17, label %$18 $18: %129 = phi i64 [%124, %$15] ; # X ; # (symb? @) %130 = xor i64 %127, 8 %131 = and i64 %130, 14 %132 = icmp eq i64 %131, 0 ; # (not (symb? @)) %133 = icmp eq i1 %132, 0 br label %$17 $17: %134 = phi i64 [%124, %$15], [%129, %$18] ; # X %135 = phi i1 [1, %$15], [%133, %$18] ; # -> br i1 %135, label %$19, label %$20 $19: %136 = phi i64 [%134, %$17] ; # X br label %$21 $20: %137 = phi i64 [%134, %$17] ; # X ; # (let (Nm (name (val (tail @))) N (bufSize Nm) P (set $ReplPrmt (a... ; # (tail @) %138 = add i64 %127, -8 ; # (val (tail @)) %139 = inttoptr i64 %138 to i64* %140 = load i64, i64* %139 ; # (name (val (tail @))) br label %$22 $22: %141 = phi i64 [%140, %$20], [%147, %$23] ; # Tail %142 = and i64 %141, 6 %143 = icmp ne i64 %142, 0 br i1 %143, label %$24, label %$23 $23: %144 = phi i64 [%141, %$22] ; # Tail %145 = inttoptr i64 %144 to i64* %146 = getelementptr i64, i64* %145, i32 1 %147 = load i64, i64* %146 br label %$22 $24: %148 = phi i64 [%141, %$22] ; # Tail ; # (bufSize Nm) %149 = call i64 @bufSize(i64 %148) ; # (set $ReplPrmt (alloc (val $ReplPrmt) (+ N (strlen Prmt)))) ; # (val $ReplPrmt) %150 = load i8*, i8** @$ReplPrmt ; # (strlen Prmt) %151 = call i64 @strlen(i8* %1) ; # (+ N (strlen Prmt)) %152 = add i64 %149, %151 ; # (alloc (val $ReplPrmt) (+ N (strlen Prmt))) %153 = call i8* @alloc(i8* %150, i64 %152) store i8* %153, i8** @$ReplPrmt ; # (bufString Nm P) %154 = call i8* @bufString(i64 %148, i8* %153) ; # (dec N) %155 = sub i64 %149, 1 ; # (ofs P (dec N)) %156 = getelementptr i8, i8* %153, i64 %155 ; # (strcpy (ofs P (dec N)) Prmt) %157 = call i8* @strcpy(i8* %156, i8* %1) br label %$21 $21: %158 = phi i64 [%136, %$19], [%137, %$24] ; # X %159 = phi i8* [%1, %$19], [%153, %$24] ; # -> store i8* %159, i8** @$LinePrmt ; # (prog2 (set $ContPrmt ($ " ")) (read1 (if ((inFile (val $InFile... ; # (set $ContPrmt ($ " ")) store i8* bitcast ([4 x i8]* @$45 to i8*), i8** @$ContPrmt ; # (if ((inFile (val $InFile)) tty) (char "^J") (i32 0)) ; # (val $InFile) %160 = load i8*, i8** @$InFile ; # ((inFile (val $InFile)) tty) %161 = getelementptr i8, i8* %160, i32 4128 %162 = bitcast i8* %161 to i1* %163 = load i1, i1* %162 br i1 %163, label %$25, label %$26 $25: %164 = phi i64 [%158, %$21] ; # X br label %$27 $26: %165 = phi i64 [%158, %$21] ; # X ; # (i32 0) br label %$27 $27: %166 = phi i64 [%164, %$25], [%165, %$26] ; # X %167 = phi i32 [10, %$25], [0, %$26] ; # -> ; # (read1 (if ((inFile (val $InFile)) tty) (char "^J") (i32 0))) %168 = call i64 @read1(i32 %167) ; # (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 %$28 $28: %169 = phi i64 [%166, %$27], [%186, %$35] ; # X ; # (val $Chr) %170 = load i32, i32* @$Chr ; # (gt0 (val $Chr)) %171 = icmp sgt i32 %170, 0 br i1 %171, label %$29, label %$30 $29: %172 = phi i64 [%169, %$28] ; # X ; # (? (== (val $Chr) (char "^J")) (set $Chr 0)) ; # (val $Chr) %173 = load i32, i32* @$Chr ; # (== (val $Chr) (char "^J")) %174 = icmp eq i32 %173, 10 br i1 %174, label %$32, label %$31 $32: %175 = phi i64 [%172, %$29] ; # X ; # (set $Chr 0) store i32 0, i32* @$Chr br label %$30 $31: %176 = phi i64 [%172, %$29] ; # X ; # (if (== (val $Chr) (char "#")) (comment) (? (> (val $Chr) (char "... ; # (val $Chr) %177 = load i32, i32* @$Chr ; # (== (val $Chr) (char "#")) %178 = icmp eq i32 %177, 35 br i1 %178, label %$33, label %$34 $33: %179 = phi i64 [%176, %$31] ; # X ; # (comment) call void @comment() br label %$35 $34: %180 = phi i64 [%176, %$31] ; # X ; # (? (> (val $Chr) (char " "))) ; # (val $Chr) %181 = load i32, i32* @$Chr ; # (> (val $Chr) (char " ")) %182 = icmp sgt i32 %181, 32 br i1 %182, label %$30, label %$36 $36: %183 = phi i64 [%180, %$34] ; # X ; # (call $Get) %184 = load i32()*, i32()** @$Get %185 = call i32 %184() br label %$35 $35: %186 = phi i64 [%179, %$33], [%183, %$36] ; # X br label %$28 $30: %187 = phi i64 [%169, %$28], [%175, %$32], [%180, %$34] ; # X br label %$16 $16: %188 = phi i64 [%122, %$14], [%187, %$30] ; # X %189 = phi i64 [%123, %$14], [%168, %$30] ; # -> ; # (? (nil? Y)) ; # (nil? Y) %190 = icmp eq i64 %189, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %190, label %$38, label %$37 $37: %191 = phi i64 [%188, %$16] ; # X ; # (set V Y) %192 = inttoptr i64 %84 to i64* store i64 %189, i64* %192 ; # (if (or (<> (val $InFile) (val (val $InFiles))) (val $Chr) (=0 Pr... ; # (or (<> (val $InFile) (val (val $InFiles))) (val $Chr) (=0 Prmt))... ; # (val $InFile) %193 = load i8*, i8** @$InFile ; # (val $InFiles) %194 = load i8**, i8*** @$InFiles ; # (val (val $InFiles)) %195 = load i8*, i8** %194 ; # (<> (val $InFile) (val (val $InFiles))) %196 = icmp ne i8* %193, %195 br i1 %196, label %$39, label %$40 $40: %197 = phi i64 [%191, %$37] ; # X ; # (val $Chr) %198 = load i32, i32* @$Chr %199 = icmp ne i32 %198, 0 br i1 %199, label %$39, label %$41 $41: %200 = phi i64 [%197, %$40] ; # X ; # (=0 Prmt) %201 = icmp eq i8* %1, null br label %$39 $39: %202 = phi i64 [%191, %$37], [%197, %$40], [%200, %$41] ; # X %203 = phi i1 [1, %$37], [1, %$40], [%201, %$41] ; # -> br i1 %203, label %$42, label %$43 $42: %204 = phi i64 [%202, %$39] ; # X ; # (eval Y) %205 = and i64 %189, 6 %206 = icmp ne i64 %205, 0 br i1 %206, label %$47, label %$46 $47: br label %$45 $46: %207 = and i64 %189, 8 %208 = icmp ne i64 %207, 0 br i1 %208, label %$49, label %$48 $49: %209 = inttoptr i64 %189 to i64* %210 = load i64, i64* %209 br label %$45 $48: %211 = call i64 @evList(i64 %189) br label %$45 $45: %212 = phi i64 [%189, %$47], [%210, %$49], [%211, %$48] ; # -> br label %$44 $43: %213 = phi i64 [%202, %$39] ; # X ; # (flushAll) call void @flushAll() ; # (let A (set At (val $At)) (setq X (eval Y)) (set $At3 (val $At2) ... ; # (set At (val $At)) ; # (val $At) %214 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* %215 = load i64, i64* %214 %216 = inttoptr i64 %92 to i64* store i64 %215, i64* %216 ; # (eval Y) %217 = and i64 %189, 6 %218 = icmp ne i64 %217, 0 br i1 %218, label %$52, label %$51 $52: br label %$50 $51: %219 = and i64 %189, 8 %220 = icmp ne i64 %219, 0 br i1 %220, label %$54, label %$53 $54: %221 = inttoptr i64 %189 to i64* %222 = load i64, i64* %221 br label %$50 $53: %223 = call i64 @evList(i64 %189) br label %$50 $50: %224 = phi i64 [%189, %$52], [%222, %$54], [%223, %$53] ; # -> ; # (set $At3 (val $At2) $At2 A $At X) ; # (val $At2) %225 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 456) to i64) to i64* %226 = load i64, i64* %225 %227 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 472) to i64) to i64* store i64 %226, i64* %227 %228 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 456) to i64) to i64* store i64 %215, i64* %228 %229 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 %224, i64* %229 ; # (outString ($ "-> ")) call void @outString(i8* bitcast ([4 x i8]* @$46 to i8*)) ; # (flushAll) call void @flushAll() ; # (print X) call void @print(i64 %224) ; # (newline) call void @newline() br label %$44 $44: %230 = phi i64 [%212, %$45], [%224, %$50] ; # X br label %$13 $38: %231 = phi i64 [%188, %$16] ; # X %232 = phi i64 [0, %$16] ; # -> ; # (popInFiles) call void @popInFiles() ; # (tosInFile) call void @tosInFile() ; # (when Raw (setRaw)) %233 = icmp ne i8* %99, null br i1 %233, label %$55, label %$56 $55: %234 = phi i64 [%231, %$38] ; # X ; # (setRaw) call void @setRaw() br label %$56 $56: %235 = phi i64 [%231, %$38], [%234, %$55] ; # X ; # (set 2 $Transient Tr2) %236 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* %237 = getelementptr i64, i64* %236, i32 1 store i64 %74, i64* %237 ; # (set $Transient Tr1) %238 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([52 x i64]* @gcData to i8*), i32 0) to i64) to i64* store i64 %63, i64* %238 ; # (set 2 $PrivT Pr2) %239 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 112) to i64) to i64* %240 = getelementptr i64, i64* %239, i32 1 store i64 %53, i64* %240 ; # (set $PrivT Pr1) %241 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 112) to i64) to i64* store i64 %42, i64* %241 ; # (set $Intern Int) %242 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 72) to i64) to i64* store i64 %32, i64* %242 ; # (drop *Safe) %243 = inttoptr i64 %36 to i64* %244 = getelementptr i64, i64* %243, i32 1 %245 = load i64, i64* %244 %246 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %245, i64* %246 br label %$8 $8: %247 = phi i64 [%14, %$6], [%235, %$56] ; # X %248 = phi i64 [%25, %$6], [%235, %$56] ; # -> ret i64 %248 } 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 ([870 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 ([870 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]* @$47 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]* @$48 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]* @$49 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]* @$50 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]* @$51 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]* @$52 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, 42 ; # (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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 42 ; # (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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 424) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 424) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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]* @$53 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]* @$54 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]* @$55 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, 42 ; # (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 ([17 x i64]* @env to i8*), i32 120) to i32*) ; # (inc (val $Protect)) %11 = add i32 %10, 1 store i32 %11, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 120) 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 ([17 x i64]* @env to i8*), i32 120) to i32*) ; # (dec (val $Protect)) %28 = sub i32 %27, 1 store i32 %28, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 120) 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, 42 ; # (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 ([870 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 (eval (cadr Exe)) (if (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] ; # -> ; # (if (and (symb? X) (sym? (val (tail X))) (isLife X)) X $Nil) ; # (and (symb? X) (sym? (val (tail X))) (isLife 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 i1 %21, label %$9, label %$7 $9: ; # (isLife X) %22 = call i1 @isLife(i64 %13) br label %$7 $7: %23 = phi i1 [0, %$2], [0, %$8], [%22, %$9] ; # -> br i1 %23, label %$10, label %$11 $10: br label %$12 $11: br label %$12 $12: %24 = phi i64 [%13, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # -> ret i64 %24 } 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 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 ([870 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]* @$56 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 42 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]* @$57 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 42 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]* @$58 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 42 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) store i32 0, i32* @$DBs ; # (when (val $DbJnl) (fclose @) (set $DbJnl null)) ; # (val $DbJnl) %74 = load i8*, i8** @$DbJnl %75 = icmp ne i8* %74, null br i1 %75, label %$7, label %$8 $7: %76 = phi i64 [%70, %$6] ; # Dbs ; # (fclose @) %77 = call i32 @fclose(i8* %74) ; # (set $DbJnl null) store i8* null, i8** @$DbJnl br label %$8 $8: %78 = phi i64 [%70, %$6], [%76, %$7] ; # Dbs ; # (when (val $DbLog) (fclose @) (set $DbLog null)) ; # (val $DbLog) %79 = load i8*, i8** @$DbLog %80 = icmp ne i8* %79, null br i1 %80, label %$9, label %$10 $9: %81 = phi i64 [%78, %$8] ; # Dbs ; # (fclose @) %82 = call i32 @fclose(i8* %79) ; # (set $DbLog null) store i8* null, i8** @$DbLog br label %$10 $10: %83 = phi i64 [%78, %$8], [%81, %$9] ; # Dbs br label %$3 $3: %84 = phi i64 [%16, %$1], [%83, %$10] ; # Dbs ; # (unless (nil? Sym1) (let (Nm (xName Exe Sym1) Len (pathSize Nm) B... ; # (nil? Sym1) %85 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %85, label %$12, label %$11 $11: %86 = phi i64 [%84, %$3] ; # Dbs ; # (let (Nm (xName Exe Sym1) Len (pathSize Nm) Buf (pathString Nm (b... ; # (xName Exe Sym1) %87 = call i64 @xName(i64 %0, i64 %4) ; # (pathSize Nm) %88 = call i64 @pathSize(i64 %87) ; # (+ Len 4) %89 = add i64 %88, 4 ; # (b8 (+ Len 4)) %90 = alloca i8, i64 %89 ; # (pathString Nm (b8 (+ Len 4))) %91 = call i8* @pathString(i64 %87, i8* %90) ; # (dec Len) %92 = sub i64 %88, 1 ; # (ofs Buf (dec Len)) %93 = getelementptr i8, i8* %91, i64 %92 ; # (when (pair Dbs) (let L Dbs (while (pair (shift L)) (inc 'Siz (db... ; # (pair Dbs) %94 = and i64 %86, 15 %95 = icmp eq i64 %94, 0 br i1 %95, label %$13, label %$14 $13: %96 = phi i64 [%86, %$11] ; # Dbs %97 = phi i64 [42, %$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: %98 = phi i64 [%96, %$13], [%106, %$16] ; # Dbs %99 = phi i64 [%97, %$13], [%109, %$16] ; # Siz %100 = phi i64 [%96, %$13], [%108, %$16] ; # L ; # (shift L) %101 = inttoptr i64 %100 to i64* %102 = getelementptr i64, i64* %101, i32 1 %103 = load i64, i64* %102 ; # (pair (shift L)) %104 = and i64 %103, 15 %105 = icmp eq i64 %104, 0 br i1 %105, label %$16, label %$17 $16: %106 = phi i64 [%98, %$15] ; # Dbs %107 = phi i64 [%99, %$15] ; # Siz %108 = phi i64 [%103, %$15] ; # L ; # (inc 'Siz (dbFile T)) %109 = add i64 %107, 42 br label %$15 $17: %110 = phi i64 [%98, %$15] ; # Dbs %111 = phi i64 [%99, %$15] ; # Siz %112 = phi i64 [%103, %$15] ; # L br label %$14 $14: %113 = phi i64 [%86, %$11], [%110, %$17] ; # Dbs %114 = phi i64 [42, %$11], [%111, %$17] ; # Siz ; # (let (Db (set $DbFiles (alloc (val $DbFiles) Siz)) P (b8 (+ BLK B... ; # (set $DbFiles (alloc (val $DbFiles) Siz)) ; # (val $DbFiles) %115 = load i8*, i8** @$DbFiles ; # (alloc (val $DbFiles) Siz) %116 = call i8* @alloc(i8* %115, i64 %114) store i8* %116, i8** @$DbFiles ; # (+ BLK BLK 1) ; # (b8 (+ BLK BLK 1)) %117 = 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: %118 = phi i64 [%113, %$14], [%284, %$36] ; # Dbs %119 = phi i64 [%114, %$14], [%285, %$36] ; # Siz %120 = phi i8* [%116, %$14], [%289, %$36] ; # Db %121 = phi i32 [0, %$14], [%287, %$36] ; # Fnr %122 = phi i32 [0, %$14], [%288, %$36] ; # Max ; # (let Db: (dbFile (set $DbFile Db)) (Db: db Fnr) (if (atom Dbs) (D... ; # (set $DbFile Db) store i8* %120, i8** @$DbFile ; # (Db: db Fnr) %123 = getelementptr i8, i8* %120, i32 4 %124 = bitcast i8* %123 to i32* store i32 %121, i32* %124 ; # (if (atom Dbs) (Db: sh 2) (set (bufAo End Fnr) 0) (Db: sh (i32 (i... ; # (atom Dbs) %125 = and i64 %118, 15 %126 = icmp ne i64 %125, 0 br i1 %126, label %$19, label %$20 $19: %127 = phi i64 [%118, %$18] ; # Dbs %128 = phi i64 [%119, %$18] ; # Siz %129 = phi i8* [%120, %$18] ; # Db %130 = phi i32 [%121, %$18] ; # Fnr %131 = phi i32 [%122, %$18] ; # Max ; # (Db: sh 2) %132 = getelementptr i8, i8* %120, i32 8 %133 = bitcast i8* %132 to i32* store i32 2, i32* %133 br label %$21 $20: %134 = phi i64 [%118, %$18] ; # Dbs %135 = phi i64 [%119, %$18] ; # Siz %136 = phi i8* [%120, %$18] ; # Db %137 = phi i32 [%121, %$18] ; # Fnr %138 = phi i32 [%122, %$18] ; # Max ; # (set (bufAo End Fnr) 0) ; # (bufAo End Fnr) %139 = call i8* @bufAo(i8* %93, i32 %137) store i8 0, i8* %139 ; # (Db: sh (i32 (int (++ Dbs)))) %140 = getelementptr i8, i8* %120, i32 8 %141 = bitcast i8* %140 to i32* %142 = inttoptr i64 %134 to i64* %143 = load i64, i64* %142 %144 = getelementptr i64, i64* %142, i32 1 %145 = load i64, i64* %144 %146 = lshr i64 %143, 4 %147 = trunc i64 %146 to i32 store i32 %147, i32* %141 br label %$21 $21: %148 = phi i64 [%127, %$19], [%145, %$20] ; # Dbs %149 = phi i64 [%128, %$19], [%135, %$20] ; # Siz %150 = phi i8* [%129, %$19], [%136, %$20] ; # Db %151 = phi i32 [%130, %$19], [%137, %$20] ; # Fnr %152 = phi i32 [%131, %$19], [%138, %$20] ; # Max %153 = phi i32 [2, %$19], [%147, %$20] ; # -> ; # (cond ((ge0 (Db: fd (openRdWr Buf))) (blkPeek 0 P (+ BLK BLK 1)) ... ; # (Db: fd (openRdWr Buf)) %154 = bitcast i8* %120 to i32* %155 = call i32 @openRdWr(i8* %91) store i32 %155, i32* %154 ; # (ge0 (Db: fd (openRdWr Buf))) %156 = icmp sge i32 %155, 0 br i1 %156, label %$24, label %$23 $24: %157 = phi i64 [%148, %$21] ; # Dbs %158 = phi i64 [%149, %$21] ; # Siz %159 = phi i8* [%150, %$21] ; # Db %160 = phi i32 [%151, %$21] ; # Fnr %161 = phi i32 [%152, %$21] ; # Max ; # (+ BLK BLK 1) ; # (blkPeek 0 P (+ BLK BLK 1)) call void @blkPeek(i64 0, i8* %117, i32 13) ; # (Db: siz (shl (i32 BLKSIZE) (Db: sh (i32 (val (+ BLK BLK 1) P))))... %162 = getelementptr i8, i8* %120, i32 12 %163 = bitcast i8* %162 to i32* %164 = getelementptr i8, i8* %120, i32 8 %165 = bitcast i8* %164 to i32* %166 = getelementptr i8, i8* %117, i32 12 %167 = load i8, i8* %166 %168 = zext i8 %167 to i32 store i32 %168, i32* %165 %169 = shl i32 64, %168 store i32 %169, i32* %163 br label %$22 $23: %170 = phi i64 [%148, %$21] ; # Dbs %171 = phi i64 [%149, %$21] ; # Siz %172 = phi i8* [%150, %$21] ; # Db %173 = phi i32 [%151, %$21] ; # Fnr %174 = phi i32 [%152, %$21] ; # Max ; # (and (== (gErrno) ENOENT) (ge0 (Db: fd (openRdWrExcl Buf)))) ; # (gErrno) %175 = call i32 @gErrno() ; # (== (gErrno) ENOENT) %176 = icmp eq i32 %175, 1 br i1 %176, label %$26, label %$25 $26: %177 = phi i64 [%170, %$23] ; # Dbs %178 = phi i64 [%171, %$23] ; # Siz %179 = phi i8* [%172, %$23] ; # Db %180 = phi i32 [%173, %$23] ; # Fnr %181 = phi i32 [%174, %$23] ; # Max ; # (Db: fd (openRdWrExcl Buf)) %182 = bitcast i8* %120 to i32* %183 = call i32 @openRdWrExcl(i8* %91) store i32 %183, i32* %182 ; # (ge0 (Db: fd (openRdWrExcl Buf))) %184 = icmp sge i32 %183, 0 br label %$25 $25: %185 = phi i64 [%170, %$23], [%177, %$26] ; # Dbs %186 = phi i64 [%171, %$23], [%178, %$26] ; # Siz %187 = phi i8* [%172, %$23], [%179, %$26] ; # Db %188 = phi i32 [%173, %$23], [%180, %$26] ; # Fnr %189 = phi i32 [%174, %$23], [%181, %$26] ; # Max %190 = phi i1 [0, %$23], [%184, %$26] ; # -> br i1 %190, label %$28, label %$27 $28: %191 = phi i64 [%185, %$25] ; # Dbs %192 = phi i64 [%186, %$25] ; # Siz %193 = phi i8* [%187, %$25] ; # Db %194 = phi i32 [%188, %$25] ; # Fnr %195 = phi i32 [%189, %$25] ; # Max ; # (let (N (shl (i32 BLKSIZE) (Db: sh)) Stk (stack) Blk (b8 (Db: siz... ; # (i32 BLKSIZE) ; # (Db: sh) %196 = getelementptr i8, i8* %120, i32 8 %197 = bitcast i8* %196 to i32* %198 = load i32, i32* %197 ; # (shl (i32 BLKSIZE) (Db: sh)) %199 = shl i32 64, %198 ; # (stack) %200 = call i8* @llvm.stacksave() ; # (Db: siz N) %201 = getelementptr i8, i8* %120, i32 12 %202 = bitcast i8* %201 to i32* store i32 %199, i32* %202 ; # (b8 (Db: siz N)) %203 = alloca i8, i32 %199 ; # (i64 N) %204 = sext i32 %199 to i64 ; # (memset Blk 0 (i64 N) T) call void @llvm.memset.p0i8.i64(i8* align 8 %203, i8 0, i64 %204, i1 0) ; # (if (== (Db:) (val $DbFiles)) (* 2 BLKSIZE) BLKSIZE) ; # (Db:) ; # (val $DbFiles) %205 = load i8*, i8** @$DbFiles ; # (== (Db:) (val $DbFiles)) %206 = icmp eq i8* %120, %205 br i1 %206, label %$29, label %$30 $29: %207 = phi i64 [%191, %$28] ; # Dbs %208 = phi i64 [%192, %$28] ; # Siz %209 = phi i8* [%193, %$28] ; # Db %210 = phi i32 [%194, %$28] ; # Fnr %211 = phi i32 [%195, %$28] ; # Max ; # (* 2 BLKSIZE) br label %$31 $30: %212 = phi i64 [%191, %$28] ; # Dbs %213 = phi i64 [%192, %$28] ; # Siz %214 = phi i8* [%193, %$28] ; # Db %215 = phi i32 [%194, %$28] ; # Fnr %216 = phi i32 [%195, %$28] ; # Max br label %$31 $31: %217 = phi i64 [%207, %$29], [%212, %$30] ; # Dbs %218 = phi i64 [%208, %$29], [%213, %$30] ; # Siz %219 = phi i8* [%209, %$29], [%214, %$30] ; # Db %220 = phi i32 [%210, %$29], [%215, %$30] ; # Fnr %221 = phi i32 [%211, %$29], [%216, %$30] ; # Max %222 = phi i64 [128, %$29], [64, %$30] ; # -> ; # (ofs Blk BLK) %223 = getelementptr i8, i8* %203, i32 6 ; # (setAdr (if (== (Db:) (val $DbFiles)) (* 2 BLKSIZE) BLKSIZE) (ofs... call void @setAdr(i64 %222, i8* %223) ; # (set (inc (* 2 BLK)) Blk (i8 (Db: sh))) ; # (* 2 BLK) ; # (inc (* 2 BLK)) ; # (Db: sh) %224 = getelementptr i8, i8* %120, i32 8 %225 = bitcast i8* %224 to i32* %226 = load i32, i32* %225 ; # (i8 (Db: sh)) %227 = trunc i32 %226 to i8 %228 = getelementptr i8, i8* %203, i32 12 store i8 %227, i8* %228 ; # (blkPoke 0 Blk N) call void @blkPoke(i64 0, i8* %203, i32 %199) ; # (when (== (Db:) (val $DbFiles)) (memset Blk 0 16 T) (setAdr 1 Blk... ; # (Db:) ; # (val $DbFiles) %229 = load i8*, i8** @$DbFiles ; # (== (Db:) (val $DbFiles)) %230 = icmp eq i8* %120, %229 br i1 %230, label %$32, label %$33 $32: %231 = phi i64 [%217, %$31] ; # Dbs %232 = phi i64 [%218, %$31] ; # Siz %233 = phi i8* [%219, %$31] ; # Db %234 = phi i32 [%220, %$31] ; # Fnr %235 = phi i32 [%221, %$31] ; # Max ; # (memset Blk 0 16 T) call void @llvm.memset.p0i8.i64(i8* align 8 %203, i8 0, i64 16, i1 0) ; # (setAdr 1 Blk) call void @setAdr(i64 1, i8* %203) ; # (Db: siz) %236 = getelementptr i8, i8* %120, i32 12 %237 = bitcast i8* %236 to i32* %238 = load i32, i32* %237 ; # (i64 (Db: siz)) %239 = sext i32 %238 to i64 ; # (blkPoke (i64 (Db: siz)) Blk N) call void @blkPoke(i64 %239, i8* %203, i32 %199) br label %$33 $33: %240 = phi i64 [%217, %$31], [%231, %$32] ; # Dbs %241 = phi i64 [%218, %$31], [%232, %$32] ; # Siz %242 = phi i8* [%219, %$31], [%233, %$32] ; # Db %243 = phi i32 [%220, %$31], [%234, %$32] ; # Fnr %244 = phi i32 [%221, %$31], [%235, %$32] ; # Max ; # (stack Stk) call void @llvm.stackrestore(i8* %200) br label %$22 $27: %245 = phi i64 [%185, %$25] ; # Dbs %246 = phi i64 [%186, %$25] ; # Siz %247 = phi i8* [%187, %$25] ; # Db %248 = phi i32 [%188, %$25] ; # Fnr %249 = phi i32 [%189, %$25] ; # Max ; # (openErr Exe Sym1) call void @openErr(i64 %0, i64 %4) unreachable $22: %250 = phi i64 [%157, %$24], [%240, %$33] ; # Dbs %251 = phi i64 [%158, %$24], [%241, %$33] ; # Siz %252 = phi i8* [%159, %$24], [%242, %$33] ; # Db %253 = phi i32 [%160, %$24], [%243, %$33] ; # Fnr %254 = phi i32 [%161, %$24], [%244, %$33] ; # Max ; # (Db: fd) %255 = bitcast i8* %120 to i32* %256 = load i32, i32* %255 ; # (closeOnExec Exe (Db: fd)) call void @closeOnExec(i64 %0, i32 %256) ; # (when (> (Db: siz) Max) (setq Max @)) ; # (Db: siz) %257 = getelementptr i8, i8* %120, i32 12 %258 = bitcast i8* %257 to i32* %259 = load i32, i32* %258 ; # (> (Db: siz) Max) %260 = icmp sgt i32 %259, %254 br i1 %260, label %$34, label %$35 $34: %261 = phi i64 [%250, %$22] ; # Dbs %262 = phi i64 [%251, %$22] ; # Siz %263 = phi i8* [%252, %$22] ; # Db %264 = phi i32 [%253, %$22] ; # Fnr %265 = phi i32 [%254, %$22] ; # Max br label %$35 $35: %266 = phi i64 [%250, %$22], [%261, %$34] ; # Dbs %267 = phi i64 [%251, %$22], [%262, %$34] ; # Siz %268 = phi i8* [%252, %$22], [%263, %$34] ; # Db %269 = phi i32 [%253, %$22], [%264, %$34] ; # Fnr %270 = phi i32 [%254, %$22], [%259, %$34] ; # Max ; # (Db: mark null) %271 = getelementptr i8, i8* %120, i32 16 %272 = bitcast i8* %271 to i8** store i8* null, i8** %272 ; # (Db: mrks 0) %273 = getelementptr i8, i8* %120, i32 24 %274 = bitcast i8* %273 to i64* store i64 0, i64* %274 ; # (Db: flu -1) %275 = getelementptr i8, i8* %120, i32 32 %276 = bitcast i8* %275 to i64* store i64 -1, i64* %276 ; # (Db: lck (Db: drt NO)) %277 = getelementptr i8, i8* %120, i32 40 %278 = bitcast i8* %277 to i1* %279 = getelementptr i8, i8* %120, i32 41 %280 = bitcast i8* %279 to i1* store i1 0, i1* %280 store i1 0, i1* %278 ; # (inc 'Fnr) %281 = add i32 %269, 1 ; # (? (atom Dbs)) ; # (atom Dbs) %282 = and i64 %266, 15 %283 = icmp ne i64 %282, 0 br i1 %283, label %$37, label %$36 $36: %284 = phi i64 [%266, %$35] ; # Dbs %285 = phi i64 [%267, %$35] ; # Siz %286 = phi i8* [%268, %$35] ; # Db %287 = phi i32 [%281, %$35] ; # Fnr %288 = phi i32 [%270, %$35] ; # Max ; # (ofs Db (dbFile T)) %289 = getelementptr i8, i8* %286, i32 42 br label %$18 $37: %290 = phi i64 [%266, %$35] ; # Dbs %291 = phi i64 [%267, %$35] ; # Siz %292 = phi i8* [%268, %$35] ; # Db %293 = phi i32 [%281, %$35] ; # Fnr %294 = phi i32 [%270, %$35] ; # Max %295 = phi i64 [0, %$35] ; # -> ; # (set $DBs Fnr $MaxBlkSize Max $DbBlock (alloc (val $DbBlock) (i64... store i32 %293, i32* @$DBs store i32 %294, i32* @$MaxBlkSize ; # (val $DbBlock) %296 = load i8*, i8** @$DbBlock ; # (i64 Max) %297 = sext i32 %294 to i64 ; # (alloc (val $DbBlock) (i64 Max)) %298 = call i8* @alloc(i8* %296, i64 %297) store i8* %298, i8** @$DbBlock ; # (unless (nil? Sym2) (let Nm (xName Exe Sym2) (unless (fopen (path... ; # (nil? Sym2) %299 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %299, label %$39, label %$38 $38: %300 = phi i64 [%290, %$37] ; # Dbs ; # (let Nm (xName Exe Sym2) (unless (fopen (pathString Nm (b8 (pathS... ; # (xName Exe Sym2) %301 = call i64 @xName(i64 %0, i64 %28) ; # (unless (fopen (pathString Nm (b8 (pathSize Nm))) ($ "a")) (openE... ; # (pathSize Nm) %302 = call i64 @pathSize(i64 %301) ; # (b8 (pathSize Nm)) %303 = alloca i8, i64 %302 ; # (pathString Nm (b8 (pathSize Nm))) %304 = call i8* @pathString(i64 %301, i8* %303) ; # (fopen (pathString Nm (b8 (pathSize Nm))) ($ "a")) %305 = call i8* @fopen(i8* %304, i8* bitcast ([2 x i8]* @$59 to i8*)) %306 = icmp ne i8* %305, null br i1 %306, label %$41, label %$40 $40: %307 = phi i64 [%300, %$38] ; # Dbs ; # (openErr Exe Sym2) call void @openErr(i64 %0, i64 %28) unreachable $41: %308 = phi i64 [%300, %$38] ; # Dbs ; # (set $DbJnl @) store i8* %305, i8** @$DbJnl ; # (fileno @) %309 = call i32 @fileno(i8* %305) ; # (closeOnExec Exe (fileno @)) call void @closeOnExec(i64 %0, i32 %309) br label %$39 $39: %310 = phi i64 [%290, %$37], [%308, %$41] ; # Dbs ; # (unless (nil? Sym3) (let Nm (xName Exe Sym3) (unless (fopen (path... ; # (nil? Sym3) %311 = icmp eq i64 %40, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %311, label %$43, label %$42 $42: %312 = phi i64 [%310, %$39] ; # Dbs ; # (let Nm (xName Exe Sym3) (unless (fopen (pathString Nm (b8 (pathS... ; # (xName Exe Sym3) %313 = call i64 @xName(i64 %0, i64 %40) ; # (unless (fopen (pathString Nm (b8 (pathSize Nm))) ($ "a+")) (open... ; # (pathSize Nm) %314 = call i64 @pathSize(i64 %313) ; # (b8 (pathSize Nm)) %315 = alloca i8, i64 %314 ; # (pathString Nm (b8 (pathSize Nm))) %316 = call i8* @pathString(i64 %313, i8* %315) ; # (fopen (pathString Nm (b8 (pathSize Nm))) ($ "a+")) %317 = call i8* @fopen(i8* %316, i8* bitcast ([3 x i8]* @$60 to i8*)) %318 = icmp ne i8* %317, null br i1 %318, label %$45, label %$44 $44: %319 = phi i64 [%312, %$42] ; # Dbs ; # (openErr Exe Sym3) call void @openErr(i64 %0, i64 %40) unreachable $45: %320 = phi i64 [%312, %$42] ; # Dbs ; # (set $DbLog @) store i8* %317, i8** @$DbLog ; # (fileno @) %321 = call i32 @fileno(i8* %317) ; # (closeOnExec Exe (fileno @)) call void @closeOnExec(i64 %0, i32 %321) ; # (when (transaction) (restore Exe)) ; # (transaction) %322 = call i1 @transaction() br i1 %322, label %$46, label %$47 $46: %323 = phi i64 [%320, %$45] ; # Dbs ; # (restore Exe) call void @restore(i64 %0) br label %$47 $47: %324 = phi i64 [%320, %$45], [%323, %$46] ; # Dbs ; # (truncLog Exe) call void @truncLog(i64 %0) br label %$43 $43: %325 = phi i64 [%310, %$39], [%324, %$47] ; # Dbs br label %$12 $12: %326 = phi i64 [%84, %$3], [%325, %$43] ; # Dbs ; # (drop *Safe) %327 = inttoptr i64 %8 to i64* %328 = getelementptr i64, i64* %327, i32 1 %329 = load i64, i64* %328 %330 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %329, i64* %330 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 Exe Sym) Jnl (val $DbJn... ; # (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 Exe Sym) %5 = call i64 @xName(i64 %0, 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 42 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 42 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 ([870 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 Exe Sym) Fp (fopen (pathString Nm (b8 (path... br label %$6 $6: %22 = phi i64 [%20, %$5], [%111, %$25] ; # X %23 = phi i64 [%21, %$5], [%113, %$25] ; # Sym ; # (let (Nm (xName Exe Sym) Fp (fopen (pathString Nm (b8 (pathSize N... ; # (xName Exe Sym) %24 = call i64 @xName(i64 %0, 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]* @$61 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 ([870 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 ([870 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 ([870 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 (evC... ; # (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 42 ; # (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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save L) %73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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, 42 ; # (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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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, 42 ; # (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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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, 42 ; # (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]* @$62 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 120) to i32*) ; # (inc (val $Protect)) %25 = add i32 %24, 1 store i32 %25, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 120) 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 42 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, 42 ; # (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 42 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]* @$63 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 ([870 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, 42 ; # (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 0... ; # (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 0) call void @tellEnd(i32 0) ; # (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, 42 ; # (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 ([870 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 ([870 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 ([870 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 0... ; # (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 0) call void @tellEnd(i32 0) ; # (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 0) (set $TellBuf (val $BufX) $Ptr (val... br label %$-2 $-2: %768 = phi i64 [%725, %$106], [%763, %$111] ; # Args %769 = phi i1 [%726, %$106], [%764, %$111] ; # Notify ; # (when Notify (tellEnd 0) (set $TellBuf (val $BufX) $Ptr (val $Ptr... br i1 %769, label %$112, label %$113 $112: %770 = phi i64 [%768, %$-2] ; # Args %771 = phi i1 [%769, %$-2] ; # Notify ; # (tellEnd 0) call void @tellEnd(i32 0) ; # (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 Ex... ; # (val $Zap) %793 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 Exe (cdr Z)) S (pathString... ; # (val $OutFile) %799 = load i8*, i8** @$OutFile ; # (cdr Z) %800 = inttoptr i64 %794 to i64* %801 = getelementptr i64, i64* %800, i32 1 %802 = load i64, i64* %801 ; # (xName Exe (cdr Z)) %803 = call i64 @xName(i64 %0, 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 ; # (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** @$OutFile ; # (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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %843 ; # (set $OutFile Out) store i8* %799, i8** @$OutFile 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 ([17 x i64]* @env to i8*), i32 120) to i32*) ; # (dec (val $Protect)) %853 = sub i32 %852, 1 store i32 %853, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 120) 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 42 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %876, i64* %877 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 42 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, 42 ; # (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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$34], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$36] ; # -> br label %$22 $22: %127 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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, 42 ; # (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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %20 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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, 42 ; # (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 ([17 x i64]* @env to i8*), i32 120) to i32*) ; # (inc (val $Protect)) %61 = add i32 %60, 1 store i32 %61, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 120) 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]* @$64 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]* @$65 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]* @$66 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 ([870 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 ([17 x i64]* @env to i8*), i32 120) to i32*) ; # (dec (val $Protect)) %265 = sub i32 %264, 1 store i32 %265, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 120) 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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) (setq P (set 2 P (push NIL $Nil ZERO (++ L) NIL))... br label %$20 $20: %90 = phi i64 [%87, %$14], [%95, %$21] ; # X %91 = phi i64 [%88, %$14], [%101, %$21] ; # L %92 = phi i64 [%89, %$14], [%103, %$21] ; # 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 ; # (set 2 P (push NIL $Nil ZERO (++ L) NIL)) ; # (++ L) %98 = inttoptr i64 %96 to i64* %99 = load i64, i64* %98 %100 = getelementptr i64, i64* %98, i32 1 %101 = load i64, i64* %100 ; # (push NIL $Nil ZERO (++ L) NIL) %102 = alloca i64, i64 5, align 16 %103 = ptrtoint i64* %102 to i64 %104 = add i64 %103, 8 %105 = inttoptr i64 %104 to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %105 %106 = add i64 %103, 16 %107 = inttoptr i64 %106 to i64* store i64 2, i64* %107 %108 = add i64 %103, 24 %109 = inttoptr i64 %108 to i64* store i64 %99, i64* %109 %110 = inttoptr i64 %97 to i64* %111 = getelementptr i64, i64* %110, i32 1 store i64 %103, i64* %111 ; # (set P (link (ofs P 3))) ; # (ofs P 3) %112 = add i64 %103, 24 ; # (link (ofs P 3)) %113 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %114 = load i64, i64* %113 %115 = inttoptr i64 %112 to i64* %116 = getelementptr i64, i64* %115, i32 1 store i64 %114, i64* %116 %117 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %112, i64* %117 %118 = inttoptr i64 %103 to i64* store i64 %112, i64* %118 br label %$20 $22: %119 = phi i64 [%90, %$20] ; # X %120 = phi i64 [%91, %$20] ; # L %121 = phi i64 [%92, %$20] ; # P ; # (evList E) %122 = call i64 @evList(i64 %17) ; # (drop *Safe) %123 = inttoptr i64 %24 to i64* %124 = getelementptr i64, i64* %123, i32 1 %125 = load i64, i64* %124 %126 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %125, i64* %126 ret i64 %122 } 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 80) 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 ([870 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %106, i64* %107 ret i64 %103 } 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R %43 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R %43 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ; # (++ 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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %62, i64* %66 ; # (ofs P 3) %67 = add i64 %13, 24 ; # (car X) %68 = inttoptr i64 %50 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 %$14, label %$13 $14: br label %$12 $13: %72 = and i64 %69, 8 %73 = icmp ne i64 %72, 0 br i1 %73, label %$16, label %$15 $16: %74 = inttoptr i64 %69 to i64* %75 = load i64, i64* %74 br label %$12 $15: %76 = call i64 @evList(i64 %69) br label %$12 $12: %77 = phi i64 [%69, %$14], [%75, %$16], [%76, %$15] ; # -> ; # (fish E (save (eval (++ X))) (ofs P 3) R (eval (car X))) call void @fish(i64 %31, i64 %58, i64 %67, i64 %5, i64 %77) ; # (val R) %78 = inttoptr i64 %5 to i64* %79 = load i64, i64* %78 ; # (drop *Safe) %80 = inttoptr i64 %5 to i64* %81 = getelementptr i64, i64* %80, i32 1 %82 = load i64, i64* %81 %83 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %82, i64* %83 ret i64 %79 } 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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** @$OutFile ; # (i8** $Put) %3 = bitcast void(i8)** @$Put 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** @$OutFile ; # (fun (void i8) _putStdout) store void(i8)* @_putStdout, void(i8)** @$Put ; # (outString ($ "# ")) call void @outString(i8* bitcast ([3 x i8]* @$67 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]* @$68 to i8*)) ; # (set (i8** $Put) Put $OutFile Out) ; # (i8** $Put) %9 = bitcast void(i8)** @$Put to i8** store i8* %4, i8** %9 store i8* %2, i8** @$OutFile 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 ([870 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 ([870 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** @$InFile ; # (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 ([870 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 ([17 x i64]* @env to i8*), i32 72) 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 (sym? (val (tai... ; # (pair X) %47 = and i64 %30, 15 %48 = icmp eq i64 %47, 0 br i1 %48, label %$14, label %$15 $14: ; # (let Val (save (eval (car X))) (when (sym? (val (tail Sym))) (if ... ; # (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 %$19, label %$18 $19: br label %$17 $18: %53 = and i64 %50, 8 %54 = icmp ne i64 %53, 0 br i1 %54, label %$21, label %$20 $21: %55 = inttoptr i64 %50 to i64* %56 = load i64, i64* %55 br label %$17 $20: %57 = call i64 @evList(i64 %50) br label %$17 $17: %58 = phi i64 [%50, %$19], [%56, %$21], [%57, %$20] ; # -> ; # (save (eval (car X))) %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %62, i64* %66 ; # (when (sym? (val (tail Sym))) (if (nil? Y) (dbFetch Exe Sym) (dbT... ; # (tail Sym) %67 = add i64 %15, -8 ; # (val (tail Sym)) %68 = inttoptr i64 %67 to i64* %69 = load i64, i64* %68 ; # (sym? (val (tail Sym))) %70 = and i64 %69, 8 %71 = icmp ne i64 %70, 0 br i1 %71, label %$22, label %$23 $22: ; # (if (nil? Y) (dbFetch Exe Sym) (dbTouch Exe Sym)) ; # (nil? Y) %72 = icmp eq i64 %38, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %72, label %$24, label %$25 $24: ; # (dbFetch Exe Sym) call void @dbFetch(i64 %0, i64 %15) br label %$26 $25: ; # (dbTouch Exe Sym) call void @dbTouch(i64 %0, i64 %15) br label %$26 $26: br label %$23 $23: ; # (let V (get Sym Y) (unless (or (nil? V) (equal V Val)) (redefMsg ... ; # (get Sym Y) %73 = call i64 @get(i64 %15, i64 %38) ; # (unless (or (nil? V) (equal V Val)) (redefMsg Sym Y)) ; # (or (nil? V) (equal V Val)) ; # (nil? V) %74 = icmp eq i64 %73, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %74, label %$27, label %$28 $28: ; # (equal V Val) %75 = call i1 @equal(i64 %73, i64 %58) br label %$27 $27: %76 = phi i1 [1, %$23], [%75, %$28] ; # -> br i1 %76, label %$30, label %$29 $29: ; # (redefMsg Sym Y) call void @redefMsg(i64 %15, i64 %38) br label %$30 $30: ; # (put Sym Y Val) call void @put(i64 %15, i64 %38, i64 %58) ; # (putSrc Sym Y) call void @putSrc(i64 %15, i64 %38) br label %$16 $15: ; # (chkVar Exe Sym) %77 = icmp uge i64 %15, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %77, label %$32, label %$31 $32: %78 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %15 br label %$31 $31: %79 = phi i1 [0, %$15], [%78, %$32] ; # -> br i1 %79, label %$33, label %$34 $33: call void @protErr(i64 %0, i64 %15) unreachable $34: ; # (when (sym? (val (tail Sym))) (dbTouch Exe Sym)) ; # (tail Sym) %80 = add i64 %15, -8 ; # (val (tail Sym)) %81 = inttoptr i64 %80 to i64* %82 = load i64, i64* %81 ; # (sym? (val (tail Sym))) %83 = and i64 %82, 8 %84 = icmp ne i64 %83, 0 br i1 %84, label %$35, label %$36 $35: ; # (dbTouch Exe Sym) call void @dbTouch(i64 %0, i64 %15) br label %$36 $36: ; # (let V (val Sym) (unless (or (nil? V) (== V Sym) (equal V Y)) (re... ; # (val Sym) %85 = inttoptr i64 %15 to i64* %86 = load i64, i64* %85 ; # (unless (or (nil? V) (== V Sym) (equal V Y)) (redefMsg Sym 0)) ; # (or (nil? V) (== V Sym) (equal V Y)) ; # (nil? V) %87 = icmp eq i64 %86, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %87, label %$37, label %$38 $38: ; # (== V Sym) %88 = icmp eq i64 %86, %15 br i1 %88, label %$37, label %$39 $39: ; # (equal V Y) %89 = call i1 @equal(i64 %86, i64 %38) br label %$37 $37: %90 = phi i1 [1, %$36], [1, %$38], [%89, %$39] ; # -> br i1 %90, label %$41, label %$40 $40: ; # (redefMsg Sym 0) call void @redefMsg(i64 %15, i64 0) br label %$41 $41: ; # (set Sym Y) %91 = inttoptr i64 %15 to i64* store i64 %38, i64* %91 ; # (putSrc Sym 0) call void @putSrc(i64 %15, i64 0) br label %$16 $16: ; # (drop *Safe) %92 = inttoptr i64 %22 to i64* %93 = getelementptr i64, i64* %92, i32 1 %94 = load i64, i64* %93 %95 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %94, i64* %95 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 ([870 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) @) (car Z))) ; # (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 ([870 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 ([870 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 ; # (get (if (nil? (cdr Z)) (val $Class) @) (car Z)) %52 = call i64 @get(i64 %49, i64 %51) br label %$5 $5: %53 = phi i64 [%22, %$7], [%33, %$9], [%47, %$12] ; # X %54 = phi i64 [%23, %$7], [%34, %$9], [%48, %$12] ; # Fun %55 = phi i64 [%25, %$7], [%30, %$9], [%52, %$12] ; # -> ; # (unless (t? Msg) (redefine Exe Msg (val $Meth))) ; # (t? Msg) %56 = icmp eq i64 %19, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br i1 %56, label %$14, label %$13 $13: %57 = phi i64 [%53, %$5] ; # X %58 = phi i64 [%54, %$5] ; # Fun ; # (val $Meth) %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 248) to i64) to i64* %60 = load i64, i64* %59 ; # (redefine Exe Msg (val $Meth)) call void @redefine(i64 %0, i64 %19, i64 %60) br label %$14 $14: %61 = phi i64 [%53, %$5], [%57, %$13] ; # X %62 = phi i64 [%54, %$5], [%58, %$13] ; # Fun ; # (when (symb? Fun) (let L (val Fun) (loop (when (or (atom L) (atom... ; # (symb? Fun) %63 = xor i64 %62, 8 %64 = and i64 %63, 14 %65 = icmp eq i64 %64, 0 br i1 %65, label %$15, label %$16 $15: %66 = phi i64 [%61, %$14] ; # X %67 = phi i64 [%62, %$14] ; # Fun ; # (let L (val Fun) (loop (when (or (atom L) (atom (car L))) (err Ex... ; # (val Fun) %68 = inttoptr i64 %67 to i64* %69 = load i64, i64* %68 ; # (loop (when (or (atom L) (atom (car L))) (err Exe Msg ($ "Bad mes... br label %$17 $17: %70 = phi i64 [%66, %$15], [%105, %$22] ; # X %71 = phi i64 [%67, %$15], [%106, %$22] ; # Fun %72 = phi i64 [%69, %$15], [%110, %$22] ; # L ; # (when (or (atom L) (atom (car L))) (err Exe Msg ($ "Bad message")... ; # (or (atom L) (atom (car L))) ; # (atom L) %73 = and i64 %72, 15 %74 = icmp ne i64 %73, 0 br i1 %74, label %$18, label %$19 $19: %75 = phi i64 [%70, %$17] ; # X %76 = phi i64 [%71, %$17] ; # Fun %77 = phi i64 [%72, %$17] ; # 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 label %$18 $18: %82 = phi i64 [%70, %$17], [%75, %$19] ; # X %83 = phi i64 [%71, %$17], [%76, %$19] ; # Fun %84 = phi i64 [%72, %$17], [%77, %$19] ; # L %85 = phi i1 [1, %$17], [%81, %$19] ; # -> br i1 %85, label %$20, label %$21 $20: %86 = phi i64 [%82, %$18] ; # X %87 = phi i64 [%83, %$18] ; # Fun %88 = phi i64 [%84, %$18] ; # L ; # (err Exe Msg ($ "Bad message") null) call void @err(i64 %0, i64 %19, i8* bitcast ([12 x i8]* @$69 to i8*), i8* null) unreachable $21: %89 = phi i64 [%82, %$18] ; # X %90 = phi i64 [%83, %$18] ; # Fun %91 = phi i64 [%84, %$18] ; # L ; # (? (== Msg (caar L)) (setq X (car L) Fun (cdr X))) ; # (caar L) %92 = inttoptr i64 %91 to i64* %93 = load i64, i64* %92 %94 = inttoptr i64 %93 to i64* %95 = load i64, i64* %94 ; # (== Msg (caar L)) %96 = icmp eq i64 %19, %95 br i1 %96, label %$24, label %$22 $24: %97 = phi i64 [%89, %$21] ; # X %98 = phi i64 [%90, %$21] ; # Fun %99 = phi i64 [%91, %$21] ; # L ; # (car L) %100 = inttoptr i64 %99 to i64* %101 = load i64, i64* %100 ; # (cdr X) %102 = inttoptr i64 %101 to i64* %103 = getelementptr i64, i64* %102, i32 1 %104 = load i64, i64* %103 br label %$23 $22: %105 = phi i64 [%89, %$21] ; # X %106 = phi i64 [%90, %$21] ; # Fun %107 = phi i64 [%91, %$21] ; # L ; # (shift L) %108 = inttoptr i64 %107 to i64* %109 = getelementptr i64, i64* %108, i32 1 %110 = load i64, i64* %109 br label %$17 $23: %111 = phi i64 [%101, %$24] ; # X %112 = phi i64 [%104, %$24] ; # Fun %113 = phi i64 [%99, %$24] ; # L %114 = phi i64 [%104, %$24] ; # -> br label %$16 $16: %115 = phi i64 [%61, %$14], [%111, %$23] ; # X %116 = phi i64 [%62, %$14], [%112, %$23] ; # Fun ; # (let (V (val Cls) L V) (loop (? (or (atom L) (atom (car L))) (set... ; # (val Cls) %117 = inttoptr i64 %55 to i64* %118 = load i64, i64* %117 ; # (loop (? (or (atom L) (atom (car L))) (set Cls (cons (if (atom (c... br label %$25 $25: %119 = phi i64 [%115, %$16], [%180, %$34] ; # X %120 = phi i64 [%116, %$16], [%181, %$34] ; # Fun %121 = phi i64 [%118, %$16], [%185, %$34] ; # L ; # (? (or (atom L) (atom (car L))) (set Cls (cons (if (atom (car X))... ; # (or (atom L) (atom (car L))) ; # (atom L) %122 = and i64 %121, 15 %123 = icmp ne i64 %122, 0 br i1 %123, label %$26, label %$27 $27: %124 = phi i64 [%119, %$25] ; # X %125 = phi i64 [%120, %$25] ; # Fun %126 = phi i64 [%121, %$25] ; # L ; # (car L) %127 = inttoptr i64 %126 to i64* %128 = load i64, i64* %127 ; # (atom (car L)) %129 = and i64 %128, 15 %130 = icmp ne i64 %129, 0 br label %$26 $26: %131 = phi i64 [%119, %$25], [%124, %$27] ; # X %132 = phi i64 [%120, %$25], [%125, %$27] ; # Fun %133 = phi i64 [%121, %$25], [%126, %$27] ; # L %134 = phi i1 [1, %$25], [%130, %$27] ; # -> br i1 %134, label %$30, label %$28 $30: %135 = phi i64 [%131, %$26] ; # X %136 = phi i64 [%132, %$26] ; # Fun %137 = phi i64 [%133, %$26] ; # L ; # (set Cls (cons (if (atom (car X)) X (cons Msg Fun)) V)) ; # (if (atom (car X)) X (cons Msg Fun)) ; # (car X) %138 = inttoptr i64 %135 to i64* %139 = load i64, i64* %138 ; # (atom (car X)) %140 = and i64 %139, 15 %141 = icmp ne i64 %140, 0 br i1 %141, label %$31, label %$32 $31: %142 = phi i64 [%135, %$30] ; # X %143 = phi i64 [%136, %$30] ; # Fun %144 = phi i64 [%137, %$30] ; # L br label %$33 $32: %145 = phi i64 [%135, %$30] ; # X %146 = phi i64 [%136, %$30] ; # Fun %147 = phi i64 [%137, %$30] ; # L ; # (cons Msg Fun) %148 = call i64 @cons(i64 %19, i64 %146) br label %$33 $33: %149 = phi i64 [%142, %$31], [%145, %$32] ; # X %150 = phi i64 [%143, %$31], [%146, %$32] ; # Fun %151 = phi i64 [%144, %$31], [%147, %$32] ; # L %152 = phi i64 [%142, %$31], [%148, %$32] ; # -> ; # (cons (if (atom (car X)) X (cons Msg Fun)) V) %153 = call i64 @cons(i64 %152, i64 %118) %154 = inttoptr i64 %55 to i64* store i64 %153, i64* %154 br label %$29 $28: %155 = phi i64 [%131, %$26] ; # X %156 = phi i64 [%132, %$26] ; # Fun %157 = phi i64 [%133, %$26] ; # L ; # (? (== Msg (caar L)) (let Z (car L) (unless (equal Fun (cdr Z)) (... ; # (caar L) %158 = inttoptr i64 %157 to i64* %159 = load i64, i64* %158 %160 = inttoptr i64 %159 to i64* %161 = load i64, i64* %160 ; # (== Msg (caar L)) %162 = icmp eq i64 %19, %161 br i1 %162, label %$35, label %$34 $35: %163 = phi i64 [%155, %$28] ; # X %164 = phi i64 [%156, %$28] ; # Fun %165 = phi i64 [%157, %$28] ; # L ; # (let Z (car L) (unless (equal Fun (cdr Z)) (redefMsg Msg Cls)) (s... ; # (car L) %166 = inttoptr i64 %165 to i64* %167 = load i64, i64* %166 ; # (unless (equal Fun (cdr Z)) (redefMsg Msg Cls)) ; # (cdr Z) %168 = inttoptr i64 %167 to i64* %169 = getelementptr i64, i64* %168, i32 1 %170 = load i64, i64* %169 ; # (equal Fun (cdr Z)) %171 = call i1 @equal(i64 %164, i64 %170) br i1 %171, label %$37, label %$36 $36: %172 = phi i64 [%163, %$35] ; # X %173 = phi i64 [%164, %$35] ; # Fun %174 = phi i64 [%165, %$35] ; # L ; # (redefMsg Msg Cls) call void @redefMsg(i64 %19, i64 %55) br label %$37 $37: %175 = phi i64 [%163, %$35], [%172, %$36] ; # X %176 = phi i64 [%164, %$35], [%173, %$36] ; # Fun %177 = phi i64 [%165, %$35], [%174, %$36] ; # L ; # (set 2 Z Fun) %178 = inttoptr i64 %167 to i64* %179 = getelementptr i64, i64* %178, i32 1 store i64 %176, i64* %179 br label %$29 $34: %180 = phi i64 [%155, %$28] ; # X %181 = phi i64 [%156, %$28] ; # Fun %182 = phi i64 [%157, %$28] ; # L ; # (shift L) %183 = inttoptr i64 %182 to i64* %184 = getelementptr i64, i64* %183, i32 1 %185 = load i64, i64* %184 br label %$25 $29: %186 = phi i64 [%149, %$33], [%175, %$37] ; # X %187 = phi i64 [%150, %$33], [%176, %$37] ; # Fun %188 = phi i64 [%151, %$33], [%177, %$37] ; # L %189 = phi i64 [%153, %$33], [%176, %$37] ; # -> ; # (putSrc Cls Msg) call void @putSrc(i64 %55, 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 ([870 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 80) 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %236 %237 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 80) 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 ([870 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 ([17 x i64]* @env to i8*), i32 88) to i64) to i64* %263 = load i64, i64* %262 ; # (val $Key) %264 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) 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 ([17 x i64]* @env to i8*), i32 88) to i64) to i64* store i64 %1, i64* %266 %267 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) 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 ([17 x i64]* @env to i8*), i32 96) to i64) to i64* store i64 %265, i64* %297 %298 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 88) to i64) to i64* store i64 %263, i64* %298 %299 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 80) 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 ([17 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 ([17 x i64]* @env to i8*), i32 80) to i64) to i64* %309 = load i64, i64* %308 ; # (set $Next $Nil) %310 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 80) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([17 x i64]* @env to i8*), i32 88) to i64) to i64* %333 = load i64, i64* %332 ; # (val $Key) %334 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) 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 ([17 x i64]* @env to i8*), i32 88) to i64) to i64* store i64 %1, i64* %336 %337 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) 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 ([17 x i64]* @env to i8*), i32 96) to i64) to i64* store i64 %335, i64* %367 %368 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 88) to i64) to i64* store i64 %333, i64* %368 %369 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 80) 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 x i64]* @env to i8*), i32 88) to i64) to i64* %422 = load i64, i64* %421 ; # (val $Key) %423 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) 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 ([17 x i64]* @env to i8*), i32 88) to i64) to i64* store i64 %1, i64* %425 %426 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) 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 ([17 x i64]* @env to i8*), i32 96) to i64) to i64* store i64 %424, i64* %456 %457 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 88) 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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]* @$69 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 ([17 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 ([870 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 ; # (let Nm (newId Exe (if (cnt? Y) (i32 (int @)) 1)) (prog1 (extern ... ; # (if (cnt? Y) (i32 (int @)) 1) ; # (cnt? Y) %25 = and i64 %15, 2 %26 = icmp ne i64 %25, 0 br i1 %26, label %$12, label %$13 $12: %27 = phi i64 [%24, %$10] ; # X ; # (int @) %28 = lshr i64 %15, 4 ; # (i32 (int @)) %29 = trunc i64 %28 to i32 br label %$14 $13: %30 = phi i64 [%24, %$10] ; # X br label %$14 $14: %31 = phi i64 [%27, %$12], [%30, %$13] ; # X %32 = phi i32 [%29, %$12], [1, %$13] ; # -> ; # (newId Exe (if (cnt? Y) (i32 (int @)) 1)) %33 = call i64 @newId(i64 %0, i32 %32) ; # (prog1 (extern Nm) (set (tail @) (sign (shr 1 (add Nm Nm) 1)))) ; # (extern Nm) %34 = call i64 @extern(i64 %33) ; # (set (tail @) (sign (shr 1 (add Nm Nm) 1))) ; # (tail @) %35 = add i64 %34, -8 ; # (add Nm Nm) %36 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %33, i64 %33) %37 = extractvalue {i64, i1} %36, 1 %38 = extractvalue {i64, i1} %36, 0 ; # (shr 1 (add Nm Nm) 1) %39 = call i64 @llvm.fshr.i64(i64 1, i64 %38, i64 1) ; # (sign (shr 1 (add Nm Nm) 1)) %40 = or i64 %39, 8 %41 = inttoptr i64 %35 to i64* store i64 %40, i64* %41 br label %$7 $7: %42 = phi i64 [%18, %$9], [%22, %$11], [%31, %$14] ; # X %43 = phi i64 [%19, %$9], [%23, %$11], [%34, %$14] ; # -> ; # (save (cond ((pair Y) (consSym ZERO Y)) ((nil? Y) (consSym ZERO Z... %44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 %43, 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %47, i64* %51 ; # (unless (pair Y) (set Obj (eval (++ X)))) ; # (pair Y) %52 = and i64 %15, 15 %53 = icmp eq i64 %52, 0 br i1 %53, label %$16, label %$15 $15: %54 = phi i64 [%42, %$7] ; # X ; # (set Obj (eval (++ X))) ; # (++ X) %55 = inttoptr i64 %54 to i64* %56 = load i64, i64* %55 %57 = getelementptr i64, i64* %55, i32 1 %58 = load i64, i64* %57 ; # (eval (++ X)) %59 = and i64 %56, 6 %60 = icmp ne i64 %59, 0 br i1 %60, label %$19, label %$18 $19: br label %$17 $18: %61 = and i64 %56, 8 %62 = icmp ne i64 %61, 0 br i1 %62, label %$21, label %$20 $21: %63 = inttoptr i64 %56 to i64* %64 = load i64, i64* %63 br label %$17 $20: %65 = call i64 @evList(i64 %56) br label %$17 $17: %66 = phi i64 [%56, %$19], [%64, %$21], [%65, %$20] ; # -> %67 = inttoptr i64 %43 to i64* store i64 %66, i64* %67 br label %$16 $16: %68 = phi i64 [%42, %$7], [%58, %$17] ; # X ; # (set $Ret 0) store i64 0, i64* @$Ret ; # (cond ((method Obj $T) (evMethod Obj (val $Ret) $T @ X)) ((pair X... ; # (method Obj $T) %69 = call i64 @method(i64 %43, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64)) %70 = icmp ne i64 %69, 0 br i1 %70, label %$24, label %$23 $24: %71 = phi i64 [%68, %$16] ; # X ; # (val $Ret) %72 = load i64, i64* @$Ret ; # (evMethod Obj (val $Ret) $T @ X) %73 = call i64 @evMethod(i64 %43, i64 %72, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), i64 %69, i64 %71) br label %$22 $23: %74 = phi i64 [%68, %$16] ; # X ; # (pair X) %75 = and i64 %74, 15 %76 = icmp eq i64 %75, 0 br i1 %76, label %$26, label %$25 $26: %77 = phi i64 [%74, %$23] ; # X ; # (let K (link (push NIL NIL)) (loop (put Obj (set K (eval (++ X)))... ; # (push NIL NIL) %78 = alloca i64, i64 2, align 16 %79 = ptrtoint i64* %78 to i64 ; # (link (push NIL NIL)) %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %81 = load i64, i64* %80 %82 = inttoptr i64 %79 to i64* %83 = getelementptr i64, i64* %82, i32 1 store i64 %81, i64* %83 %84 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %79, i64* %84 ; # (loop (put Obj (set K (eval (++ X))) (eval (++ X))) (? (atom X)))... br label %$27 $27: %85 = phi i64 [%77, %$26], [%113, %$38] ; # X ; # (set K (eval (++ X))) ; # (++ X) %86 = inttoptr i64 %85 to i64* %87 = load i64, i64* %86 %88 = getelementptr i64, i64* %86, i32 1 %89 = load i64, i64* %88 ; # (eval (++ X)) %90 = and i64 %87, 6 %91 = icmp ne i64 %90, 0 br i1 %91, label %$30, label %$29 $30: br label %$28 $29: %92 = and i64 %87, 8 %93 = icmp ne i64 %92, 0 br i1 %93, label %$32, label %$31 $32: %94 = inttoptr i64 %87 to i64* %95 = load i64, i64* %94 br label %$28 $31: %96 = call i64 @evList(i64 %87) br label %$28 $28: %97 = phi i64 [%87, %$30], [%95, %$32], [%96, %$31] ; # -> %98 = inttoptr i64 %79 to i64* store i64 %97, i64* %98 ; # (++ X) %99 = inttoptr i64 %89 to i64* %100 = load i64, i64* %99 %101 = getelementptr i64, i64* %99, i32 1 %102 = load i64, i64* %101 ; # (eval (++ X)) %103 = and i64 %100, 6 %104 = icmp ne i64 %103, 0 br i1 %104, label %$35, label %$34 $35: br label %$33 $34: %105 = and i64 %100, 8 %106 = icmp ne i64 %105, 0 br i1 %106, label %$37, label %$36 $37: %107 = inttoptr i64 %100 to i64* %108 = load i64, i64* %107 br label %$33 $36: %109 = call i64 @evList(i64 %100) br label %$33 $33: %110 = phi i64 [%100, %$35], [%108, %$37], [%109, %$36] ; # -> ; # (put Obj (set K (eval (++ X))) (eval (++ X))) call void @put(i64 %43, i64 %97, i64 %110) ; # (? (atom X)) ; # (atom X) %111 = and i64 %102, 15 %112 = icmp ne i64 %111, 0 br i1 %112, label %$39, label %$38 $38: %113 = phi i64 [%102, %$33] ; # X br label %$27 $39: %114 = phi i64 [%102, %$33] ; # X %115 = phi i64 [0, %$33] ; # -> br label %$22 $25: %116 = phi i64 [%74, %$23] ; # X br label %$22 $22: %117 = phi i64 [%71, %$24], [%114, %$39], [%116, %$25] ; # X %118 = phi i64 [%73, %$24], [%115, %$39], [0, %$25] ; # -> ; # (drop *Safe) %119 = inttoptr i64 %47 to i64* %120 = getelementptr i64, i64* %119, i32 1 %121 = load i64, i64* %120 %122 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %121, i64* %122 ret i64 %43 } 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$21], [%53, %$26], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%59, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$30] ; # -> br label %$9 $9: %69 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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]* @$69 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$-1] ; # -> br label %$14 $14: %59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 x i64]* @env to i8*), i32 88) 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 ([870 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 ([17 x i64]* @env to i8*), i32 96) 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]* @$70 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 ([17 x i64]* @env to i8*), i32 88) to i64) to i64* %34 = load i64, i64* %33 ; # (val $Key) %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) 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 ([17 x i64]* @env to i8*), i32 88) to i64) to i64* store i64 %37, i64* %38 %39 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) 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 ([17 x i64]* @env to i8*), i32 96) to i64) to i64* store i64 %36, i64* %41 %42 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 88) 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 (sh... 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 ([17 x i64]* @env to i8*), i32 88) 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: ; # (? (gt0 (extra (car Lst) Key)) @) ; # (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) ; # (gt0 (extra (car Lst) Key)) %46 = icmp sgt i64 %45, 0 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) (when (le0 (extra (val $This) Key)) (err Exe ... ; # (val $Key) %1 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) to i64) to i64* %2 = load i64, i64* %1 ; # (when (le0 (extra (val $This) Key)) (err Exe Key ($ "Bad extra") ... ; # (val $This) %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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) ; # (le0 (extra (val $This) Key)) %6 = icmp sle i64 %5, 0 br i1 %6, label %$2, label %$3 $2: ; # (err Exe Key ($ "Bad extra") null) call void @err(i64 %0, i64 %2, i8* bitcast ([10 x i8]* @$71 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 ([17 x i64]* @env to i8*), i32 88) to i64) to i64* %8 = load i64, i64* %7 ; # (val $Key) %9 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) 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 ([17 x i64]* @env to i8*), i32 88) to i64) to i64* store i64 %11, i64* %12 %13 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 96) 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 ([17 x i64]* @env to i8*), i32 96) to i64) to i64* store i64 %10, i64* %15 %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 88) 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 @_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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 (++ V)) (? (=... %93 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 (++ V)) (? (=0 (& (se... br label %$26 $26: %101 = phi i64 [%89, %$17], [%124, %$30] ; # X %102 = phi i64 [%90, %$17], [%125, %$30] ; # Y %103 = phi i64 [%91, %$17], [%126, %$30] ; # R %104 = phi i64 [%92, %$17], [%127, %$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 (++ V)) ; # (++ V) %116 = inttoptr i64 %115 to i64* %117 = load i64, i64* %116 %118 = getelementptr i64, i64* %116, i32 1 %119 = load i64, i64* %118 %120 = inttoptr i64 %113 to i64* store i64 %117, i64* %120 ; # (? (=0 (& (setq R (loop1 X)) 1))) ; # (loop1 X) %121 = call i64 @loop1(i64 %112) ; # (& (setq R (loop1 X)) 1) %122 = and i64 %121, 1 ; # (=0 (& (setq R (loop1 X)) 1)) %123 = icmp eq i64 %122, 0 br i1 %123, label %$28, label %$30 $30: %124 = phi i64 [%112, %$27] ; # X %125 = phi i64 [%113, %$27] ; # Y %126 = phi i64 [%121, %$27] ; # R %127 = phi i64 [%119, %$27] ; # V br label %$26 $28: %128 = phi i64 [%107, %$29], [%112, %$27] ; # X %129 = phi i64 [%108, %$29], [%113, %$27] ; # Y %130 = phi i64 [%111, %$29], [%121, %$27] ; # R %131 = phi i64 [%110, %$29], [%119, %$27] ; # V %132 = phi i64 [%111, %$29], [0, %$27] ; # -> ; # drop %133 = inttoptr i64 %96 to i64* %134 = getelementptr i64, i64* %133, i32 1 %135 = load i64, i64* %134 %136 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %135, i64* %136 br label %$18 $18: %137 = phi i64 [%85, %$20], [%128, %$28] ; # X %138 = phi i64 [%86, %$20], [%129, %$28] ; # Y %139 = phi i64 [%87, %$20], [%130, %$28] ; # R %140 = phi i64 [%88, %$20], [%131, %$28] ; # V ; # (set Y (val P) $Bind (val 3 P)) ; # (val P) %141 = inttoptr i64 %21 to i64* %142 = load i64, i64* %141 %143 = inttoptr i64 %138 to i64* store i64 %142, i64* %143 ; # (val 3 P) %144 = inttoptr i64 %21 to i64* %145 = getelementptr i64, i64* %144, i32 2 %146 = load i64, i64* %145 %147 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %146, i64* %147 br label %$2 $3: %148 = phi i64 [%7, %$1] ; # X %149 = phi i64 [%5, %$1] ; # Y %150 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$1] ; # R ; # (cdr Y) %151 = inttoptr i64 %149 to i64* %152 = getelementptr i64, i64* %151, i32 1 %153 = load i64, i64* %152 ; # (atom (cdr Y)) %154 = and i64 %153, 15 %155 = icmp ne i64 %154, 0 br i1 %155, label %$32, label %$31 $32: %156 = phi i64 [%148, %$3] ; # X %157 = phi i64 [%149, %$3] ; # Y %158 = phi i64 [%150, %$3] ; # R ; # (let Sym2 (needChkVar Exe @) (needChkVar Exe (setq Y (car Y))) (l... ; # (needChkVar Exe @) %159 = and i64 %153, 6 %160 = icmp ne i64 %159, 0 br i1 %160, label %$33, label %$34 $33: call void @varErr(i64 %0, i64 %153) unreachable $34: %161 = icmp uge i64 %153, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %161, label %$36, label %$35 $36: %162 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %153 br label %$35 $35: %163 = phi i1 [0, %$34], [%162, %$36] ; # -> br i1 %163, label %$37, label %$38 $37: call void @protErr(i64 %0, i64 %153) unreachable $38: ; # (car Y) %164 = inttoptr i64 %157 to i64* %165 = load i64, i64* %164 ; # (needChkVar Exe (setq Y (car Y))) %166 = and i64 %165, 6 %167 = icmp ne i64 %166, 0 br i1 %167, label %$39, label %$40 $39: call void @varErr(i64 %0, i64 %165) unreachable $40: %168 = icmp uge i64 %165, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %168, label %$42, label %$41 $42: %169 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %165 br label %$41 $41: %170 = phi i1 [0, %$40], [%169, %$42] ; # -> br i1 %170, label %$43, label %$44 $43: call void @protErr(i64 %0, i64 %165) 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) %171 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* %172 = load i64, i64* %171 ; # (push NIL NIL (val $Bind)) %173 = alloca i64, i64 3, align 16 %174 = ptrtoint i64* %173 to i64 %175 = add i64 %174, 16 %176 = inttoptr i64 %175 to i64* store i64 %172, i64* %176 %177 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %174, i64* %177 ; # (set P (val Y) 2 P Y) ; # (val Y) %178 = inttoptr i64 %165 to i64* %179 = load i64, i64* %178 %180 = inttoptr i64 %174 to i64* store i64 %179, i64* %180 %181 = inttoptr i64 %174 to i64* %182 = getelementptr i64, i64* %181, i32 1 store i64 %165, i64* %182 ; # (let (Q (set $Bind (push (val Sym2) Sym2 (val $Bind))) V (save (e... ; # (set $Bind (push (val Sym2) Sym2 (val $Bind))) ; # (val Sym2) %183 = inttoptr i64 %153 to i64* %184 = load i64, i64* %183 ; # (val $Bind) %185 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* %186 = load i64, i64* %185 ; # (push (val Sym2) Sym2 (val $Bind)) %187 = alloca i64, i64 3, align 16 %188 = ptrtoint i64* %187 to i64 %189 = inttoptr i64 %188 to i64* store i64 %184, i64* %189 %190 = add i64 %188, 8 %191 = inttoptr i64 %190 to i64* store i64 %153, i64* %191 %192 = add i64 %188, 16 %193 = inttoptr i64 %192 to i64* store i64 %186, i64* %193 %194 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %188, i64* %194 ; # (++ X) %195 = inttoptr i64 %156 to i64* %196 = load i64, i64* %195 %197 = getelementptr i64, i64* %195, i32 1 %198 = load i64, i64* %197 ; # (eval (++ X)) %199 = and i64 %196, 6 %200 = icmp ne i64 %199, 0 br i1 %200, label %$47, label %$46 $47: br label %$45 $46: %201 = and i64 %196, 8 %202 = icmp ne i64 %201, 0 br i1 %202, label %$49, label %$48 $49: %203 = inttoptr i64 %196 to i64* %204 = load i64, i64* %203 br label %$45 $48: %205 = call i64 @evList(i64 %196) br label %$45 $45: %206 = phi i64 [%196, %$47], [%204, %$49], [%205, %$48] ; # -> ; # (save (eval (++ X))) %207 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %208 = load i64, i64* %207 %209 = alloca i64, i64 2, align 16 %210 = ptrtoint i64* %209 to i64 %211 = inttoptr i64 %210 to i64* store i64 %206, i64* %211 %212 = add i64 %210, 8 %213 = inttoptr i64 %212 to i64* store i64 %208, i64* %213 %214 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %210, i64* %214 ; # (set Y ONE) %215 = inttoptr i64 %165 to i64* store i64 18, i64* %215 ; # (loop (? (atom V) (setq R (& R -2))) (set Sym2 (++ V)) (? (=0 (& ... br label %$50 $50: %216 = phi i64 [%198, %$45], [%239, %$54] ; # X %217 = phi i64 [%165, %$45], [%240, %$54] ; # Y %218 = phi i64 [%158, %$45], [%241, %$54] ; # R %219 = phi i64 [%206, %$45], [%242, %$54] ; # V ; # (? (atom V) (setq R (& R -2))) ; # (atom V) %220 = and i64 %219, 15 %221 = icmp ne i64 %220, 0 br i1 %221, label %$53, label %$51 $53: %222 = phi i64 [%216, %$50] ; # X %223 = phi i64 [%217, %$50] ; # Y %224 = phi i64 [%218, %$50] ; # R %225 = phi i64 [%219, %$50] ; # V ; # (& R -2) %226 = and i64 %224, -2 br label %$52 $51: %227 = phi i64 [%216, %$50] ; # X %228 = phi i64 [%217, %$50] ; # Y %229 = phi i64 [%218, %$50] ; # R %230 = phi i64 [%219, %$50] ; # V ; # (set Sym2 (++ V)) ; # (++ V) %231 = inttoptr i64 %230 to i64* %232 = load i64, i64* %231 %233 = getelementptr i64, i64* %231, i32 1 %234 = load i64, i64* %233 %235 = inttoptr i64 %153 to i64* store i64 %232, i64* %235 ; # (? (=0 (& (setq R (loop1 X)) 1))) ; # (loop1 X) %236 = call i64 @loop1(i64 %227) ; # (& (setq R (loop1 X)) 1) %237 = and i64 %236, 1 ; # (=0 (& (setq R (loop1 X)) 1)) %238 = icmp eq i64 %237, 0 br i1 %238, label %$52, label %$54 $54: %239 = phi i64 [%227, %$51] ; # X %240 = phi i64 [%228, %$51] ; # Y %241 = phi i64 [%236, %$51] ; # R %242 = phi i64 [%234, %$51] ; # V ; # (set Y (+ (val Y) (hex "10"))) ; # (val Y) %243 = inttoptr i64 %240 to i64* %244 = load i64, i64* %243 ; # (+ (val Y) (hex "10")) %245 = add i64 %244, 16 %246 = inttoptr i64 %240 to i64* store i64 %245, i64* %246 br label %$50 $52: %247 = phi i64 [%222, %$53], [%227, %$51] ; # X %248 = phi i64 [%223, %$53], [%228, %$51] ; # Y %249 = phi i64 [%226, %$53], [%236, %$51] ; # R %250 = phi i64 [%225, %$53], [%234, %$51] ; # V %251 = phi i64 [%226, %$53], [0, %$51] ; # -> ; # (set Sym2 (val Q)) ; # (val Q) %252 = inttoptr i64 %188 to i64* %253 = load i64, i64* %252 %254 = inttoptr i64 %153 to i64* store i64 %253, i64* %254 ; # (drop *Safe) %255 = inttoptr i64 %210 to i64* %256 = getelementptr i64, i64* %255, i32 1 %257 = load i64, i64* %256 %258 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %257, i64* %258 ; # (set Y (val P) $Bind (val 3 P)) ; # (val P) %259 = inttoptr i64 %174 to i64* %260 = load i64, i64* %259 %261 = inttoptr i64 %248 to i64* store i64 %260, i64* %261 ; # (val 3 P) %262 = inttoptr i64 %174 to i64* %263 = getelementptr i64, i64* %262, i32 2 %264 = load i64, i64* %263 %265 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %264, i64* %265 br label %$2 $31: %266 = phi i64 [%148, %$3] ; # X %267 = phi i64 [%149, %$3] ; # Y %268 = phi i64 [%150, %$3] ; # R ; # (car Y) %269 = inttoptr i64 %267 to i64* %270 = load i64, i64* %269 ; # (atom (car Y)) %271 = and i64 %270, 15 %272 = icmp ne i64 %271, 0 br i1 %272, label %$56, label %$55 $56: %273 = phi i64 [%266, %$31] ; # X %274 = phi i64 [%267, %$31] ; # Y %275 = phi i64 [%268, %$31] ; # R ; # (let Z (cdr Y) (needChkVar Exe (setq Y @)) (let P (set $Bind (pus... ; # (cdr Y) %276 = inttoptr i64 %274 to i64* %277 = getelementptr i64, i64* %276, i32 1 %278 = load i64, i64* %277 ; # (needChkVar Exe (setq Y @)) %279 = and i64 %270, 6 %280 = icmp ne i64 %279, 0 br i1 %280, label %$57, label %$58 $57: call void @varErr(i64 %0, i64 %270) unreachable $58: %281 = icmp uge i64 %270, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %281, label %$60, label %$59 $60: %282 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %270 br label %$59 $59: %283 = phi i1 [0, %$58], [%282, %$60] ; # -> br i1 %283, label %$61, label %$62 $61: call void @protErr(i64 %0, i64 %270) 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) %284 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* %285 = load i64, i64* %284 ; # (push NIL NIL (val $Bind)) %286 = alloca i64, i64 3, align 16 %287 = ptrtoint i64* %286 to i64 %288 = add i64 %287, 16 %289 = inttoptr i64 %288 to i64* store i64 %285, i64* %289 %290 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %287, i64* %290 ; # (set P (val Y) 2 P Y Y (eval (++ Z))) ; # (val Y) %291 = inttoptr i64 %270 to i64* %292 = load i64, i64* %291 %293 = inttoptr i64 %287 to i64* store i64 %292, i64* %293 %294 = inttoptr i64 %287 to i64* %295 = getelementptr i64, i64* %294, i32 1 store i64 %270, i64* %295 ; # (++ Z) %296 = inttoptr i64 %278 to i64* %297 = load i64, i64* %296 %298 = getelementptr i64, i64* %296, i32 1 %299 = load i64, i64* %298 ; # (eval (++ Z)) %300 = and i64 %297, 6 %301 = icmp ne i64 %300, 0 br i1 %301, label %$65, label %$64 $65: br label %$63 $64: %302 = and i64 %297, 8 %303 = icmp ne i64 %302, 0 br i1 %303, label %$67, label %$66 $67: %304 = inttoptr i64 %297 to i64* %305 = load i64, i64* %304 br label %$63 $66: %306 = call i64 @evList(i64 %297) br label %$63 $63: %307 = phi i64 [%297, %$65], [%305, %$67], [%306, %$66] ; # -> %308 = inttoptr i64 %270 to i64* store i64 %307, i64* %308 ; # (save R (loop (? (nil? (eval (car Z)))) (set $At @) (? (=0 (& (se... %309 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %310 = load i64, i64* %309 %311 = alloca i64, i64 2, align 16 %312 = ptrtoint i64* %311 to i64 %313 = inttoptr i64 %312 to i64* store i64 %275, i64* %313 %314 = add i64 %312, 8 %315 = inttoptr i64 %314 to i64* store i64 %310, i64* %315 %316 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %312, i64* %316 ; # (loop (? (nil? (eval (car Z)))) (set $At @) (? (=0 (& (setq R (lo... br label %$68 $68: %317 = phi i64 [%273, %$63], [%382, %$78] ; # X %318 = phi i64 [%270, %$63], [%383, %$78] ; # Y %319 = phi i64 [%275, %$63], [%384, %$78] ; # R %320 = phi i64 [%299, %$63], [%385, %$78] ; # Z ; # (? (nil? (eval (car Z)))) ; # (car Z) %321 = inttoptr i64 %320 to i64* %322 = load i64, i64* %321 ; # (eval (car Z)) %323 = and i64 %322, 6 %324 = icmp ne i64 %323, 0 br i1 %324, label %$71, label %$70 $71: br label %$69 $70: %325 = and i64 %322, 8 %326 = icmp ne i64 %325, 0 br i1 %326, label %$73, label %$72 $73: %327 = inttoptr i64 %322 to i64* %328 = load i64, i64* %327 br label %$69 $72: %329 = call i64 @evList(i64 %322) br label %$69 $69: %330 = phi i64 [%322, %$71], [%328, %$73], [%329, %$72] ; # -> ; # (nil? (eval (car Z))) %331 = icmp eq i64 %330, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %331, label %$75, label %$74 $74: %332 = phi i64 [%317, %$69] ; # X %333 = phi i64 [%318, %$69] ; # Y %334 = phi i64 [%319, %$69] ; # R %335 = phi i64 [%320, %$69] ; # Z ; # (set $At @) %336 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 %330, i64* %336 ; # (? (=0 (& (setq R (loop1 X)) 1))) ; # (loop1 X) %337 = call i64 @loop1(i64 %332) ; # (& (setq R (loop1 X)) 1) %338 = and i64 %337, 1 ; # (=0 (& (setq R (loop1 X)) 1)) %339 = icmp eq i64 %338, 0 br i1 %339, label %$75, label %$76 $76: %340 = phi i64 [%332, %$74] ; # X %341 = phi i64 [%333, %$74] ; # Y %342 = phi i64 [%337, %$74] ; # R %343 = phi i64 [%335, %$74] ; # Z ; # (& R -2) %344 = and i64 %342, -2 ; # (safe (setq R (& R -2))) %345 = inttoptr i64 %312 to i64* store i64 %344, i64* %345 ; # (when (pair (cdr Z)) (set Y (run @))) ; # (cdr Z) %346 = inttoptr i64 %343 to i64* %347 = getelementptr i64, i64* %346, i32 1 %348 = load i64, i64* %347 ; # (pair (cdr Z)) %349 = and i64 %348, 15 %350 = icmp eq i64 %349, 0 br i1 %350, label %$77, label %$78 $77: %351 = phi i64 [%340, %$76] ; # X %352 = phi i64 [%341, %$76] ; # Y %353 = phi i64 [%344, %$76] ; # R %354 = phi i64 [%343, %$76] ; # Z ; # (set Y (run @)) ; # (run @) br label %$79 $79: %355 = phi i64 [%348, %$77], [%377, %$88] ; # Prg %356 = inttoptr i64 %355 to i64* %357 = load i64, i64* %356 %358 = getelementptr i64, i64* %356, i32 1 %359 = load i64, i64* %358 %360 = and i64 %359, 15 %361 = icmp ne i64 %360, 0 br i1 %361, label %$82, label %$80 $82: %362 = phi i64 [%359, %$79] ; # Prg %363 = and i64 %357, 6 %364 = icmp ne i64 %363, 0 br i1 %364, label %$85, label %$84 $85: br label %$83 $84: %365 = and i64 %357, 8 %366 = icmp ne i64 %365, 0 br i1 %366, label %$87, label %$86 $87: %367 = inttoptr i64 %357 to i64* %368 = load i64, i64* %367 br label %$83 $86: %369 = call i64 @evList(i64 %357) br label %$83 $83: %370 = phi i64 [%357, %$85], [%368, %$87], [%369, %$86] ; # -> br label %$81 $80: %371 = phi i64 [%359, %$79] ; # Prg %372 = and i64 %357, 15 %373 = icmp eq i64 %372, 0 br i1 %373, label %$89, label %$88 $89: %374 = phi i64 [%371, %$80] ; # Prg %375 = call i64 @evList(i64 %357) %376 = icmp ne i64 %375, 0 br label %$88 $88: %377 = phi i64 [%371, %$80], [%374, %$89] ; # Prg %378 = phi i1 [0, %$80], [%376, %$89] ; # -> br label %$79 $81: %379 = phi i64 [%362, %$83] ; # Prg %380 = phi i64 [%370, %$83] ; # -> %381 = inttoptr i64 %352 to i64* store i64 %380, i64* %381 br label %$78 $78: %382 = phi i64 [%340, %$76], [%351, %$81] ; # X %383 = phi i64 [%341, %$76], [%352, %$81] ; # Y %384 = phi i64 [%344, %$76], [%353, %$81] ; # R %385 = phi i64 [%343, %$76], [%354, %$81] ; # Z br label %$68 $75: %386 = phi i64 [%317, %$69], [%332, %$74] ; # X %387 = phi i64 [%318, %$69], [%333, %$74] ; # Y %388 = phi i64 [%319, %$69], [%337, %$74] ; # R %389 = phi i64 [%320, %$69], [%335, %$74] ; # Z %390 = phi i64 [0, %$69], [0, %$74] ; # -> ; # drop %391 = inttoptr i64 %312 to i64* %392 = getelementptr i64, i64* %391, i32 1 %393 = load i64, i64* %392 %394 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %393, i64* %394 ; # (set Y (val P) $Bind (val 3 P)) ; # (val P) %395 = inttoptr i64 %287 to i64* %396 = load i64, i64* %395 %397 = inttoptr i64 %387 to i64* store i64 %396, i64* %397 ; # (val 3 P) %398 = inttoptr i64 %287 to i64* %399 = getelementptr i64, i64* %398, i32 2 %400 = load i64, i64* %399 %401 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %400, i64* %401 br label %$2 $55: %402 = phi i64 [%266, %$31] ; # X %403 = phi i64 [%267, %$31] ; # Y %404 = phi i64 [%268, %$31] ; # R ; # (let (Sym2 (cdr @) Z (cdr Y)) (setq Y (car @)) (needChkVar Exe Y)... ; # (cdr @) %405 = inttoptr i64 %270 to i64* %406 = getelementptr i64, i64* %405, i32 1 %407 = load i64, i64* %406 ; # (cdr Y) %408 = inttoptr i64 %403 to i64* %409 = getelementptr i64, i64* %408, i32 1 %410 = load i64, i64* %409 ; # (car @) %411 = inttoptr i64 %270 to i64* %412 = load i64, i64* %411 ; # (needChkVar Exe Y) %413 = and i64 %412, 6 %414 = icmp ne i64 %413, 0 br i1 %414, label %$90, label %$91 $90: call void @varErr(i64 %0, i64 %412) unreachable $91: %415 = icmp uge i64 %412, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %415, label %$93, label %$92 $93: %416 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %412 br label %$92 $92: %417 = phi i1 [0, %$91], [%416, %$93] ; # -> br i1 %417, label %$94, label %$95 $94: call void @protErr(i64 %0, i64 %412) unreachable $95: ; # (needChkVar Exe Sym2) %418 = and i64 %407, 6 %419 = icmp ne i64 %418, 0 br i1 %419, label %$96, label %$97 $96: call void @varErr(i64 %0, i64 %407) unreachable $97: %420 = icmp uge i64 %407, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %420, label %$99, label %$98 $99: %421 = icmp uge i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %407 br label %$98 $98: %422 = phi i1 [0, %$97], [%421, %$99] ; # -> br i1 %422, label %$100, label %$101 $100: call void @protErr(i64 %0, i64 %407) 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) %423 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* %424 = load i64, i64* %423 ; # (push NIL NIL (val $Bind)) %425 = alloca i64, i64 3, align 16 %426 = ptrtoint i64* %425 to i64 %427 = add i64 %426, 16 %428 = inttoptr i64 %427 to i64* store i64 %424, i64* %428 %429 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %426, i64* %429 ; # (set P (val Y) 2 P Y) ; # (val Y) %430 = inttoptr i64 %412 to i64* %431 = load i64, i64* %430 %432 = inttoptr i64 %426 to i64* store i64 %431, i64* %432 %433 = inttoptr i64 %426 to i64* %434 = getelementptr i64, i64* %433, i32 1 store i64 %412, i64* %434 ; # (save R (let Q (set $Bind (push (val Sym2) Sym2 (val $Bind))) (se... %435 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %436 = load i64, i64* %435 %437 = alloca i64, i64 2, align 16 %438 = ptrtoint i64* %437 to i64 %439 = inttoptr i64 %438 to i64* store i64 %404, i64* %439 %440 = add i64 %438, 8 %441 = inttoptr i64 %440 to i64* store i64 %436, i64* %441 %442 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %438, i64* %442 ; # (let Q (set $Bind (push (val Sym2) Sym2 (val $Bind))) (set Sym2 (... ; # (set $Bind (push (val Sym2) Sym2 (val $Bind))) ; # (val Sym2) %443 = inttoptr i64 %407 to i64* %444 = load i64, i64* %443 ; # (val $Bind) %445 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* %446 = load i64, i64* %445 ; # (push (val Sym2) Sym2 (val $Bind)) %447 = alloca i64, i64 3, align 16 %448 = ptrtoint i64* %447 to i64 %449 = inttoptr i64 %448 to i64* store i64 %444, i64* %449 %450 = add i64 %448, 8 %451 = inttoptr i64 %450 to i64* store i64 %407, i64* %451 %452 = add i64 %448, 16 %453 = inttoptr i64 %452 to i64* store i64 %446, i64* %453 %454 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %448, i64* %454 ; # (set Sym2 (save (eval (++ Z))) Y ONE) ; # (++ Z) %455 = inttoptr i64 %410 to i64* %456 = load i64, i64* %455 %457 = getelementptr i64, i64* %455, i32 1 %458 = load i64, i64* %457 ; # (eval (++ Z)) %459 = and i64 %456, 6 %460 = icmp ne i64 %459, 0 br i1 %460, label %$104, label %$103 $104: br label %$102 $103: %461 = and i64 %456, 8 %462 = icmp ne i64 %461, 0 br i1 %462, label %$106, label %$105 $106: %463 = inttoptr i64 %456 to i64* %464 = load i64, i64* %463 br label %$102 $105: %465 = call i64 @evList(i64 %456) br label %$102 $102: %466 = phi i64 [%456, %$104], [%464, %$106], [%465, %$105] ; # -> ; # (save (eval (++ Z))) %467 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %468 = load i64, i64* %467 %469 = alloca i64, i64 2, align 16 %470 = ptrtoint i64* %469 to i64 %471 = inttoptr i64 %470 to i64* store i64 %466, i64* %471 %472 = add i64 %470, 8 %473 = inttoptr i64 %472 to i64* store i64 %468, i64* %473 %474 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %470, i64* %474 %475 = inttoptr i64 %407 to i64* store i64 %466, i64* %475 %476 = inttoptr i64 %412 to i64* store i64 18, i64* %476 ; # (loop (? (nil? (eval (car Z)))) (set $At @) (? (=0 (& (setq R (lo... br label %$107 $107: %477 = phi i64 [%402, %$102], [%542, %$117] ; # X %478 = phi i64 [%412, %$102], [%543, %$117] ; # Y %479 = phi i64 [%404, %$102], [%544, %$117] ; # R %480 = phi i64 [%458, %$102], [%545, %$117] ; # Z ; # (? (nil? (eval (car Z)))) ; # (car Z) %481 = inttoptr i64 %480 to i64* %482 = load i64, i64* %481 ; # (eval (car Z)) %483 = and i64 %482, 6 %484 = icmp ne i64 %483, 0 br i1 %484, label %$110, label %$109 $110: br label %$108 $109: %485 = and i64 %482, 8 %486 = icmp ne i64 %485, 0 br i1 %486, label %$112, label %$111 $112: %487 = inttoptr i64 %482 to i64* %488 = load i64, i64* %487 br label %$108 $111: %489 = call i64 @evList(i64 %482) br label %$108 $108: %490 = phi i64 [%482, %$110], [%488, %$112], [%489, %$111] ; # -> ; # (nil? (eval (car Z))) %491 = icmp eq i64 %490, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %491, label %$114, label %$113 $113: %492 = phi i64 [%477, %$108] ; # X %493 = phi i64 [%478, %$108] ; # Y %494 = phi i64 [%479, %$108] ; # R %495 = phi i64 [%480, %$108] ; # Z ; # (set $At @) %496 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 %490, i64* %496 ; # (? (=0 (& (setq R (loop1 X)) 1))) ; # (loop1 X) %497 = call i64 @loop1(i64 %492) ; # (& (setq R (loop1 X)) 1) %498 = and i64 %497, 1 ; # (=0 (& (setq R (loop1 X)) 1)) %499 = icmp eq i64 %498, 0 br i1 %499, label %$114, label %$115 $115: %500 = phi i64 [%492, %$113] ; # X %501 = phi i64 [%493, %$113] ; # Y %502 = phi i64 [%497, %$113] ; # R %503 = phi i64 [%495, %$113] ; # Z ; # (& R -2) %504 = and i64 %502, -2 ; # (safe (setq R (& R -2))) %505 = inttoptr i64 %438 to i64* store i64 %504, i64* %505 ; # (when (pair (cdr Z)) (set Sym2 (run @))) ; # (cdr Z) %506 = inttoptr i64 %503 to i64* %507 = getelementptr i64, i64* %506, i32 1 %508 = load i64, i64* %507 ; # (pair (cdr Z)) %509 = and i64 %508, 15 %510 = icmp eq i64 %509, 0 br i1 %510, label %$116, label %$117 $116: %511 = phi i64 [%500, %$115] ; # X %512 = phi i64 [%501, %$115] ; # Y %513 = phi i64 [%504, %$115] ; # R %514 = phi i64 [%503, %$115] ; # Z ; # (set Sym2 (run @)) ; # (run @) br label %$118 $118: %515 = phi i64 [%508, %$116], [%537, %$127] ; # Prg %516 = inttoptr i64 %515 to i64* %517 = load i64, i64* %516 %518 = getelementptr i64, i64* %516, i32 1 %519 = load i64, i64* %518 %520 = and i64 %519, 15 %521 = icmp ne i64 %520, 0 br i1 %521, label %$121, label %$119 $121: %522 = phi i64 [%519, %$118] ; # Prg %523 = and i64 %517, 6 %524 = icmp ne i64 %523, 0 br i1 %524, label %$124, label %$123 $124: br label %$122 $123: %525 = and i64 %517, 8 %526 = icmp ne i64 %525, 0 br i1 %526, label %$126, label %$125 $126: %527 = inttoptr i64 %517 to i64* %528 = load i64, i64* %527 br label %$122 $125: %529 = call i64 @evList(i64 %517) br label %$122 $122: %530 = phi i64 [%517, %$124], [%528, %$126], [%529, %$125] ; # -> br label %$120 $119: %531 = phi i64 [%519, %$118] ; # Prg %532 = and i64 %517, 15 %533 = icmp eq i64 %532, 0 br i1 %533, label %$128, label %$127 $128: %534 = phi i64 [%531, %$119] ; # Prg %535 = call i64 @evList(i64 %517) %536 = icmp ne i64 %535, 0 br label %$127 $127: %537 = phi i64 [%531, %$119], [%534, %$128] ; # Prg %538 = phi i1 [0, %$119], [%536, %$128] ; # -> br label %$118 $120: %539 = phi i64 [%522, %$122] ; # Prg %540 = phi i64 [%530, %$122] ; # -> %541 = inttoptr i64 %407 to i64* store i64 %540, i64* %541 br label %$117 $117: %542 = phi i64 [%500, %$115], [%511, %$120] ; # X %543 = phi i64 [%501, %$115], [%512, %$120] ; # Y %544 = phi i64 [%504, %$115], [%513, %$120] ; # R %545 = phi i64 [%503, %$115], [%514, %$120] ; # Z ; # (set Y (+ (val Y) (hex "10"))) ; # (val Y) %546 = inttoptr i64 %543 to i64* %547 = load i64, i64* %546 ; # (+ (val Y) (hex "10")) %548 = add i64 %547, 16 %549 = inttoptr i64 %543 to i64* store i64 %548, i64* %549 br label %$107 $114: %550 = phi i64 [%477, %$108], [%492, %$113] ; # X %551 = phi i64 [%478, %$108], [%493, %$113] ; # Y %552 = phi i64 [%479, %$108], [%497, %$113] ; # R %553 = phi i64 [%480, %$108], [%495, %$113] ; # Z %554 = phi i64 [0, %$108], [0, %$113] ; # -> ; # (set Sym2 (val Q)) ; # (val Q) %555 = inttoptr i64 %448 to i64* %556 = load i64, i64* %555 %557 = inttoptr i64 %407 to i64* store i64 %556, i64* %557 ; # drop %558 = inttoptr i64 %438 to i64* %559 = getelementptr i64, i64* %558, i32 1 %560 = load i64, i64* %559 %561 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %560, i64* %561 ; # (set Y (val P) $Bind (val 3 P)) ; # (val P) %562 = inttoptr i64 %426 to i64* %563 = load i64, i64* %562 %564 = inttoptr i64 %551 to i64* store i64 %563, i64* %564 ; # (val 3 P) %565 = inttoptr i64 %426 to i64* %566 = getelementptr i64, i64* %565, i32 2 %567 = load i64, i64* %566 %568 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %567, i64* %568 br label %$2 $2: %569 = phi i64 [%137, %$18], [%247, %$52], [%386, %$75], [%550, %$114] ; # X %570 = phi i64 [%138, %$18], [%248, %$52], [%387, %$75], [%551, %$114] ; # Y %571 = phi i64 [%139, %$18], [%249, %$52], [%388, %$75], [%552, %$114] ; # R %572 = phi i64 [%146, %$18], [%264, %$52], [%400, %$75], [%567, %$114] ; # -> ret i64 %571 } 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ; # (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 ; # (prog1 (run X) (set Y (val P) $Bind (val 3 P))) ; # (run X) br label %$18 $18: %49 = phi i64 [%16, %$17], [%71, %$27] ; # Prg %50 = inttoptr i64 %49 to i64* %51 = load i64, i64* %50 %52 = getelementptr i64, i64* %50, i32 1 %53 = load i64, i64* %52 %54 = and i64 %53, 15 %55 = icmp ne i64 %54, 0 br i1 %55, label %$21, label %$19 $21: %56 = phi i64 [%53, %$18] ; # Prg %57 = and i64 %51, 6 %58 = icmp ne i64 %57, 0 br i1 %58, label %$24, label %$23 $24: br label %$22 $23: %59 = and i64 %51, 8 %60 = icmp ne i64 %59, 0 br i1 %60, label %$26, label %$25 $26: %61 = inttoptr i64 %51 to i64* %62 = load i64, i64* %61 br label %$22 $25: %63 = call i64 @evList(i64 %51) br label %$22 $22: %64 = phi i64 [%51, %$24], [%62, %$26], [%63, %$25] ; # -> br label %$20 $19: %65 = phi i64 [%53, %$18] ; # Prg %66 = and i64 %51, 15 %67 = icmp eq i64 %66, 0 br i1 %67, label %$28, label %$27 $28: %68 = phi i64 [%65, %$19] ; # Prg %69 = call i64 @evList(i64 %51) %70 = icmp ne i64 %69, 0 br label %$27 $27: %71 = phi i64 [%65, %$19], [%68, %$28] ; # Prg %72 = phi i1 [0, %$19], [%70, %$28] ; # -> br label %$18 $20: %73 = phi i64 [%56, %$22] ; # Prg %74 = phi i64 [%64, %$22] ; # -> ; # (set Y (val P) $Bind (val 3 P)) ; # (val P) %75 = inttoptr i64 %32 to i64* %76 = load i64, i64* %75 %77 = inttoptr i64 %5 to i64* store i64 %76, i64* %77 ; # (val 3 P) %78 = inttoptr i64 %32 to i64* %79 = getelementptr i64, i64* %78, i32 2 %80 = load i64, i64* %79 %81 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %80, i64* %81 ret i64 %74 } define i64 @_catch(i64) align 8 { $1: ; # (let (X (cdr Exe) Ca: (caFrame (b8 (+ (val JmpBufSize) (caFrame T... ; # (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, 168 ; # (b8 (+ (val JmpBufSize) (caFrame T))) %6 = alloca i8, i64 %5 ; # (Ca: tag (eval (++ X))) %7 = getelementptr i8, i8* %6, i32 8 %8 = ptrtoint i8* %7 to i64 %9 = inttoptr i64 %3 to i64* %10 = load i64, i64* %9 %11 = getelementptr i64, i64* %9, i32 1 %12 = load i64, i64* %11 %13 = and i64 %10, 6 %14 = icmp ne i64 %13, 0 br i1 %14, label %$4, label %$3 $4: br label %$2 $3: %15 = and i64 %10, 8 %16 = icmp ne i64 %15, 0 br i1 %16, label %$6, label %$5 $6: %17 = inttoptr i64 %10 to i64* %18 = load i64, i64* %17 br label %$2 $5: %19 = call i64 @evList(i64 %10) br label %$2 $2: %20 = phi i64 [%10, %$4], [%18, %$6], [%19, %$5] ; # -> %21 = inttoptr i64 %8 to i64* store i64 %20, i64* %21 ; # (Ca: link (val $Catch)) %22 = bitcast i8* %6 to i8** %23 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) store i8* %23, i8** %22 ; # (set $Catch (Ca:)) ; # (Ca:) store i8* %6, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (Ca: fin ZERO) %24 = getelementptr i8, i8* %6, i32 16 %25 = ptrtoint i8* %24 to i64 %26 = inttoptr i64 %25 to i64* store i64 2, i64* %26 ; # (Ca: co (val $Current)) %27 = getelementptr i8, i8* %6, i32 24 %28 = bitcast i8* %27 to i8** %29 = load i8*, i8** @$Current store i8* %29, i8** %28 ; # (Ca: (env)) %30 = getelementptr i8, i8* %6, i32 32 ; # (i8* $Link) %31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i8* ; # (memcpy (Ca: (env)) (env) (env T) T) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %30, i8* %31, i64 136, i1 0) ; # (prog1 (if (setjmp (Ca: (rst))) (val $Ret) (run X)) (set $Catch (... ; # (if (setjmp (Ca: (rst))) (val $Ret) (run X)) ; # (Ca: (rst)) %32 = getelementptr i8, i8* %6, i32 168 ; # (setjmp (Ca: (rst))) %33 = call i32 @setjmp(i8* %32) %34 = icmp ne i32 %33, 0 br i1 %34, label %$7, label %$8 $7: %35 = phi i64 [%12, %$2] ; # X ; # (val $Ret) %36 = load i64, i64* @$Ret br label %$9 $8: %37 = phi i64 [%12, %$2] ; # X ; # (run X) br label %$10 $10: %38 = phi i64 [%37, %$8], [%60, %$19] ; # 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 %$13, label %$11 $13: %45 = phi i64 [%42, %$10] ; # Prg %46 = and i64 %40, 6 %47 = icmp ne i64 %46, 0 br i1 %47, label %$16, label %$15 $16: br label %$14 $15: %48 = and i64 %40, 8 %49 = icmp ne i64 %48, 0 br i1 %49, label %$18, label %$17 $18: %50 = inttoptr i64 %40 to i64* %51 = load i64, i64* %50 br label %$14 $17: %52 = call i64 @evList(i64 %40) br label %$14 $14: %53 = phi i64 [%40, %$16], [%51, %$18], [%52, %$17] ; # -> br label %$12 $11: %54 = phi i64 [%42, %$10] ; # Prg %55 = and i64 %40, 15 %56 = icmp eq i64 %55, 0 br i1 %56, label %$20, label %$19 $20: %57 = phi i64 [%54, %$11] ; # Prg %58 = call i64 @evList(i64 %40) %59 = icmp ne i64 %58, 0 br label %$19 $19: %60 = phi i64 [%54, %$11], [%57, %$20] ; # Prg %61 = phi i1 [0, %$11], [%59, %$20] ; # -> br label %$10 $12: %62 = phi i64 [%45, %$14] ; # Prg %63 = phi i64 [%53, %$14] ; # -> br label %$9 $9: %64 = phi i64 [%35, %$7], [%37, %$12] ; # X %65 = phi i64 [%36, %$7], [%63, %$12] ; # -> ; # (set $Catch (Ca: link)) ; # (Ca: link) %66 = bitcast i8* %6 to i8** %67 = load i8*, i8** %66 store i8* %67, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ret i64 %65 } 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 24) 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 ([870 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 168 ; # (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]* @$72 to i8*), i8* null) unreachable } define i64 @_finally(i64) align 8 { $1: ; # (let (X (cdr Exe) Ca: (caFrame (b8 (+ (val JmpBufSize) (caFrame T... ; # (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, 168 ; # (b8 (+ (val JmpBufSize) (caFrame T))) %6 = alloca i8, i64 %5 ; # (Ca: tag 0) %7 = getelementptr i8, i8* %6, i32 8 %8 = ptrtoint i8* %7 to i64 %9 = inttoptr i64 %8 to i64* store i64 0, i64* %9 ; # (Ca: link (val $Catch)) %10 = bitcast i8* %6 to i8** %11 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) store i8* %11, i8** %10 ; # (set $Catch (Ca:)) ; # (Ca:) store i8* %6, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (Ca: fin (++ X)) %12 = getelementptr i8, i8* %6, i32 16 %13 = ptrtoint i8* %12 to i64 %14 = inttoptr i64 %3 to i64* %15 = load i64, i64* %14 %16 = getelementptr i64, i64* %14, i32 1 %17 = load i64, i64* %16 %18 = inttoptr i64 %13 to i64* store i64 %15, i64* %18 ; # (Ca: co (val $Current)) %19 = getelementptr i8, i8* %6, i32 24 %20 = bitcast i8* %19 to i8** %21 = load i8*, i8** @$Current store i8* %21, i8** %20 ; # (Ca: (env)) %22 = getelementptr i8, i8* %6, i32 32 ; # (i8* $Link) %23 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i8* ; # (memcpy (Ca: (env)) (env) (env T) T) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %22, i8* %23, i64 136, i1 0) ; # (prog1 (save (run X)) (eval (Ca: fin)) (set $Catch (Ca: link))) ; # (run X) br label %$2 $2: %24 = phi i64 [%17, %$1], [%46, %$11] ; # 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 %$5, label %$3 $5: %31 = phi i64 [%28, %$2] ; # Prg %32 = and i64 %26, 6 %33 = icmp ne i64 %32, 0 br i1 %33, label %$8, label %$7 $8: br label %$6 $7: %34 = and i64 %26, 8 %35 = icmp ne i64 %34, 0 br i1 %35, label %$10, label %$9 $10: %36 = inttoptr i64 %26 to i64* %37 = load i64, i64* %36 br label %$6 $9: %38 = call i64 @evList(i64 %26) br label %$6 $6: %39 = phi i64 [%26, %$8], [%37, %$10], [%38, %$9] ; # -> br label %$4 $3: %40 = phi i64 [%28, %$2] ; # Prg %41 = and i64 %26, 15 %42 = icmp eq i64 %41, 0 br i1 %42, label %$12, label %$11 $12: %43 = phi i64 [%40, %$3] ; # Prg %44 = call i64 @evList(i64 %26) %45 = icmp ne i64 %44, 0 br label %$11 $11: %46 = phi i64 [%40, %$3], [%43, %$12] ; # Prg %47 = phi i1 [0, %$3], [%45, %$12] ; # -> br label %$2 $4: %48 = phi i64 [%31, %$6] ; # Prg %49 = phi i64 [%39, %$6] ; # -> ; # (save (run X)) %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %53, i64* %57 ; # (Ca: fin) %58 = getelementptr i8, i8* %6, i32 16 %59 = ptrtoint i8* %58 to i64 %60 = inttoptr i64 %59 to i64* %61 = load i64, i64* %60 ; # (eval (Ca: fin)) %62 = and i64 %61, 6 %63 = icmp ne i64 %62, 0 br i1 %63, label %$15, label %$14 $15: br label %$13 $14: %64 = and i64 %61, 8 %65 = icmp ne i64 %64, 0 br i1 %65, label %$17, label %$16 $17: %66 = inttoptr i64 %61 to i64* %67 = load i64, i64* %66 br label %$13 $16: %68 = call i64 @evList(i64 %61) br label %$13 $13: %69 = phi i64 [%61, %$15], [%67, %$17], [%68, %$16] ; # -> ; # (set $Catch (Ca: link)) ; # (Ca: link) %70 = bitcast i8* %6 to i8** %71 = load i8*, i8** %70 store i8* %71, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (drop *Safe) %72 = inttoptr i64 %53 to i64* %73 = getelementptr i64, i64* %72, i32 1 %74 = load i64, i64* %73 %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %74, i64* %75 ret i64 %49 } 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]* @$73 to i8*), i8* null) unreachable } define void @saveCoIO() align 8 { $1: ; # (val $OutFrames) %0 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) 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)** @$Put to i8** %4 = load i8*, i8** %3 store i8* %4, i8** %2 ; # (let Io: (ioFrame (val $InFrames)) (Io: fun (val (i8** $Get))) ((... ; # (val $InFrames) %5 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (Io: fun (val (i8** $Get))) %6 = getelementptr i8, i8* %5, i32 16 %7 = bitcast i8* %6 to i8** %8 = bitcast i32()** @$Get to i8** %9 = load i8*, i8** %8 store i8* %9, i8** %7 ; # (Io: file) %10 = getelementptr i8, i8* %5, i32 8 %11 = bitcast i8* %10 to i8** %12 = load i8*, i8** %11 ; # ((inFile (Io: file)) chr (val $Chr)) %13 = getelementptr i8, i8* %12, i32 12 %14 = bitcast i8* %13 to i32* %15 = load i32, i32* @$Chr store i32 %15, i32* %14 ret void } define void @saveCoEnv(i8*) align 8 { $1: ; # (let Crt: (coroutine Crt) (Crt: at (val $At)) (memcpy (Crt: (env)... ; # (Crt: at (val $At)) %1 = getelementptr i8, i8* %0, i32 48 %2 = ptrtoint i8* %1 to i64 %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* %4 = load i64, i64* %3 %5 = inttoptr i64 %2 to i64* store i64 %4, i64* %5 ; # (Crt: (env)) %6 = getelementptr i8, i8* %0, i32 112 ; # (i8* $Link) %7 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i8* ; # (memcpy (Crt: (env)) (env) (env T) T) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %6, i8* %7, i64 136, i1 0) ret void } define i64 @loadCoEnv(i8*) align 8 { $1: ; # (let Crt: (coroutine (set $Current Crt)) (set $StkLimit (+ (Crt: ... ; # (set $Current Crt) store i8* %0, i8** @$Current ; # (set $StkLimit (+ (Crt: lim) 4096)) ; # (Crt: lim) %1 = getelementptr i8, i8* %0, i32 40 %2 = bitcast i8* %1 to i8** %3 = load i8*, i8** %2 ; # (+ (Crt: lim) 4096) %4 = getelementptr i8, i8* %3, i32 4096 store i8* %4, i8** @$StkLimit ; # (i8* $Link) %5 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i8* ; # (Crt: (env)) %6 = getelementptr i8, i8* %0, i32 112 ; # (memcpy (env) (Crt: (env)) (env T) T) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %5, i8* %6, i64 136, i1 0) ; # (tosInFile) call void @tosInFile() ; # (tosOutFile) call void @tosOutFile() ; # (set $At (Crt: at)) ; # (Crt: at) %7 = getelementptr i8, i8* %0, i32 48 %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 ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 %10, i64* %11 ; # (Crt: at 0) %12 = getelementptr i8, i8* %0, i32 48 %13 = ptrtoint i8* %12 to i64 %14 = inttoptr i64 %13 to i64* store i64 0, i64* %14 ; # (val $Ret) %15 = load i64, i64* @$Ret ret i64 %15 } 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$6] ; # -> br label %$4 $3: %16 = phi i64 [%3, %$1] ; # X ; # (let Tag (eval (++ X)) (cond ((pair X) (unless (val $Coroutines) ... ; # (++ 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] ; # -> ; # (cond ((pair X) (unless (val $Coroutines) (let Main: (coroutine (... ; # (pair X) %29 = and i64 %20, 15 %30 = icmp eq i64 %29, 0 br i1 %30, label %$15, label %$14 $15: %31 = phi i64 [%20, %$8] ; # X ; # (unless (val $Coroutines) (let Main: (coroutine (alloc null (+ (v... ; # (val $Coroutines) %32 = load i8*, i8** @$Coroutines %33 = icmp ne i8* %32, null br i1 %33, label %$17, label %$16 $16: %34 = phi i64 [%31, %$15] ; # X ; # (let Main: (coroutine (alloc null (+ (val JmpBufSize) (coroutine ... ; # (val JmpBufSize) %35 = load i64, i64* @JmpBufSize ; # (+ (val JmpBufSize) (coroutine T)) %36 = add i64 %35, 248 ; # (alloc null (+ (val JmpBufSize) (coroutine T))) %37 = call i8* @alloc(i8* null, i64 %36) ; # (Main: tag $T) %38 = ptrtoint i8* %37 to i64 %39 = inttoptr i64 %38 to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), i64* %39 ; # (Main: prv null) %40 = getelementptr i8, i8* %37, i32 8 %41 = bitcast i8* %40 to i8** store i8* null, i8** %41 ; # (Main: nxt null) %42 = getelementptr i8, i8* %37, i32 16 %43 = bitcast i8* %42 to i8** store i8* null, i8** %43 ; # (Main: org null) %44 = getelementptr i8, i8* %37, i32 24 %45 = bitcast i8* %44 to i8** store i8* null, i8** %45 ; # (Main: prg $Nil) %46 = getelementptr i8, i8* %37, i32 32 %47 = ptrtoint i8* %46 to i64 %48 = inttoptr i64 %47 to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %48 ; # (let (Siz (val $StkSizeT) Stk (stack)) (memset (Main: lim (stack ... ; # (val $StkSizeT) %49 = load i64, i64* @$StkSizeT ; # (stack) %50 = call i8* @llvm.stacksave() ; # (Main: lim (stack (ofs Stk (- Siz)))) %51 = getelementptr i8, i8* %37, i32 40 %52 = bitcast i8* %51 to i8** %53 = sub i64 0, %49 %54 = getelementptr i8, i8* %50, i64 %53 call void @llvm.stackrestore(i8* %54) store i8* %54, i8** %52 ; # (- Siz 256) %55 = sub i64 %49, 256 ; # (memset (Main: lim (stack (ofs Stk (- Siz)))) 7 (- Siz 256) T) call void @llvm.memset.p0i8.i64(i8* align 8 %54, i8 7, i64 %55, i1 0) ; # (stack Stk) call void @llvm.stackrestore(i8* %50) ; # (Main: at 0) %56 = getelementptr i8, i8* %37, i32 48 %57 = ptrtoint i8* %56 to i64 %58 = inttoptr i64 %57 to i64* store i64 0, i64* %58 ; # (set $Coroutines (set $Current (Main:))) ; # (set $Current (Main:)) ; # (Main:) store i8* %37, i8** @$Current store i8* %37, i8** @$Coroutines br label %$17 $17: %59 = phi i64 [%31, %$15], [%34, %$16] ; # X ; # (let (Src: (coroutine (val $Current)) Crt (val $Coroutines) P (i8... ; # (val $Current) %60 = load i8*, i8** @$Current ; # (val $Coroutines) %61 = load i8*, i8** @$Coroutines ; # (i8* null) %62 = inttoptr i64 0 to i8* ; # (saveCoIO) call void @saveCoIO() ; # (Src:) ; # (saveCoEnv (Src:)) call void @saveCoEnv(i8* %60) ; # (loop (let Crt: (coroutine Crt) (when (== Tag (Crt: tag)) (unless... br label %$18 $18: %63 = phi i64 [%59, %$17], [%118, %$28] ; # X %64 = phi i8* [%61, %$17], [%116, %$28] ; # Crt %65 = phi i8* [%62, %$17], [%120, %$28] ; # P ; # (let Crt: (coroutine Crt) (when (== Tag (Crt: tag)) (unless (Crt:... ; # (when (== Tag (Crt: tag)) (unless (Crt: at) (reentErr Exe Tag)) (... ; # (Crt: tag) %66 = ptrtoint i8* %64 to i64 %67 = inttoptr i64 %66 to i64* %68 = load i64, i64* %67 ; # (== Tag (Crt: tag)) %69 = icmp eq i64 %28, %68 br i1 %69, label %$19, label %$20 $19: %70 = phi i64 [%63, %$18] ; # X %71 = phi i8* [%64, %$18] ; # Crt %72 = phi i8* [%65, %$18] ; # P ; # (unless (Crt: at) (reentErr Exe Tag)) ; # (Crt: at) %73 = getelementptr i8, i8* %64, i32 48 %74 = ptrtoint i8* %73 to i64 %75 = inttoptr i64 %74 to i64* %76 = load i64, i64* %75 %77 = icmp ne i64 %76, 0 br i1 %77, label %$22, label %$21 $21: %78 = phi i64 [%70, %$19] ; # X %79 = phi i8* [%71, %$19] ; # Crt %80 = phi i8* [%72, %$19] ; # P ; # (reentErr Exe Tag) call void @reentErr(i64 %0, i64 %28) unreachable $22: %81 = phi i64 [%70, %$19] ; # X %82 = phi i8* [%71, %$19] ; # Crt %83 = phi i8* [%72, %$19] ; # P ; # (when (setjmp (Src: (rst))) (ret (loadCoEnv (Src:)))) ; # (Src: (rst)) %84 = getelementptr i8, i8* %60, i32 248 ; # (setjmp (Src: (rst))) %85 = call i32 @setjmp(i8* %84) %86 = icmp ne i32 %85, 0 br i1 %86, label %$23, label %$24 $23: %87 = phi i64 [%81, %$22] ; # X %88 = phi i8* [%82, %$22] ; # Crt %89 = phi i8* [%83, %$22] ; # P ; # (Src:) ; # (loadCoEnv (Src:)) %90 = call i64 @loadCoEnv(i8* %60) ; # (ret (loadCoEnv (Src:))) ret i64 %90 $24: %91 = phi i64 [%81, %$22] ; # X %92 = phi i8* [%82, %$22] ; # Crt %93 = phi i8* [%83, %$22] ; # P ; # (set $Ret $Nil) store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* @$Ret ; # (Crt: (rst)) %94 = getelementptr i8, i8* %64, i32 248 ; # (longjmp (Crt: (rst)) 1) call void @longjmp(i8* %94, i32 1) unreachable $20: %95 = phi i64 [%63, %$18] ; # X %96 = phi i8* [%64, %$18] ; # Crt %97 = phi i8* [%65, %$18] ; # P ; # (or P (Crt: tag) (setq P Crt)) %98 = icmp ne i8* %97, null br i1 %98, label %$25, label %$26 $26: %99 = phi i64 [%95, %$20] ; # X %100 = phi i8* [%96, %$20] ; # Crt %101 = phi i8* [%97, %$20] ; # P ; # (Crt: tag) %102 = ptrtoint i8* %64 to i64 %103 = inttoptr i64 %102 to i64* %104 = load i64, i64* %103 %105 = icmp ne i64 %104, 0 br i1 %105, label %$25, label %$27 $27: %106 = phi i64 [%99, %$26] ; # X %107 = phi i8* [%100, %$26] ; # Crt %108 = phi i8* [%101, %$26] ; # P %109 = icmp ne i8* %107, null br label %$25 $25: %110 = phi i64 [%95, %$20], [%99, %$26], [%106, %$27] ; # X %111 = phi i8* [%96, %$20], [%100, %$26], [%107, %$27] ; # Crt %112 = phi i8* [%97, %$20], [%101, %$26], [%107, %$27] ; # P %113 = phi i1 [1, %$20], [1, %$26], [%109, %$27] ; # -> ; # (? (=0 (Crt: nxt))) ; # (Crt: nxt) %114 = getelementptr i8, i8* %64, i32 16 %115 = bitcast i8* %114 to i8** %116 = load i8*, i8** %115 ; # (=0 (Crt: nxt)) %117 = icmp eq i8* %116, null br i1 %117, label %$29, label %$28 $28: %118 = phi i64 [%110, %$25] ; # X %119 = phi i8* [%111, %$25] ; # Crt %120 = phi i8* [%112, %$25] ; # P br label %$18 $29: %121 = phi i64 [%110, %$25] ; # X %122 = phi i8* [%111, %$25] ; # Crt %123 = phi i8* [%112, %$25] ; # P %124 = phi i64 [0, %$25] ; # -> ; # (when (setjmp (Src: (rst))) (ret (loadCoEnv (Src:)))) ; # (Src: (rst)) %125 = getelementptr i8, i8* %60, i32 248 ; # (setjmp (Src: (rst))) %126 = call i32 @setjmp(i8* %125) %127 = icmp ne i32 %126, 0 br i1 %127, label %$30, label %$31 $30: %128 = phi i64 [%121, %$29] ; # X %129 = phi i8* [%122, %$29] ; # Crt %130 = phi i8* [%123, %$29] ; # P ; # (Src:) ; # (loadCoEnv (Src:)) %131 = call i64 @loadCoEnv(i8* %60) ; # (ret (loadCoEnv (Src:))) ret i64 %131 $31: %132 = phi i64 [%121, %$29] ; # X %133 = phi i8* [%122, %$29] ; # Crt %134 = phi i8* [%123, %$29] ; # P ; # (if P (stack P) (stack ((coroutine Crt) lim)) (setq P (b8 (+ (val... %135 = icmp ne i8* %134, null br i1 %135, label %$32, label %$33 $32: %136 = phi i64 [%132, %$31] ; # X %137 = phi i8* [%133, %$31] ; # Crt %138 = phi i8* [%134, %$31] ; # P ; # (stack P) call void @llvm.stackrestore(i8* %138) br label %$34 $33: %139 = phi i64 [%132, %$31] ; # X %140 = phi i8* [%133, %$31] ; # Crt %141 = phi i8* [%134, %$31] ; # P ; # ((coroutine Crt) lim) %142 = getelementptr i8, i8* %140, i32 40 %143 = bitcast i8* %142 to i8** %144 = load i8*, i8** %143 ; # (stack ((coroutine Crt) lim)) call void @llvm.stackrestore(i8* %144) ; # (val JmpBufSize) %145 = load i64, i64* @JmpBufSize ; # (+ (val JmpBufSize) (coroutine T)) %146 = add i64 %145, 248 ; # (b8 (+ (val JmpBufSize) (coroutine T))) %147 = alloca i8, i64 %146 ; # ((coroutine Crt) nxt P) %148 = getelementptr i8, i8* %140, i32 16 %149 = bitcast i8* %148 to i8** store i8* %147, i8** %149 ; # ((coroutine P) prv Crt) %150 = getelementptr i8, i8* %147, i32 8 %151 = bitcast i8* %150 to i8** store i8* %140, i8** %151 ; # ((coroutine P) nxt null) %152 = getelementptr i8, i8* %147, i32 16 %153 = bitcast i8* %152 to i8** store i8* null, i8** %153 br label %$34 $34: %154 = phi i64 [%136, %$32], [%139, %$33] ; # X %155 = phi i8* [%137, %$32], [%140, %$33] ; # Crt %156 = phi i8* [%138, %$32], [%147, %$33] ; # P %157 = phi i8* [%138, %$32], [null, %$33] ; # -> ; # (let Dst: (coroutine P) (Dst: tag Tag) (Dst: org (val $Current)) ... ; # (Dst: tag Tag) %158 = ptrtoint i8* %156 to i64 %159 = inttoptr i64 %158 to i64* store i64 %28, i64* %159 ; # (Dst: org (val $Current)) %160 = getelementptr i8, i8* %156, i32 24 %161 = bitcast i8* %160 to i8** %162 = load i8*, i8** @$Current store i8* %162, i8** %161 ; # (Dst: prg X) %163 = getelementptr i8, i8* %156, i32 32 %164 = ptrtoint i8* %163 to i64 %165 = inttoptr i64 %164 to i64* store i64 %154, i64* %165 ; # (let (Siz (val $StkSize) Stk (stack)) (memset (Dst: lim (stack (o... ; # (val $StkSize) %166 = load i64, i64* @$StkSize ; # (stack) %167 = call i8* @llvm.stacksave() ; # (Dst: lim (stack (ofs P (- Siz)))) %168 = getelementptr i8, i8* %156, i32 40 %169 = bitcast i8* %168 to i8** %170 = sub i64 0, %166 %171 = getelementptr i8, i8* %156, i64 %170 call void @llvm.stackrestore(i8* %171) store i8* %171, i8** %169 ; # (- Siz 256) %172 = sub i64 %166, 256 ; # (memset (Dst: lim (stack (ofs P (- Siz)))) 7 (- Siz 256) T) call void @llvm.memset.p0i8.i64(i8* align 8 %171, i8 7, i64 %172, i1 0) ; # (stack Stk) call void @llvm.stackrestore(i8* %167) ; # (Dst: at 0) %173 = getelementptr i8, i8* %156, i32 48 %174 = ptrtoint i8* %173 to i64 %175 = inttoptr i64 %174 to i64* store i64 0, i64* %175 ; # (Dst: lnk (val $Link)) %176 = getelementptr i8, i8* %156, i32 56 %177 = ptrtoint i8* %176 to i64 %178 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %179 = load i64, i64* %178 %180 = inttoptr i64 %177 to i64* store i64 %179, i64* %180 ; # (Dst: bnd (set $Bind (push ZERO $At (val $Bind) Exe))) %181 = getelementptr i8, i8* %156, i32 64 %182 = ptrtoint i8* %181 to i64 %183 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* %184 = load i64, i64* %183 %185 = alloca i64, i64 4, align 16 %186 = ptrtoint i64* %185 to i64 %187 = inttoptr i64 %186 to i64* store i64 2, i64* %187 %188 = add i64 %186, 8 %189 = inttoptr i64 %188 to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64), i64* %189 %190 = add i64 %186, 16 %191 = inttoptr i64 %190 to i64* store i64 %184, i64* %191 %192 = add i64 %186, 24 %193 = inttoptr i64 %192 to i64* store i64 %0, i64* %193 %194 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %186, i64* %194 %195 = inttoptr i64 %182 to i64* store i64 %186, i64* %195 ; # (Dst: ca (val $Catch)) %196 = getelementptr i8, i8* %156, i32 72 %197 = bitcast i8* %196 to i8** %198 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) store i8* %198, i8** %197 ; # (Dst: in (val $InFrames)) %199 = getelementptr i8, i8* %156, i32 80 %200 = bitcast i8* %199 to i8** %201 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) store i8* %201, i8** %200 ; # (Dst: out (val $OutFrames)) %202 = getelementptr i8, i8* %156, i32 88 %203 = bitcast i8* %202 to i8** %204 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) store i8* %204, i8** %203 ; # (Dst: err (val $ErrFrames)) %205 = getelementptr i8, i8* %156, i32 96 %206 = bitcast i8* %205 to i8** %207 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 48) to i8**) store i8* %207, i8** %206 ; # (Dst: ctl (val $CtlFrames)) %208 = getelementptr i8, i8* %156, i32 104 %209 = bitcast i8* %208 to i8** %210 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 56) to i8**) store i8* %210, i8** %209 ; # (Dst: (env)) %211 = getelementptr i8, i8* %156, i32 112 ; # (i8* $Link) %212 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i8* ; # (memcpy (Dst: (env)) (env) (env T) T) call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %211, i8* %212, i64 136, i1 0) ; # (set $Next $Nil $Make 0 $Yoke 0 $Current (Dst:) $StkLimit (+ (Dst... %213 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 80) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %213 %214 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 104) to i64) to i64* store i64 0, i64* %214 %215 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 112) to i64) to i64* store i64 0, i64* %215 ; # (Dst:) store i8* %156, i8** @$Current ; # (Dst: lim) %216 = getelementptr i8, i8* %156, i32 40 %217 = bitcast i8* %216 to i8** %218 = load i8*, i8** %217 ; # (+ (Dst: lim) 4096) %219 = getelementptr i8, i8* %218, i32 4096 store i8* %219, i8** @$StkLimit ; # (set $Ret (run X)) ; # (run X) br label %$35 $35: %220 = phi i64 [%154, %$34], [%242, %$44] ; # Prg %221 = inttoptr i64 %220 to i64* %222 = load i64, i64* %221 %223 = getelementptr i64, i64* %221, i32 1 %224 = load i64, i64* %223 %225 = and i64 %224, 15 %226 = icmp ne i64 %225, 0 br i1 %226, label %$38, label %$36 $38: %227 = phi i64 [%224, %$35] ; # Prg %228 = and i64 %222, 6 %229 = icmp ne i64 %228, 0 br i1 %229, label %$41, label %$40 $41: br label %$39 $40: %230 = and i64 %222, 8 %231 = icmp ne i64 %230, 0 br i1 %231, label %$43, label %$42 $43: %232 = inttoptr i64 %222 to i64* %233 = load i64, i64* %232 br label %$39 $42: %234 = call i64 @evList(i64 %222) br label %$39 $39: %235 = phi i64 [%222, %$41], [%233, %$43], [%234, %$42] ; # -> br label %$37 $36: %236 = phi i64 [%224, %$35] ; # Prg %237 = and i64 %222, 15 %238 = icmp eq i64 %237, 0 br i1 %238, label %$45, label %$44 $45: %239 = phi i64 [%236, %$36] ; # Prg %240 = call i64 @evList(i64 %222) %241 = icmp ne i64 %240, 0 br label %$44 $44: %242 = phi i64 [%236, %$36], [%239, %$45] ; # Prg %243 = phi i1 [0, %$36], [%241, %$45] ; # -> br label %$35 $37: %244 = phi i64 [%227, %$39] ; # Prg %245 = phi i64 [%235, %$39] ; # -> store i64 %245, i64* @$Ret ; # (Dst:) ; # (stop (Dst:)) call void @stop(i8* %156) ; # (Dst: org) %246 = getelementptr i8, i8* %156, i32 24 %247 = bitcast i8* %246 to i8** %248 = load i8*, i8** %247 ; # ((coroutine (Dst: org)) (rst)) %249 = getelementptr i8, i8* %248, i32 248 ; # (longjmp ((coroutine (Dst: org)) (rst)) 1) call void @longjmp(i8* %249, i32 1) unreachable $14: %250 = phi i64 [%20, %$8] ; # X ; # (t? Tag) %251 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br i1 %251, label %$47, label %$46 $47: %252 = phi i64 [%250, %$14] ; # X ; # (err Exe 0 ($ "Can't stop main routine") null) call void @err(i64 %0, i64 0, i8* bitcast ([24 x i8]* @$74 to i8*), i8* null) unreachable $46: %253 = phi i64 [%250, %$14] ; # X ; # (val $Coroutines) %254 = load i8*, i8** @$Coroutines %255 = icmp ne i8* %254, null br i1 %255, label %$49, label %$48 $49: %256 = phi i64 [%253, %$46] ; # X ; # (let Crt @ (loop (let Crt: (coroutine Crt) (? (== Tag (Crt: tag))... ; # (loop (let Crt: (coroutine Crt) (? (== Tag (Crt: tag)) (stop (Crt... br label %$50 $50: %257 = phi i64 [%256, %$49], [%271, %$54] ; # X %258 = phi i8* [%254, %$49], [%272, %$54] ; # Crt ; # (let Crt: (coroutine Crt) (? (== Tag (Crt: tag)) (stop (Crt:))) (... ; # (? (== Tag (Crt: tag)) (stop (Crt:))) ; # (Crt: tag) %259 = ptrtoint i8* %258 to i64 %260 = inttoptr i64 %259 to i64* %261 = load i64, i64* %260 ; # (== Tag (Crt: tag)) %262 = icmp eq i64 %28, %261 br i1 %262, label %$53, label %$51 $53: %263 = phi i64 [%257, %$50] ; # X %264 = phi i8* [%258, %$50] ; # Crt ; # (Crt:) ; # (stop (Crt:)) call void @stop(i8* %258) br label %$52 $51: %265 = phi i64 [%257, %$50] ; # X %266 = phi i8* [%258, %$50] ; # Crt ; # (? (=0 (setq Crt (Crt: nxt)))) ; # (Crt: nxt) %267 = getelementptr i8, i8* %258, i32 16 %268 = bitcast i8* %267 to i8** %269 = load i8*, i8** %268 ; # (=0 (setq Crt (Crt: nxt))) %270 = icmp eq i8* %269, null br i1 %270, label %$52, label %$54 $54: %271 = phi i64 [%265, %$51] ; # X %272 = phi i8* [%269, %$51] ; # Crt br label %$50 $52: %273 = phi i64 [%263, %$53], [%265, %$51] ; # X %274 = phi i8* [%264, %$53], [%269, %$51] ; # Crt br label %$13 $48: %275 = phi i64 [%253, %$46] ; # X br label %$13 $13: %276 = phi i64 [%273, %$52], [%275, %$48] ; # X %277 = phi i64 [%28, %$52], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$48] ; # -> br label %$4 $4: %278 = phi i64 [%14, %$7], [%276, %$13] ; # X %279 = phi i64 [%15, %$7], [%277, %$13] ; # -> ret i64 %279 } 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 ([17 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 ([17 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]* @$75 to i8*), i8* null) unreachable $13: %39 = phi i8* [%36, %$7] ; # Crt ; # (let (Src: (coroutine (val $Current)) Dst: (coroutine (cond ((not... ; # (val $Current) %40 = load i8*, i8** @$Current ; # (cond ((not (nil? Tag)) (loop (let Crt: (coroutine Crt) (? (== Ta... ; # (nil? Tag) %41 = icmp eq i64 %35, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) ; # (not (nil? Tag)) %42 = icmp eq i1 %41, 0 br i1 %42, label %$16, label %$15 $16: %43 = phi i8* [%39, %$13] ; # Crt ; # (loop (let Crt: (coroutine Crt) (? (== Tag (Crt: tag)) (unless (C... br label %$17 $17: %44 = phi i8* [%43, %$16], [%63, %$24] ; # Crt ; # (let Crt: (coroutine Crt) (? (== Tag (Crt: tag)) (unless (Crt: at... ; # (? (== Tag (Crt: tag)) (unless (Crt: at) (reentErr Exe Tag)) Crt)... ; # (Crt: tag) %45 = ptrtoint i8* %44 to i64 %46 = inttoptr i64 %45 to i64* %47 = load i64, i64* %46 ; # (== Tag (Crt: tag)) %48 = icmp eq i64 %35, %47 br i1 %48, label %$20, label %$18 $20: %49 = phi i8* [%44, %$17] ; # Crt ; # (unless (Crt: at) (reentErr Exe Tag)) ; # (Crt: at) %50 = getelementptr i8, i8* %44, i32 48 %51 = ptrtoint i8* %50 to i64 %52 = inttoptr i64 %51 to i64* %53 = load i64, i64* %52 %54 = icmp ne i64 %53, 0 br i1 %54, label %$22, label %$21 $21: %55 = phi i8* [%49, %$20] ; # Crt ; # (reentErr Exe Tag) call void @reentErr(i64 %0, i64 %35) unreachable $22: %56 = phi i8* [%49, %$20] ; # Crt br label %$19 $18: %57 = phi i8* [%44, %$17] ; # Crt ; # (unless (setq Crt (Crt: nxt)) (err Exe Tag ($ "Coroutine not foun... ; # (Crt: nxt) %58 = getelementptr i8, i8* %44, i32 16 %59 = bitcast i8* %58 to i8** %60 = load i8*, i8** %59 %61 = icmp ne i8* %60, null br i1 %61, label %$24, label %$23 $23: %62 = phi i8* [%60, %$18] ; # Crt ; # (err Exe Tag ($ "Coroutine not found") null) call void @err(i64 %0, i64 %35, i8* bitcast ([20 x i8]* @$76 to i8*), i8* null) unreachable $24: %63 = phi i8* [%60, %$18] ; # Crt br label %$17 $19: %64 = phi i8* [%56, %$22] ; # Crt %65 = phi i8* [%56, %$22] ; # -> br label %$14 $15: %66 = phi i8* [%39, %$13] ; # Crt ; # (Src: org) %67 = getelementptr i8, i8* %40, i32 24 %68 = bitcast i8* %67 to i8** %69 = load i8*, i8** %68 %70 = icmp ne i8* %69, null br i1 %70, label %$26, label %$25 $26: %71 = phi i8* [%66, %$15] ; # Crt br label %$14 $25: %72 = phi i8* [%66, %$15] ; # Crt ; # (err Exe 0 ($ "Tag expected") null) call void @err(i64 %0, i64 0, i8* bitcast ([13 x i8]* @$77 to i8*), i8* null) unreachable $14: %73 = phi i8* [%64, %$19], [%71, %$26] ; # Crt %74 = phi i8* [%65, %$19], [%69, %$26] ; # -> ; # (any 0) ; # (any 0) ; # (i8* null) %75 = inttoptr i64 0 to i8* ; # (val $Stdin) %76 = load i8*, i8** @$Stdin ; # (val $Stdout) %77 = load i8*, i8** @$Stdout ; # (i8* null) %78 = inttoptr i64 0 to i8* ; # (i8* null) %79 = inttoptr i64 0 to i8* ; # (saveCoIO) call void @saveCoIO() ; # (unless (t? (Src: tag)) (let P (val $Link) (until (== P (Src: lnk... ; # (Src: tag) %80 = ptrtoint i8* %40 to i64 %81 = inttoptr i64 %80 to i64* %82 = load i64, i64* %81 ; # (t? (Src: tag)) %83 = icmp eq i64 %82, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br i1 %83, label %$28, label %$27 $27: %84 = phi i8* [%73, %$14] ; # Crt %85 = phi i64 [0, %$14] ; # Lnk %86 = phi i64 [0, %$14] ; # Bnd %87 = phi i8* [%75, %$14] ; # Ca %88 = phi i8* [%76, %$14] ; # In %89 = phi i8* [%77, %$14] ; # Out %90 = phi i8* [%78, %$14] ; # Err %91 = phi i8* [%79, %$14] ; # Ctl ; # (let P (val $Link) (until (== P (Src: lnk)) (let Q P (setq P (val... ; # (val $Link) %92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %93 = load i64, i64* %92 ; # (until (== P (Src: lnk)) (let Q P (setq P (val 2 Q)) (set 2 Q Lnk... br label %$29 $29: %94 = phi i8* [%84, %$27], [%108, %$30] ; # Crt %95 = phi i64 [%85, %$27], [%116, %$30] ; # Lnk %96 = phi i64 [%86, %$27], [%110, %$30] ; # Bnd %97 = phi i8* [%87, %$27], [%111, %$30] ; # Ca %98 = phi i8* [%88, %$27], [%112, %$30] ; # In %99 = phi i8* [%89, %$27], [%113, %$30] ; # Out %100 = phi i8* [%90, %$27], [%114, %$30] ; # Err %101 = phi i8* [%91, %$27], [%115, %$30] ; # Ctl %102 = phi i64 [%93, %$27], [%119, %$30] ; # P ; # (Src: lnk) %103 = getelementptr i8, i8* %40, i32 56 %104 = ptrtoint i8* %103 to i64 %105 = inttoptr i64 %104 to i64* %106 = load i64, i64* %105 ; # (== P (Src: lnk)) %107 = icmp eq i64 %102, %106 br i1 %107, label %$31, label %$30 $30: %108 = phi i8* [%94, %$29] ; # Crt %109 = phi i64 [%95, %$29] ; # Lnk %110 = phi i64 [%96, %$29] ; # Bnd %111 = phi i8* [%97, %$29] ; # Ca %112 = phi i8* [%98, %$29] ; # In %113 = phi i8* [%99, %$29] ; # Out %114 = phi i8* [%100, %$29] ; # Err %115 = phi i8* [%101, %$29] ; # Ctl %116 = phi i64 [%102, %$29] ; # P ; # (let Q P (setq P (val 2 Q)) (set 2 Q Lnk) (setq Lnk Q)) ; # (val 2 Q) %117 = inttoptr i64 %116 to i64* %118 = getelementptr i64, i64* %117, i32 1 %119 = load i64, i64* %118 ; # (set 2 Q Lnk) %120 = inttoptr i64 %116 to i64* %121 = getelementptr i64, i64* %120, i32 1 store i64 %109, i64* %121 br label %$29 $31: %122 = phi i8* [%94, %$29] ; # Crt %123 = phi i64 [%95, %$29] ; # Lnk %124 = phi i64 [%96, %$29] ; # Bnd %125 = phi i8* [%97, %$29] ; # Ca %126 = phi i8* [%98, %$29] ; # In %127 = phi i8* [%99, %$29] ; # Out %128 = phi i8* [%100, %$29] ; # Err %129 = phi i8* [%101, %$29] ; # Ctl %130 = phi i64 [%102, %$29] ; # P ; # (set $Link Lnk) %131 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %123, i64* %131 ; # (let P (val $Bind) (until (== P (Src: bnd)) (let Q P (xchg (val 2... ; # (val $Bind) %132 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* %133 = load i64, i64* %132 ; # (until (== P (Src: bnd)) (let Q P (xchg (val 2 Q) Q) (setq P (val... br label %$32 $32: %134 = phi i8* [%122, %$31], [%148, %$33] ; # Crt %135 = phi i64 [%123, %$31], [%149, %$33] ; # Lnk %136 = phi i64 [%124, %$31], [%156, %$33] ; # Bnd %137 = phi i8* [%125, %$31], [%151, %$33] ; # Ca %138 = phi i8* [%126, %$31], [%152, %$33] ; # In %139 = phi i8* [%127, %$31], [%153, %$33] ; # Out %140 = phi i8* [%128, %$31], [%154, %$33] ; # Err %141 = phi i8* [%129, %$31], [%155, %$33] ; # Ctl %142 = phi i64 [%133, %$31], [%166, %$33] ; # P ; # (Src: bnd) %143 = getelementptr i8, i8* %40, i32 64 %144 = ptrtoint i8* %143 to i64 %145 = inttoptr i64 %144 to i64* %146 = load i64, i64* %145 ; # (== P (Src: bnd)) %147 = icmp eq i64 %142, %146 br i1 %147, label %$34, label %$33 $33: %148 = phi i8* [%134, %$32] ; # Crt %149 = phi i64 [%135, %$32] ; # Lnk %150 = phi i64 [%136, %$32] ; # Bnd %151 = phi i8* [%137, %$32] ; # Ca %152 = phi i8* [%138, %$32] ; # In %153 = phi i8* [%139, %$32] ; # Out %154 = phi i8* [%140, %$32] ; # Err %155 = phi i8* [%141, %$32] ; # Ctl %156 = phi i64 [%142, %$32] ; # P ; # (let Q P (xchg (val 2 Q) Q) (setq P (val 3 Q)) (set 3 Q Bnd) (set... ; # (val 2 Q) %157 = inttoptr i64 %156 to i64* %158 = getelementptr i64, i64* %157, i32 1 %159 = load i64, i64* %158 ; # (xchg (val 2 Q) Q) %160 = inttoptr i64 %159 to i64* %161 = load i64, i64* %160 %162 = inttoptr i64 %156 to i64* %163 = load i64, i64* %162 store i64 %163, i64* %160 store i64 %161, i64* %162 ; # (val 3 Q) %164 = inttoptr i64 %156 to i64* %165 = getelementptr i64, i64* %164, i32 2 %166 = load i64, i64* %165 ; # (set 3 Q Bnd) %167 = inttoptr i64 %156 to i64* %168 = getelementptr i64, i64* %167, i32 2 store i64 %150, i64* %168 br label %$32 $34: %169 = phi i8* [%134, %$32] ; # Crt %170 = phi i64 [%135, %$32] ; # Lnk %171 = phi i64 [%136, %$32] ; # Bnd %172 = phi i8* [%137, %$32] ; # Ca %173 = phi i8* [%138, %$32] ; # In %174 = phi i8* [%139, %$32] ; # Out %175 = phi i8* [%140, %$32] ; # Err %176 = phi i8* [%141, %$32] ; # Ctl %177 = phi i64 [%142, %$32] ; # P ; # (let Q (Src: bnd) (set 3 Q Bnd) (set $Bind Q)) ; # (Src: bnd) %178 = getelementptr i8, i8* %40, i32 64 %179 = ptrtoint i8* %178 to i64 %180 = inttoptr i64 %179 to i64* %181 = load i64, i64* %180 ; # (set 3 Q Bnd) %182 = inttoptr i64 %181 to i64* %183 = getelementptr i64, i64* %182, i32 2 store i64 %171, i64* %183 ; # (set $Bind Q) %184 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %181, i64* %184 ; # (let P (val $Catch) (until (== P (Src: ca)) (let Ca: (caFrame P) ... ; # (val $Catch) %185 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (until (== P (Src: ca)) (let Ca: (caFrame P) (setq P (Ca: link)) ... br label %$35 $35: %186 = phi i8* [%169, %$34], [%199, %$36] ; # Crt %187 = phi i64 [%170, %$34], [%200, %$36] ; # Lnk %188 = phi i64 [%171, %$34], [%201, %$36] ; # Bnd %189 = phi i8* [%172, %$34], [%207, %$36] ; # Ca %190 = phi i8* [%173, %$34], [%203, %$36] ; # In %191 = phi i8* [%174, %$34], [%204, %$36] ; # Out %192 = phi i8* [%175, %$34], [%205, %$36] ; # Err %193 = phi i8* [%176, %$34], [%206, %$36] ; # Ctl %194 = phi i8* [%185, %$34], [%209, %$36] ; # P ; # (Src: ca) %195 = getelementptr i8, i8* %40, i32 72 %196 = bitcast i8* %195 to i8** %197 = load i8*, i8** %196 ; # (== P (Src: ca)) %198 = icmp eq i8* %194, %197 br i1 %198, label %$37, label %$36 $36: %199 = phi i8* [%186, %$35] ; # Crt %200 = phi i64 [%187, %$35] ; # Lnk %201 = phi i64 [%188, %$35] ; # Bnd %202 = phi i8* [%189, %$35] ; # Ca %203 = phi i8* [%190, %$35] ; # In %204 = phi i8* [%191, %$35] ; # Out %205 = phi i8* [%192, %$35] ; # Err %206 = phi i8* [%193, %$35] ; # Ctl %207 = phi i8* [%194, %$35] ; # P ; # (let Ca: (caFrame P) (setq P (Ca: link)) (Ca: link Ca) (setq Ca (... ; # (Ca: link) %208 = bitcast i8* %207 to i8** %209 = load i8*, i8** %208 ; # (Ca: link Ca) %210 = bitcast i8* %207 to i8** store i8* %202, i8** %210 ; # (Ca:) br label %$35 $37: %211 = phi i8* [%186, %$35] ; # Crt %212 = phi i64 [%187, %$35] ; # Lnk %213 = phi i64 [%188, %$35] ; # Bnd %214 = phi i8* [%189, %$35] ; # Ca %215 = phi i8* [%190, %$35] ; # In %216 = phi i8* [%191, %$35] ; # Out %217 = phi i8* [%192, %$35] ; # Err %218 = phi i8* [%193, %$35] ; # Ctl %219 = phi i8* [%194, %$35] ; # P ; # (set $Catch Ca) store i8* %214, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (let P (val $InFrames) (until (== P (Src: in)) (let In: (ioFrame ... ; # (val $InFrames) %220 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (until (== P (Src: in)) (let In: (ioFrame P) (setq P (In: link)) ... br label %$38 $38: %221 = phi i8* [%211, %$37], [%234, %$39] ; # Crt %222 = phi i64 [%212, %$37], [%235, %$39] ; # Lnk %223 = phi i64 [%213, %$37], [%236, %$39] ; # Bnd %224 = phi i8* [%214, %$37], [%237, %$39] ; # Ca %225 = phi i8* [%215, %$37], [%242, %$39] ; # In %226 = phi i8* [%216, %$37], [%239, %$39] ; # Out %227 = phi i8* [%217, %$37], [%240, %$39] ; # Err %228 = phi i8* [%218, %$37], [%241, %$39] ; # Ctl %229 = phi i8* [%220, %$37], [%244, %$39] ; # P ; # (Src: in) %230 = getelementptr i8, i8* %40, i32 80 %231 = bitcast i8* %230 to i8** %232 = load i8*, i8** %231 ; # (== P (Src: in)) %233 = icmp eq i8* %229, %232 br i1 %233, label %$40, label %$39 $39: %234 = phi i8* [%221, %$38] ; # Crt %235 = phi i64 [%222, %$38] ; # Lnk %236 = phi i64 [%223, %$38] ; # Bnd %237 = phi i8* [%224, %$38] ; # Ca %238 = phi i8* [%225, %$38] ; # In %239 = phi i8* [%226, %$38] ; # Out %240 = phi i8* [%227, %$38] ; # Err %241 = phi i8* [%228, %$38] ; # Ctl %242 = phi i8* [%229, %$38] ; # P ; # (let In: (ioFrame P) (setq P (In: link)) (In: link In) (setq In (... ; # (In: link) %243 = bitcast i8* %242 to i8** %244 = load i8*, i8** %243 ; # (In: link In) %245 = bitcast i8* %242 to i8** store i8* %238, i8** %245 ; # (In:) br label %$38 $40: %246 = phi i8* [%221, %$38] ; # Crt %247 = phi i64 [%222, %$38] ; # Lnk %248 = phi i64 [%223, %$38] ; # Bnd %249 = phi i8* [%224, %$38] ; # Ca %250 = phi i8* [%225, %$38] ; # In %251 = phi i8* [%226, %$38] ; # Out %252 = phi i8* [%227, %$38] ; # Err %253 = phi i8* [%228, %$38] ; # Ctl %254 = phi i8* [%229, %$38] ; # P ; # (set $InFrames In) store i8* %250, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (let P (val $OutFrames) (until (== P (Src: out)) (let Out: (ioFra... ; # (val $OutFrames) %255 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (until (== P (Src: out)) (let Out: (ioFrame P) (setq P (Out: link... br label %$41 $41: %256 = phi i8* [%246, %$40], [%269, %$42] ; # Crt %257 = phi i64 [%247, %$40], [%270, %$42] ; # Lnk %258 = phi i64 [%248, %$40], [%271, %$42] ; # Bnd %259 = phi i8* [%249, %$40], [%272, %$42] ; # Ca %260 = phi i8* [%250, %$40], [%273, %$42] ; # In %261 = phi i8* [%251, %$40], [%277, %$42] ; # Out %262 = phi i8* [%252, %$40], [%275, %$42] ; # Err %263 = phi i8* [%253, %$40], [%276, %$42] ; # Ctl %264 = phi i8* [%255, %$40], [%279, %$42] ; # P ; # (Src: out) %265 = getelementptr i8, i8* %40, i32 88 %266 = bitcast i8* %265 to i8** %267 = load i8*, i8** %266 ; # (== P (Src: out)) %268 = icmp eq i8* %264, %267 br i1 %268, label %$43, label %$42 $42: %269 = phi i8* [%256, %$41] ; # Crt %270 = phi i64 [%257, %$41] ; # Lnk %271 = phi i64 [%258, %$41] ; # Bnd %272 = phi i8* [%259, %$41] ; # Ca %273 = phi i8* [%260, %$41] ; # In %274 = phi i8* [%261, %$41] ; # Out %275 = phi i8* [%262, %$41] ; # Err %276 = phi i8* [%263, %$41] ; # Ctl %277 = phi i8* [%264, %$41] ; # P ; # (let Out: (ioFrame P) (setq P (Out: link)) (Out: link Out) (setq ... ; # (Out: link) %278 = bitcast i8* %277 to i8** %279 = load i8*, i8** %278 ; # (Out: link Out) %280 = bitcast i8* %277 to i8** store i8* %274, i8** %280 ; # (Out:) br label %$41 $43: %281 = phi i8* [%256, %$41] ; # Crt %282 = phi i64 [%257, %$41] ; # Lnk %283 = phi i64 [%258, %$41] ; # Bnd %284 = phi i8* [%259, %$41] ; # Ca %285 = phi i8* [%260, %$41] ; # In %286 = phi i8* [%261, %$41] ; # Out %287 = phi i8* [%262, %$41] ; # Err %288 = phi i8* [%263, %$41] ; # Ctl %289 = phi i8* [%264, %$41] ; # P ; # (set $OutFrames Out) store i8* %286, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (let P (val $ErrFrames) (until (== P (Src: err)) (let Err: (ioFra... ; # (val $ErrFrames) %290 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 48) to i8**) ; # (until (== P (Src: err)) (let Err: (ioFrame P) (setq P (Err: link... br label %$44 $44: %291 = phi i8* [%281, %$43], [%304, %$45] ; # Crt %292 = phi i64 [%282, %$43], [%305, %$45] ; # Lnk %293 = phi i64 [%283, %$43], [%306, %$45] ; # Bnd %294 = phi i8* [%284, %$43], [%307, %$45] ; # Ca %295 = phi i8* [%285, %$43], [%308, %$45] ; # In %296 = phi i8* [%286, %$43], [%309, %$45] ; # Out %297 = phi i8* [%287, %$43], [%312, %$45] ; # Err %298 = phi i8* [%288, %$43], [%311, %$45] ; # Ctl %299 = phi i8* [%290, %$43], [%314, %$45] ; # P ; # (Src: err) %300 = getelementptr i8, i8* %40, i32 96 %301 = bitcast i8* %300 to i8** %302 = load i8*, i8** %301 ; # (== P (Src: err)) %303 = icmp eq i8* %299, %302 br i1 %303, label %$46, label %$45 $45: %304 = phi i8* [%291, %$44] ; # Crt %305 = phi i64 [%292, %$44] ; # Lnk %306 = phi i64 [%293, %$44] ; # Bnd %307 = phi i8* [%294, %$44] ; # Ca %308 = phi i8* [%295, %$44] ; # In %309 = phi i8* [%296, %$44] ; # Out %310 = phi i8* [%297, %$44] ; # Err %311 = phi i8* [%298, %$44] ; # Ctl %312 = phi i8* [%299, %$44] ; # P ; # (let Err: (ioFrame P) (setq P (Err: link)) (Err: link Err) (setq ... ; # (Err: link) %313 = bitcast i8* %312 to i8** %314 = load i8*, i8** %313 ; # (Err: link Err) %315 = bitcast i8* %312 to i8** store i8* %310, i8** %315 ; # (Err:) br label %$44 $46: %316 = phi i8* [%291, %$44] ; # Crt %317 = phi i64 [%292, %$44] ; # Lnk %318 = phi i64 [%293, %$44] ; # Bnd %319 = phi i8* [%294, %$44] ; # Ca %320 = phi i8* [%295, %$44] ; # In %321 = phi i8* [%296, %$44] ; # Out %322 = phi i8* [%297, %$44] ; # Err %323 = phi i8* [%298, %$44] ; # Ctl %324 = phi i8* [%299, %$44] ; # P ; # (set $ErrFrames Err) store i8* %322, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 48) to i8**) ; # (let P (val $CtlFrames) (until (== P (Src: ctl)) (let Ctl: (ioFra... ; # (val $CtlFrames) %325 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 56) to i8**) ; # (until (== P (Src: ctl)) (let Ctl: (ioFrame P) (setq P (Ctl: link... br label %$47 $47: %326 = phi i8* [%316, %$46], [%339, %$48] ; # Crt %327 = phi i64 [%317, %$46], [%340, %$48] ; # Lnk %328 = phi i64 [%318, %$46], [%341, %$48] ; # Bnd %329 = phi i8* [%319, %$46], [%342, %$48] ; # Ca %330 = phi i8* [%320, %$46], [%343, %$48] ; # In %331 = phi i8* [%321, %$46], [%344, %$48] ; # Out %332 = phi i8* [%322, %$46], [%345, %$48] ; # Err %333 = phi i8* [%323, %$46], [%347, %$48] ; # Ctl %334 = phi i8* [%325, %$46], [%349, %$48] ; # P ; # (Src: ctl) %335 = getelementptr i8, i8* %40, i32 104 %336 = bitcast i8* %335 to i8** %337 = load i8*, i8** %336 ; # (== P (Src: ctl)) %338 = icmp eq i8* %334, %337 br i1 %338, label %$49, label %$48 $48: %339 = phi i8* [%326, %$47] ; # Crt %340 = phi i64 [%327, %$47] ; # Lnk %341 = phi i64 [%328, %$47] ; # Bnd %342 = phi i8* [%329, %$47] ; # Ca %343 = phi i8* [%330, %$47] ; # In %344 = phi i8* [%331, %$47] ; # Out %345 = phi i8* [%332, %$47] ; # Err %346 = phi i8* [%333, %$47] ; # Ctl %347 = phi i8* [%334, %$47] ; # P ; # (let Ctl: (ioFrame P) (setq P (Ctl: link)) (Ctl: link Ctl) (setq ... ; # (Ctl: link) %348 = bitcast i8* %347 to i8** %349 = load i8*, i8** %348 ; # (Ctl: link Ctl) %350 = bitcast i8* %347 to i8** store i8* %346, i8** %350 ; # (Ctl:) br label %$47 $49: %351 = phi i8* [%326, %$47] ; # Crt %352 = phi i64 [%327, %$47] ; # Lnk %353 = phi i64 [%328, %$47] ; # Bnd %354 = phi i8* [%329, %$47] ; # Ca %355 = phi i8* [%330, %$47] ; # In %356 = phi i8* [%331, %$47] ; # Out %357 = phi i8* [%332, %$47] ; # Err %358 = phi i8* [%333, %$47] ; # Ctl %359 = phi i8* [%334, %$47] ; # P ; # (set $CtlFrames Ctl) store i8* %358, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 56) to i8**) br label %$28 $28: %360 = phi i8* [%73, %$14], [%351, %$49] ; # Crt %361 = phi i64 [0, %$14], [%352, %$49] ; # Lnk %362 = phi i64 [0, %$14], [%353, %$49] ; # Bnd %363 = phi i8* [%75, %$14], [%354, %$49] ; # Ca %364 = phi i8* [%76, %$14], [%355, %$49] ; # In %365 = phi i8* [%77, %$14], [%356, %$49] ; # Out %366 = phi i8* [%78, %$14], [%357, %$49] ; # Err %367 = phi i8* [%79, %$14], [%358, %$49] ; # Ctl ; # (Src:) ; # (saveCoEnv (Src:)) call void @saveCoEnv(i8* %40) ; # (unless (setjmp (Src: (rst))) (set $Ret Val) (longjmp (Dst: (rst)... ; # (Src: (rst)) %368 = getelementptr i8, i8* %40, i32 248 ; # (setjmp (Src: (rst))) %369 = call i32 @setjmp(i8* %368) %370 = icmp ne i32 %369, 0 br i1 %370, label %$51, label %$50 $50: %371 = phi i8* [%360, %$28] ; # Crt %372 = phi i64 [%361, %$28] ; # Lnk %373 = phi i64 [%362, %$28] ; # Bnd %374 = phi i8* [%363, %$28] ; # Ca %375 = phi i8* [%364, %$28] ; # In %376 = phi i8* [%365, %$28] ; # Out %377 = phi i8* [%366, %$28] ; # Err %378 = phi i8* [%367, %$28] ; # Ctl ; # (set $Ret Val) store i64 %15, i64* @$Ret ; # (Dst: (rst)) %379 = getelementptr i8, i8* %74, i32 248 ; # (longjmp (Dst: (rst)) 1) call void @longjmp(i8* %379, i32 1) unreachable $51: %380 = phi i8* [%360, %$28] ; # Crt %381 = phi i64 [%361, %$28] ; # Lnk %382 = phi i64 [%362, %$28] ; # Bnd %383 = phi i8* [%363, %$28] ; # Ca %384 = phi i8* [%364, %$28] ; # In %385 = phi i8* [%365, %$28] ; # Out %386 = phi i8* [%366, %$28] ; # Err %387 = phi i8* [%367, %$28] ; # Ctl ; # (unless (t? (Src: tag)) (let P (val $CtlFrames) (Src: ctl P) (whi... ; # (Src: tag) %388 = ptrtoint i8* %40 to i64 %389 = inttoptr i64 %388 to i64* %390 = load i64, i64* %389 ; # (t? (Src: tag)) %391 = icmp eq i64 %390, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64) br i1 %391, label %$53, label %$52 $52: %392 = phi i8* [%380, %$51] ; # Crt %393 = phi i64 [%381, %$51] ; # Lnk %394 = phi i64 [%382, %$51] ; # Bnd %395 = phi i8* [%383, %$51] ; # Ca %396 = phi i8* [%384, %$51] ; # In %397 = phi i8* [%385, %$51] ; # Out %398 = phi i8* [%386, %$51] ; # Err %399 = phi i8* [%387, %$51] ; # Ctl ; # (let P (val $CtlFrames) (Src: ctl P) (while Ctl (let Ctl: (ioFram... ; # (val $CtlFrames) %400 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 56) to i8**) ; # (Src: ctl P) %401 = getelementptr i8, i8* %40, i32 104 %402 = bitcast i8* %401 to i8** store i8* %400, i8** %402 ; # (while Ctl (let Ctl: (ioFrame Ctl) (setq Ctl (Ctl: link)) (Ctl: l... br label %$54 $54: %403 = phi i8* [%392, %$52], [%413, %$55] ; # Crt %404 = phi i64 [%393, %$52], [%414, %$55] ; # Lnk %405 = phi i64 [%394, %$52], [%415, %$55] ; # Bnd %406 = phi i8* [%395, %$52], [%416, %$55] ; # Ca %407 = phi i8* [%396, %$52], [%417, %$55] ; # In %408 = phi i8* [%397, %$52], [%418, %$55] ; # Out %409 = phi i8* [%398, %$52], [%419, %$55] ; # Err %410 = phi i8* [%399, %$52], [%423, %$55] ; # Ctl %411 = phi i8* [%400, %$52], [%420, %$55] ; # P %412 = icmp ne i8* %410, null br i1 %412, label %$55, label %$56 $55: %413 = phi i8* [%403, %$54] ; # Crt %414 = phi i64 [%404, %$54] ; # Lnk %415 = phi i64 [%405, %$54] ; # Bnd %416 = phi i8* [%406, %$54] ; # Ca %417 = phi i8* [%407, %$54] ; # In %418 = phi i8* [%408, %$54] ; # Out %419 = phi i8* [%409, %$54] ; # Err %420 = phi i8* [%410, %$54] ; # Ctl %421 = phi i8* [%411, %$54] ; # P ; # (let Ctl: (ioFrame Ctl) (setq Ctl (Ctl: link)) (Ctl: link P) (set... ; # (Ctl: link) %422 = bitcast i8* %420 to i8** %423 = load i8*, i8** %422 ; # (Ctl: link P) %424 = bitcast i8* %420 to i8** store i8* %421, i8** %424 ; # (Ctl:) br label %$54 $56: %425 = phi i8* [%403, %$54] ; # Crt %426 = phi i64 [%404, %$54] ; # Lnk %427 = phi i64 [%405, %$54] ; # Bnd %428 = phi i8* [%406, %$54] ; # Ca %429 = phi i8* [%407, %$54] ; # In %430 = phi i8* [%408, %$54] ; # Out %431 = phi i8* [%409, %$54] ; # Err %432 = phi i8* [%410, %$54] ; # Ctl %433 = phi i8* [%411, %$54] ; # P ; # (Src: (env $CtlFrames i8*) P) %434 = getelementptr i8, i8* %40, i32 112 %435 = getelementptr i8, i8* %434, i32 56 %436 = bitcast i8* %435 to i8** store i8* %433, i8** %436 ; # (let P (val $ErrFrames) (Src: err P) (while Err (let Err: (ioFram... ; # (val $ErrFrames) %437 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 48) to i8**) ; # (Src: err P) %438 = getelementptr i8, i8* %40, i32 96 %439 = bitcast i8* %438 to i8** store i8* %437, i8** %439 ; # (while Err (let Err: (ioFrame Err) (setq Err (Err: link)) (Err: l... br label %$57 $57: %440 = phi i8* [%425, %$56], [%450, %$58] ; # Crt %441 = phi i64 [%426, %$56], [%451, %$58] ; # Lnk %442 = phi i64 [%427, %$56], [%452, %$58] ; # Bnd %443 = phi i8* [%428, %$56], [%453, %$58] ; # Ca %444 = phi i8* [%429, %$56], [%454, %$58] ; # In %445 = phi i8* [%430, %$56], [%455, %$58] ; # Out %446 = phi i8* [%431, %$56], [%460, %$58] ; # Err %447 = phi i8* [%432, %$56], [%457, %$58] ; # Ctl %448 = phi i8* [%437, %$56], [%456, %$58] ; # P %449 = icmp ne i8* %446, null br i1 %449, label %$58, label %$59 $58: %450 = phi i8* [%440, %$57] ; # Crt %451 = phi i64 [%441, %$57] ; # Lnk %452 = phi i64 [%442, %$57] ; # Bnd %453 = phi i8* [%443, %$57] ; # Ca %454 = phi i8* [%444, %$57] ; # In %455 = phi i8* [%445, %$57] ; # Out %456 = phi i8* [%446, %$57] ; # Err %457 = phi i8* [%447, %$57] ; # Ctl %458 = phi i8* [%448, %$57] ; # P ; # (let Err: (ioFrame Err) (setq Err (Err: link)) (Err: link P) (set... ; # (Err: link) %459 = bitcast i8* %456 to i8** %460 = load i8*, i8** %459 ; # (Err: link P) %461 = bitcast i8* %456 to i8** store i8* %458, i8** %461 ; # (Err:) br label %$57 $59: %462 = phi i8* [%440, %$57] ; # Crt %463 = phi i64 [%441, %$57] ; # Lnk %464 = phi i64 [%442, %$57] ; # Bnd %465 = phi i8* [%443, %$57] ; # Ca %466 = phi i8* [%444, %$57] ; # In %467 = phi i8* [%445, %$57] ; # Out %468 = phi i8* [%446, %$57] ; # Err %469 = phi i8* [%447, %$57] ; # Ctl %470 = phi i8* [%448, %$57] ; # P ; # (Src: (env $ErrFrames i8*) P) %471 = getelementptr i8, i8* %40, i32 112 %472 = getelementptr i8, i8* %471, i32 48 %473 = bitcast i8* %472 to i8** store i8* %470, i8** %473 ; # (let P (val $OutFrames) (Src: out P) (until (== Out (val $Stdout)... ; # (val $OutFrames) %474 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (Src: out P) %475 = getelementptr i8, i8* %40, i32 88 %476 = bitcast i8* %475 to i8** store i8* %474, i8** %476 ; # (until (== Out (val $Stdout)) (let Out: (ioFrame Out) (setq Out (... br label %$60 $60: %477 = phi i8* [%462, %$59], [%488, %$61] ; # Crt %478 = phi i64 [%463, %$59], [%489, %$61] ; # Lnk %479 = phi i64 [%464, %$59], [%490, %$61] ; # Bnd %480 = phi i8* [%465, %$59], [%491, %$61] ; # Ca %481 = phi i8* [%466, %$59], [%492, %$61] ; # In %482 = phi i8* [%467, %$59], [%498, %$61] ; # Out %483 = phi i8* [%468, %$59], [%494, %$61] ; # Err %484 = phi i8* [%469, %$59], [%495, %$61] ; # Ctl %485 = phi i8* [%474, %$59], [%493, %$61] ; # P ; # (val $Stdout) %486 = load i8*, i8** @$Stdout ; # (== Out (val $Stdout)) %487 = icmp eq i8* %482, %486 br i1 %487, label %$62, label %$61 $61: %488 = phi i8* [%477, %$60] ; # Crt %489 = phi i64 [%478, %$60] ; # Lnk %490 = phi i64 [%479, %$60] ; # Bnd %491 = phi i8* [%480, %$60] ; # Ca %492 = phi i8* [%481, %$60] ; # In %493 = phi i8* [%482, %$60] ; # Out %494 = phi i8* [%483, %$60] ; # Err %495 = phi i8* [%484, %$60] ; # Ctl %496 = phi i8* [%485, %$60] ; # P ; # (let Out: (ioFrame Out) (setq Out (Out: link)) (Out: link P) (set... ; # (Out: link) %497 = bitcast i8* %493 to i8** %498 = load i8*, i8** %497 ; # (Out: link P) %499 = bitcast i8* %493 to i8** store i8* %496, i8** %499 ; # (Out:) br label %$60 $62: %500 = phi i8* [%477, %$60] ; # Crt %501 = phi i64 [%478, %$60] ; # Lnk %502 = phi i64 [%479, %$60] ; # Bnd %503 = phi i8* [%480, %$60] ; # Ca %504 = phi i8* [%481, %$60] ; # In %505 = phi i8* [%482, %$60] ; # Out %506 = phi i8* [%483, %$60] ; # Err %507 = phi i8* [%484, %$60] ; # Ctl %508 = phi i8* [%485, %$60] ; # P ; # (Src: (env $OutFrames i8*) P) %509 = getelementptr i8, i8* %40, i32 112 %510 = getelementptr i8, i8* %509, i32 40 %511 = bitcast i8* %510 to i8** store i8* %508, i8** %511 ; # (let P (val $InFrames) (Src: in P) (until (== In (val $Stdin)) (l... ; # (val $InFrames) %512 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (Src: in P) %513 = getelementptr i8, i8* %40, i32 80 %514 = bitcast i8* %513 to i8** store i8* %512, i8** %514 ; # (until (== In (val $Stdin)) (let In: (ioFrame In) (setq In (In: l... br label %$63 $63: %515 = phi i8* [%500, %$62], [%526, %$64] ; # Crt %516 = phi i64 [%501, %$62], [%527, %$64] ; # Lnk %517 = phi i64 [%502, %$62], [%528, %$64] ; # Bnd %518 = phi i8* [%503, %$62], [%529, %$64] ; # Ca %519 = phi i8* [%504, %$62], [%536, %$64] ; # In %520 = phi i8* [%505, %$62], [%531, %$64] ; # Out %521 = phi i8* [%506, %$62], [%532, %$64] ; # Err %522 = phi i8* [%507, %$62], [%533, %$64] ; # Ctl %523 = phi i8* [%512, %$62], [%530, %$64] ; # P ; # (val $Stdin) %524 = load i8*, i8** @$Stdin ; # (== In (val $Stdin)) %525 = icmp eq i8* %519, %524 br i1 %525, label %$65, label %$64 $64: %526 = phi i8* [%515, %$63] ; # Crt %527 = phi i64 [%516, %$63] ; # Lnk %528 = phi i64 [%517, %$63] ; # Bnd %529 = phi i8* [%518, %$63] ; # Ca %530 = phi i8* [%519, %$63] ; # In %531 = phi i8* [%520, %$63] ; # Out %532 = phi i8* [%521, %$63] ; # Err %533 = phi i8* [%522, %$63] ; # Ctl %534 = phi i8* [%523, %$63] ; # P ; # (let In: (ioFrame In) (setq In (In: link)) (In: link P) (setq P (... ; # (In: link) %535 = bitcast i8* %530 to i8** %536 = load i8*, i8** %535 ; # (In: link P) %537 = bitcast i8* %530 to i8** store i8* %534, i8** %537 ; # (In:) br label %$63 $65: %538 = phi i8* [%515, %$63] ; # Crt %539 = phi i64 [%516, %$63] ; # Lnk %540 = phi i64 [%517, %$63] ; # Bnd %541 = phi i8* [%518, %$63] ; # Ca %542 = phi i8* [%519, %$63] ; # In %543 = phi i8* [%520, %$63] ; # Out %544 = phi i8* [%521, %$63] ; # Err %545 = phi i8* [%522, %$63] ; # Ctl %546 = phi i8* [%523, %$63] ; # P ; # (Src: (env $InFrames i8*) P) %547 = getelementptr i8, i8* %40, i32 112 %548 = getelementptr i8, i8* %547, i32 32 %549 = bitcast i8* %548 to i8** store i8* %546, i8** %549 ; # (let P (val $Catch) (Src: ca P) (while Ca (let Ca: (caFrame Ca) (... ; # (val $Catch) %550 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 24) to i8**) ; # (Src: ca P) %551 = getelementptr i8, i8* %40, i32 72 %552 = bitcast i8* %551 to i8** store i8* %550, i8** %552 ; # (while Ca (let Ca: (caFrame Ca) (setq Ca (Ca: link)) (Ca: link P)... br label %$66 $66: %553 = phi i8* [%538, %$65], [%563, %$67] ; # Crt %554 = phi i64 [%539, %$65], [%564, %$67] ; # Lnk %555 = phi i64 [%540, %$65], [%565, %$67] ; # Bnd %556 = phi i8* [%541, %$65], [%573, %$67] ; # Ca %557 = phi i8* [%542, %$65], [%567, %$67] ; # In %558 = phi i8* [%543, %$65], [%568, %$67] ; # Out %559 = phi i8* [%544, %$65], [%569, %$67] ; # Err %560 = phi i8* [%545, %$65], [%570, %$67] ; # Ctl %561 = phi i8* [%550, %$65], [%566, %$67] ; # P %562 = icmp ne i8* %556, null br i1 %562, label %$67, label %$68 $67: %563 = phi i8* [%553, %$66] ; # Crt %564 = phi i64 [%554, %$66] ; # Lnk %565 = phi i64 [%555, %$66] ; # Bnd %566 = phi i8* [%556, %$66] ; # Ca %567 = phi i8* [%557, %$66] ; # In %568 = phi i8* [%558, %$66] ; # Out %569 = phi i8* [%559, %$66] ; # Err %570 = phi i8* [%560, %$66] ; # Ctl %571 = phi i8* [%561, %$66] ; # P ; # (let Ca: (caFrame Ca) (setq Ca (Ca: link)) (Ca: link P) (setq P (... ; # (Ca: link) %572 = bitcast i8* %566 to i8** %573 = load i8*, i8** %572 ; # (Ca: link P) %574 = bitcast i8* %566 to i8** store i8* %571, i8** %574 ; # (Ca:) br label %$66 $68: %575 = phi i8* [%553, %$66] ; # Crt %576 = phi i64 [%554, %$66] ; # Lnk %577 = phi i64 [%555, %$66] ; # Bnd %578 = phi i8* [%556, %$66] ; # Ca %579 = phi i8* [%557, %$66] ; # In %580 = phi i8* [%558, %$66] ; # Out %581 = phi i8* [%559, %$66] ; # Err %582 = phi i8* [%560, %$66] ; # Ctl %583 = phi i8* [%561, %$66] ; # P ; # (Src: (env $Catch i8*) P) %584 = getelementptr i8, i8* %40, i32 112 %585 = getelementptr i8, i8* %584, i32 24 %586 = bitcast i8* %585 to i8** store i8* %583, i8** %586 ; # (let P (val $Bind) (set 3 (Src: bnd) P) (setq P (Src: bnd)) (Src:... ; # (val $Bind) %587 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* %588 = load i64, i64* %587 ; # (set 3 (Src: bnd) P) ; # (Src: bnd) %589 = getelementptr i8, i8* %40, i32 64 %590 = ptrtoint i8* %589 to i64 %591 = inttoptr i64 %590 to i64* %592 = load i64, i64* %591 %593 = inttoptr i64 %592 to i64* %594 = getelementptr i64, i64* %593, i32 2 store i64 %588, i64* %594 ; # (Src: bnd) %595 = getelementptr i8, i8* %40, i32 64 %596 = ptrtoint i8* %595 to i64 %597 = inttoptr i64 %596 to i64* %598 = load i64, i64* %597 ; # (Src: bnd P) %599 = getelementptr i8, i8* %40, i32 64 %600 = ptrtoint i8* %599 to i64 %601 = inttoptr i64 %600 to i64* store i64 %598, i64* %601 ; # (while Bnd (let Q Bnd (xchg (val 2 Q) Q) (setq Bnd (val 3 Q)) (se... br label %$69 $69: %602 = phi i8* [%575, %$68], [%612, %$70] ; # Crt %603 = phi i64 [%576, %$68], [%613, %$70] ; # Lnk %604 = phi i64 [%577, %$68], [%630, %$70] ; # Bnd %605 = phi i8* [%578, %$68], [%615, %$70] ; # Ca %606 = phi i8* [%579, %$68], [%616, %$70] ; # In %607 = phi i8* [%580, %$68], [%617, %$70] ; # Out %608 = phi i8* [%581, %$68], [%618, %$70] ; # Err %609 = phi i8* [%582, %$68], [%619, %$70] ; # Ctl %610 = phi i64 [%598, %$68], [%614, %$70] ; # P %611 = icmp ne i64 %604, 0 br i1 %611, label %$70, label %$71 $70: %612 = phi i8* [%602, %$69] ; # Crt %613 = phi i64 [%603, %$69] ; # Lnk %614 = phi i64 [%604, %$69] ; # Bnd %615 = phi i8* [%605, %$69] ; # Ca %616 = phi i8* [%606, %$69] ; # In %617 = phi i8* [%607, %$69] ; # Out %618 = phi i8* [%608, %$69] ; # Err %619 = phi i8* [%609, %$69] ; # Ctl %620 = phi i64 [%610, %$69] ; # P ; # (let Q Bnd (xchg (val 2 Q) Q) (setq Bnd (val 3 Q)) (set 3 Q P) (s... ; # (val 2 Q) %621 = inttoptr i64 %614 to i64* %622 = getelementptr i64, i64* %621, i32 1 %623 = load i64, i64* %622 ; # (xchg (val 2 Q) Q) %624 = inttoptr i64 %623 to i64* %625 = load i64, i64* %624 %626 = inttoptr i64 %614 to i64* %627 = load i64, i64* %626 store i64 %627, i64* %624 store i64 %625, i64* %626 ; # (val 3 Q) %628 = inttoptr i64 %614 to i64* %629 = getelementptr i64, i64* %628, i32 2 %630 = load i64, i64* %629 ; # (set 3 Q P) %631 = inttoptr i64 %614 to i64* %632 = getelementptr i64, i64* %631, i32 2 store i64 %620, i64* %632 br label %$69 $71: %633 = phi i8* [%602, %$69] ; # Crt %634 = phi i64 [%603, %$69] ; # Lnk %635 = phi i64 [%604, %$69] ; # Bnd %636 = phi i8* [%605, %$69] ; # Ca %637 = phi i8* [%606, %$69] ; # In %638 = phi i8* [%607, %$69] ; # Out %639 = phi i8* [%608, %$69] ; # Err %640 = phi i8* [%609, %$69] ; # Ctl %641 = phi i64 [%610, %$69] ; # P ; # (Src: (env $Bind any) P) %642 = getelementptr i8, i8* %40, i32 112 %643 = getelementptr i8, i8* %642, i32 8 %644 = ptrtoint i8* %643 to i64 %645 = inttoptr i64 %644 to i64* store i64 %641, i64* %645 ; # (let P (val $Link) (Src: lnk P) (while Lnk (let Q Lnk (setq Lnk (... ; # (val $Link) %646 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %647 = load i64, i64* %646 ; # (Src: lnk P) %648 = getelementptr i8, i8* %40, i32 56 %649 = ptrtoint i8* %648 to i64 %650 = inttoptr i64 %649 to i64* store i64 %647, i64* %650 ; # (while Lnk (let Q Lnk (setq Lnk (val 2 Q)) (set 2 Q P) (setq P Q)... br label %$72 $72: %651 = phi i8* [%633, %$71], [%661, %$73] ; # Crt %652 = phi i64 [%634, %$71], [%672, %$73] ; # Lnk %653 = phi i64 [%635, %$71], [%663, %$73] ; # Bnd %654 = phi i8* [%636, %$71], [%664, %$73] ; # Ca %655 = phi i8* [%637, %$71], [%665, %$73] ; # In %656 = phi i8* [%638, %$71], [%666, %$73] ; # Out %657 = phi i8* [%639, %$71], [%667, %$73] ; # Err %658 = phi i8* [%640, %$71], [%668, %$73] ; # Ctl %659 = phi i64 [%647, %$71], [%662, %$73] ; # P %660 = icmp ne i64 %652, 0 br i1 %660, label %$73, label %$74 $73: %661 = phi i8* [%651, %$72] ; # Crt %662 = phi i64 [%652, %$72] ; # Lnk %663 = phi i64 [%653, %$72] ; # Bnd %664 = phi i8* [%654, %$72] ; # Ca %665 = phi i8* [%655, %$72] ; # In %666 = phi i8* [%656, %$72] ; # Out %667 = phi i8* [%657, %$72] ; # Err %668 = phi i8* [%658, %$72] ; # Ctl %669 = phi i64 [%659, %$72] ; # P ; # (let Q Lnk (setq Lnk (val 2 Q)) (set 2 Q P) (setq P Q)) ; # (val 2 Q) %670 = inttoptr i64 %662 to i64* %671 = getelementptr i64, i64* %670, i32 1 %672 = load i64, i64* %671 ; # (set 2 Q P) %673 = inttoptr i64 %662 to i64* %674 = getelementptr i64, i64* %673, i32 1 store i64 %669, i64* %674 br label %$72 $74: %675 = phi i8* [%651, %$72] ; # Crt %676 = phi i64 [%652, %$72] ; # Lnk %677 = phi i64 [%653, %$72] ; # Bnd %678 = phi i8* [%654, %$72] ; # Ca %679 = phi i8* [%655, %$72] ; # In %680 = phi i8* [%656, %$72] ; # Out %681 = phi i8* [%657, %$72] ; # Err %682 = phi i8* [%658, %$72] ; # Ctl %683 = phi i64 [%659, %$72] ; # P ; # (Src: (env $Link any) P) %684 = getelementptr i8, i8* %40, i32 112 %685 = ptrtoint i8* %684 to i64 %686 = inttoptr i64 %685 to i64* store i64 %683, i64* %686 br label %$53 $53: %687 = phi i8* [%380, %$51], [%675, %$74] ; # Crt %688 = phi i64 [%381, %$51], [%676, %$74] ; # Lnk %689 = phi i64 [%382, %$51], [%677, %$74] ; # Bnd %690 = phi i8* [%383, %$51], [%678, %$74] ; # Ca %691 = phi i8* [%384, %$51], [%679, %$74] ; # In %692 = phi i8* [%385, %$51], [%680, %$74] ; # Out %693 = phi i8* [%386, %$51], [%681, %$74] ; # Err %694 = phi i8* [%387, %$51], [%682, %$74] ; # Ctl ; # (Src:) ; # (loadCoEnv (Src:)) %695 = call i64 @loadCoEnv(i8* %40) ; # (drop *Safe) %696 = inttoptr i64 %19 to i64* %697 = getelementptr i64, i64* %696, i32 1 %698 = load i64, i64* %697 %699 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %698, i64* %699 ret i64 %695 } 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 600) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %54 ; # (let Raw (val Termio) (setCooked) (pushOutFile (b8 (ioFrame T)) (... ; # (val Termio) %55 = load i8*, i8** @Termio ; # (setCooked) call void @setCooked() ; # (b8 (ioFrame T)) %56 = alloca i8, i64 28 ; # (val $OutFiles) %57 = load i8**, i8*** @$OutFiles ; # (val 2 (val $OutFiles)) %58 = getelementptr i8*, i8** %57, i32 1 %59 = load i8*, i8** %58 ; # (pushOutFile (b8 (ioFrame T)) (val 2 (val $OutFiles)) 0) call void @pushOutFile(i8* %56, i8* %59, i32 0) ; # (print Exe) call void @print(i64 %19) ; # (newline) call void @newline() ; # (repl 0 ($ "! ") $Nil) %60 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$78 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (popOutFiles) call void @popOutFiles() ; # (tosOutFile) call void @tosOutFile() ; # (when Raw (setRaw)) %61 = icmp ne i8* %55, null br i1 %61, label %$7, label %$8 $7: %62 = phi i64 [%19, %$5] ; # Exe ; # (setRaw) call void @setRaw() br label %$8 $8: %63 = phi i64 [%19, %$5], [%62, %$7] ; # Exe ; # (val $Up) %64 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 728) to i64) to i64* %65 = load i64, i64* %64 ; # (let P (val $Bind) (set $Run (val P)) (setq P (val 3 P)) (set $Up... ; # (val $Bind) %66 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* %67 = load i64, i64* %66 ; # (set $Run (val P)) ; # (val P) %68 = inttoptr i64 %67 to i64* %69 = load i64, i64* %68 %70 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 600) to i64) to i64* store i64 %69, i64* %70 ; # (val 3 P) %71 = inttoptr i64 %67 to i64* %72 = getelementptr i64, i64* %71, i32 2 %73 = load i64, i64* %72 ; # (set $Up (val P)) ; # (val P) %74 = inttoptr i64 %73 to i64* %75 = load i64, i64* %74 %76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 728) to i64) to i64* store i64 %75, i64* %76 ; # (val 3 P) %77 = inttoptr i64 %73 to i64* %78 = getelementptr i64, i64* %77, i32 2 %79 = load i64, i64* %78 ; # (set $At (val P)) ; # (val P) %80 = inttoptr i64 %79 to i64* %81 = load i64, i64* %80 %82 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 %81, i64* %82 ; # (set $Bind (val 3 P)) ; # (val 3 P) %83 = inttoptr i64 %79 to i64* %84 = getelementptr i64, i64* %83, i32 2 %85 = load i64, i64* %84 %86 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 8) to i64) to i64* store i64 %85, i64* %86 ; # (set $Break 0) %87 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 16) to i64) to i64* store i64 0, i64* %87 br label %$6 $6: %88 = phi i64 [%17, %$2], [%65, %$8] ; # Exe ret i64 %88 } 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 ([870 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 ([870 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 ([17 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]* @$79 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 824) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (val $OutFrames) %48 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (popInFiles) call void @popInFiles() ; # (tosInFile) call void @tosInFile() ; # (popOutFiles) call void @popOutFiles() ; # (tosOutFile) call void @tosOutFile() ; # (prog1 (if (pair (cdr Exe)) (run @) (eval (val $Up))) (pushOutFil... ; # (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 ([870 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] ; # -> ; # (Out:) ; # (Out: file) %91 = getelementptr i8, i8* %48, i32 8 %92 = bitcast i8* %91 to i8** %93 = load i8*, i8** %92 ; # (Out: pid) %94 = getelementptr i8, i8* %48, i32 24 %95 = bitcast i8* %94 to i32* %96 = load i32, i32* %95 ; # (pushOutFile (Out:) (Out: file) (Out: pid)) call void @pushOutFile(i8* %48, i8* %93, i32 %96) ; # (In:) ; # (In: file) %97 = getelementptr i8, i8* %47, i32 8 %98 = bitcast i8* %97 to i8** %99 = load i8*, i8** %98 ; # (In: pid) %100 = getelementptr i8, i8* %47, i32 24 %101 = bitcast i8* %100 to i32* %102 = load i32, i32* %101 ; # (pushInFile (In:) (In: file) (In: pid)) call void @pushInFile(i8* %47, i8* %99, i32 %102) ; # (set $Run Run $At At $Dbg Dbg) %103 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 600) to i64) to i64* store i64 %25, i64* %103 %104 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 440) to i64) to i64* store i64 %15, i64* %104 %105 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 824) to i64) to i64* store i64 %5, i64* %105 ; # (drop *Safe) %106 = inttoptr i64 %9 to i64* %107 = getelementptr i64, i64* %106, i32 1 %108 = load i64, i64* %107 %109 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %108, i64* %109 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 ([870 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 ([870 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 ([870 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** @$OutFile ; # (i8** $Put) %42 = bitcast void(i8)** @$Put 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** @$OutFile ; # (fun (void i8) _putStdout) store void(i8)* @_putStdout, void(i8)** @$Put ; # (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 ([17 x i64]* @env to i8*), i32 128) to i32*) ; # (inc (val $Trace)) %56 = add i32 %55, 1 store i32 %56, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 128) 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]* @$80 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 ([870 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 ([17 x i64]* @env to i8*), i32 80) 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 ([870 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)** @$Put to i8** store i8* %43, i8** %101 store i8* %41, i8** @$OutFile ; # (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** @$OutFile ; # (fun (void i8) _putStdout) store void(i8)* @_putStdout, void(i8)** @$Put ; # (let I (val $Trace) (trace I Y) (set $Trace (dec I))) ; # (val $Trace) %131 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 128) 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 ([17 x i64]* @env to i8*), i32 128) to i32*) ; # (outString ($ " = ")) call void @outString(i8* bitcast ([4 x i8]* @$81 to i8*)) ; # (print @) call void @print(i64 %127) ; # (newline) call void @newline() ; # (set (i8** $Put) Put $OutFile Out) ; # (i8** $Put) %133 = bitcast void(i8)** @$Put to i8** store i8* %43, i8** %133 store i8* %41, i8** @$OutFile 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 Exe (evSym... ; # (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 Exe (evSym X)) %19 = call i64 @xName(i64 %0, 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 ; # (let A Av (while (pair (shift X)) (let Nm (xName Exe (evSym X)) (... ; # (while (pair (shift X)) (let Nm (xName Exe (evSym X)) (set (inc '... br label %$5 $5: %23 = phi i64 [%3, %$4], [%30, %$6] ; # X %24 = phi i8** [%17, %$4], [%34, %$6] ; # A ; # (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 %$6, label %$7 $6: %30 = phi i64 [%27, %$5] ; # X %31 = phi i8** [%24, %$5] ; # A ; # (let Nm (xName Exe (evSym X)) (set (inc 'A) (bufString Nm (b8 (bu... ; # (evSym X) %32 = call i64 @evSym(i64 %30) ; # (xName Exe (evSym X)) %33 = call i64 @xName(i64 %0, i64 %32) ; # (set (inc 'A) (bufString Nm (b8 (bufSize Nm)))) ; # (inc 'A) %34 = getelementptr i8*, i8** %31, i32 1 ; # (bufSize Nm) %35 = call i64 @bufSize(i64 %33) ; # (b8 (bufSize Nm)) %36 = alloca i8, i64 %35 ; # (bufString Nm (b8 (bufSize Nm))) %37 = call i8* @bufString(i64 %33, i8* %36) store i8* %37, i8** %34 br label %$5 $7: %38 = phi i64 [%27, %$5] ; # X %39 = phi i8** [%24, %$5] ; # A ; # (set (inc 'A) null) ; # (inc 'A) %40 = getelementptr i8*, i8** %39, i32 1 store i8* null, i8** %40 ; # (flushAll) call void @flushAll() ; # (val Av) %41 = load i8*, i8** %17 ; # (execvp (val Av) Av) %42 = call i32 @execvp(i8* %41, i8** %17) ; # (val Av) %43 = load i8*, i8** %17 ; # (execErr (val Av)) call void @execErr(i8* %43) unreachable } define i64 @_call(i64) align 8 { $1: ; # (let (X (cdr Exe) Av (b8* (inc (length X))) Cmd (xName Exe (evSym... ; # (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 Exe (evSym X)) %19 = call i64 @xName(i64 %0, 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 ; # (let A Av (while (pair (shift X)) (let Nm (xName Exe (evSym X)) (... ; # (while (pair (shift X)) (let Nm (xName Exe (evSym X)) (set (inc '... br label %$5 $5: %23 = phi i64 [%3, %$4], [%30, %$6] ; # X %24 = phi i8** [%17, %$4], [%34, %$6] ; # A ; # (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 %$6, label %$7 $6: %30 = phi i64 [%27, %$5] ; # X %31 = phi i8** [%24, %$5] ; # A ; # (let Nm (xName Exe (evSym X)) (set (inc 'A) (bufString Nm (b8 (bu... ; # (evSym X) %32 = call i64 @evSym(i64 %30) ; # (xName Exe (evSym X)) %33 = call i64 @xName(i64 %0, i64 %32) ; # (set (inc 'A) (bufString Nm (b8 (bufSize Nm)))) ; # (inc 'A) %34 = getelementptr i8*, i8** %31, i32 1 ; # (bufSize Nm) %35 = call i64 @bufSize(i64 %33) ; # (b8 (bufSize Nm)) %36 = alloca i8, i64 %35 ; # (bufString Nm (b8 (bufSize Nm))) %37 = call i8* @bufString(i64 %33, i8* %36) store i8* %37, i8** %34 br label %$5 $7: %38 = phi i64 [%27, %$5] ; # X %39 = phi i8** [%24, %$5] ; # A ; # (set (inc 'A) null) ; # (inc 'A) %40 = getelementptr i8*, i8** %39, i32 1 store i8* null, i8** %40 ; # (flushAll) call void @flushAll() ; # (cond ((lt0 (fork)) (forkErr Exe)) ((=0 @) (setpgid 0 0) (execvp ... ; # (fork) %41 = call i32 @fork() ; # (lt0 (fork)) %42 = icmp slt i32 %41, 0 br i1 %42, label %$10, label %$9 $10: %43 = phi i64 [%38, %$7] ; # X ; # (forkErr Exe) call void @forkErr(i64 %0) unreachable $9: %44 = phi i64 [%38, %$7] ; # X ; # (=0 @) %45 = icmp eq i32 %41, 0 br i1 %45, label %$12, label %$11 $12: %46 = phi i64 [%44, %$9] ; # X ; # (setpgid 0 0) %47 = call i32 @setpgid(i32 0, i32 0) ; # (val Av) %48 = load i8*, i8** %17 ; # (execvp (val Av) Av) %49 = call i32 @execvp(i8* %48, i8** %17) ; # (val Av) %50 = load i8*, i8** %17 ; # (execErr (val Av)) call void @execErr(i8* %50) unreachable $11: %51 = phi i64 [%44, %$9] ; # X br label %$8 $8: %52 = phi i64 [%51, %$11] ; # X %53 = phi i64 [0, %$11] ; # -> ; # (let (Pid @ Res (b32 1)) (setpgid Pid 0) (tcsetpgrp 0 Pid) (loop ... ; # (b32 1) %54 = alloca i32, i64 1 ; # (setpgid Pid 0) %55 = call i32 @setpgid(i32 %41, i32 0) ; # (tcsetpgrp 0 Pid) %56 = call i32 @tcsetpgrp(i32 0, i32 %41) ; # (loop (while (lt0 (waitWuntraced Pid Res)) (unless (== (gErrno) E... br label %$13 $13: %57 = phi i64 [%52, %$8], [%85, %$21] ; # X ; # (while (lt0 (waitWuntraced Pid Res)) (unless (== (gErrno) EINTR) ... br label %$14 $14: %58 = phi i64 [%57, %$13], [%65, %$20] ; # X ; # (waitWuntraced Pid Res) %59 = call i32 @waitWuntraced(i32 %41, i32* %54) ; # (lt0 (waitWuntraced Pid Res)) %60 = icmp slt i32 %59, 0 br i1 %60, label %$15, label %$16 $15: %61 = phi i64 [%58, %$14] ; # X ; # (unless (== (gErrno) EINTR) (err Exe 0 ($ "wait pid") null)) ; # (gErrno) %62 = call i32 @gErrno() ; # (== (gErrno) EINTR) %63 = icmp eq i32 %62, 2 br i1 %63, label %$18, label %$17 $17: %64 = phi i64 [%61, %$15] ; # X ; # (err Exe 0 ($ "wait pid") null) call void @err(i64 %0, i64 0, i8* bitcast ([9 x i8]* @$82 to i8*), i8* null) unreachable $18: %65 = phi i64 [%61, %$15] ; # X ; # (sigChk Exe) %66 = load i32, i32* bitcast ([16 x i32]* @$Signal to i32*) %67 = icmp ne i32 %66, 0 br i1 %67, label %$19, label %$20 $19: call void @sighandler(i64 %0) br label %$20 $20: br label %$14 $16: %68 = phi i64 [%58, %$14] ; # X ; # (getpgrp) %69 = call i32 @getpgrp() ; # (tcsetpgrp 0 (getpgrp)) %70 = call i32 @tcsetpgrp(i32 0, i32 %69) ; # (? (=0 (wifStopped Res)) (set $At2 (cnt (i64 (val Res)))) (if (va... ; # (wifStopped Res) %71 = call i32 @wifStopped(i32* %54) ; # (=0 (wifStopped Res)) %72 = icmp eq i32 %71, 0 br i1 %72, label %$23, label %$21 $23: %73 = phi i64 [%68, %$16] ; # X ; # (set $At2 (cnt (i64 (val Res)))) ; # (val Res) %74 = load i32, i32* %54 ; # (i64 (val Res)) %75 = sext i32 %74 to i64 ; # (cnt (i64 (val Res))) %76 = shl i64 %75, 4 %77 = or i64 %76, 2 %78 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 456) to i64) to i64* store i64 %77, i64* %78 ; # (if (val Res) $Nil $T) ; # (val Res) %79 = load i32, i32* %54 %80 = icmp ne i32 %79, 0 br i1 %80, label %$24, label %$25 $24: %81 = phi i64 [%73, %$23] ; # X br label %$26 $25: %82 = phi i64 [%73, %$23] ; # X br label %$26 $26: %83 = phi i64 [%81, %$24], [%82, %$25] ; # X %84 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$24], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$25] ; # -> br label %$22 $21: %85 = phi i64 [%68, %$16] ; # X ; # (repl 0 ($ "+ ") $Nil) %86 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$83 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (tcsetpgrp 0 Pid) %87 = call i32 @tcsetpgrp(i32 0, i32 %41) ; # (val SIGCONT Sig) %88 = getelementptr i32, i32* @Sig, i32 8 %89 = load i32, i32* %88 ; # (kill Pid (val SIGCONT Sig)) %90 = call i32 @kill(i32 %41, i32 %89) br label %$13 $22: %91 = phi i64 [%83, %$26] ; # X %92 = phi i64 [%84, %$26] ; # -> ret i64 %92 } define i64 @_ipid(i64) align 8 { $1: ; # (let Io: (ioFrame (val $InFrames)) (if (and (Io:) (> (Io: pid) 1)... ; # (val $InFrames) %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 32) to i8**) ; # (if (and (Io:) (> (Io: pid) 1)) (cnt (i64 (Io: pid))) $Nil) ; # (and (Io:) (> (Io: pid) 1)) ; # (Io:) %2 = icmp ne i8* %1, null br i1 %2, label %$3, label %$2 $3: ; # (Io: pid) %3 = getelementptr i8, i8* %1, i32 24 %4 = bitcast i8* %3 to i32* %5 = load i32, i32* %4 ; # (> (Io: pid) 1) %6 = icmp sgt i32 %5, 1 br label %$2 $2: %7 = phi i1 [0, %$1], [%6, %$3] ; # -> br i1 %7, label %$4, label %$5 $4: ; # (Io: pid) %8 = getelementptr i8, i8* %1, i32 24 %9 = bitcast i8* %8 to i32* %10 = load i32, i32* %9 ; # (i64 (Io: pid)) %11 = sext i32 %10 to i64 ; # (cnt (i64 (Io: pid))) %12 = shl i64 %11, 4 %13 = or i64 %12, 2 br label %$6 $5: br label %$6 $6: %14 = phi i64 [%13, %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$5] ; # -> ret i64 %14 } define i64 @_opid(i64) align 8 { $1: ; # (let Io: (ioFrame (val $OutFrames)) (if (and (Io:) (> (Io: pid) 1... ; # (val $OutFrames) %1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 40) to i8**) ; # (if (and (Io:) (> (Io: pid) 1)) (cnt (i64 (Io: pid))) $Nil) ; # (and (Io:) (> (Io: pid) 1)) ; # (Io:) %2 = icmp ne i8* %1, null br i1 %2, label %$3, label %$2 $3: ; # (Io: pid) %3 = getelementptr i8, i8* %1, i32 24 %4 = bitcast i8* %3 to i32* %5 = load i32, i32* %4 ; # (> (Io: pid) 1) %6 = icmp sgt i32 %5, 1 br label %$2 $2: %7 = phi i1 [0, %$1], [%6, %$3] ; # -> br i1 %7, label %$4, label %$5 $4: ; # (Io: pid) %8 = getelementptr i8, i8* %1, i32 24 %9 = bitcast i8* %8 to i32* %10 = load i32, i32* %9 ; # (i64 (Io: pid)) %11 = sext i32 %10 to i64 ; # (cnt (i64 (Io: pid))) %12 = shl i64 %11, 4 %13 = or i64 %12, 2 br label %$6 $5: br label %$6 $6: %14 = phi i64 [%13, %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$5] ; # -> ret i64 %14 } 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 216) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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]* @$84 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save (cons N $Nil)) %19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 x i64]* @env to i8*), i32 104) to i64) to i64* %2 = load i64, i64* %1 ; # (val $Yoke) %3 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 112) 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %7 ; # (link (push $Nil NIL)) %8 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 112) to i64) to i64* store i64 %6, i64* %13 %14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 104) 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 $Make Make $Yoke Yoke) %33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 104) to i64) to i64* store i64 %2, i64* %33 %34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 112) to i64) to i64* store i64 %4, i64* %34 ; # (pop R) %35 = inttoptr i64 %6 to i64* %36 = load i64, i64* %35 %37 = inttoptr i64 %6 to i64* %38 = getelementptr i64, i64* %37, i32 1 %39 = load i64, i64* %38 %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %39, i64* %40 ret i64 %36 } 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 ([17 x i64]* @env to i8*), i32 104) 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) (set (val $Yoke) (eval (++ X))) (let Y (eval (car ... ; # (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 ; # (set (val $Yoke) (eval (++ X))) ; # (val $Yoke) %12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 112) 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 ; # (let Y (eval (car X)) (when (atom Y) (setq Y (val (val $Yoke))) (... ; # (car X) %27 = inttoptr i64 %17 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 %$13, label %$12 $13: br label %$11 $12: %31 = and i64 %28, 8 %32 = icmp ne i64 %31, 0 br i1 %32, label %$15, label %$14 $15: %33 = inttoptr i64 %28 to i64* %34 = load i64, i64* %33 br label %$11 $14: %35 = call i64 @evList(i64 %28) br label %$11 $11: %36 = phi i64 [%28, %$13], [%34, %$15], [%35, %$14] ; # -> ; # (when (atom Y) (setq Y (val (val $Yoke))) (while (pair (cdr Y)) (... ; # (atom Y) %37 = and i64 %36, 15 %38 = icmp ne i64 %37, 0 br i1 %38, label %$16, label %$17 $16: %39 = phi i64 [%17, %$11] ; # X %40 = phi i64 [%36, %$11] ; # Y ; # (val $Yoke) %41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 112) to i64) to i64* %42 = load i64, i64* %41 ; # (val (val $Yoke)) %43 = inttoptr i64 %42 to i64* %44 = load i64, i64* %43 ; # (while (pair (cdr Y)) (setq Y @)) br label %$18 $18: %45 = phi i64 [%39, %$16], [%52, %$19] ; # X %46 = phi i64 [%44, %$16], [%49, %$19] ; # Y ; # (cdr Y) %47 = inttoptr i64 %46 to i64* %48 = getelementptr i64, i64* %47, i32 1 %49 = load i64, i64* %48 ; # (pair (cdr Y)) %50 = and i64 %49, 15 %51 = icmp eq i64 %50, 0 br i1 %51, label %$19, label %$20 $19: %52 = phi i64 [%45, %$18] ; # X %53 = phi i64 [%46, %$18] ; # Y br label %$18 $20: %54 = phi i64 [%45, %$18] ; # X %55 = phi i64 [%46, %$18] ; # Y br label %$17 $17: %56 = phi i64 [%17, %$11], [%54, %$20] ; # X %57 = phi i64 [%36, %$11], [%55, %$20] ; # Y ; # (set $Make (ofs Y 1)) ; # (ofs Y 1) %58 = add i64 %57, 8 %59 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 104) to i64) to i64* store i64 %58, i64* %59 br label %$5 $5: %60 = phi i64 [%8, %$3], [%56, %$17] ; # X ; # (val $Yoke) %61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 112) to i64) to i64* %62 = load i64, i64* %61 ; # (val (val $Yoke)) %63 = inttoptr i64 %62 to i64* %64 = load i64, i64* %63 ret i64 %64 } 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 ([17 x i64]* @env to i8*), i32 104) 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 ([17 x i64]* @env to i8*), i32 104) 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 ([17 x i64]* @env to i8*), i32 104) 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 ([17 x i64]* @env to i8*), i32 104) 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 ([17 x i64]* @env to i8*), i32 104) 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 ([870 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 ([17 x i64]* @env to i8*), i32 104) 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 ([17 x i64]* @env to i8*), i32 104) 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 ([17 x i64]* @env to i8*), i32 112) 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 ([17 x i64]* @env to i8*), i32 104) 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 ([17 x i64]* @env to i8*), i32 104) 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Z) %80 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([870 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], [%140, %$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 (save @) R (safe (cons (++ Y) Y)... ; # (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 (save @) R (safe (cons (++ Y) Y)) Z R) (while (pair Y) (s... ; # (save @) %35 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %36 = load i64, i64* %35 %37 = alloca i64, i64 2, align 16 %38 = ptrtoint i64* %37 to i64 %39 = inttoptr i64 %38 to i64* store i64 %31, i64* %39 %40 = add i64 %38, 8 %41 = inttoptr i64 %40 to i64* store i64 %36, i64* %41 %42 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %38, i64* %42 ; # (++ Y) %43 = inttoptr i64 %31 to i64* %44 = load i64, i64* %43 %45 = getelementptr i64, i64* %43, i32 1 %46 = load i64, i64* %45 ; # (cons (++ Y) Y) %47 = call i64 @cons(i64 %44, i64 %46) ; # (safe (cons (++ Y) Y)) %48 = inttoptr i64 %38 to i64* store i64 %47, i64* %48 ; # (while (pair Y) (setq Z (set 2 Z (cons (++ Y) Y)))) br label %$18 $18: %49 = phi i64 [%34, %$17], [%54, %$19] ; # X %50 = phi i64 [%46, %$17], [%60, %$19] ; # Y %51 = phi i64 [%47, %$17], [%61, %$19] ; # Z ; # (pair Y) %52 = and i64 %50, 15 %53 = icmp eq i64 %52, 0 br i1 %53, label %$19, label %$20 $19: %54 = phi i64 [%49, %$18] ; # X %55 = phi i64 [%50, %$18] ; # Y %56 = phi i64 [%51, %$18] ; # Z ; # (set 2 Z (cons (++ Y) Y)) ; # (++ Y) %57 = inttoptr i64 %55 to i64* %58 = load i64, i64* %57 %59 = getelementptr i64, i64* %57, i32 1 %60 = load i64, i64* %59 ; # (cons (++ Y) Y) %61 = call i64 @cons(i64 %58, i64 %60) %62 = inttoptr i64 %56 to i64* %63 = getelementptr i64, i64* %62, i32 1 store i64 %61, i64* %63 br label %$18 $20: %64 = phi i64 [%49, %$18] ; # X %65 = phi i64 [%50, %$18] ; # Y %66 = phi i64 [%51, %$18] ; # Z ; # (while (pair (cdr (shift X))) (save (setq Y (eval (car X))) (whil... br label %$21 $21: %67 = phi i64 [%64, %$20], [%114, %$31] ; # X %68 = phi i64 [%65, %$20], [%115, %$31] ; # Y %69 = phi i64 [%66, %$20], [%116, %$31] ; # Z ; # (shift X) %70 = inttoptr i64 %67 to i64* %71 = getelementptr i64, i64* %70, i32 1 %72 = load i64, i64* %71 ; # (cdr (shift X)) %73 = inttoptr i64 %72 to i64* %74 = getelementptr i64, i64* %73, i32 1 %75 = load i64, i64* %74 ; # (pair (cdr (shift X))) %76 = and i64 %75, 15 %77 = icmp eq i64 %76, 0 br i1 %77, label %$22, label %$23 $22: %78 = phi i64 [%72, %$21] ; # X %79 = phi i64 [%68, %$21] ; # Y %80 = phi i64 [%69, %$21] ; # Z ; # (car X) %81 = inttoptr i64 %78 to i64* %82 = load i64, i64* %81 ; # (eval (car X)) %83 = and i64 %82, 6 %84 = icmp ne i64 %83, 0 br i1 %84, label %$26, label %$25 $26: br label %$24 $25: %85 = and i64 %82, 8 %86 = icmp ne i64 %85, 0 br i1 %86, label %$28, label %$27 $28: %87 = inttoptr i64 %82 to i64* %88 = load i64, i64* %87 br label %$24 $27: %89 = call i64 @evList(i64 %82) br label %$24 $24: %90 = phi i64 [%82, %$26], [%88, %$28], [%89, %$27] ; # -> ; # (save (setq Y (eval (car X))) (while (pair Y) (setq Z (set 2 Z (c... %91 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %94, i64* %98 ; # (while (pair Y) (setq Z (set 2 Z (cons (++ Y) Y)))) br label %$29 $29: %99 = phi i64 [%78, %$24], [%104, %$30] ; # X %100 = phi i64 [%90, %$24], [%110, %$30] ; # Y %101 = phi i64 [%80, %$24], [%111, %$30] ; # Z ; # (pair Y) %102 = and i64 %100, 15 %103 = icmp eq i64 %102, 0 br i1 %103, label %$30, label %$31 $30: %104 = phi i64 [%99, %$29] ; # X %105 = phi i64 [%100, %$29] ; # Y %106 = phi i64 [%101, %$29] ; # Z ; # (set 2 Z (cons (++ Y) Y)) ; # (++ Y) %107 = inttoptr i64 %105 to i64* %108 = load i64, i64* %107 %109 = getelementptr i64, i64* %107, i32 1 %110 = load i64, i64* %109 ; # (cons (++ Y) Y) %111 = call i64 @cons(i64 %108, i64 %110) %112 = inttoptr i64 %106 to i64* %113 = getelementptr i64, i64* %112, i32 1 store i64 %111, i64* %113 br label %$29 $31: %114 = phi i64 [%99, %$29] ; # X %115 = phi i64 [%100, %$29] ; # Y %116 = phi i64 [%101, %$29] ; # Z ; # drop %117 = inttoptr i64 %94 to i64* %118 = getelementptr i64, i64* %117, i32 1 %119 = load i64, i64* %118 %120 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %119, i64* %120 br label %$21 $23: %121 = phi i64 [%72, %$21] ; # X %122 = phi i64 [%68, %$21] ; # Y %123 = phi i64 [%69, %$21] ; # Z ; # (set 2 Z (eval (car X))) ; # (car X) %124 = inttoptr i64 %121 to i64* %125 = load i64, i64* %124 ; # (eval (car X)) %126 = and i64 %125, 6 %127 = icmp ne i64 %126, 0 br i1 %127, label %$34, label %$33 $34: br label %$32 $33: %128 = and i64 %125, 8 %129 = icmp ne i64 %128, 0 br i1 %129, label %$36, label %$35 $36: %130 = inttoptr i64 %125 to i64* %131 = load i64, i64* %130 br label %$32 $35: %132 = call i64 @evList(i64 %125) br label %$32 $32: %133 = phi i64 [%125, %$34], [%131, %$36], [%132, %$35] ; # -> %134 = inttoptr i64 %123 to i64* %135 = getelementptr i64, i64* %134, i32 1 store i64 %133, i64* %135 ; # (drop *Safe) %136 = inttoptr i64 %38 to i64* %137 = getelementptr i64, i64* %136, i32 1 %138 = load i64, i64* %137 %139 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %138, i64* %139 br label %$4 $16: %140 = phi i64 [%21, %$11] ; # X br label %$2 $4: %141 = phi i64 [%10, %$6], [%121, %$32] ; # X %142 = phi i64 [%20, %$6], [%47, %$32] ; # -> ret i64 %142 } 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %60 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Z) %67 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %66 ; # (link (push P NIL)) %67 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %74 ; # (link (push Q NIL)) %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%215, %$31] ; # P %85 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Z) %128 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$20], [%15, %$22], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %67, i64* %68 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %81, i64* %82 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %44 ; # (link (push $Nil NIL)) %45 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %44 ; # (link (push $Nil NIL)) %45 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%48, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %59, i64* %60 ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 -2 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 -2 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 -2 0 0 null) %17 = call i64 @fmtNum(i64 %16, i64 -2, 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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))) (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] ; # -> ; # (save (eval (++ X))) %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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], [%53, %$18] ; # 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 ; # (shift Z) %51 = inttoptr i64 %50 to i64* %52 = getelementptr i64, i64* %51, i32 1 %53 = load i64, i64* %52 br label %$12 $14: %54 = phi i64 [%37, %$15], [%49, %$19] ; # Z %55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19] ; # -> ; # (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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %58, i64* %59 ret i64 %55 } define i64 @_rassoc(i64) align 8 { $1: ; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X))) (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] ; # -> ; # (save (eval (++ X))) %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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], [%54, %$18] ; # 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 ; # (shift Z) %52 = inttoptr i64 %51 to i64* %53 = getelementptr i64, i64* %52, i32 1 %54 = load i64, i64* %53 br label %$12 $14: %55 = phi i64 [%37, %$15], [%50, %$19] ; # Z %56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19] ; # -> ; # (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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %59, i64* %60 ret i64 %56 } define i64 @_asoq(i64) align 8 { $1: ; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X))) (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] ; # -> ; # (save (eval (++ X))) %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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], [%53, %$18] ; # 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 ; # (shift Z) %51 = inttoptr i64 %50 to i64* %52 = getelementptr i64, i64* %51, i32 1 %53 = load i64, i64* %52 br label %$12 $14: %54 = phi i64 [%37, %$15], [%49, %$19] ; # Z %55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19] ; # -> ; # (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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %58, i64* %59 ret i64 %55 } define i64 @_rasoq(i64) align 8 { $1: ; # (let (X (cdr Exe) Y (save (eval (++ X))) Z (eval (car X))) (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] ; # -> ; # (save (eval (++ X))) %16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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], [%54, %$18] ; # 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 ; # (shift Z) %52 = inttoptr i64 %51 to i64* %53 = getelementptr i64, i64* %52, i32 1 %54 = load i64, i64* %53 br label %$12 $14: %55 = phi i64 [%37, %$15], [%50, %$19] ; # Z %56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19] ; # -> ; # (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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %59, i64* %60 ret i64 %56 } 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %49, i64* %50 ret i64 %46 } define i64 @fill(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 ([870 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 ([870 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 (fill X Y) @... ; # (== Z $Up) %57 = icmp eq i64 %54, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 (fill X Y) @ X) (save (setq... ; # (++ 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 (fill X Y) @ X) (save (setq Z V) (if (atom V) (s... ; # (nil? V) %72 = icmp eq i64 %71, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 (fill X Y) @ X) ; # (fill X Y) %76 = call i64 @fill(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 ([17 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 ([17 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 ([870 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 (fill X Y) @ X)) ; # (if (fill X Y) @ X) ; # (fill X Y) %126 = call i64 @fill(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 ([17 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 ; # (let V (fill Z Y) (cond (V (save V (cons V (if (fill X Y) @ X))))... ; # (fill Z Y) %150 = call i64 @fill(i64 %149, i64 %1) ; # (cond (V (save V (cons V (if (fill X Y) @ X)))) ((fill X Y) (cons... %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 V (cons V (if (fill X Y) @ X))) %154 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %157, i64* %161 ; # (if (fill X Y) @ X) ; # (fill X Y) %162 = call i64 @fill(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 V (if (fill 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 ([17 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 ; # (fill X Y) %178 = call i64 @fill(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 @_fill(i64) align 8 { $1: ; # (let (X (cdr Exe) Y (save (eval (++ X)))) (if (fill Y (save (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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %19, i64* %23 ; # (if (fill Y (save (eval (car X)))) @ Y) ; # (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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %37, i64* %41 ; # (fill Y (save (eval (car X)))) %42 = call i64 @fill(i64 %15, i64 %33) %43 = icmp ne i64 %42, 0 br i1 %43, label %$12, label %$13 $12: br label %$14 $13: br label %$14 $14: %44 = phi i64 [%42, %$12], [%15, %$13] ; # -> ; # (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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %47, i64* %48 ret i64 %44 } @$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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %124 ; # (link (push $Nil NIL)) %125 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$80], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %390 ; # (link (push $Nil NIL)) %391 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %405, i64* %411 ; # (push NIL $Nil ZERO NIL) %412 = alloca i64, i64 4, align 16 %413 = ptrtoint i64* %412 to i64 %414 = add i64 %413, 8 %415 = inttoptr i64 %414 to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %415 %416 = add i64 %413, 16 %417 = inttoptr i64 %416 to i64* store i64 2, i64* %417 ; # (push NIL B ZERO NIL) %418 = alloca i64, i64 4, align 16 %419 = ptrtoint i64* %418 to i64 %420 = add i64 %419, 8 %421 = inttoptr i64 %420 to i64* store i64 %413, i64* %421 %422 = add i64 %419, 16 %423 = inttoptr i64 %422 to i64* store i64 2, i64* %423 ; # (car X) %424 = inttoptr i64 %7 to i64* %425 = load i64, i64* %424 ; # (eval (car X)) %426 = and i64 %425, 6 %427 = icmp ne i64 %426, 0 br i1 %427, label %$52, label %$51 $52: br label %$50 $51: %428 = and i64 %425, 8 %429 = icmp ne i64 %428, 0 br i1 %429, label %$54, label %$53 $54: %430 = inttoptr i64 %425 to i64* %431 = load i64, i64* %430 br label %$50 $53: %432 = call i64 @evList(i64 %425) br label %$50 $50: %433 = phi i64 [%425, %$52], [%431, %$54], [%432, %$53] ; # -> ; # (push NIL A ZERO (eval (car X)) NIL) %434 = alloca i64, i64 5, align 16 %435 = ptrtoint i64* %434 to i64 %436 = add i64 %435, 8 %437 = inttoptr i64 %436 to i64* store i64 %419, i64* %437 %438 = add i64 %435, 16 %439 = inttoptr i64 %438 to i64* store i64 2, i64* %439 %440 = add i64 %435, 24 %441 = inttoptr i64 %440 to i64* store i64 %433, i64* %441 ; # (set B (ofs B 3) A (ofs A 3) E (link (ofs E 3))) ; # (ofs B 3) %442 = add i64 %413, 24 %443 = inttoptr i64 %413 to i64* store i64 %442, i64* %443 ; # (ofs A 3) %444 = add i64 %419, 24 %445 = inttoptr i64 %419 to i64* store i64 %444, i64* %445 ; # (ofs E 3) %446 = add i64 %435, 24 ; # (link (ofs E 3)) %447 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* %448 = load i64, i64* %447 %449 = inttoptr i64 %446 to i64* %450 = getelementptr i64, i64* %449, i32 1 store i64 %448, i64* %450 %451 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %446, i64* %451 %452 = inttoptr i64 %435 to i64* store i64 %446, i64* %452 ; # (loop (set In0 (val Out0) In1 (val Out1)) (if (and (pair (val In1... br label %$55 $55: %453 = phi i64 [%413, %$50], [%896, %$114] ; # B %454 = phi i64 [%419, %$50], [%897, %$114] ; # A %455 = phi i64 [%435, %$50], [%898, %$114] ; # E ; # (set In0 (val Out0) In1 (val Out1)) ; # (val Out0) %456 = inttoptr i64 %381 to i64* %457 = load i64, i64* %456 %458 = inttoptr i64 %397 to i64* store i64 %457, i64* %458 ; # (val Out1) %459 = inttoptr i64 %389 to i64* %460 = load i64, i64* %459 %461 = inttoptr i64 %405 to i64* store i64 %460, i64* %461 ; # (if (and (pair (val In1)) (ge0 (cmpSort (caar In0) (caar In1)))) ... ; # (and (pair (val In1)) (ge0 (cmpSort (caar In0) (caar In1)))) ; # (val In1) %462 = inttoptr i64 %405 to i64* %463 = load i64, i64* %462 ; # (pair (val In1)) %464 = and i64 %463, 15 %465 = icmp eq i64 %464, 0 br i1 %465, label %$57, label %$56 $57: %466 = phi i64 [%453, %$55] ; # B %467 = phi i64 [%454, %$55] ; # A %468 = phi i64 [%455, %$55] ; # E ; # (caar In0) %469 = inttoptr i64 %397 to i64* %470 = load i64, i64* %469 %471 = inttoptr i64 %470 to i64* %472 = load i64, i64* %471 ; # (caar In1) %473 = inttoptr i64 %405 to i64* %474 = load i64, i64* %473 %475 = inttoptr i64 %474 to i64* %476 = load i64, i64* %475 ; # (cmpSort (caar In0) (caar In1)) %477 = inttoptr i64 %467 to i64* %478 = getelementptr i64, i64* %477, i32 3 store i64 %472, i64* %478 %479 = inttoptr i64 %466 to i64* %480 = getelementptr i64, i64* %479, i32 3 store i64 %476, i64* %480 %481 = call i64 @evList(i64 %468) %482 = icmp eq i64 %481, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %482, label %$58, label %$59 $58: br label %$60 $59: br label %$60 $60: %483 = phi i64 [0, %$58], [-1, %$59] ; # -> ; # (ge0 (cmpSort (caar In0) (caar In1))) %484 = icmp sge i64 %483, 0 br label %$56 $56: %485 = phi i64 [%453, %$55], [%466, %$60] ; # B %486 = phi i64 [%454, %$55], [%467, %$60] ; # A %487 = phi i64 [%455, %$55], [%468, %$60] ; # E %488 = phi i1 [0, %$55], [%484, %$60] ; # -> br i1 %488, label %$61, label %$62 $61: %489 = phi i64 [%485, %$56] ; # B %490 = phi i64 [%486, %$56] ; # A %491 = phi i64 [%487, %$56] ; # E ; # (set In1 (cdr (setq P (val In1)))) ; # (val In1) %492 = inttoptr i64 %405 to i64* %493 = load i64, i64* %492 ; # (cdr (setq P (val In1))) %494 = inttoptr i64 %493 to i64* %495 = getelementptr i64, i64* %494, i32 1 %496 = load i64, i64* %495 %497 = inttoptr i64 %405 to i64* store i64 %496, i64* %497 br label %$63 $62: %498 = phi i64 [%485, %$56] ; # B %499 = phi i64 [%486, %$56] ; # A %500 = phi i64 [%487, %$56] ; # E ; # (set In0 (cdr (setq P (val In0)))) ; # (val In0) %501 = inttoptr i64 %397 to i64* %502 = load i64, i64* %501 ; # (cdr (setq P (val In0))) %503 = inttoptr i64 %502 to i64* %504 = getelementptr i64, i64* %503, i32 1 %505 = load i64, i64* %504 %506 = inttoptr i64 %397 to i64* store i64 %505, i64* %506 br label %$63 $63: %507 = phi i64 [%489, %$61], [%498, %$62] ; # B %508 = phi i64 [%490, %$61], [%499, %$62] ; # A %509 = phi i64 [%491, %$61], [%500, %$62] ; # E %510 = phi i64 [%493, %$61], [%502, %$62] ; # P %511 = phi i64 [%496, %$61], [%505, %$62] ; # -> ; # (let (Tail0 (ofs P 1) Tail1 0 Last (car P)) (set Out0 P Out1 $Nil... ; # (ofs P 1) %512 = add i64 %510, 8 ; # (car P) %513 = inttoptr i64 %510 to i64* %514 = load i64, i64* %513 ; # (set Out0 P Out1 $Nil) %515 = inttoptr i64 %381 to i64* store i64 %510, i64* %515 %516 = inttoptr i64 %389 to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %516 ; # (set 2 P $Nil) %517 = inttoptr i64 %510 to i64* %518 = getelementptr i64, i64* %517, i32 1 store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %518 ; # (while (or (pair (val In0)) (pair (val In1))) (cond ((atom (val I... br label %$64 $64: %519 = phi i64 [%507, %$63], [%866, %$113] ; # B %520 = phi i64 [%508, %$63], [%867, %$113] ; # A %521 = phi i64 [%509, %$63], [%868, %$113] ; # E %522 = phi i64 [%510, %$63], [%869, %$113] ; # P %523 = phi i64 [%512, %$63], [%874, %$113] ; # Tail0 %524 = phi i64 [0, %$63], [%871, %$113] ; # Tail1 %525 = phi i64 [%514, %$63], [%878, %$113] ; # Last ; # (or (pair (val In0)) (pair (val In1))) ; # (val In0) %526 = inttoptr i64 %397 to i64* %527 = load i64, i64* %526 ; # (pair (val In0)) %528 = and i64 %527, 15 %529 = icmp eq i64 %528, 0 br i1 %529, label %$65, label %$66 $66: %530 = phi i64 [%519, %$64] ; # B %531 = phi i64 [%520, %$64] ; # A %532 = phi i64 [%521, %$64] ; # E %533 = phi i64 [%522, %$64] ; # P %534 = phi i64 [%523, %$64] ; # Tail0 %535 = phi i64 [%524, %$64] ; # Tail1 %536 = phi i64 [%525, %$64] ; # Last ; # (val In1) %537 = inttoptr i64 %405 to i64* %538 = load i64, i64* %537 ; # (pair (val In1)) %539 = and i64 %538, 15 %540 = icmp eq i64 %539, 0 br label %$65 $65: %541 = phi i64 [%519, %$64], [%530, %$66] ; # B %542 = phi i64 [%520, %$64], [%531, %$66] ; # A %543 = phi i64 [%521, %$64], [%532, %$66] ; # E %544 = phi i64 [%522, %$64], [%533, %$66] ; # P %545 = phi i64 [%523, %$64], [%534, %$66] ; # Tail0 %546 = phi i64 [%524, %$64], [%535, %$66] ; # Tail1 %547 = phi i64 [%525, %$64], [%536, %$66] ; # Last %548 = phi i1 [1, %$64], [%540, %$66] ; # -> br i1 %548, label %$67, label %$68 $67: %549 = phi i64 [%541, %$65] ; # B %550 = phi i64 [%542, %$65] ; # A %551 = phi i64 [%543, %$65] ; # E %552 = phi i64 [%544, %$65] ; # P %553 = phi i64 [%545, %$65] ; # Tail0 %554 = phi i64 [%546, %$65] ; # Tail1 %555 = phi i64 [%547, %$65] ; # Last ; # (cond ((atom (val In1)) (set In0 (cdr (setq P (val In0)))) (when ... ; # (val In1) %556 = inttoptr i64 %405 to i64* %557 = load i64, i64* %556 ; # (atom (val In1)) %558 = and i64 %557, 15 %559 = icmp ne i64 %558, 0 br i1 %559, label %$71, label %$70 $71: %560 = phi i64 [%549, %$67] ; # B %561 = phi i64 [%550, %$67] ; # A %562 = phi i64 [%551, %$67] ; # E %563 = phi i64 [%552, %$67] ; # P %564 = phi i64 [%553, %$67] ; # Tail0 %565 = phi i64 [%554, %$67] ; # Tail1 %566 = phi i64 [%555, %$67] ; # Last ; # (set In0 (cdr (setq P (val In0)))) ; # (val In0) %567 = inttoptr i64 %397 to i64* %568 = load i64, i64* %567 ; # (cdr (setq P (val In0))) %569 = inttoptr i64 %568 to i64* %570 = getelementptr i64, i64* %569, i32 1 %571 = load i64, i64* %570 %572 = inttoptr i64 %397 to i64* store i64 %571, i64* %572 ; # (when (lt0 (cmpSort (car P) Last)) (xchg 'Tail0 'Tail1)) ; # (car P) %573 = inttoptr i64 %568 to i64* %574 = load i64, i64* %573 ; # (cmpSort (car P) Last) %575 = inttoptr i64 %561 to i64* %576 = getelementptr i64, i64* %575, i32 3 store i64 %574, i64* %576 %577 = inttoptr i64 %560 to i64* %578 = getelementptr i64, i64* %577, i32 3 store i64 %566, i64* %578 %579 = call i64 @evList(i64 %562) %580 = icmp eq i64 %579, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %580, label %$72, label %$73 $72: br label %$74 $73: br label %$74 $74: %581 = phi i64 [0, %$72], [-1, %$73] ; # -> ; # (lt0 (cmpSort (car P) Last)) %582 = icmp slt i64 %581, 0 br i1 %582, label %$75, label %$76 $75: %583 = phi i64 [%560, %$74] ; # B %584 = phi i64 [%561, %$74] ; # A %585 = phi i64 [%562, %$74] ; # E %586 = phi i64 [%568, %$74] ; # P %587 = phi i64 [%564, %$74] ; # Tail0 %588 = phi i64 [%565, %$74] ; # Tail1 %589 = phi i64 [%566, %$74] ; # Last ; # (xchg 'Tail0 'Tail1) br label %$76 $76: %590 = phi i64 [%560, %$74], [%583, %$75] ; # B %591 = phi i64 [%561, %$74], [%584, %$75] ; # A %592 = phi i64 [%562, %$74], [%585, %$75] ; # E %593 = phi i64 [%568, %$74], [%586, %$75] ; # P %594 = phi i64 [%564, %$74], [%588, %$75] ; # Tail0 %595 = phi i64 [%565, %$74], [%587, %$75] ; # Tail1 %596 = phi i64 [%566, %$74], [%589, %$75] ; # Last br label %$69 $70: %597 = phi i64 [%549, %$67] ; # B %598 = phi i64 [%550, %$67] ; # A %599 = phi i64 [%551, %$67] ; # E %600 = phi i64 [%552, %$67] ; # P %601 = phi i64 [%553, %$67] ; # Tail0 %602 = phi i64 [%554, %$67] ; # Tail1 %603 = phi i64 [%555, %$67] ; # Last ; # (val In0) %604 = inttoptr i64 %397 to i64* %605 = load i64, i64* %604 ; # (atom (val In0)) %606 = and i64 %605, 15 %607 = icmp ne i64 %606, 0 br i1 %607, label %$78, label %$77 $78: %608 = phi i64 [%597, %$70] ; # B %609 = phi i64 [%598, %$70] ; # A %610 = phi i64 [%599, %$70] ; # E %611 = phi i64 [%600, %$70] ; # P %612 = phi i64 [%601, %$70] ; # Tail0 %613 = phi i64 [%602, %$70] ; # Tail1 %614 = phi i64 [%603, %$70] ; # Last ; # (set In1 (cdr (setq P (val In1)))) ; # (val In1) %615 = inttoptr i64 %405 to i64* %616 = load i64, i64* %615 ; # (cdr (setq P (val In1))) %617 = inttoptr i64 %616 to i64* %618 = getelementptr i64, i64* %617, i32 1 %619 = load i64, i64* %618 %620 = inttoptr i64 %405 to i64* store i64 %619, i64* %620 ; # (when (lt0 (cmpSort (car P) Last)) (xchg 'Tail0 'Tail1)) ; # (car P) %621 = inttoptr i64 %616 to i64* %622 = load i64, i64* %621 ; # (cmpSort (car P) Last) %623 = inttoptr i64 %609 to i64* %624 = getelementptr i64, i64* %623, i32 3 store i64 %622, i64* %624 %625 = inttoptr i64 %608 to i64* %626 = getelementptr i64, i64* %625, i32 3 store i64 %614, i64* %626 %627 = call i64 @evList(i64 %610) %628 = icmp eq i64 %627, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %628, label %$79, label %$80 $79: br label %$81 $80: br label %$81 $81: %629 = phi i64 [0, %$79], [-1, %$80] ; # -> ; # (lt0 (cmpSort (car P) Last)) %630 = icmp slt i64 %629, 0 br i1 %630, label %$82, label %$83 $82: %631 = phi i64 [%608, %$81] ; # B %632 = phi i64 [%609, %$81] ; # A %633 = phi i64 [%610, %$81] ; # E %634 = phi i64 [%616, %$81] ; # P %635 = phi i64 [%612, %$81] ; # Tail0 %636 = phi i64 [%613, %$81] ; # Tail1 %637 = phi i64 [%614, %$81] ; # Last ; # (xchg 'Tail0 'Tail1) br label %$83 $83: %638 = phi i64 [%608, %$81], [%631, %$82] ; # B %639 = phi i64 [%609, %$81], [%632, %$82] ; # A %640 = phi i64 [%610, %$81], [%633, %$82] ; # E %641 = phi i64 [%616, %$81], [%634, %$82] ; # P %642 = phi i64 [%612, %$81], [%636, %$82] ; # Tail0 %643 = phi i64 [%613, %$81], [%635, %$82] ; # Tail1 %644 = phi i64 [%614, %$81], [%637, %$82] ; # Last br label %$69 $77: %645 = phi i64 [%597, %$70] ; # B %646 = phi i64 [%598, %$70] ; # A %647 = phi i64 [%599, %$70] ; # E %648 = phi i64 [%600, %$70] ; # P %649 = phi i64 [%601, %$70] ; # Tail0 %650 = phi i64 [%602, %$70] ; # Tail1 %651 = phi i64 [%603, %$70] ; # Last ; # (caar In0) %652 = inttoptr i64 %397 to i64* %653 = load i64, i64* %652 %654 = inttoptr i64 %653 to i64* %655 = load i64, i64* %654 ; # (cmpSort (caar In0) Last) %656 = inttoptr i64 %646 to i64* %657 = getelementptr i64, i64* %656, i32 3 store i64 %655, i64* %657 %658 = inttoptr i64 %645 to i64* %659 = getelementptr i64, i64* %658, i32 3 store i64 %651, i64* %659 %660 = call i64 @evList(i64 %647) %661 = icmp eq i64 %660, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %661, label %$84, label %$85 $84: br label %$86 $85: br label %$86 $86: %662 = phi i64 [0, %$84], [-1, %$85] ; # -> ; # (lt0 (cmpSort (caar In0) Last)) %663 = icmp slt i64 %662, 0 br i1 %663, label %$88, label %$87 $88: %664 = phi i64 [%645, %$86] ; # B %665 = phi i64 [%646, %$86] ; # A %666 = phi i64 [%647, %$86] ; # E %667 = phi i64 [%648, %$86] ; # P %668 = phi i64 [%649, %$86] ; # Tail0 %669 = phi i64 [%650, %$86] ; # Tail1 %670 = phi i64 [%651, %$86] ; # Last ; # (if (ge0 (cmpSort (caar In1) Last)) (set In1 (cdr (setq P (val In... ; # (caar In1) %671 = inttoptr i64 %405 to i64* %672 = load i64, i64* %671 %673 = inttoptr i64 %672 to i64* %674 = load i64, i64* %673 ; # (cmpSort (caar In1) Last) %675 = inttoptr i64 %665 to i64* %676 = getelementptr i64, i64* %675, i32 3 store i64 %674, i64* %676 %677 = inttoptr i64 %664 to i64* %678 = getelementptr i64, i64* %677, i32 3 store i64 %670, i64* %678 %679 = call i64 @evList(i64 %666) %680 = icmp eq i64 %679, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %680, label %$89, label %$90 $89: br label %$91 $90: br label %$91 $91: %681 = phi i64 [0, %$89], [-1, %$90] ; # -> ; # (ge0 (cmpSort (caar In1) Last)) %682 = icmp sge i64 %681, 0 br i1 %682, label %$92, label %$93 $92: %683 = phi i64 [%664, %$91] ; # B %684 = phi i64 [%665, %$91] ; # A %685 = phi i64 [%666, %$91] ; # E %686 = phi i64 [%667, %$91] ; # P %687 = phi i64 [%668, %$91] ; # Tail0 %688 = phi i64 [%669, %$91] ; # Tail1 %689 = phi i64 [%670, %$91] ; # Last ; # (set In1 (cdr (setq P (val In1)))) ; # (val In1) %690 = inttoptr i64 %405 to i64* %691 = load i64, i64* %690 ; # (cdr (setq P (val In1))) %692 = inttoptr i64 %691 to i64* %693 = getelementptr i64, i64* %692, i32 1 %694 = load i64, i64* %693 %695 = inttoptr i64 %405 to i64* store i64 %694, i64* %695 br label %$94 $93: %696 = phi i64 [%664, %$91] ; # B %697 = phi i64 [%665, %$91] ; # A %698 = phi i64 [%666, %$91] ; # E %699 = phi i64 [%667, %$91] ; # P %700 = phi i64 [%668, %$91] ; # Tail0 %701 = phi i64 [%669, %$91] ; # Tail1 %702 = phi i64 [%670, %$91] ; # Last ; # (if (lt0 (cmpSort (caar In0) (caar In1))) (set In0 (cdr (setq P (... ; # (caar In0) %703 = inttoptr i64 %397 to i64* %704 = load i64, i64* %703 %705 = inttoptr i64 %704 to i64* %706 = load i64, i64* %705 ; # (caar In1) %707 = inttoptr i64 %405 to i64* %708 = load i64, i64* %707 %709 = inttoptr i64 %708 to i64* %710 = load i64, i64* %709 ; # (cmpSort (caar In0) (caar In1)) %711 = inttoptr i64 %697 to i64* %712 = getelementptr i64, i64* %711, i32 3 store i64 %706, i64* %712 %713 = inttoptr i64 %696 to i64* %714 = getelementptr i64, i64* %713, i32 3 store i64 %710, i64* %714 %715 = call i64 @evList(i64 %698) %716 = icmp eq i64 %715, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %716, label %$95, label %$96 $95: br label %$97 $96: br label %$97 $97: %717 = phi i64 [0, %$95], [-1, %$96] ; # -> ; # (lt0 (cmpSort (caar In0) (caar In1))) %718 = icmp slt i64 %717, 0 br i1 %718, label %$98, label %$99 $98: %719 = phi i64 [%696, %$97] ; # B %720 = phi i64 [%697, %$97] ; # A %721 = phi i64 [%698, %$97] ; # E %722 = phi i64 [%699, %$97] ; # P %723 = phi i64 [%700, %$97] ; # Tail0 %724 = phi i64 [%701, %$97] ; # Tail1 %725 = phi i64 [%702, %$97] ; # Last ; # (set In0 (cdr (setq P (val In0)))) ; # (val In0) %726 = inttoptr i64 %397 to i64* %727 = load i64, i64* %726 ; # (cdr (setq P (val In0))) %728 = inttoptr i64 %727 to i64* %729 = getelementptr i64, i64* %728, i32 1 %730 = load i64, i64* %729 %731 = inttoptr i64 %397 to i64* store i64 %730, i64* %731 br label %$100 $99: %732 = phi i64 [%696, %$97] ; # B %733 = phi i64 [%697, %$97] ; # A %734 = phi i64 [%698, %$97] ; # E %735 = phi i64 [%699, %$97] ; # P %736 = phi i64 [%700, %$97] ; # Tail0 %737 = phi i64 [%701, %$97] ; # Tail1 %738 = phi i64 [%702, %$97] ; # Last ; # (set In1 (cdr (setq P (val In1)))) ; # (val In1) %739 = inttoptr i64 %405 to i64* %740 = load i64, i64* %739 ; # (cdr (setq P (val In1))) %741 = inttoptr i64 %740 to i64* %742 = getelementptr i64, i64* %741, i32 1 %743 = load i64, i64* %742 %744 = inttoptr i64 %405 to i64* store i64 %743, i64* %744 br label %$100 $100: %745 = phi i64 [%719, %$98], [%732, %$99] ; # B %746 = phi i64 [%720, %$98], [%733, %$99] ; # A %747 = phi i64 [%721, %$98], [%734, %$99] ; # E %748 = phi i64 [%727, %$98], [%740, %$99] ; # P %749 = phi i64 [%723, %$98], [%736, %$99] ; # Tail0 %750 = phi i64 [%724, %$98], [%737, %$99] ; # Tail1 %751 = phi i64 [%725, %$98], [%738, %$99] ; # Last %752 = phi i64 [%730, %$98], [%743, %$99] ; # -> ; # (xchg 'Tail0 'Tail1) br label %$94 $94: %753 = phi i64 [%683, %$92], [%745, %$100] ; # B %754 = phi i64 [%684, %$92], [%746, %$100] ; # A %755 = phi i64 [%685, %$92], [%747, %$100] ; # E %756 = phi i64 [%691, %$92], [%748, %$100] ; # P %757 = phi i64 [%687, %$92], [%750, %$100] ; # Tail0 %758 = phi i64 [%688, %$92], [%749, %$100] ; # Tail1 %759 = phi i64 [%689, %$92], [%751, %$100] ; # Last %760 = phi i64 [%694, %$92], [%749, %$100] ; # -> br label %$69 $87: %761 = phi i64 [%645, %$86] ; # B %762 = phi i64 [%646, %$86] ; # A %763 = phi i64 [%647, %$86] ; # E %764 = phi i64 [%648, %$86] ; # P %765 = phi i64 [%649, %$86] ; # Tail0 %766 = phi i64 [%650, %$86] ; # Tail1 %767 = phi i64 [%651, %$86] ; # Last ; # (caar In1) %768 = inttoptr i64 %405 to i64* %769 = load i64, i64* %768 %770 = inttoptr i64 %769 to i64* %771 = load i64, i64* %770 ; # (cmpSort (caar In1) Last) %772 = inttoptr i64 %762 to i64* %773 = getelementptr i64, i64* %772, i32 3 store i64 %771, i64* %773 %774 = inttoptr i64 %761 to i64* %775 = getelementptr i64, i64* %774, i32 3 store i64 %767, i64* %775 %776 = call i64 @evList(i64 %763) %777 = icmp eq i64 %776, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %777, label %$101, label %$102 $101: br label %$103 $102: br label %$103 $103: %778 = phi i64 [0, %$101], [-1, %$102] ; # -> ; # (lt0 (cmpSort (caar In1) Last)) %779 = icmp slt i64 %778, 0 br i1 %779, label %$105, label %$104 $105: %780 = phi i64 [%761, %$103] ; # B %781 = phi i64 [%762, %$103] ; # A %782 = phi i64 [%763, %$103] ; # E %783 = phi i64 [%764, %$103] ; # P %784 = phi i64 [%765, %$103] ; # Tail0 %785 = phi i64 [%766, %$103] ; # Tail1 %786 = phi i64 [%767, %$103] ; # Last ; # (set In0 (cdr (setq P (val In0)))) ; # (val In0) %787 = inttoptr i64 %397 to i64* %788 = load i64, i64* %787 ; # (cdr (setq P (val In0))) %789 = inttoptr i64 %788 to i64* %790 = getelementptr i64, i64* %789, i32 1 %791 = load i64, i64* %790 %792 = inttoptr i64 %397 to i64* store i64 %791, i64* %792 br label %$69 $104: %793 = phi i64 [%761, %$103] ; # B %794 = phi i64 [%762, %$103] ; # A %795 = phi i64 [%763, %$103] ; # E %796 = phi i64 [%764, %$103] ; # P %797 = phi i64 [%765, %$103] ; # Tail0 %798 = phi i64 [%766, %$103] ; # Tail1 %799 = phi i64 [%767, %$103] ; # Last ; # (caar In0) %800 = inttoptr i64 %397 to i64* %801 = load i64, i64* %800 %802 = inttoptr i64 %801 to i64* %803 = load i64, i64* %802 ; # (caar In1) %804 = inttoptr i64 %405 to i64* %805 = load i64, i64* %804 %806 = inttoptr i64 %805 to i64* %807 = load i64, i64* %806 ; # (cmpSort (caar In0) (caar In1)) %808 = inttoptr i64 %794 to i64* %809 = getelementptr i64, i64* %808, i32 3 store i64 %803, i64* %809 %810 = inttoptr i64 %793 to i64* %811 = getelementptr i64, i64* %810, i32 3 store i64 %807, i64* %811 %812 = call i64 @evList(i64 %795) %813 = icmp eq i64 %812, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %813, label %$106, label %$107 $106: br label %$108 $107: br label %$108 $108: %814 = phi i64 [0, %$106], [-1, %$107] ; # -> ; # (lt0 (cmpSort (caar In0) (caar In1))) %815 = icmp slt i64 %814, 0 br i1 %815, label %$110, label %$109 $110: %816 = phi i64 [%793, %$108] ; # B %817 = phi i64 [%794, %$108] ; # A %818 = phi i64 [%795, %$108] ; # E %819 = phi i64 [%796, %$108] ; # P %820 = phi i64 [%797, %$108] ; # Tail0 %821 = phi i64 [%798, %$108] ; # Tail1 %822 = phi i64 [%799, %$108] ; # Last ; # (set In0 (cdr (setq P (val In0)))) ; # (val In0) %823 = inttoptr i64 %397 to i64* %824 = load i64, i64* %823 ; # (cdr (setq P (val In0))) %825 = inttoptr i64 %824 to i64* %826 = getelementptr i64, i64* %825, i32 1 %827 = load i64, i64* %826 %828 = inttoptr i64 %397 to i64* store i64 %827, i64* %828 br label %$69 $109: %829 = phi i64 [%793, %$108] ; # B %830 = phi i64 [%794, %$108] ; # A %831 = phi i64 [%795, %$108] ; # E %832 = phi i64 [%796, %$108] ; # P %833 = phi i64 [%797, %$108] ; # Tail0 %834 = phi i64 [%798, %$108] ; # Tail1 %835 = phi i64 [%799, %$108] ; # Last ; # (set In1 (cdr (setq P (val In1)))) ; # (val In1) %836 = inttoptr i64 %405 to i64* %837 = load i64, i64* %836 ; # (cdr (setq P (val In1))) %838 = inttoptr i64 %837 to i64* %839 = getelementptr i64, i64* %838, i32 1 %840 = load i64, i64* %839 %841 = inttoptr i64 %405 to i64* store i64 %840, i64* %841 br label %$69 $69: %842 = phi i64 [%590, %$76], [%638, %$83], [%753, %$94], [%780, %$105], [%816, %$110], [%829, %$109] ; # B %843 = phi i64 [%591, %$76], [%639, %$83], [%754, %$94], [%781, %$105], [%817, %$110], [%830, %$109] ; # A %844 = phi i64 [%592, %$76], [%640, %$83], [%755, %$94], [%782, %$105], [%818, %$110], [%831, %$109] ; # E %845 = phi i64 [%593, %$76], [%641, %$83], [%756, %$94], [%788, %$105], [%824, %$110], [%837, %$109] ; # P %846 = phi i64 [%594, %$76], [%642, %$83], [%757, %$94], [%784, %$105], [%820, %$110], [%833, %$109] ; # Tail0 %847 = phi i64 [%595, %$76], [%643, %$83], [%758, %$94], [%785, %$105], [%821, %$110], [%834, %$109] ; # Tail1 %848 = phi i64 [%596, %$76], [%644, %$83], [%759, %$94], [%786, %$105], [%822, %$110], [%835, %$109] ; # Last ; # (if Tail0 (set Tail0 P) (set Out1 P)) %849 = icmp ne i64 %846, 0 br i1 %849, label %$111, label %$112 $111: %850 = phi i64 [%842, %$69] ; # B %851 = phi i64 [%843, %$69] ; # A %852 = phi i64 [%844, %$69] ; # E %853 = phi i64 [%845, %$69] ; # P %854 = phi i64 [%846, %$69] ; # Tail0 %855 = phi i64 [%847, %$69] ; # Tail1 %856 = phi i64 [%848, %$69] ; # Last ; # (set Tail0 P) %857 = inttoptr i64 %854 to i64* store i64 %853, i64* %857 br label %$113 $112: %858 = phi i64 [%842, %$69] ; # B %859 = phi i64 [%843, %$69] ; # A %860 = phi i64 [%844, %$69] ; # E %861 = phi i64 [%845, %$69] ; # P %862 = phi i64 [%846, %$69] ; # Tail0 %863 = phi i64 [%847, %$69] ; # Tail1 %864 = phi i64 [%848, %$69] ; # Last ; # (set Out1 P) %865 = inttoptr i64 %389 to i64* store i64 %861, i64* %865 br label %$113 $113: %866 = phi i64 [%850, %$111], [%858, %$112] ; # B %867 = phi i64 [%851, %$111], [%859, %$112] ; # A %868 = phi i64 [%852, %$111], [%860, %$112] ; # E %869 = phi i64 [%853, %$111], [%861, %$112] ; # P %870 = phi i64 [%854, %$111], [%862, %$112] ; # Tail0 %871 = phi i64 [%855, %$111], [%863, %$112] ; # Tail1 %872 = phi i64 [%856, %$111], [%864, %$112] ; # Last %873 = phi i64 [%853, %$111], [%861, %$112] ; # -> ; # (ofs (if Tail0 (set Tail0 P) (set Out1 P)) 1) %874 = add i64 %873, 8 ; # (set 2 P $Nil) %875 = inttoptr i64 %869 to i64* %876 = getelementptr i64, i64* %875, i32 1 store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %876 ; # (car P) %877 = inttoptr i64 %869 to i64* %878 = load i64, i64* %877 br label %$64 $68: %879 = phi i64 [%541, %$65] ; # B %880 = phi i64 [%542, %$65] ; # A %881 = phi i64 [%543, %$65] ; # E %882 = phi i64 [%544, %$65] ; # P %883 = phi i64 [%545, %$65] ; # Tail0 %884 = phi i64 [%546, %$65] ; # Tail1 %885 = phi i64 [%547, %$65] ; # Last ; # (? (atom (val Out1)) (val Out0)) ; # (val Out1) %886 = inttoptr i64 %389 to i64* %887 = load i64, i64* %886 ; # (atom (val Out1)) %888 = and i64 %887, 15 %889 = icmp ne i64 %888, 0 br i1 %889, label %$116, label %$114 $116: %890 = phi i64 [%879, %$68] ; # B %891 = phi i64 [%880, %$68] ; # A %892 = phi i64 [%881, %$68] ; # E %893 = phi i64 [%882, %$68] ; # P ; # (val Out0) %894 = inttoptr i64 %381 to i64* %895 = load i64, i64* %894 br label %$115 $114: %896 = phi i64 [%879, %$68] ; # B %897 = phi i64 [%880, %$68] ; # A %898 = phi i64 [%881, %$68] ; # E %899 = phi i64 [%882, %$68] ; # P br label %$55 $115: %900 = phi i64 [%890, %$116] ; # B %901 = phi i64 [%891, %$116] ; # A %902 = phi i64 [%892, %$116] ; # E %903 = phi i64 [%893, %$116] ; # P %904 = phi i64 [%895, %$116] ; # -> ; # (drop *Safe) %905 = inttoptr i64 %381 to i64* %906 = getelementptr i64, i64* %905, i32 1 %907 = load i64, i64* %906 %908 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %907, i64* %908 br label %$7 $7: %909 = phi i64 [%15, %$9], [%379, %$48], [%904, %$115] ; # -> ret i64 %909 } define i64 @_quit(i64) align 8 { $1: ; # (let (X (cdr Exe) Nm (xName Exe (evSym X)) Msg (bufString Nm (b8 ... ; # (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 Exe (evSym X)) %5 = call i64 @xName(i64 %0, 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]* @$85 to i8*), i8* %8) unreachable } define i64 @_sys(i64) align 8 { $1: ; # (let (X (cdr Exe) Nm (xName Exe (evSym X)) S (bufString Nm (b8 (b... ; # (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 Exe (evSym X)) %5 = call i64 @xName(i64 %0, 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 Exe Y)) (if (setenv S (bufString Nm2... ; # (evSym X) %18 = call i64 @evSym(i64 %17) ; # (xName Exe Y) %19 = call i64 @xName(i64 %0, 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # -> ret i64 %4 } define i64 @_cd(i64) align 8 { $1: ; # (let (Nm (xName Exe (evSym (cdr Exe))) P (getcwd null 0)) (if P (... ; # (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 Exe (evSym (cdr Exe))) %5 = call i64 @xName(i64 %0, i64 %4) ; # (getcwd null 0) %6 = call i8* @getcwd(i8* null, i64 0) ; # (if P (prog1 (if (lt0 (chdir (pathString Nm (b8 (pathSize Nm)))))... %7 = icmp ne i8* %6, null br i1 %7, label %$2, label %$3 $2: ; # (prog1 (if (lt0 (chdir (pathString Nm (b8 (pathSize Nm))))) $Nil ... ; # (if (lt0 (chdir (pathString Nm (b8 (pathSize Nm))))) $Nil (mkStr ... ; # (pathSize Nm) %8 = call i64 @pathSize(i64 %5) ; # (b8 (pathSize Nm)) %9 = alloca i8, i64 %8 ; # (pathString Nm (b8 (pathSize Nm))) %10 = call i8* @pathString(i64 %5, i8* %9) ; # (chdir (pathString Nm (b8 (pathSize Nm)))) %11 = call i32 @chdir(i8* %10) ; # (lt0 (chdir (pathString 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 ([870 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 ([870 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 ([870 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]* @$86 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 Exe (xSym X)) (if (reopenTty (bufString Nm (b8 (bu... ; # (xSym X) %74 = call i64 @xSym(i64 %13) ; # (xName Exe (xSym X)) %75 = call i64 @xName(i64 %0, 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 ([870 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 ([870 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 ([870 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 Exe @) %8 = call i64 @xName(i64 %0, i64 %4) ; # (val $AV0) %9 = load i8*, i8** @$AV0 ; # (bufString (xName Exe @) (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 (if (nil? (evSym X)) ($ ".") (let Nm... ; # (cdr Exe) %1 = inttoptr i64 %0 to i64* %2 = getelementptr i64, i64* %1, i32 1 %3 = load i64, i64* %2 ; # (if (getDir (if (nil? (evSym X)) ($ ".") (let Nm (xName Exe @) (p... ; # (if (nil? (evSym X)) ($ ".") (let Nm (xName Exe @) (pathString Nm... ; # (evSym X) %4 = call i64 @evSym(i64 %3) ; # (nil? (evSym X)) %5 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 Nm (xName Exe @) (pathString Nm (b8 (pathSize Nm)))) ; # (xName Exe @) %8 = call i64 @xName(i64 %0, i64 %4) ; # (pathSize Nm) %9 = call i64 @pathSize(i64 %8) ; # (b8 (pathSize Nm)) %10 = alloca i8, i64 %9 ; # (pathString Nm (b8 (pathSize Nm))) %11 = call i8* @pathString(i64 %8, i8* %10) br label %$4 $4: %12 = phi i64 [%6, %$2], [%7, %$3] ; # X %13 = phi i8* [bitcast ([2 x i8]* @$87 to i8*), %$2], [%11, %$3] ; # -> ; # (getDir (if (nil? (evSym X)) ($ ".") (let Nm (xName Exe @) (pathS... %14 = call i8* @getDir(i8* %13) %15 = icmp ne i8* %14, null br i1 %15, label %$5, label %$6 $5: %16 = phi i64 [%12, %$4] ; # X ; # (let (P @ F (eval (car (shift X)))) (when (nil? F) (while (== (va... ; # (shift X) %17 = inttoptr i64 %16 to i64* %18 = getelementptr i64, i64* %17, i32 1 %19 = load i64, i64* %18 ; # (car (shift X)) %20 = inttoptr i64 %19 to i64* %21 = load i64, i64* %20 ; # (eval (car (shift X))) %22 = and i64 %21, 6 %23 = icmp ne i64 %22, 0 br i1 %23, label %$10, label %$9 $10: br label %$8 $9: %24 = and i64 %21, 8 %25 = icmp ne i64 %24, 0 br i1 %25, label %$12, label %$11 $12: %26 = inttoptr i64 %21 to i64* %27 = load i64, i64* %26 br label %$8 $11: %28 = call i64 @evList(i64 %21) br label %$8 $8: %29 = phi i64 [%21, %$10], [%27, %$12], [%28, %$11] ; # -> ; # (when (nil? F) (while (== (val P) (char ".")) (unless (setq P (ge... ; # (nil? F) %30 = icmp eq i64 %29, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %30, label %$13, label %$14 $13: %31 = phi i64 [%19, %$8] ; # X %32 = phi i8* [%14, %$8] ; # P ; # (while (== (val P) (char ".")) (unless (setq P (getDir null)) (re... br label %$15 $15: %33 = phi i64 [%31, %$13], [%43, %$19] ; # X %34 = phi i8* [%32, %$13], [%44, %$19] ; # P ; # (val P) %35 = load i8, i8* %34 ; # (== (val P) (char ".")) %36 = icmp eq i8 %35, 46 br i1 %36, label %$16, label %$17 $16: %37 = phi i64 [%33, %$15] ; # X %38 = phi i8* [%34, %$15] ; # P ; # (unless (setq P (getDir null)) (ret $Nil)) ; # (getDir null) %39 = call i8* @getDir(i8* null) %40 = icmp ne i8* %39, null br i1 %40, label %$19, label %$18 $18: %41 = phi i64 [%37, %$16] ; # X %42 = phi i8* [%39, %$16] ; # P ; # (ret $Nil) ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) $19: %43 = phi i64 [%37, %$16] ; # X %44 = phi i8* [%39, %$16] ; # P br label %$15 $17: %45 = phi i64 [%33, %$15] ; # X %46 = phi i8* [%34, %$15] ; # P br label %$14 $14: %47 = phi i64 [%19, %$8], [%45, %$17] ; # X %48 = phi i8* [%14, %$8], [%46, %$17] ; # P ; # (let (Y (cons (mkStr P) $Nil) R (save Y)) (while (setq P (getDir ... ; # (mkStr P) %49 = call i64 @mkStr(i8* %48) ; # (cons (mkStr P) $Nil) %50 = call i64 @cons(i64 %49, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %54, i64* %58 ; # (while (setq P (getDir null)) (unless (and (nil? F) (== (val P) (... br label %$20 $20: %59 = phi i64 [%47, %$14], [%84, %$26] ; # X %60 = phi i8* [%48, %$14], [%85, %$26] ; # P %61 = phi i64 [%50, %$14], [%86, %$26] ; # Y ; # (getDir null) %62 = call i8* @getDir(i8* null) %63 = icmp ne i8* %62, null br i1 %63, label %$21, label %$22 $21: %64 = phi i64 [%59, %$20] ; # X %65 = phi i8* [%62, %$20] ; # P %66 = phi i64 [%61, %$20] ; # Y ; # (unless (and (nil? F) (== (val P) (char "."))) (setq Y (set 2 Y (... ; # (and (nil? F) (== (val P) (char "."))) ; # (nil? F) %67 = icmp eq i64 %29, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64) br i1 %67, label %$24, label %$23 $24: %68 = phi i64 [%64, %$21] ; # X %69 = phi i8* [%65, %$21] ; # P %70 = phi i64 [%66, %$21] ; # Y ; # (val P) %71 = load i8, i8* %69 ; # (== (val P) (char ".")) %72 = icmp eq i8 %71, 46 br label %$23 $23: %73 = phi i64 [%64, %$21], [%68, %$24] ; # X %74 = phi i8* [%65, %$21], [%69, %$24] ; # P %75 = phi i64 [%66, %$21], [%70, %$24] ; # Y %76 = phi i1 [0, %$21], [%72, %$24] ; # -> br i1 %76, label %$26, label %$25 $25: %77 = phi i64 [%73, %$23] ; # X %78 = phi i8* [%74, %$23] ; # P %79 = phi i64 [%75, %$23] ; # Y ; # (set 2 Y (cons (mkStr P) $Nil)) ; # (mkStr P) %80 = call i64 @mkStr(i8* %78) ; # (cons (mkStr P) $Nil) %81 = call i64 @cons(i64 %80, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) %82 = inttoptr i64 %79 to i64* %83 = getelementptr i64, i64* %82, i32 1 store i64 %81, i64* %83 br label %$26 $26: %84 = phi i64 [%73, %$23], [%77, %$25] ; # X %85 = phi i8* [%74, %$23], [%78, %$25] ; # P %86 = phi i64 [%75, %$23], [%81, %$25] ; # Y br label %$20 $22: %87 = phi i64 [%59, %$20] ; # X %88 = phi i8* [%62, %$20] ; # P %89 = phi i64 [%61, %$20] ; # Y ; # (drop *Safe) %90 = inttoptr i64 %54 to i64* %91 = getelementptr i64, i64* %90, i32 1 %92 = load i64, i64* %91 %93 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 x i64]* @env to i8*), i32 0) to i64) to i64* store i64 %92, i64* %93 br label %$7 $6: %94 = phi i64 [%12, %$4] ; # X br label %$7 $7: %95 = phi i64 [%87, %$22], [%94, %$6] ; # X %96 = phi i64 [%50, %$22], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$6] ; # -> ret i64 %96 } define i64 @_info(i64) align 8 { $1: ; # (let (X (cdr Exe) Nm (xName Exe (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 ([870 x i64]* @SymTab to i8*), i32 456) to i64) to i64* store i64 %4, i64* %5 ; # (xName Exe (set $At2 (evSym X))) %6 = call i64 @xName(i64 %0, i64 %4) ; # (b64 1) %7 = alloca i64, i64 1 ; # (if (lt0 (fileInfo (nil? (eval (car (shift X)))) (pathString Nm (... ; # (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 ([870 x i64]* @SymTab to i8*), i32 8) to i64) ; # (pathSize Nm) %22 = call i64 @pathSize(i64 %6) ; # (b8 (pathSize Nm)) %23 = alloca i8, i64 %22 ; # (pathString Nm (b8 (pathSize Nm))) %24 = call i8* @pathString(i64 %6, i8* %23) ; # (fileInfo (nil? (eval (car (shift X)))) (pathString Nm (b8 (pathS... %25 = call i64 @fileInfo(i1 %21, i8* %24, i64* %7) ; # (lt0 (fileInfo (nil? (eval (car (shift X)))) (pathString Nm (b8 (... %26 = icmp slt i64 %25, 0 br i1 %26, label %$7, label %$8 $7: %27 = phi i64 [%10, %$2] ; # X br label %$9 $8: %28 = 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) %29 = and i64 %25, 3 switch i64 %29, label %$10 [ i64 1, label %$12 i64 2, label %$13 ] $12: %30 = phi i64 [%28, %$8] ; # X %31 = phi i64 [%25, %$8] ; # N br label %$11 $13: %32 = phi i64 [%28, %$8] ; # X %33 = phi i64 [%25, %$8] ; # N br label %$11 $10: %34 = phi i64 [%28, %$8] ; # X %35 = phi i64 [%25, %$8] ; # N ; # (val Size) %36 = load i64, i64* %7 ; # (box64 (val Size)) %37 = and i64 %36, 17293822569102704640 %38 = icmp ne i64 %37, 0 br i1 %38, label %$14, label %$15 $14: %39 = call i64 @boxNum(i64 %36) br label %$16 $15: %40 = shl i64 %36, 4 %41 = or i64 %40, 2 br label %$16 $16: %42 = phi i64 [%39, %$14], [%41, %$15] ; # -> br label %$11 $11: %43 = phi i64 [%30, %$12], [%32, %$13], [%34, %$16] ; # X %44 = phi i64 [%31, %$12], [%33, %$13], [%35, %$16] ; # N %45 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%42, %$16] ; # -> ; # (shr N 2) %46 = lshr i64 %44, 2 ; # (& (setq N (shr N 2)) (hex "FFFF")) %47 = and i64 %46, 65535 ; # (shr N 16) %48 = lshr i64 %46, 16 ; # (& (setq N (shr N 16)) (hex "FF")) %49 = and i64 %48, 255 ; # (shr N 8) %50 = lshr i64 %48, 8 ; # (& (setq N (shr N 8)) (hex "FF")) %51 = and i64 %50, 255 ; # (tmDate (& (setq N (shr N 2)) (hex "FFFF")) (& (setq N (shr N 16)... %52 = call i64 @tmDate(i64 %47, i64 %49, i64 %51) ; # (shr N 8) %53 = lshr i64 %50, 8 ; # (cnt (shr N 8)) %54 = shl i64 %53, 4 %55 = or i64 %54, 2 ; # (cons (tmDate (& (setq N (shr N 2)) (hex "FFFF")) (& (setq N (shr... %56 = call i64 @cons(i64 %52, i64 %55) ; # (cons (case (& N 3) (1 $T) (2 $Nil) (T (box64 (val Size)))) (cons... %57 = call i64 @cons(i64 %45, i64 %56) br label %$9 $9: %58 = phi i64 [%27, %$7], [%43, %$11] ; # X %59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%57, %$11] ; # -> ret i64 %59 } define i64 @_file(i64) align 8 { $1: ; # (let In: (inFile (val $InFile)) (ifn (and (In:) (In: name)) $Nil ... ; # (val $InFile) %1 = load i8*, i8** @$InFile ; # (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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %40 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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]* @$88 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save (cons R $Nil)) %148 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 Exe Fun) (unless (ffiPrep Lib (bufString Nm (b8 (b... ; # (xName Exe Fun) %24 = call i64 @xName(i64 %0, 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]* @$89 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save (cons R $Nil)) %163 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save (cons (eval (++ X)) $Nil)) %37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 Exe Y) %34 = call i64 @xName(i64 %0, i64 %15) ; # (| 2 (>> -4 (char "@"))) ; # (== (xName Exe 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]* @$90 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 ([17 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 ([17 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save (cons (eval (++ X)) $Nil)) %90 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([52 x i64]* @gcData to i8*), i32 408) 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 ([52 x i64]* @gcData to i8*), i32 32) 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 ([870 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 ([52 x i64]* @gcData to i8*), i32 408) 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]* @$91 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 ([17 x i64]* @env to i8*), i32 80) 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 x i64]* @env to i8*), i32 80) 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 ([17 x i64]* @env to i8*), i32 80) 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 ([17 x i64]* @env to i8*), i32 80) 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 ([870 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 ([17 x i64]* @env to i8*), i32 80) 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), i64* %74 ; # (link (push $Nil NIL)) %75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 ([17 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save Y) %15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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 ([870 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 ([17 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 ([870 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 ([870 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 Exe (xSym (++ Z))) Stk (stack)) (... 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 Exe (xSym (++ Z))) Stk (stack)) (add_history (buf... ; # (++ 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 Exe (xSym (++ Z))) %66 = call i64 @xName(i64 %0, 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 ([870 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)** @$Put 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)** @$Put 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 ([870 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 (set $StkBr... ; # (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 ; # (set $StkBrk (ulimStk)) ; # (ulimStk) %4 = call i8* @ulimStk() store i8* %4, i8** @$StkBrk 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]* @$92 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 ([870 x i64]* @SymTab to i8*), i32 824) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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]* @$93 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 ([870 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 6952) 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 ([870 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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 200) to i64) to i64* store i64 %84, i64* %85 %86 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 232) to i64) to i64* store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 408) to i64), i64* %86 ; # (tail $Db1) %87 = add i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 408) to i64), -8 %88 = inttoptr i64 %87 to i64* store i64 26, i64* %88 ; # (cons $Db1 $Nil) %89 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 408) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) store i64 %89, i64* @$Extern ; # (b8 (ioFrame T)) %90 = alloca i8, i64 28 ; # (initOutFile 2) %91 = call i8* @initOutFile(i32 2) ; # (pushOutFile (b8 (ioFrame T)) (initOutFile 2) 0) call void @pushOutFile(i8* %90, i8* %91, i32 0) ; # (set $Stdout (b8 (ioFrame T))) ; # (b8 (ioFrame T)) %92 = alloca i8, i64 28 store i8* %92, i8** @$Stdout ; # (initOutFile 1) %93 = call i8* @initOutFile(i32 1) ; # (pushOutFile (set $Stdout (b8 (ioFrame T))) (initOutFile 1) 0) call void @pushOutFile(i8* %92, i8* %93, i32 0) ; # (set $Stdin (b8 (ioFrame T))) ; # (b8 (ioFrame T)) %94 = alloca i8, i64 28 store i8* %94, i8** @$Stdin ; # (initInFile 0 null) %95 = call i8* @initInFile(i32 0, i8* null) ; # (pushInFile (set $Stdin (b8 (ioFrame T))) (initInFile 0 null) 0) call void @pushInFile(i8* %94, i8* %95, i32 0) ; # (set Tio (=0 (tcgetattr 0 OrgTermio))) ; # (tcgetattr 0 OrgTermio) %96 = call i32 @tcgetattr(i32 0, i8* @OrgTermio) ; # (=0 (tcgetattr 0 OrgTermio)) %97 = icmp eq i32 %96, 0 store i1 %97, i1* @Tio ; # (sigUnblock 0) call void @sigUnblock(i32 0) ; # (val SIGHUP Sig) %98 = getelementptr i32, i32* @Sig, i32 0 %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 SIGHUP Sig) (fun sig)) call void @iSignal(i32 %99, i8* %100) ; # (val SIGUSR1 Sig) %101 = getelementptr i32, i32* @Sig, i32 2 %102 = load i32, i32* %101 ; # (fun sig) ; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar... %103 = bitcast void(i32)* @sig to i8* ; # (iSignal (val SIGUSR1 Sig) (fun sig)) call void @iSignal(i32 %102, i8* %103) ; # (val SIGUSR2 Sig) %104 = getelementptr i32, i32* @Sig, i32 3 %105 = load i32, i32* %104 ; # (fun sig) ; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar... %106 = bitcast void(i32)* @sig to i8* ; # (iSignal (val SIGUSR2 Sig) (fun sig)) call void @iSignal(i32 %105, i8* %106) ; # (val SIGALRM Sig) %107 = getelementptr i32, i32* @Sig, i32 5 %108 = load i32, i32* %107 ; # (fun sig) ; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar... %109 = bitcast void(i32)* @sig to i8* ; # (iSignal (val SIGALRM Sig) (fun sig)) call void @iSignal(i32 %108, i8* %109) ; # (val SIGTERM Sig) %110 = getelementptr i32, i32* @Sig, i32 6 %111 = load i32, i32* %110 ; # (fun sig) ; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar... %112 = bitcast void(i32)* @sig to i8* ; # (iSignal (val SIGTERM Sig) (fun sig)) call void @iSignal(i32 %111, i8* %112) ; # (val SIGWINCH Sig) %113 = getelementptr i32, i32* @Sig, i32 13 %114 = load i32, i32* %113 ; # (fun sig) ; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar... %115 = bitcast void(i32)* @sig to i8* ; # (iSignal (val SIGWINCH Sig) (fun sig)) call void @iSignal(i32 %114, i8* %115) ; # (val SIGIO Sig) %116 = getelementptr i32, i32* @Sig, i32 14 %117 = load i32, i32* %116 ; # (fun sig) ; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar... %118 = bitcast void(i32)* @sig to i8* ; # (iSignal (val SIGIO Sig) (fun sig)) call void @iSignal(i32 %117, i8* %118) ; # (when (== (signal (val SIGTSTP Sig) (val SigIgn)) (val SigDfl)) (... ; # (val SIGTSTP Sig) %119 = getelementptr i32, i32* @Sig, i32 10 %120 = load i32, i32* %119 ; # (val SigIgn) %121 = load i8*, i8** @SigIgn ; # (signal (val SIGTSTP Sig) (val SigIgn)) %122 = call i8* @signal(i32 %120, i8* %121) ; # (val SigDfl) %123 = load i8*, i8** @SigDfl ; # (== (signal (val SIGTSTP Sig) (val SigIgn)) (val SigDfl)) %124 = icmp eq i8* %122, %123 br i1 %124, label %$23, label %$24 $23: %125 = phi i8** [%74, %$20] ; # Av ; # (val SIGTSTP Sig) %126 = getelementptr i32, i32* @Sig, i32 10 %127 = load i32, i32* %126 ; # (fun sig) ; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar... %128 = bitcast void(i32)* @sig to i8* ; # (iSignal (val SIGTSTP Sig) (fun sig)) call void @iSignal(i32 %127, i8* %128) br label %$24 $24: %129 = phi i8** [%74, %$20], [%125, %$23] ; # Av ; # (val SIGINT Sig) %130 = getelementptr i32, i32* @Sig, i32 1 %131 = load i32, i32* %130 ; # (fun sigTerm) ; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar... %132 = bitcast void(i32)* @sigTerm to i8* ; # (iSignal (val SIGINT Sig) (fun sigTerm)) call void @iSignal(i32 %131, i8* %132) ; # (val SIGCHLD Sig) %133 = getelementptr i32, i32* @Sig, i32 7 %134 = load i32, i32* %133 ; # (fun sigChld) ; # (i8* (def (pico~pack "@" (pico~car cross~Args)) (func (; cross~Ar... %135 = bitcast void(i32)* @sigChld to i8* ; # (signal (val SIGCHLD Sig) (fun sigChld)) %136 = call i8* @signal(i32 %134, i8* %135) ; # (val SIGPIPE Sig) %137 = getelementptr i32, i32* @Sig, i32 4 %138 = load i32, i32* %137 ; # (val SigIgn) %139 = load i8*, i8** @SigIgn ; # (signal (val SIGPIPE Sig) (val SigIgn)) %140 = call i8* @signal(i32 %138, i8* %139) ; # (val SIGTTIN Sig) %141 = getelementptr i32, i32* @Sig, i32 11 %142 = load i32, i32* %141 ; # (val SigIgn) %143 = load i8*, i8** @SigIgn ; # (signal (val SIGTTIN Sig) (val SigIgn)) %144 = call i8* @signal(i32 %142, i8* %143) ; # (val SIGTTOU Sig) %145 = getelementptr i32, i32* @Sig, i32 12 %146 = load i32, i32* %145 ; # (val SigIgn) %147 = load i8*, i8** @SigIgn ; # (signal (val SIGTTOU Sig) (val SigIgn)) %148 = call i8* @signal(i32 %146, i8* %147) ; # (initReadline) call void @initReadline() ; # (set $USec (getUsec YES)) ; # (getUsec YES) %149 = call i64 @getUsec(i1 1) store i64 %149, i64* @$USec ; # (unless (setjmp QuitRst) (loadAll 0)) ; # (setjmp QuitRst) %150 = call i32 @setjmp(i8* @QuitRst) %151 = icmp ne i32 %150, 0 br i1 %151, label %$26, label %$25 $25: %152 = phi i8** [%129, %$24] ; # Av ; # (loadAll 0) %153 = call i64 @loadAll(i64 0) br label %$26 $26: %154 = phi i8** [%129, %$24], [%152, %$25] ; # Av ; # (loop (repl 0 ($ ": ") $Nil)) br label %$27 $27: %155 = phi i8** [%154, %$26], [%155, %$27] ; # Av ; # (repl 0 ($ ": ") $Nil) %156 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$94 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 x i64]* @SymTab to i8*), i32 8) to i64)) br label %$27 } @$94 = private constant [3 x i8] c": \00" @$93 = private constant [5 x i8] c"HOME\00" @$92 = private constant [2 x i8] c"+\00" @$91 = private constant [19 x i8] c"Too many callbacks\00" @$90 = private constant [9 x i8] c"[DLL] %s\00" @$89 = private constant [8 x i8] c"Bad ffi\00" @$88 = private constant [16 x i8] c"Bad result spec\00" @$87 = private constant [2 x i8] c".\00" @$86 = private constant [19 x i8] c"Can't open PTY: %s\00" @$85 = private constant [3 x i8] c"%s\00" @$84 = private constant [11 x i8] c"Not making\00" @$83 = private constant [3 x i8] c"+ \00" @$82 = private constant [9 x i8] c"wait pid\00" @$81 = private constant [4 x i8] c" = \00" @$80 = private constant [3 x i8] c" :\00" @$79 = private constant [9 x i8] c"No Break\00" @$78 = private constant [3 x i8] c"! \00" @$77 = private constant [13 x i8] c"Tag expected\00" @$76 = private constant [20 x i8] c"Coroutine not found\00" @$75 = private constant [14 x i8] c"No coroutines\00" @$74 = private constant [24 x i8] c"Can't stop main routine\00" @$73 = private constant [20 x i8] c"Reentrant coroutine\00" @$72 = private constant [14 x i8] c"Tag not found\00" @$71 = private constant [10 x i8] c"Bad extra\00" @$70 = private constant [10 x i8] c"Bad super\00" @$69 = private constant [12 x i8] c"Bad message\00" @$68 = private constant [12 x i8] c" redefined\0A\00" @$67 = private constant [3 x i8] c"# \00" @$66 = private constant [10 x i8] c"Bad count\00" @$65 = private constant [10 x i8] c"Bad chain\00" @$64 = private constant [19 x i8] c"Circular free list\00" @$63 = private constant [28 x i8] c"Transaction fsync error: %s\00" @$62 = private constant [7 x i8] c"Bad ID\00" @$61 = private constant [2 x i8] c"r\00" @$60 = private constant [3 x i8] c"a+\00" @$59 = private constant [2 x i8] c"a\00" @$58 = private constant [23 x i8] c"Log truncate error: %s\00" @$57 = private constant [42 x i8] c"Last transaction not completed: Rollback\0A\00" @$56 = private constant [35 x i8] c"Discarding incomplete transaction\0A\00" @$55 = private constant [12 x i8] c"DB Oversize\00" @$54 = private constant [14 x i8] c"Log write: %s\00" @$53 = private constant [18 x i8] c"Journal write: %s\00" @$52 = private constant [19 x i8] c"DB fsync error: %s\00" @$51 = private constant [12 x i8] c"Bad Journal\00" @$50 = private constant [13 x i8] c"DB write: %s\00" @$49 = private constant [12 x i8] c"DB read: %s\00" @$48 = private constant [12 x i8] c"Bad DB file\00" @$47 = private constant [3 x i8] c"> \00" @$46 = private constant [4 x i8] c"-> \00" @$45 = private constant [4 x i8] c" \00" @$44 = private constant [4 x i8] c" . \00" @$43 = private constant [6 x i8] c"priv~\00" @$42 = private constant [27 x i8] c"Super parentheses mismatch\00" @$41 = private constant [16 x i8] c"Bad dotted pair\00" @$40 = private constant [15 x i8] c"sync write: %s\00" @$39 = private constant [14 x i8] c"No current fd\00" @$38 = private constant [14 x i8] c"Tell PIPE_BUF\00" @$37 = private constant [16 x i8] c"child write: %s\00" @$36 = private constant [16 x i8] c"bytes write: %s\00" @$35 = private constant [9 x i8] c"SETFD %s\00" @$34 = private constant [17 x i8] c"Select error: %s\00" @$33 = private constant [7 x i8] c"Bad FD\00" @$32 = private constant [15 x i8] c"Bad input '%s'\00" @$31 = private constant [12 x i8] c"EOF Overrun\00" @$30 = private constant [14 x i8] c"Size overflow\00" @$29 = private constant [15 x i8] c"Pipe error: %s\00" @$28 = private constant [16 x i8] c"Close error: %s\00" @$27 = private constant [15 x i8] c"Open error: %s\00" @$26 = private constant [10 x i8] c"Undefined\00" @$25 = private constant [6 x i8] c"Div/0\00" @$24 = private constant [4 x i8] c".so\00" @$23 = private constant [5 x i8] c"lib/\00" @$22 = private constant [21 x i8] c"Bad symbol namespace\00" @$21 = private constant [11 x i8] c"Can't fork\00" @$20 = private constant [14 x i8] c"File lock: %s\00" @$19 = private constant [10 x i8] c"Protected\00" @$18 = private constant [15 x i8] c"Item not found\00" @$17 = private constant [18 x i8] c"Variable expected\00" @$16 = private constant [14 x i8] c"List expected\00" @$15 = private constant [19 x i8] c"Cons pair expected\00" @$14 = private constant [14 x i8] c"Atom expected\00" @$13 = private constant [14 x i8] c"Name expected\00" @$12 = private constant [25 x i8] c"External symbol expected\00" @$11 = private constant [16 x i8] c"Symbol expected\00" @$10 = private constant [16 x i8] c"Number expected\00" @$9 = private constant [22 x i8] c"Small number expected\00" @$8 = private constant [13 x i8] c"Bad argument\00" @$7 = private constant [15 x i8] c"Stack overflow\00" @$6 = private constant [3 x i8] c"? \00" @$5 = private constant [5 x i8] c" -- \00" @$4 = private constant [4 x i8] c"!? \00" @$3 = private constant [10 x i8] c"No memory\00" @$2 = private constant [16 x i8] c"%s: Can't exec\0A\00" @$1 = private constant [2 x i8] c"\0A\00" pil21/src/ext.l0000644000000000000000000001663413726377137010471 0ustar # 10sep20 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 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 Exe @) 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.ll0000644000000000000000000010342114162303715010616 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 @$Current = external global i8* @$Coroutines = external global i8* @$StkBrk = 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 @$InFiles = external global i8** @$InFDs = external global i32 @$OutFiles = external global i8** @$InFile = external global i8* @$OutFile = external global i8* @$Chr = external global i32 @$Put = external global void(i8)* @$Get = external global i32()* @$PutBin = external global void(i8)* @$GetBin = external global i32()* @$OutFDs = external global i32 @$Poll = external global i64* @$Nfds = external global i32 @$SeedL = external global i64 @$SeedH = external global i64 @$USec = external global i64 @$TickU = external global i64 @$TickS = 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 [870 x i64] @gcData = external global [52 x i64] @cbFuns = external global [24 x i64] @env = external global [17 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 @$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 @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 i8* @readline(i8*) 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 i32 @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 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 @sigUnblock(i32) declare void @iSignal(i32, i8*) 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, 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 @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 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 i64 @brkLoad(i64) declare i64 @xCnt(i64, i64) declare i64 @evCnt(i64, i64) declare i64 @evSym(i64) declare i64 @xName(i64, 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 Ex... ; # (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 Exe @) NIL) C (symC... ; # (evSym X) %4 = call i64 @evSym(i64 %3) ; # (nil? (evSym X)) %5 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 Exe @) NIL) C (symChar P)) (while (> SNXBA... ; # (xName Exe @) %8 = call i64 @xName(i64 %0, i64 %4) ; # (push 0 (xName Exe @) 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 ([870 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 ([17 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 ([17 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 ([17 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 ([17 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 ([17 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* @$Chr ; # (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()** @$Get %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()** @$Get %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 ([870 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()** @$Get %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()** @$Get %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()** @$Get %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 ([870 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 ([870 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)** @$Put 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 ([870 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)** @$Put call void %140(i8 %139) ; # (call $Put (char "=")) %141 = load void(i8)*, void(i8)** @$Put call void %141(i8 61) ; # (call $Put (char "=")) %142 = load void(i8)*, void(i8)** @$Put call void %142(i8 61) ; # (ret $Nil) ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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)** @$Put 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 ([870 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)** @$Put call void %173(i8 %172) ; # (call $Put (char "=")) %174 = load void(i8)*, void(i8)** @$Put call void %174(i8 61) ; # (ret $Nil) ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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)** @$Put 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)** @$Put 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 ([870 x i64]* @SymTab to i8*), i32 280) to i64), %$43] ; # -> ret i64 %190 } pil21/src/ht.l0000644000000000000000000002544014032346220010253 0ustar # 04apr21 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)) (de T i1 flush (i8*)) # (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 (val $Chr) (unless C (setq C (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.ll0000644000000000000000000017271714162303715010447 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 @$Current = external global i8* @$Coroutines = external global i8* @$StkBrk = 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 @$InFiles = external global i8** @$InFDs = external global i32 @$OutFiles = external global i8** @$InFile = external global i8* @$OutFile = external global i8* @$Chr = external global i32 @$Put = external global void(i8)* @$Get = external global i32()* @$PutBin = external global void(i8)* @$GetBin = external global i32()* @$OutFDs = external global i32 @$Poll = external global i64* @$Nfds = external global i32 @$SeedL = external global i64 @$SeedH = external global i64 @$USec = external global i64 @$TickU = external global i64 @$TickS = 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 [870 x i64] @gcData = external global [52 x i64] @cbFuns = external global [24 x i64] @env = external global [17 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 @$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 @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 i8* @readline(i8*) 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 i32 @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 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 @sigUnblock(i32) declare void @iSignal(i32, i8*) 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, 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 @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 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 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) declare i1 @flush(i8*) 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 ([870 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)** @$Put call void %54(i8 247) ; # (call $Put (hex "BF")) %55 = load void(i8)*, void(i8)** @$Put call void %55(i8 191) ; # (call $Put (hex "BF")) %56 = load void(i8)*, void(i8)** @$Put call void %56(i8 191) ; # (call $Put (hex "BF")) %57 = load void(i8)*, void(i8)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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 ([870 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)** @$Put 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)** @$Put 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)** @$Put 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 ([17 x i64]* @env to i8*), i32 72) 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)** @$Put 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)** @$Put 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 ([17 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 ([17 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 ([870 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put 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)** @$Put call void %128(i8 38) ; # (call $Put (char "#")) %129 = load void(i8)*, void(i8)** @$Put 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)** @$Put 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 ([17 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* @$Chr ; # (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()** @$Get %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 ([870 x i64]* @SymTab to i8*), i32 8) to i64)) ; # (save X) %52 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([17 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 ([17 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* @$Chr 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()** @$Get %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 ([870 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 ([870 x i64]* @SymTab to i8*), i32 8) to i64), %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([870 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 ([17 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 ([870 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 ([870 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 (val $Chr) (unless C (setq C (call $SvGet))) (when (ge0 (s... ; # (val $Chr) %0 = load i32, i32* @$Chr ; # (unless C (setq C (call $SvGet))) %1 = icmp ne i32 %0, 0 br i1 %1, label %$3, label %$2 $2: %2 = phi i32 [%0, %$1] ; # C ; # (call $SvGet) %3 = load i32()*, i32()** @$SvGet %4 = call i32 %3() br label %$3 $3: %5 = phi i32 [%0, %$1], [%4, %$2] ; # C ; # (when (ge0 (set $CnkCnt (chrHex C))) (while (ge0 (chrHex (setq C ... ; # (set $CnkCnt (chrHex C)) ; # (chrHex C) %6 = call i32 @chrHex(i32 %5) store i32 %6, i32* @$CnkCnt ; # (ge0 (set $CnkCnt (chrHex C))) %7 = icmp sge i32 %6, 0 br i1 %7, label %$4, label %$5 $4: %8 = phi i32 [%5, %$3] ; # C ; # (while (ge0 (chrHex (setq C (call $SvGet)))) (set $CnkCnt (| @ (s... br label %$6 $6: %9 = phi i32 [%8, %$4], [%14, %$7] ; # C ; # (call $SvGet) %10 = load i32()*, i32()** @$SvGet %11 = call i32 %10() ; # (chrHex (setq C (call $SvGet))) %12 = call i32 @chrHex(i32 %11) ; # (ge0 (chrHex (setq C (call $SvGet)))) %13 = icmp sge i32 %12, 0 br i1 %13, label %$7, label %$8 $7: %14 = phi i32 [%11, %$6] ; # C ; # (set $CnkCnt (| @ (shl (val $CnkCnt) 4))) ; # (val $CnkCnt) %15 = load i32, i32* @$CnkCnt ; # (shl (val $CnkCnt) 4) %16 = shl i32 %15, 4 ; # (| @ (shl (val $CnkCnt) 4)) %17 = or i32 %12, %16 store i32 %17, i32* @$CnkCnt br label %$6 $8: %18 = phi i32 [%11, %$6] ; # C ; # (loop (? (== C (char "^J")) (call $SvGet) (when (=0 (val $CnkCnt)... br label %$9 $9: %19 = phi i32 [%18, %$8], [%34, %$15] ; # C ; # (? (== C (char "^J")) (call $SvGet) (when (=0 (val $CnkCnt)) (cal... ; # (== C (char "^J")) %20 = icmp eq i32 %19, 10 br i1 %20, label %$12, label %$10 $12: %21 = phi i32 [%19, %$9] ; # C ; # (call $SvGet) %22 = load i32()*, i32()** @$SvGet %23 = call i32 %22() ; # (when (=0 (val $CnkCnt)) (call $SvGet) (set $Chr 0)) ; # (val $CnkCnt) %24 = load i32, i32* @$CnkCnt ; # (=0 (val $CnkCnt)) %25 = icmp eq i32 %24, 0 br i1 %25, label %$13, label %$14 $13: %26 = phi i32 [%21, %$12] ; # C ; # (call $SvGet) %27 = load i32()*, i32()** @$SvGet %28 = call i32 %27() ; # (set $Chr 0) store i32 0, i32* @$Chr br label %$14 $14: %29 = phi i32 [%21, %$12], [%26, %$13] ; # C br label %$11 $10: %30 = phi i32 [%19, %$9] ; # C ; # (? (lt0 C)) ; # (lt0 C) %31 = icmp slt i32 %30, 0 br i1 %31, label %$11, label %$15 $15: %32 = phi i32 [%30, %$10] ; # C ; # (call $SvGet) %33 = load i32()*, i32()** @$SvGet %34 = call i32 %33() br label %$9 $11: %35 = phi i32 [%29, %$14], [%30, %$10] ; # C br label %$5 $5: %36 = phi i32 [%5, %$3], [%35, %$11] ; # 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* @$Chr 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* @$Chr 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 ([870 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()** @$Get to i8** ; # (val (i8** $Get)) %47 = load i8*, i8** %46 store i8* %47, i8** %45 ; # (fun (i32) getChunked) store i32()* @getChunked, i32()** @$Get ; # (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()** @$Get 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* @$Chr 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 ([870 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)** @$Put 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)** @$Put ; # (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)** @$Put 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 ([870 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** @$OutFile ; # (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.c0000644000000000000000000002465414035575133010450 0ustar // 14apr21 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 || *av[3] == '\0') 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); giveup("Can't connect"); } 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 = -1; char *q; while (p = readdir(dp)) if ((n = (int)strtol(p->d_name, &q, 10)) > max && !*q) max = n; if (max >= 0) { 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))) { 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 && stat(nm, &st) >= 0) { 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); } } } closedir(dp); } sleep(sec); } } pil21/src/httpGate.c0000644000000000000000000003434314160650605011420 0ustar // 22dec21 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 inline bool pre(char *p, char *s) { while (*s) if (*p++ != *s++) return NO; return YES; } 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 (pre(buf, "GET /")) p = buf + 5; else if (pre(buf, "POST /")) p = buf + 6; 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/map0000644000000000000000000017020514162303700010142 0ustar llvm~$ (251 "@src/lib/llvm.l" llvm pico) llvm~$AV (6 "@src/glob.l" llvm pico) llvm~$AV0 (5 "@src/glob.l" llvm pico) llvm~$Alarm (552 "@src/glob.l" llvm pico) llvm~$At (130 "@src/glob.l" llvm pico) llvm~$At2 (131 "@src/glob.l" llvm pico) llvm~$At3 (132 "@src/glob.l" llvm pico) llvm~$Avail (12 "@src/glob.l" llvm pico) llvm~$B (124 "@src/glob.l" llvm pico) llvm~$Bind (634 "@src/glob.l" llvm pico) llvm~$BlkEnd (78 "@src/glob.l" llvm pico) llvm~$BlkIndex (75 "@src/glob.l" llvm pico) llvm~$BlkLink (76 "@src/glob.l" llvm pico) llvm~$BlkPtr (77 "@src/glob.l" llvm pico) llvm~$Break (635 "@src/glob.l" llvm pico) llvm~$BufX (61 "@src/glob.l" llvm pico) llvm~$Bye (153 "@src/glob.l" llvm pico) llvm~$C (122 "@src/glob.l" llvm pico) llvm~$CPU (114 "@src/glob.l" llvm pico) llvm~$Catch (636 "@src/glob.l" llvm pico) llvm~$Cb (604 "@src/glob.l" llvm pico) llvm~$Cell (652 "@src/glob.l" llvm pico) llvm~$Child (49 "@src/glob.l" llvm pico) llvm~$Children (50 "@src/glob.l" llvm pico) llvm~$Chr (36 "@src/glob.l" llvm pico) llvm~$Class (139 "@src/glob.l" llvm pico) llvm~$Complete (155 "@src/glob.l" llvm pico) llvm~$ContPrmt (28 "@src/glob.l" llvm pico) llvm~$Coroutines (17 "@src/glob.l" llvm pico) llvm~$CtlFrames (640 "@src/glob.l" llvm pico) llvm~$Current (16 "@src/glob.l" llvm pico) llvm~$D (660 "@src/glob.l" llvm pico) llvm~$DB (117 "@src/glob.l" llvm pico) llvm~$DBs (72 "@src/glob.l" llvm pico) llvm~$Db1 (128 "@src/glob.l" llvm pico) llvm~$DbBlock (74 "@src/glob.l" llvm pico) llvm~$DbFile (71 "@src/glob.l" llvm pico) llvm~$DbFiles (70 "@src/glob.l" llvm pico) llvm~$DbJnl (79 "@src/glob.l" llvm pico) llvm~$DbLog (80 "@src/glob.l" llvm pico) llvm~$Dbg (154 "@src/glob.l" llvm pico) llvm~$Delim (680 "@src/glob.l" llvm pico) llvm~$Empty (679 "@src/glob.l" llvm pico) llvm~$End (60 "@src/glob.l" llvm pico) llvm~$EndX (63 "@src/glob.l" llvm pico) llvm~$Err (149 "@src/glob.l" llvm pico) llvm~$ErrFrames (639 "@src/glob.l" llvm pico) llvm~$Ext (136 "@src/glob.l" llvm pico) llvm~$ExtCnt (14 "@src/glob.l" llvm pico) llvm~$ExtN (64 "@src/glob.l" llvm pico) llvm~$ExtSkip (15 "@src/glob.l" llvm pico) llvm~$Extern (13 "@src/glob.l" llvm pico) llvm~$Extn (65 "@src/glob.l" llvm pico) llvm~$Fork (152 "@src/glob.l" llvm pico) llvm~$GcCount (67 "@src/glob.l" llvm pico) llvm~$Get (38 "@src/glob.l" llvm pico) llvm~$GetBin (40 "@src/glob.l" llvm pico) llvm~$Heaps (11 "@src/glob.l" llvm pico) llvm~$Hear (56 "@src/glob.l" llvm pico) llvm~$Hup (141 "@src/glob.l" llvm pico) llvm~$I (125 "@src/glob.l" llvm pico) llvm~$InBye (675 "@src/glob.l" llvm pico) llvm~$InFDs (32 "@src/glob.l" llvm pico) llvm~$InFile (34 "@src/glob.l" llvm pico) llvm~$InFiles (31 "@src/glob.l" llvm pico) llvm~$InFrames (637 "@src/glob.l" llvm pico) llvm~$Intern (642 "@src/glob.l" llvm pico) llvm~$Jam (674 "@src/glob.l" llvm pico) llvm~$Key (645 "@src/glob.l" llvm pico) llvm~$LastSym (535 "@src/glob.l" llvm pico) llvm~$LineBuf (25 "@src/glob.l" llvm pico) llvm~$LinePrmt (26 "@src/glob.l" llvm pico) llvm~$LinePtr (24 "@src/glob.l" llvm pico) llvm~$Link (633 "@src/glob.l" llvm pico) llvm~$Lisp (554 "@src/glob.l" llvm pico) llvm~$LispEnd (601 "@src/glob.l" llvm pico) llvm~$M (659 "@src/glob.l" llvm pico) llvm~$Make (646 "@src/glob.l" llvm pico) llvm~$MaxBlkSize (73 "@src/glob.l" llvm pico) llvm~$Meth (118 "@src/glob.l" llvm pico) llvm~$Mic (53 "@src/glob.l" llvm pico) llvm~$Month (668 "@src/glob.l" llvm pico) llvm~$Msg (150 "@src/glob.l" llvm pico) llvm~$N (121 "@src/glob.l" llvm pico) llvm~$Next (643 "@src/glob.l" llvm pico) llvm~$Nfds (43 "@src/glob.l" llvm pico) llvm~$Nil (103 "@src/glob.l" llvm pico) llvm~$OS (113 "@src/glob.l" llvm pico) llvm~$OutFDs (41 "@src/glob.l" llvm pico) llvm~$OutFile (35 "@src/glob.l" llvm pico) llvm~$OutFiles (33 "@src/glob.l" llvm pico) llvm~$OutFrames (638 "@src/glob.l" llvm pico) llvm~$P (126 "@src/glob.l" llvm pico) llvm~$PPid (116 "@src/glob.l" llvm pico) llvm~$PRepl (673 "@src/glob.l" llvm pico) llvm~$Parser (641 "@src/glob.l" llvm pico) llvm~$Penv (1286 "@src/subr.l" llvm pico) llvm~$Pico (107 "@src/glob.l" llvm pico) llvm~$Pico1 (109 "@src/glob.l" llvm pico) llvm~$PicoT (106 "@src/glob.l" llvm pico) llvm~$Pid (115 "@src/glob.l" llvm pico) llvm~$PilHome (7 "@src/glob.l" llvm pico) llvm~$PilLen (8 "@src/glob.l" llvm pico) llvm~$Pnl (1287 "@src/subr.l" llvm pico) llvm~$Poll (42 "@src/glob.l" llvm pico) llvm~$Priv (111 "@src/glob.l" llvm pico) llvm~$PrivT (110 "@src/glob.l" llvm pico) llvm~$Prompt (134 "@src/glob.l" llvm pico) llvm~$Protect (648 "@src/glob.l" llvm pico) llvm~$Ptr (59 "@src/glob.l" llvm pico) llvm~$PtrX (62 "@src/glob.l" llvm pico) llvm~$Put (37 "@src/glob.l" llvm pico) llvm~$PutBin (39 "@src/glob.l" llvm pico) llvm~$Quote (119 "@src/glob.l" llvm pico) llvm~$Repl (672 "@src/glob.l" llvm pico) llvm~$ReplPrmt (27 "@src/glob.l" llvm pico) llvm~$Ret (29 "@src/glob.l" llvm pico) llvm~$Rule (138 "@src/glob.l" llvm pico) llvm~$Run (140 "@src/glob.l" llvm pico) llvm~$S (123 "@src/glob.l" llvm pico) llvm~$Scl (137 "@src/glob.l" llvm pico) llvm~$SeedH (45 "@src/glob.l" llvm pico) llvm~$SeedL (44 "@src/glob.l" llvm pico) llvm~$Sig1 (142 "@src/glob.l" llvm pico) llvm~$Sig2 (143 "@src/glob.l" llvm pico) llvm~$Sigio (553 "@src/glob.l" llvm pico) llvm~$Signal (83 "@src/glob.l" llvm pico) llvm~$Slot (51 "@src/glob.l" llvm pico) llvm~$Solo (129 "@src/glob.l" llvm pico) llvm~$SpMiPipe (54 "@src/glob.l" llvm pico) llvm~$Spkr (52 "@src/glob.l" llvm pico) llvm~$Stdin (22 "@src/glob.l" llvm pico) llvm~$Stdout (23 "@src/glob.l" llvm pico) llvm~$StkBrk (18 "@src/glob.l" llvm pico) llvm~$StkLimit (19 "@src/glob.l" llvm pico) llvm~$StkSize (21 "@src/glob.l" llvm pico) llvm~$StkSizeT (20 "@src/glob.l" llvm pico) llvm~$StrP (66 "@src/glob.l" llvm pico) llvm~$Sync (676 "@src/glob.l" llvm pico) llvm~$T (120 "@src/glob.l" llvm pico) llvm~$TBuf (663 "@src/glob.l" llvm pico) llvm~$TStp1 (145 "@src/glob.l" llvm pico) llvm~$TStp2 (146 "@src/glob.l" llvm pico) llvm~$Talking (55 "@src/glob.l" llvm pico) llvm~$Tell (57 "@src/glob.l" llvm pico) llvm~$TellBuf (58 "@src/glob.l" llvm pico) llvm~$Term (147 "@src/glob.l" llvm pico) llvm~$This (133 "@src/glob.l" llvm pico) llvm~$TickS (48 "@src/glob.l" llvm pico) llvm~$TickU (47 "@src/glob.l" llvm pico) llvm~$Tilde (105 "@src/glob.l" llvm pico) llvm~$Trace (649 "@src/glob.l" llvm pico) llvm~$Transient (550 "@src/glob.l" llvm pico) llvm~$TtyPid (30 "@src/glob.l" llvm pico) llvm~$Typ (644 "@src/glob.l" llvm pico) llvm~$USec (46 "@src/glob.l" llvm pico) llvm~$Uni (151 "@src/glob.l" llvm pico) llvm~$Up (148 "@src/glob.l" llvm pico) llvm~$UsrHome (9 "@src/glob.l" llvm pico) llvm~$UsrLen (10 "@src/glob.l" llvm pico) llvm~$Version (657 "@src/glob.l" llvm pico) llvm~$W (127 "@src/glob.l" llvm pico) llvm~$Winch (144 "@src/glob.l" llvm pico) llvm~$Y (658 "@src/glob.l" llvm pico) llvm~$Yoke (647 "@src/glob.l" llvm pico) llvm~$Zap (135 "@src/glob.l" llvm pico) llvm~$pico (108 "@src/glob.l" llvm pico) llvm~$priv (112 "@src/glob.l" llvm pico) llvm~$rem (165 "@src/glob.l" llvm pico) llvm~% (943 "@src/lib/llvm.l" llvm pico) llvm~& (943 "@src/lib/llvm.l" llvm pico) llvm~* (943 "@src/lib/llvm.l" llvm pico) llvm~+ (873 "@src/lib/llvm.l" llvm pico) llvm~++ (1042 "@src/lib/llvm.l" llvm pico) llvm~+bind (172 "@src/lib/llvm.l" llvm pico) llvm~+lbl (169 "@src/lib/llvm.l" llvm pico) llvm~+phi (124 "@src/lib/llvm.l" llvm pico) llvm~- (873 "@src/lib/llvm.l" llvm pico) llvm~-ZERO (53 "@src/lib/llvm.l" llvm pico) llvm~/ (943 "@src/lib/llvm.l" llvm pico) llvm~292MY (8 "@src/defs.l" llvm pico) llvm~: (1414 "@src/lib/llvm.l" llvm pico) llvm~< (838 "@src/lib/llvm.l" llvm pico) llvm~<= (838 "@src/lib/llvm.l" llvm pico) llvm~<> (828 "@src/lib/llvm.l" llvm pico) llvm~=0 (851 "@src/lib/llvm.l" llvm pico) llvm~== (828 "@src/lib/llvm.l" llvm pico) llvm~> (838 "@src/lib/llvm.l" llvm pico) llvm~>= (838 "@src/lib/llvm.l" llvm pico) llvm~? (1340 "@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~Fdigit (165 "@src/dec.l" llvm pico) llvm~Fsign (164 "@src/dec.l" llvm pico) llvm~HEAP (8 "@src/defs.l" llvm pico) llvm~INTERN (20 "@src/defs.l" llvm pico) llvm~JmpBufSize (266 "@src/dec.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~OrgTermio (225 "@src/dec.l" llvm pico) llvm~PipeBufSize (163 "@src/dec.l" llvm pico) llvm~QuitRst (267 "@src/dec.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~Sig (204 "@src/dec.l" llvm pico) llvm~SigDfl (205 "@src/dec.l" llvm pico) llvm~SigIgn (206 "@src/dec.l" llvm pico) llvm~TOP (8 "@src/defs.l" llvm pico) llvm~TRANSIENT (20 "@src/defs.l" llvm pico) llvm~Termio (226 "@src/dec.l" llvm pico) llvm~TgCPU (162 "@src/dec.l" llvm pico) llvm~TgOS (161 "@src/dec.l" llvm pico) llvm~Tio (224 "@src/dec.l" llvm pico) llvm~YES (51 "@src/lib/llvm.l" llvm pico) llvm~ZERO (52 "@src/lib/llvm.l" llvm pico) llvm~__meth (301 "@src/flow.l" llvm pico) llvm~_abs (1349 "@src/big.l" llvm pico) llvm~_add (1103 "@src/big.l" llvm pico) llvm~_adr (1623 "@src/main.l" llvm pico) llvm~_alarm (480 "@src/main.l" llvm pico) llvm~_all (606 "@src/sym.l" llvm pico) llvm~_and (490 "@src/flow.l" llvm pico) llvm~_any (2627 "@src/io.l" llvm pico) llvm~_append (370 "@src/subr.l" llvm pico) llvm~_apply (6 "@src/apply.l" llvm pico) llvm~_arg (1603 "@src/main.l" llvm pico) llvm~_args (1593 "@src/main.l" llvm pico) llvm~_argv (1147 "@src/main.l" llvm pico) llvm~_arrow (1573 "@src/subr.l" llvm pico) llvm~_as (62 "@src/flow.l" llvm pico) llvm~_asoq (1157 "@src/subr.l" llvm pico) llvm~_assoc (1133 "@src/subr.l" llvm pico) llvm~_at (694 "@src/flow.l" llvm pico) llvm~_atom (817 "@src/subr.l" llvm pico) llvm~_bind (864 "@src/flow.l" llvm pico) llvm~_bitAnd (1380 "@src/big.l" llvm pico) llvm~_bitOr (1393 "@src/big.l" llvm pico) llvm~_bitQ (1356 "@src/big.l" llvm pico) llvm~_bitXor (1406 "@src/big.l" llvm pico) llvm~_blk (675 "@src/db.l" llvm pico) llvm~_bool (534 "@src/flow.l" llvm pico) llvm~_box (311 "@src/flow.l" llvm pico) llvm~_boxQ (706 "@src/sym.l" llvm pico) llvm~_break (1395 "@src/flow.l" llvm pico) llvm~_buf (1027 "@src/flow.l" llvm pico) llvm~_by (648 "@src/apply.l" llvm pico) llvm~_bye (1587 "@src/flow.l" llvm pico) llvm~_byte (1630 "@src/main.l" llvm pico) llvm~_bytes (1129 "@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 (1500 "@src/flow.l" llvm pico) llvm~_car (17 "@src/subr.l" llvm pico) llvm~_case (640 "@src/flow.l" llvm pico) llvm~_casq (652 "@src/flow.l" llvm pico) llvm~_catch (1039 "@src/flow.l" llvm pico) llvm~_cb1 (1503 "@src/main.l" llvm pico) llvm~_cb10 (1530 "@src/main.l" llvm pico) llvm~_cb11 (1533 "@src/main.l" llvm pico) llvm~_cb12 (1536 "@src/main.l" llvm pico) llvm~_cb13 (1539 "@src/main.l" llvm pico) llvm~_cb14 (1542 "@src/main.l" llvm pico) llvm~_cb15 (1545 "@src/main.l" llvm pico) llvm~_cb16 (1548 "@src/main.l" llvm pico) llvm~_cb17 (1551 "@src/main.l" llvm pico) llvm~_cb18 (1554 "@src/main.l" llvm pico) llvm~_cb19 (1557 "@src/main.l" llvm pico) llvm~_cb2 (1506 "@src/main.l" llvm pico) llvm~_cb20 (1560 "@src/main.l" llvm pico) llvm~_cb21 (1563 "@src/main.l" llvm pico) llvm~_cb22 (1566 "@src/main.l" llvm pico) llvm~_cb23 (1569 "@src/main.l" llvm pico) llvm~_cb24 (1572 "@src/main.l" llvm pico) llvm~_cb3 (1509 "@src/main.l" llvm pico) llvm~_cb4 (1512 "@src/main.l" llvm pico) llvm~_cb5 (1515 "@src/main.l" llvm pico) llvm~_cb6 (1518 "@src/main.l" llvm pico) llvm~_cb7 (1521 "@src/main.l" llvm pico) llvm~_cb8 (1524 "@src/main.l" llvm pico) llvm~_cb9 (1527 "@src/main.l" llvm pico) llvm~_cd (1010 "@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 (286 "@src/subr.l" llvm pico) llvm~_char (1671 "@src/io.l" llvm pico) llvm~_chop (736 "@src/sym.l" llvm pico) llvm~_circ (155 "@src/subr.l" llvm pico) llvm~_circQ (825 "@src/subr.l" llvm pico) llvm~_clip (609 "@src/subr.l" llvm pico) llvm~_close (2089 "@src/io.l" llvm pico) llvm~_cmd (1079 "@src/main.l" llvm pico) llvm~_cnt (476 "@src/apply.l" llvm pico) llvm~_co (1116 "@src/flow.l" llvm pico) llvm~_col (1654 "@src/sym.l" llvm pico) llvm~_commit (885 "@src/db.l" llvm pico) llvm~_con (121 "@src/subr.l" llvm pico) llvm~_conc (140 "@src/subr.l" llvm pico) llvm~_cond (620 "@src/flow.l" llvm pico) llvm~_cons (128 "@src/subr.l" llvm pico) llvm~_copy (329 "@src/subr.l" llvm pico) llvm~_ctl (1906 "@src/io.l" llvm pico) llvm~_ctty (1024 "@src/main.l" llvm pico) llvm~_cut (1011 "@src/sym.l" llvm pico) llvm~_date (602 "@src/main.l" llvm pico) llvm~_dbck (1197 "@src/db.l" llvm pico) llvm~_de (150 "@src/flow.l" llvm pico) llvm~_dec (1154 "@src/big.l" llvm pico) llvm~_def (123 "@src/flow.l" llvm pico) llvm~_default (939 "@src/sym.l" llvm pico) llvm~_del (1030 "@src/sym.l" llvm pico) llvm~_delete (390 "@src/subr.l" llvm pico) llvm~_delq (411 "@src/subr.l" llvm pico) llvm~_detach (1569 "@src/flow.l" llvm pico) llvm~_diff (911 "@src/subr.l" llvm pico) llvm~_dir (1086 "@src/main.l" llvm pico) llvm~_div (1223 "@src/big.l" llvm pico) llvm~_dm (158 "@src/flow.l" llvm pico) llvm~_do (749 "@src/flow.l" llvm pico) llvm~_e (1402 "@src/flow.l" llvm pico) llvm~_echo (2102 "@src/io.l" llvm pico) llvm~_enum (1137 "@src/sym.l" llvm pico) llvm~_enumQ (1234 "@src/sym.l" llvm pico) llvm~_env (1648 "@src/main.l" llvm pico) llvm~_eof (1705 "@src/io.l" llvm pico) llvm~_eol (1698 "@src/io.l" llvm pico) llvm~_eq (715 "@src/subr.l" llvm pico) llvm~_eq0 (743 "@src/subr.l" llvm pico) llvm~_eq1 (747 "@src/subr.l" llvm pico) llvm~_eqT (751 "@src/subr.l" llvm pico) llvm~_equal (729 "@src/subr.l" llvm pico) llvm~_err (1898 "@src/io.l" llvm pico) llvm~_errno (1194 "@src/main.l" llvm pico) llvm~_eval (81 "@src/flow.l" llvm pico) llvm~_exec (1483 "@src/flow.l" llvm pico) llvm~_ext (2465 "@src/io.l" llvm pico) llvm~_extQ (246 "@src/db.l" llvm pico) llvm~_extern (348 "@src/db.l" llvm pico) llvm~_extra (479 "@src/flow.l" llvm pico) llvm~_extract (320 "@src/apply.l" llvm pico) llvm~_fd (1914 "@src/io.l" llvm pico) llvm~_fifo (1073 "@src/sym.l" llvm pico) llvm~_file (1133 "@src/main.l" llvm pico) llvm~_fill (1278 "@src/subr.l" llvm pico) llvm~_filter (282 "@src/apply.l" llvm pico) llvm~_fin (699 "@src/subr.l" llvm pico) llvm~_finally (1072 "@src/flow.l" llvm pico) llvm~_find (381 "@src/apply.l" llvm pico) llvm~_fish (631 "@src/apply.l" llvm pico) llvm~_flgQ (845 "@src/subr.l" llvm pico) llvm~_flip (566 "@src/subr.l" llvm pico) llvm~_flush (2449 "@src/io.l" llvm pico) llvm~_fold (1827 "@src/sym.l" llvm pico) llvm~_for (770 "@src/flow.l" llvm pico) llvm~_fork (1563 "@src/flow.l" llvm pico) llvm~_format (1067 "@src/big.l" llvm pico) llvm~_free (1169 "@src/db.l" llvm pico) llvm~_from (1716 "@src/io.l" llvm pico) llvm~_full (252 "@src/subr.l" llvm pico) llvm~_fully (445 "@src/apply.l" llvm pico) llvm~_funQ (545 "@src/sym.l" llvm pico) llvm~_gc (258 "@src/gc.l" llvm pico) llvm~_ge (790 "@src/subr.l" llvm pico) llvm~_ge0 (1330 "@src/big.l" llvm pico) llvm~_get (1593 "@src/sym.l" llvm pico) llvm~_getStdin (1174 "@src/io.l" llvm pico) llvm~_getd (551 "@src/sym.l" llvm pico) llvm~_getl (1705 "@src/sym.l" llvm pico) llvm~_glue (765 "@src/sym.l" llvm pico) llvm~_group (1606 "@src/subr.l" llvm pico) llvm~_gt (781 "@src/subr.l" llvm pico) llvm~_gt0 (1339 "@src/big.l" llvm pico) llvm~_hash (1500 "@src/big.l" llvm pico) llvm~_head (616 "@src/subr.l" llvm pico) llvm~_heap (514 "@src/main.l" llvm pico) llvm~_hear (913 "@src/io.l" llvm pico) llvm~_hide (702 "@src/sym.l" llvm pico) llvm~_history (1740 "@src/main.l" llvm pico) llvm~_id (654 "@src/db.l" llvm pico) llvm~_idx (1320 "@src/sym.l" llvm pico) llvm~_if (574 "@src/flow.l" llvm pico) llvm~_if2 (590 "@src/flow.l" llvm pico) llvm~_ifn (582 "@src/flow.l" llvm pico) llvm~_in (1880 "@src/io.l" llvm pico) llvm~_inc (1133 "@src/big.l" llvm pico) llvm~_index (929 "@src/subr.l" llvm pico) llvm~_info (1107 "@src/main.l" llvm pico) llvm~_insert (457 "@src/subr.l" llvm pico) llvm~_intern (679 "@src/sym.l" llvm pico) llvm~_ipid (1537 "@src/flow.l" llvm pico) llvm~_isa (383 "@src/flow.l" llvm pico) llvm~_job (898 "@src/flow.l" llvm pico) llvm~_journal (605 "@src/db.l" llvm pico) llvm~_key (1629 "@src/io.l" llvm pico) llvm~_kids (494 "@src/main.l" llvm pico) llvm~_kill (1551 "@src/flow.l" llvm pico) llvm~_last (706 "@src/subr.l" llvm pico) llvm~_le (772 "@src/subr.l" llvm pico) llvm~_le0 (1321 "@src/big.l" llvm pico) llvm~_length (969 "@src/subr.l" llvm pico) llvm~_let (936 "@src/flow.l" llvm pico) llvm~_letQ (995 "@src/flow.l" llvm pico) llvm~_lieu (755 "@src/db.l" llvm pico) llvm~_line (1807 "@src/io.l" llvm pico) llvm~_link (300 "@src/subr.l" llvm pico) llvm~_lisp (1576 "@src/main.l" llvm pico) llvm~_list (187 "@src/subr.l" llvm pico) llvm~_lit (69 "@src/flow.l" llvm pico) llvm~_load (2764 "@src/io.l" llvm pico) llvm~_lock (772 "@src/db.l" llvm pico) llvm~_loop (764 "@src/flow.l" llvm pico) llvm~_lowQ (1780 "@src/sym.l" llvm pico) llvm~_lowc (1794 "@src/sym.l" llvm pico) llvm~_lstQ (829 "@src/subr.l" llvm pico) llvm~_lt (763 "@src/subr.l" llvm pico) llvm~_lt0 (1315 "@src/big.l" llvm pico) llvm~_lup (1335 "@src/sym.l" llvm pico) llvm~_made (271 "@src/subr.l" llvm pico) llvm~_make (260 "@src/subr.l" llvm pico) llvm~_map (89 "@src/apply.l" llvm pico) llvm~_mapc (112 "@src/apply.l" llvm pico) llvm~_mapcan (241 "@src/apply.l" llvm pico) llvm~_mapcar (172 "@src/apply.l" llvm pico) llvm~_mapcon (209 "@src/apply.l" llvm pico) llvm~_maplist (144 "@src/apply.l" llvm pico) llvm~_maps (44 "@src/apply.l" llvm pico) llvm~_mark (1121 "@src/db.l" llvm pico) llvm~_match (1227 "@src/subr.l" llvm pico) llvm~_max (799 "@src/subr.l" llvm pico) llvm~_maxi (543 "@src/apply.l" llvm pico) llvm~_member (851 "@src/subr.l" llvm pico) llvm~_memq (864 "@src/subr.l" llvm pico) llvm~_meta (1765 "@src/sym.l" llvm pico) llvm~_method (401 "@src/flow.l" llvm pico) llvm~_min (808 "@src/subr.l" llvm pico) llvm~_mini (580 "@src/apply.l" llvm pico) llvm~_mix (344 "@src/subr.l" llvm pico) llvm~_mmeq (877 "@src/subr.l" llvm pico) llvm~_mul (1174 "@src/big.l" llvm pico) llvm~_mulDiv (1195 "@src/big.l" llvm pico) llvm~_name (510 "@src/sym.l" llvm pico) llvm~_nand (508 "@src/flow.l" llvm pico) llvm~_nat (1424 "@src/main.l" llvm pico) llvm~_native (1437 "@src/main.l" llvm pico) llvm~_need (199 "@src/subr.l" llvm pico) llvm~_neq (722 "@src/subr.l" llvm pico) llvm~_neq0 (755 "@src/subr.l" llvm pico) llvm~_neqT (759 "@src/subr.l" llvm pico) llvm~_nequal (736 "@src/subr.l" llvm pico) llvm~_new (315 "@src/flow.l" llvm pico) llvm~_next (1597 "@src/main.l" llvm pico) llvm~_nil (545 "@src/flow.l" llvm pico) llvm~_nond (630 "@src/flow.l" llvm pico) llvm~_nor (517 "@src/flow.l" llvm pico) llvm~_not (538 "@src/flow.l" llvm pico) llvm~_nsp (520 "@src/sym.l" llvm pico) llvm~_nth (109 "@src/subr.l" llvm pico) llvm~_numQ (835 "@src/subr.l" llvm pico) llvm~_off (908 "@src/sym.l" llvm pico) llvm~_offset (943 "@src/subr.l" llvm pico) llvm~_on (901 "@src/sym.l" llvm pico) llvm~_onOff (915 "@src/sym.l" llvm pico) llvm~_one (932 "@src/sym.l" llvm pico) llvm~_open (2073 "@src/io.l" llvm pico) llvm~_opid (1544 "@src/flow.l" llvm pico) llvm~_opt (1181 "@src/main.l" llvm pico) llvm~_or (499 "@src/flow.l" llvm pico) llvm~_out (1889 "@src/io.l" llvm pico) llvm~_pack (754 "@src/sym.l" llvm pico) llvm~_pair (821 "@src/subr.l" llvm pico) llvm~_pass (24 "@src/apply.l" llvm pico) llvm~_patQ (538 "@src/sym.l" llvm pico) llvm~_path (668 "@src/io.l" llvm pico) llvm~_peek (1661 "@src/io.l" llvm pico) llvm~_pick (414 "@src/apply.l" llvm pico) llvm~_pipe (2029 "@src/io.l" llvm pico) llvm~_place (491 "@src/subr.l" llvm pico) llvm~_plio (2487 "@src/io.l" llvm pico) llvm~_poll (957 "@src/io.l" llvm pico) llvm~_pool (455 "@src/db.l" llvm pico) llvm~_pool2 (564 "@src/db.l" llvm pico) llvm~_pop (986 "@src/sym.l" llvm pico) llvm~_popq (996 "@src/sym.l" llvm pico) llvm~_pr (2552 "@src/io.l" llvm pico) llvm~_preQ (829 "@src/sym.l" llvm pico) llvm~_prin (2409 "@src/io.l" llvm pico) llvm~_prinl (2417 "@src/io.l" llvm pico) llvm~_print (2432 "@src/io.l" llvm pico) llvm~_println (2445 "@src/io.l" llvm pico) llvm~_printsp (2441 "@src/io.l" llvm pico) llvm~_prior (956 "@src/subr.l" llvm pico) llvm~_prog (555 "@src/flow.l" llvm pico) llvm~_prog1 (559 "@src/flow.l" llvm pico) llvm~_prog2 (566 "@src/flow.l" llvm pico) llvm~_prop (1604 "@src/sym.l" llvm pico) llvm~_propCol (1661 "@src/sym.l" llvm pico) llvm~_protect (506 "@src/main.l" llvm pico) llvm~_prove (1440 "@src/subr.l" llvm pico) llvm~_push (948 "@src/sym.l" llvm pico) llvm~_push1 (960 "@src/sym.l" llvm pico) llvm~_push1q (973 "@src/sym.l" llvm pico) llvm~_put (1568 "@src/sym.l" llvm pico) llvm~_putStdout (2208 "@src/io.l" llvm pico) llvm~_putl (1675 "@src/sym.l" llvm pico) llvm~_pwd (1003 "@src/main.l" llvm pico) llvm~_queue (1055 "@src/sym.l" llvm pico) llvm~_quit (974 "@src/main.l" llvm pico) llvm~_quote (58 "@src/flow.l" llvm pico) llvm~_rand (1510 "@src/big.l" llvm pico) llvm~_range (231 "@src/subr.l" llvm pico) llvm~_rank (1181 "@src/subr.l" llvm pico) llvm~_rasoq (1169 "@src/subr.l" llvm pico) llvm~_rassoc (1145 "@src/subr.l" llvm pico) llvm~_raw (471 "@src/main.l" llvm pico) llvm~_rd (2513 "@src/io.l" llvm pico) llvm~_read (1614 "@src/io.l" llvm pico) llvm~_rem (1245 "@src/big.l" llvm pico) llvm~_remove (472 "@src/subr.l" llvm pico) llvm~_replace (432 "@src/subr.l" llvm pico) llvm~_rest (1612 "@src/main.l" llvm pico) llvm~_rev (1301 "@src/big.l" llvm pico) llvm~_reverse (556 "@src/subr.l" llvm pico) llvm~_rewind (2453 "@src/io.l" llvm pico) llvm~_rid (1104 "@src/sym.l" llvm pico) llvm~_rollback (299 "@src/db.l" llvm pico) llvm~_rot (166 "@src/subr.l" llvm pico) llvm~_run (99 "@src/flow.l" llvm pico) llvm~_sect (893 "@src/subr.l" llvm pico) llvm~_seed (1494 "@src/big.l" llvm pico) llvm~_seek (358 "@src/apply.l" llvm pico) llvm~_semicol (1622 "@src/sym.l" llvm pico) llvm~_send (411 "@src/flow.l" llvm pico) llvm~_seq (724 "@src/db.l" llvm pico) llvm~_set (857 "@src/sym.l" llvm pico) llvm~_setCol (1633 "@src/sym.l" llvm pico) llvm~_setq (869 "@src/sym.l" llvm pico) llvm~_shift (1004 "@src/sym.l" llvm pico) llvm~_shr (1267 "@src/big.l" llvm pico) llvm~_sigio (487 "@src/main.l" llvm pico) llvm~_size (1072 "@src/subr.l" llvm pico) llvm~_skip (1692 "@src/io.l" llvm pico) llvm~_sort (1642 "@src/subr.l" llvm pico) llvm~_spQ (532 "@src/sym.l" llvm pico) llvm~_space (2421 "@src/io.l" llvm pico) llvm~_split (519 "@src/subr.l" llvm pico) llvm~_sqrt (1419 "@src/big.l" llvm pico) llvm~_stack (527 "@src/main.l" llvm pico) llvm~_state (661 "@src/flow.l" llvm pico) llvm~_stem (679 "@src/subr.l" llvm pico) llvm~_str (2641 "@src/io.l" llvm pico) llvm~_strQ (717 "@src/sym.l" llvm pico) llvm~_strip (511 "@src/subr.l" llvm pico) llvm~_struct (1464 "@src/main.l" llvm pico) llvm~_sub (1116 "@src/big.l" llvm pico) llvm~_subQ (843 "@src/sym.l" llvm pico) llvm~_sum (509 "@src/apply.l" llvm pico) llvm~_super (441 "@src/flow.l" llvm pico) llvm~_swap (876 "@src/sym.l" llvm pico) llvm~_sym (2633 "@src/io.l" llvm pico) llvm~_symQ (839 "@src/subr.l" llvm pico) llvm~_symbols (640 "@src/sym.l" llvm pico) llvm~_sync (891 "@src/io.l" llvm pico) llvm~_sys (987 "@src/main.l" llvm pico) llvm~_t (550 "@src/flow.l" llvm pico) llvm~_tail (649 "@src/subr.l" llvm pico) llvm~_tell (932 "@src/io.l" llvm pico) llvm~_text (778 "@src/sym.l" llvm pico) llvm~_throw (1056 "@src/flow.l" llvm pico) llvm~_till (1761 "@src/io.l" llvm pico) llvm~_time (654 "@src/main.l" llvm pico) llvm~_touch (868 "@src/db.l" llvm pico) llvm~_trace (1443 "@src/flow.l" llvm pico) llvm~_trail (1683 "@src/main.l" llvm pico) llvm~_trim (605 "@src/subr.l" llvm pico) llvm~_try (424 "@src/flow.l" llvm pico) llvm~_tty (459 "@src/main.l" llvm pico) llvm~_type (348 "@src/flow.l" llvm pico) llvm~_unify (1583 "@src/subr.l" llvm pico) llvm~_unless (612 "@src/flow.l" llvm pico) llvm~_until (686 "@src/flow.l" llvm pico) llvm~_up (1705 "@src/main.l" llvm pico) llvm~_uppQ (1787 "@src/sym.l" llvm pico) llvm~_uppc (1809 "@src/sym.l" llvm pico) llvm~_use (1007 "@src/flow.l" llvm pico) llvm~_usec (684 "@src/main.l" llvm pico) llvm~_val (850 "@src/sym.l" llvm pico) llvm~_version (1763 "@src/main.l" llvm pico) llvm~_wait (873 "@src/io.l" llvm pico) llvm~_when (604 "@src/flow.l" llvm pico) llvm~_while (678 "@src/flow.l" llvm pico) llvm~_wipe (1741 "@src/sym.l" llvm pico) llvm~_with (853 "@src/flow.l" llvm pico) llvm~_wr (2561 "@src/io.l" llvm pico) llvm~_xchg (887 "@src/sym.l" llvm pico) llvm~_xor (527 "@src/flow.l" llvm pico) llvm~_yield (1210 "@src/flow.l" llvm pico) llvm~_yoke (313 "@src/subr.l" llvm pico) llvm~_zap (728 "@src/sym.l" llvm pico) llvm~_zero (925 "@src/sym.l" llvm pico) llvm~add (902 "@src/lib/llvm.l" llvm pico) llvm~adds (819 "@src/big.l" llvm pico) llvm~addu (415 "@src/big.l" llvm pico) llvm~alloc (139 "@src/main.l" llvm pico) llvm~and (1213 "@src/lib/llvm.l" llvm pico) llvm~andu (306 "@src/big.l" llvm pico) llvm~anonymous (1326 "@src/io.l" llvm pico) llvm~any (747 "@src/lib/llvm.l" llvm pico) llvm~argErr (323 "@src/main.l" llvm pico) llvm~array (344 "@src/lib/llvm.l" llvm pico) llvm~asm (95 "@src/lib/llvm.l" llvm pico) llvm~atom (790 "@src/lib/llvm.l" llvm pico) llvm~atomErr (341 "@src/main.l" llvm pico) llvm~b32 (1162 "@src/lib/llvm.l" llvm pico) llvm~b64 (1162 "@src/lib/llvm.l" llvm pico) llvm~b8 (1162 "@src/lib/llvm.l" llvm pico) llvm~b8* (1162 "@src/lib/llvm.l" llvm pico) llvm~badFd (29 "@src/io.l" llvm pico) llvm~badInput (23 "@src/io.l" llvm pico) llvm~begString (2608 "@src/io.l" llvm pico) llvm~begin (57 "@src/lib/llvm.l" llvm pico) llvm~big (772 "@src/lib/llvm.l" llvm pico) llvm~big? (790 "@src/lib/llvm.l" llvm pico) llvm~binPrint (386 "@src/io.l" llvm pico) llvm~binRead (280 "@src/io.l" llvm pico) llvm~binSize (1023 "@src/subr.l" llvm pico) llvm~blkPeek (120 "@src/db.l" llvm pico) llvm~blkPoke (137 "@src/db.l" llvm pico) llvm~box (380 "@src/gc.l" llvm pico) llvm~box64 (408 "@src/dec.l" llvm pico) llvm~boxNum (359 "@src/gc.l" llvm pico) llvm~br (132 "@src/lib/llvm.l" llvm pico) llvm~brkLoad (1361 "@src/flow.l" llvm pico) llvm~bufAo (2258 "@src/io.l" llvm pico) llvm~bufSize (7 "@src/sym.l" llvm pico) llvm~bufString (38 "@src/sym.l" llvm pico) llvm~bye (124 "@src/main.l" llvm pico) llvm~byteNum (58 "@src/big.l" llvm pico) llvm~byteSym (97 "@src/big.l" llvm pico) llvm~caFrame (49 "@src/dec.l" llvm pico) llvm~caar (348 "@src/dec.l" llvm pico) llvm~cadr (351 "@src/dec.l" llvm pico) llvm~call (1394 "@src/lib/llvm.l" llvm pico) llvm~car (1027 "@src/lib/llvm.l" llvm pico) llvm~case (1306 "@src/lib/llvm.l" llvm pico) llvm~cbFuns (603 "@src/glob.l" llvm pico) llvm~cbl (1484 "@src/main.l" llvm pico) llvm~cdar (354 "@src/dec.l" llvm pico) llvm~cddr (357 "@src/dec.l" llvm pico) llvm~cdr (1034 "@src/lib/llvm.l" llvm pico) llvm~charSym (122 "@src/big.l" llvm pico) llvm~child (81 "@src/dec.l" llvm pico) llvm~chkA (7 "@src/subr.l" llvm pico) llvm~chkD (10 "@src/subr.l" llvm pico) llvm~chkVar (479 "@src/dec.l" llvm pico) llvm~chopExtNm (212 "@src/sym.l" llvm pico) llvm~circ (404 "@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 (117 "@src/io.l" llvm pico) llvm~clsChild (206 "@src/io.l" llvm pico) llvm~cmpLong (244 "@src/sym.l" llvm pico) llvm~cmpNum (889 "@src/big.l" llvm pico) llvm~cmpSort (1637 "@src/subr.l" llvm pico) llvm~cmpu (843 "@src/big.l" llvm pico) llvm~cnt (363 "@src/dec.l" llvm pico) llvm~cnt? (790 "@src/lib/llvm.l" llvm pico) llvm~cntErr (326 "@src/main.l" llvm pico) llvm~comment (1252 "@src/io.l" llvm pico) llvm~compare (794 "@src/main.l" llvm pico) llvm~cond (1275 "@src/lib/llvm.l" llvm pico) llvm~cons (274 "@src/gc.l" llvm pico) llvm~cons2 (285 "@src/gc.l" llvm pico) llvm~cons3 (307 "@src/gc.l" llvm pico) llvm~consExt (355 "@src/gc.l" llvm pico) llvm~consNum (369 "@src/gc.l" llvm pico) llvm~consStr (350 "@src/gc.l" llvm pico) llvm~consSym (335 "@src/gc.l" llvm pico) llvm~consTree (563 "@src/sym.l" llvm pico) llvm~const (321 "@src/lib/llvm.l" llvm pico) llvm~coroutine (60 "@src/dec.l" llvm pico) llvm~ctFrame (31 "@src/dec.l" llvm pico) llvm~ctOpen (1135 "@src/io.l" llvm pico) llvm~currFd (572 "@src/io.l" llvm pico) llvm~db (792 "@src/db.l" llvm pico) llvm~dbFetch (843 "@src/db.l" llvm pico) llvm~dbFile (35 "@src/dec.l" llvm pico) llvm~dbRdErr (10 "@src/db.l" llvm pico) llvm~dbSyncErr (19 "@src/db.l" llvm pico) llvm~dbTouch (853 "@src/db.l" llvm pico) llvm~dbWrErr (13 "@src/db.l" llvm pico) llvm~dbZap (874 "@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 (650 "@src/lib/llvm.l" llvm pico) llvm~dec (921 "@src/lib/llvm.l" llvm pico) llvm~decs (813 "@src/big.l" llvm pico) llvm~define (514 "@src/lib/llvm.l" llvm pico) llvm~delNode (460 "@src/sym.l" llvm pico) llvm~dig (772 "@src/lib/llvm.l" llvm pico) llvm~div (971 "@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 (1450 "@src/lib/llvm.l" llvm pico) llvm~end (73 "@src/lib/llvm.l" llvm pico) llvm~endString (2618 "@src/io.l" llvm pico) llvm~env (632 "@src/glob.l" llvm pico) llvm~eofErr (20 "@src/io.l" llvm pico) llvm~eol (1794 "@src/io.l" llvm pico) llvm~equ (273 "@src/lib/llvm.l" llvm pico) llvm~equal (736 "@src/main.l" llvm pico) llvm~equalBig (725 "@src/main.l" llvm pico) llvm~erOpen (1113 "@src/io.l" llvm pico) llvm~err (248 "@src/main.l" llvm pico) llvm~evBool (662 "@src/lib/llvm.l" llvm pico) llvm~evCnt (375 "@src/main.l" llvm pico) llvm~evExpr (871 "@src/main.l" llvm pico) llvm~evList (942 "@src/main.l" llvm pico) llvm~evLst (378 "@src/main.l" llvm pico) llvm~evMethod (206 "@src/flow.l" llvm pico) llvm~evSym (392 "@src/main.l" llvm pico) llvm~eval (414 "@src/dec.l" llvm pico) llvm~exec (421 "@src/dec.l" llvm pico) llvm~execAt (10 "@src/main.l" llvm pico) llvm~execErr (132 "@src/main.l" llvm pico) llvm~extErr (335 "@src/main.l" llvm pico) llvm~extNm (146 "@src/sym.l" llvm pico) llvm~extern (385 "@src/sym.l" llvm pico) llvm~extra (460 "@src/flow.l" llvm pico) llvm~fetchChar (1200 "@src/main.l" llvm pico) llvm~ffi (1363 "@src/main.l" llvm pico) llvm~fill (1238 "@src/subr.l" llvm pico) llvm~findSym (286 "@src/sym.l" llvm pico) llvm~finish (116 "@src/main.l" llvm pico) llvm~firstByte (118 "@src/sym.l" llvm pico) llvm~firstChar (126 "@src/sym.l" llvm pico) llvm~fish (618 "@src/apply.l" llvm pico) llvm~flush (239 "@src/io.l" llvm pico) llvm~flushAll (248 "@src/io.l" llvm pico) llvm~fmtNum (965 "@src/big.l" llvm pico) llvm~fmtWord (952 "@src/big.l" llvm pico) llvm~forkErr (362 "@src/main.l" llvm pico) llvm~forkLisp (1919 "@src/io.l" llvm pico) llvm~fsyncDB (406 "@src/db.l" llvm pico) llvm~fun (763 "@src/lib/llvm.l" llvm pico) llvm~func (205 "@src/lib/llvm.l" llvm pico) llvm~funq (424 "@src/main.l" llvm pico) llvm~gc (37 "@src/gc.l" llvm pico) llvm~gcData (549 "@src/glob.l" llvm pico) llvm~ge0 (861 "@src/lib/llvm.l" llvm pico) llvm~get (1481 "@src/sym.l" llvm pico) llvm~getAdr (26 "@src/db.l" llvm pico) llvm~getBinary (270 "@src/io.l" llvm pico) llvm~getBlock (271 "@src/db.l" llvm pico) llvm~getChar (1221 "@src/io.l" llvm pico) llvm~getParse (2570 "@src/io.l" llvm pico) llvm~getPlio (2474 "@src/io.l" llvm pico) llvm~getn (1514 "@src/sym.l" llvm pico) llvm~giveup (120 "@src/main.l" llvm pico) llvm~global (277 "@src/lib/llvm.l" llvm pico) llvm~goto (1421 "@src/lib/llvm.l" llvm pico) llvm~gt0 (861 "@src/lib/llvm.l" llvm pico) llvm~half (186 "@src/big.l" llvm pico) llvm~hasData (689 "@src/io.l" llvm pico) llvm~heapAlloc (144 "@src/main.l" llvm pico) llvm~i1* (721 "@src/lib/llvm.l" llvm pico) llvm~i16 (683 "@src/lib/llvm.l" llvm pico) llvm~i16* (721 "@src/lib/llvm.l" llvm pico) llvm~i32 (695 "@src/lib/llvm.l" llvm pico) llvm~i32* (721 "@src/lib/llvm.l" llvm pico) llvm~i64 (707 "@src/lib/llvm.l" llvm pico) llvm~i64* (721 "@src/lib/llvm.l" llvm pico) llvm~i8 (672 "@src/lib/llvm.l" llvm pico) llvm~i8* (721 "@src/lib/llvm.l" llvm pico) llvm~i8** (721 "@src/lib/llvm.l" llvm pico) llvm~idxDel (1287 "@src/sym.l" llvm pico) llvm~idxGet (1278 "@src/sym.l" llvm pico) llvm~idxPut (1253 "@src/sym.l" llvm pico) llvm~if (1245 "@src/lib/llvm.l" llvm pico) llvm~ifn (1245 "@src/lib/llvm.l" llvm pico) llvm~ignLog (384 "@src/db.l" llvm pico) llvm~inFile (8 "@src/dec.l" llvm pico) llvm~inReady (698 "@src/io.l" llvm pico) llvm~inc (921 "@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 (1475 "@src/big.l" llvm pico) llvm~inline (487 "@src/lib/llvm.l" llvm pico) llvm~int (360 "@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~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 (368 "@src/flow.l" llvm pico) llvm~itemErr (353 "@src/main.l" llvm pico) llvm~jnlErr (16 "@src/db.l" llvm pico) llvm~label (138 "@src/lib/llvm.l" llvm pico) llvm~le0 (861 "@src/lib/llvm.l" llvm pico) llvm~length (400 "@src/dec.l" llvm pico) llvm~let (1129 "@src/lib/llvm.l" llvm pico) llvm~link (1440 "@src/lib/llvm.l" llvm pico) llvm~loadAll (2749 "@src/io.l" llvm pico) llvm~loadCoEnv (1105 "@src/flow.l" llvm pico) llvm~lockErr (359 "@src/main.l" llvm pico) llvm~lockJnl (110 "@src/db.l" llvm pico) llvm~log (86 "@src/lib/llvm.l" llvm pico) llvm~logBlock (163 "@src/db.l" llvm pico) llvm~lookup (1364 "@src/subr.l" llvm pico) llvm~loop (1377 "@src/lib/llvm.l" llvm pico) llvm~loop1 (710 "@src/flow.l" llvm pico) llvm~loop2 (730 "@src/flow.l" llvm pico) llvm~lstErr (347 "@src/main.l" llvm pico) llvm~lt0 (861 "@src/lib/llvm.l" llvm pico) llvm~lup (1337 "@src/subr.l" llvm pico) llvm~main (1778 "@src/main.l" llvm pico) llvm~makeErr (13 "@src/subr.l" llvm pico) llvm~mark (7 "@src/gc.l" llvm pico) llvm~match (1198 "@src/subr.l" llvm pico) llvm~member (384 "@src/dec.l" llvm pico) llvm~memcpy (1107 "@src/lib/llvm.l" llvm pico) llvm~memq (377 "@src/dec.l" llvm pico) llvm~memset (1118 "@src/lib/llvm.l" llvm pico) llvm~meta (1754 "@src/sym.l" llvm pico) llvm~method (284 "@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 (957 "@src/lib/llvm.l" llvm pico) llvm~mulAddHiLo (575 "@src/big.l" llvm pico) llvm~mulu (583 "@src/big.l" llvm pico) llvm~n0 (851 "@src/lib/llvm.l" llvm pico) llvm~name (372 "@src/dec.l" llvm pico) llvm~nameErr (338 "@src/main.l" llvm pico) llvm~natBuf (1231 "@src/main.l" llvm pico) llvm~natErr (1272 "@src/main.l" llvm pico) llvm~natRetBuf (1293 "@src/main.l" llvm pico) llvm~natRetDouble (1284 "@src/main.l" llvm pico) llvm~natRetFloat (1275 "@src/main.l" llvm pico) llvm~need3 (252 "@src/gc.l" llvm pico) llvm~needChkVar (484 "@src/dec.l" llvm pico) llvm~needCnt (449 "@src/dec.l" llvm pico) llvm~needLst (469 "@src/dec.l" llvm pico) llvm~needNsp (490 "@src/dec.l" llvm pico) llvm~needNum (454 "@src/dec.l" llvm pico) llvm~needPair (464 "@src/dec.l" llvm pico) llvm~needSymb (459 "@src/dec.l" llvm pico) llvm~needVar (474 "@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 (2223 "@src/io.l" llvm pico) llvm~nil? (819 "@src/lib/llvm.l" llvm pico) llvm~noToken (1542 "@src/io.l" llvm pico) llvm~nond (1275 "@src/lib/llvm.l" llvm pico) llvm~not (813 "@src/lib/llvm.l" llvm pico) llvm~nth (391 "@src/dec.l" llvm pico) llvm~null (48 "@src/lib/llvm.l" llvm pico) llvm~num? (790 "@src/lib/llvm.l" llvm pico) llvm~numErr (329 "@src/main.l" llvm pico) llvm~objFile (163 "@src/sym.l" llvm pico) llvm~objId (169 "@src/sym.l" llvm pico) llvm~ofs (1006 "@src/lib/llvm.l" llvm pico) llvm~openErr (8 "@src/io.l" llvm pico) llvm~or (1213 "@src/lib/llvm.l" llvm pico) llvm~oru (335 "@src/big.l" llvm pico) llvm~outAo (2251 "@src/io.l" llvm pico) llvm~outFile (19 "@src/dec.l" llvm pico) llvm~outNum (2238 "@src/io.l" llvm pico) llvm~outOct (2244 "@src/io.l" llvm pico) llvm~outString (2275 "@src/io.l" llvm pico) llvm~outWord (2232 "@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 (790 "@src/lib/llvm.l" llvm pico) llvm~pairErr (344 "@src/main.l" llvm pico) llvm~parse (2579 "@src/io.l" llvm pico) llvm~pathSize (18 "@src/sym.l" llvm pico) llvm~pathString (44 "@src/sym.l" llvm pico) llvm~phi (111 "@src/lib/llvm.l" llvm pico) llvm~pipeErr (14 "@src/io.l" llvm pico) llvm~pointee (219 "@src/lib/llvm.l" llvm pico) llvm~pollfd (674 "@src/io.l" llvm pico) llvm~pop (1462 "@src/lib/llvm.l" llvm pico) llvm~popCtlFiles (660 "@src/io.l" llvm pico) llvm~popErrFiles (654 "@src/io.l" llvm pico) llvm~popInFiles (620 "@src/io.l" llvm pico) llvm~popOutFiles (637 "@src/io.l" llvm pico) llvm~pos (7 "@src/big.l" llvm pico) llvm~pr (503 "@src/io.l" llvm pico) llvm~prCnt (376 "@src/io.l" llvm pico) llvm~prExt (2267 "@src/io.l" llvm pico) llvm~prName (2280 "@src/io.l" llvm pico) llvm~prSym (2285 "@src/io.l" llvm pico) llvm~prTell (513 "@src/io.l" llvm pico) llvm~preStr (810 "@src/sym.l" llvm pico) llvm~prin (2390 "@src/io.l" llvm pico) llvm~print (2309 "@src/io.l" llvm pico) llvm~printName (2288 "@src/io.l" llvm pico) llvm~printSym (2304 "@src/io.l" llvm pico) llvm~prog1 (1230 "@src/lib/llvm.l" llvm pico) llvm~prog2 (1237 "@src/lib/llvm.l" llvm pico) llvm~prop (1531 "@src/sym.l" llvm pico) llvm~protErr (356 "@src/main.l" llvm pico) llvm~ptr (212 "@src/lib/llvm.l" llvm pico) llvm~push (1173 "@src/lib/llvm.l" llvm pico) llvm~pushCtlFile (614 "@src/io.l" llvm pico) llvm~pushErrFile (610 "@src/io.l" llvm pico) llvm~pushInFile (589 "@src/io.l" llvm pico) llvm~pushOutFile (601 "@src/io.l" llvm pico) llvm~put (1402 "@src/sym.l" llvm pico) llvm~putBlock (280 "@src/db.l" llvm pico) llvm~putPlio (2479 "@src/io.l" llvm pico) llvm~putSrc (20 "@src/flow.l" llvm pico) llvm~putString (2605 "@src/io.l" llvm pico) llvm~putTell (507 "@src/io.l" llvm pico) llvm~putn (1462 "@src/sym.l" llvm pico) llvm~rdAtom (1340 "@src/io.l" llvm pico) llvm~rdBlock (125 "@src/db.l" llvm pico) llvm~rdBytes (157 "@src/io.l" llvm pico) llvm~rdBytesNb (168 "@src/io.l" llvm pico) llvm~rdList (1419 "@src/io.l" llvm pico) llvm~rdLockDb (70 "@src/db.l" llvm pico) llvm~rdLockWait (44 "@src/io.l" llvm pico) llvm~rdOpen (978 "@src/io.l" llvm pico) llvm~rdl (1380 "@src/io.l" llvm pico) llvm~read0 (1442 "@src/io.l" llvm pico) llvm~read1 (1535 "@src/io.l" llvm pico) llvm~redefMsg (7 "@src/flow.l" llvm pico) llvm~redefine (49 "@src/flow.l" llvm pico) llvm~reentErr (1090 "@src/flow.l" llvm pico) llvm~remu (797 "@src/big.l" llvm pico) llvm~repl (2662 "@src/io.l" llvm pico) llvm~requestSym (375 "@src/sym.l" llvm pico) llvm~restore (415 "@src/db.l" llvm pico) llvm~ret (1425 "@src/lib/llvm.l" llvm pico) llvm~rlAvail (1171 "@src/io.l" llvm pico) llvm~rlGetc (1166 "@src/io.l" llvm pico) llvm~run (428 "@src/dec.l" llvm pico) llvm~runAt (15 "@src/main.l" llvm pico) llvm~safe (1499 "@src/lib/llvm.l" llvm pico) llvm~save (1469 "@src/lib/llvm.l" llvm pico) llvm~save2 (1484 "@src/lib/llvm.l" llvm pico) llvm~saveCoEnv (1100 "@src/flow.l" llvm pico) llvm~saveCoIO (1094 "@src/flow.l" llvm pico) llvm~selectErr (35 "@src/io.l" llvm pico) llvm~set (1085 "@src/lib/llvm.l" llvm pico) llvm~setAdr (48 "@src/db.l" llvm pico) llvm~setDestruct (921 "@src/flow.l" llvm pico) llvm~sharedLib (693 "@src/main.l" llvm pico) llvm~shift (1053 "@src/lib/llvm.l" llvm pico) llvm~shl (988 "@src/lib/llvm.l" llvm pico) llvm~shlu (240 "@src/big.l" llvm pico) llvm~short (270 "@src/lib/llvm.l" llvm pico) llvm~shr (988 "@src/lib/llvm.l" llvm pico) llvm~shru (263 "@src/big.l" llvm pico) llvm~sig (158 "@src/main.l" llvm pico) llvm~sigChk (442 "@src/dec.l" llvm pico) llvm~sigTerm (165 "@src/main.l" llvm pico) llvm~sighandler (172 "@src/main.l" llvm pico) llvm~sign (366 "@src/dec.l" llvm pico) llvm~sign? (790 "@src/lib/llvm.l" llvm pico) llvm~size (1001 "@src/subr.l" llvm pico) llvm~sizeErr (17 "@src/io.l" llvm pico) llvm~skip (1273 "@src/io.l" llvm pico) llvm~skipc (1239 "@src/io.l" llvm pico) llvm~slow (127 "@src/io.l" llvm pico) llvm~slowNb (139 "@src/io.l" llvm pico) llvm~space (2226 "@src/io.l" llvm pico) llvm~ssa (105 "@src/lib/llvm.l" llvm pico) llvm~stack (1152 "@src/lib/llvm.l" llvm pico) llvm~stdinByte (256 "@src/io.l" llvm pico) llvm~stkChk (438 "@src/dec.l" llvm pico) llvm~stkErr (319 "@src/main.l" llvm pico) llvm~stop (50 "@src/main.l" llvm pico) llvm~store (224 "@src/lib/llvm.l" llvm pico) llvm~str (310 "@src/lib/llvm.l" llvm pico) llvm~struct (600 "@src/lib/llvm.l" llvm pico) llvm~sub (902 "@src/lib/llvm.l" llvm pico) llvm~sub1 (480 "@src/big.l" llvm pico) llvm~subStr (817 "@src/sym.l" llvm pico) llvm~subr (1205 "@src/lib/llvm.l" llvm pico) llvm~subs (830 "@src/big.l" llvm pico) llvm~subu (508 "@src/big.l" llvm pico) llvm~sym (369 "@src/dec.l" llvm pico) llvm~sym? (790 "@src/lib/llvm.l" llvm pico) llvm~symByte (21 "@src/big.l" llvm pico) llvm~symChar (36 "@src/big.l" llvm pico) llvm~symErr (332 "@src/main.l" llvm pico) llvm~symNspErr (365 "@src/main.l" llvm pico) llvm~symTab (417 "@src/lib/llvm.l" llvm pico) llvm~symToNum (902 "@src/big.l" llvm pico) llvm~symb? (804 "@src/lib/llvm.l" llvm pico) llvm~t? (819 "@src/lib/llvm.l" llvm pico) llvm~tabComplete (694 "@src/apply.l" llvm pico) llvm~table (370 "@src/lib/llvm.l" llvm pico) llvm~tail (772 "@src/lib/llvm.l" llvm pico) llvm~tailcall (510 "@src/lib/llvm.l" llvm pico) llvm~tellBeg (519 "@src/io.l" llvm pico) llvm~tellEnd (526 "@src/io.l" llvm pico) llvm~tenfold (221 "@src/big.l" llvm pico) llvm~testEsc (1285 "@src/io.l" llvm pico) llvm~tglString (2615 "@src/io.l" llvm pico) llvm~tmDate (559 "@src/main.l" llvm pico) llvm~tmTime (587 "@src/main.l" llvm pico) llvm~token (1550 "@src/io.l" llvm pico) llvm~tosInFile (631 "@src/io.l" llvm pico) llvm~tosOutFile (648 "@src/io.l" llvm pico) llvm~trace (1429 "@src/flow.l" llvm pico) llvm~transaction (388 "@src/db.l" llvm pico) llvm~trim (595 "@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 (198 "@src/lib/llvm.l" llvm pico) llvm~unLockDb (78 "@src/db.l" llvm pico) llvm~unLockJnl (113 "@src/db.l" llvm pico) llvm~undefined (867 "@src/main.l" llvm pico) llvm~uniFill (1372 "@src/subr.l" llvm pico) llvm~uniRun (1382 "@src/subr.l" llvm pico) llvm~unify (1289 "@src/subr.l" llvm pico) llvm~unintern (481 "@src/sym.l" llvm pico) llvm~unless (1263 "@src/lib/llvm.l" llvm pico) llvm~unsync (552 "@src/io.l" llvm pico) llvm~until (1362 "@src/lib/llvm.l" llvm pico) llvm~unwind (59 "@src/main.l" llvm pico) llvm~val (1061 "@src/lib/llvm.l" llvm pico) llvm~var (304 "@src/lib/llvm.l" llvm pico) llvm~varErr (350 "@src/main.l" llvm pico) llvm~void (47 "@src/lib/llvm.l" llvm pico) llvm~waitFd (715 "@src/io.l" llvm pico) llvm~waitFile (563 "@src/io.l" llvm pico) llvm~when (1263 "@src/lib/llvm.l" llvm pico) llvm~while (1362 "@src/lib/llvm.l" llvm pico) llvm~wipe (1724 "@src/sym.l" llvm pico) llvm~wrBlock (156 "@src/db.l" llvm pico) llvm~wrBytes (190 "@src/io.l" llvm pico) llvm~wrChild (215 "@src/io.l" llvm pico) llvm~wrLockDb (74 "@src/db.l" llvm pico) llvm~wrLockWait (49 "@src/io.l" llvm pico) llvm~wrOpen (1046 "@src/io.l" llvm pico) llvm~writeErr (32 "@src/io.l" llvm pico) llvm~wrnl (21 "@src/main.l" llvm pico) llvm~xCnt (371 "@src/main.l" llvm pico) llvm~xName (395 "@src/main.l" llvm pico) llvm~xSym (384 "@src/main.l" llvm pico) llvm~xchg (1094 "@src/lib/llvm.l" llvm pico) llvm~xoru (374 "@src/big.l" llvm pico) llvm~x| (943 "@src/lib/llvm.l" llvm pico) llvm~zapZero (143 "@src/big.l" llvm pico) llvm~| (943 "@src/lib/llvm.l" llvm pico) pico~! (1395 "@src/flow.l" llvm pico) pico~$ (1443 "@src/flow.l" llvm pico) pico~% (1245 "@src/big.l" llvm pico) pico~%@ (1424 "@src/main.l" llvm pico) pico~& (1380 "@src/big.l" llvm pico) pico~* (1174 "@src/big.l" llvm pico) pico~*/ (1195 "@src/big.l" llvm pico) pico~+ (1103 "@src/big.l" llvm pico) pico~++ (996 "@src/sym.l" llvm pico) pico~- (1116 "@src/big.l" llvm pico) pico~-> (1573 "@src/subr.l" llvm pico) pico~/ (1223 "@src/big.l" llvm pico) pico~: (1654 "@src/sym.l" llvm pico) pico~:: (1661 "@src/sym.l" llvm pico) pico~; (1622 "@src/sym.l" llvm pico) pico~< (763 "@src/subr.l" llvm pico) pico~<= (772 "@src/subr.l" llvm pico) pico~<> (736 "@src/subr.l" llvm pico) pico~= (729 "@src/subr.l" llvm pico) pico~=0 (743 "@src/subr.l" llvm pico) pico~=1 (747 "@src/subr.l" llvm pico) pico~=: (1633 "@src/sym.l" llvm pico) pico~== (715 "@src/subr.l" llvm pico) pico~==== (702 "@src/sym.l" llvm pico) pico~=T (751 "@src/subr.l" llvm pico) pico~> (781 "@src/subr.l" llvm pico) pico~>= (790 "@src/subr.l" llvm pico) pico~>> (1267 "@src/big.l" llvm pico) pico~abs (1349 "@src/big.l" llvm pico) pico~adr (1623 "@src/main.l" llvm pico) pico~alarm (480 "@src/main.l" llvm pico) pico~all (606 "@src/sym.l" llvm pico) pico~and (490 "@src/flow.l" llvm pico) pico~any (2627 "@src/io.l" llvm pico) pico~append (370 "@src/subr.l" llvm pico) pico~apply (6 "@src/apply.l" llvm pico) pico~arg (1603 "@src/main.l" llvm pico) pico~args (1593 "@src/main.l" llvm pico) pico~argv (1147 "@src/main.l" llvm pico) pico~as (62 "@src/flow.l" llvm pico) pico~asoq (1157 "@src/subr.l" llvm pico) pico~assoc (1133 "@src/subr.l" llvm pico) pico~at (694 "@src/flow.l" llvm pico) pico~atom (817 "@src/subr.l" llvm pico) pico~bind (864 "@src/flow.l" llvm pico) pico~bit? (1356 "@src/big.l" llvm pico) pico~blk (675 "@src/db.l" llvm pico) pico~bool (534 "@src/flow.l" llvm pico) pico~box (311 "@src/flow.l" llvm pico) pico~box? (706 "@src/sym.l" llvm pico) pico~buf (1027 "@src/flow.l" llvm pico) pico~by (648 "@src/apply.l" llvm pico) pico~bye (1587 "@src/flow.l" llvm pico) pico~byte (1630 "@src/main.l" llvm pico) pico~bytes (1129 "@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 (1500 "@src/flow.l" llvm pico) pico~car (17 "@src/subr.l" llvm pico) pico~case (640 "@src/flow.l" llvm pico) pico~casq (652 "@src/flow.l" llvm pico) pico~catch (1039 "@src/flow.l" llvm pico) pico~cd (1010 "@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 (286 "@src/subr.l" llvm pico) pico~char (1671 "@src/io.l" llvm pico) pico~chop (736 "@src/sym.l" llvm pico) pico~circ (155 "@src/subr.l" llvm pico) pico~circ? (825 "@src/subr.l" llvm pico) pico~clip (609 "@src/subr.l" llvm pico) pico~close (2089 "@src/io.l" llvm pico) pico~cmd (1079 "@src/main.l" llvm pico) pico~cnt (476 "@src/apply.l" llvm pico) pico~co (1116 "@src/flow.l" llvm pico) pico~commit (885 "@src/db.l" llvm pico) pico~con (121 "@src/subr.l" llvm pico) pico~conc (140 "@src/subr.l" llvm pico) pico~cond (620 "@src/flow.l" llvm pico) pico~cons (128 "@src/subr.l" llvm pico) pico~copy (329 "@src/subr.l" llvm pico) pico~ctl (1906 "@src/io.l" llvm pico) pico~ctty (1024 "@src/main.l" llvm pico) pico~cut (1011 "@src/sym.l" llvm pico) pico~date (602 "@src/main.l" llvm pico) pico~dbck (1197 "@src/db.l" llvm pico) pico~de (150 "@src/flow.l" llvm pico) pico~dec (1154 "@src/big.l" llvm pico) pico~def (123 "@src/flow.l" llvm pico) pico~default (939 "@src/sym.l" llvm pico) pico~del (1030 "@src/sym.l" llvm pico) pico~delete (390 "@src/subr.l" llvm pico) pico~delq (411 "@src/subr.l" llvm pico) pico~detach (1569 "@src/flow.l" llvm pico) pico~diff (911 "@src/subr.l" llvm pico) pico~dir (1086 "@src/main.l" llvm pico) pico~dm (158 "@src/flow.l" llvm pico) pico~do (749 "@src/flow.l" llvm pico) pico~e (1402 "@src/flow.l" llvm pico) pico~echo (2102 "@src/io.l" llvm pico) pico~enum (1137 "@src/sym.l" llvm pico) pico~enum? (1234 "@src/sym.l" llvm pico) pico~env (1648 "@src/main.l" llvm pico) pico~eof (1705 "@src/io.l" llvm pico) pico~eol (1698 "@src/io.l" llvm pico) pico~err (1898 "@src/io.l" llvm pico) pico~errno (1194 "@src/main.l" llvm pico) pico~eval (81 "@src/flow.l" llvm pico) pico~exec (1483 "@src/flow.l" llvm pico) pico~ext (2465 "@src/io.l" llvm pico) pico~ext? (246 "@src/db.l" llvm pico) pico~extern (348 "@src/db.l" llvm pico) pico~extra (479 "@src/flow.l" llvm pico) pico~extract (320 "@src/apply.l" llvm pico) pico~fd (1914 "@src/io.l" llvm pico) pico~fifo (1073 "@src/sym.l" llvm pico) pico~file (1133 "@src/main.l" llvm pico) pico~fill (1278 "@src/subr.l" llvm pico) pico~filter (282 "@src/apply.l" llvm pico) pico~fin (699 "@src/subr.l" llvm pico) pico~finally (1072 "@src/flow.l" llvm pico) pico~find (381 "@src/apply.l" llvm pico) pico~fish (631 "@src/apply.l" llvm pico) pico~flg? (845 "@src/subr.l" llvm pico) pico~flip (566 "@src/subr.l" llvm pico) pico~flush (2449 "@src/io.l" llvm pico) pico~fold (1827 "@src/sym.l" llvm pico) pico~for (770 "@src/flow.l" llvm pico) pico~fork (1563 "@src/flow.l" llvm pico) pico~format (1067 "@src/big.l" llvm pico) pico~free (1169 "@src/db.l" llvm pico) pico~from (1716 "@src/io.l" llvm pico) pico~full (252 "@src/subr.l" llvm pico) pico~fully (445 "@src/apply.l" llvm pico) pico~fun? (545 "@src/sym.l" llvm pico) pico~gc (258 "@src/gc.l" llvm pico) pico~ge0 (1330 "@src/big.l" llvm pico) pico~get (1593 "@src/sym.l" llvm pico) pico~getd (551 "@src/sym.l" llvm pico) pico~getl (1705 "@src/sym.l" llvm pico) pico~glue (765 "@src/sym.l" llvm pico) pico~group (1606 "@src/subr.l" llvm pico) pico~gt0 (1339 "@src/big.l" llvm pico) pico~hash (1500 "@src/big.l" llvm pico) pico~head (616 "@src/subr.l" llvm pico) pico~heap (514 "@src/main.l" llvm pico) pico~hear (913 "@src/io.l" llvm pico) pico~history (1740 "@src/main.l" llvm pico) pico~id (654 "@src/db.l" llvm pico) pico~idx (1320 "@src/sym.l" llvm pico) pico~if (574 "@src/flow.l" llvm pico) pico~if2 (590 "@src/flow.l" llvm pico) pico~ifn (582 "@src/flow.l" llvm pico) pico~in (1880 "@src/io.l" llvm pico) pico~inc (1133 "@src/big.l" llvm pico) pico~index (929 "@src/subr.l" llvm pico) pico~info (1107 "@src/main.l" llvm pico) pico~insert (457 "@src/subr.l" llvm pico) pico~intern (679 "@src/sym.l" llvm pico) pico~ipid (1537 "@src/flow.l" llvm pico) pico~isa (383 "@src/flow.l" llvm pico) pico~job (898 "@src/flow.l" llvm pico) pico~journal (605 "@src/db.l" llvm pico) pico~key (1629 "@src/io.l" llvm pico) pico~kids (494 "@src/main.l" llvm pico) pico~kill (1551 "@src/flow.l" llvm pico) pico~last (706 "@src/subr.l" llvm pico) pico~le0 (1321 "@src/big.l" llvm pico) pico~length (969 "@src/subr.l" llvm pico) pico~let (936 "@src/flow.l" llvm pico) pico~let? (995 "@src/flow.l" llvm pico) pico~lieu (755 "@src/db.l" llvm pico) pico~line (1807 "@src/io.l" llvm pico) pico~link (300 "@src/subr.l" llvm pico) pico~lisp (1576 "@src/main.l" llvm pico) pico~list (187 "@src/subr.l" llvm pico) pico~lit (69 "@src/flow.l" llvm pico) pico~load (2764 "@src/io.l" llvm pico) pico~lock (772 "@src/db.l" llvm pico) pico~loop (764 "@src/flow.l" llvm pico) pico~low? (1780 "@src/sym.l" llvm pico) pico~lowc (1794 "@src/sym.l" llvm pico) pico~lst? (829 "@src/subr.l" llvm pico) pico~lt0 (1315 "@src/big.l" llvm pico) pico~lup (1335 "@src/sym.l" llvm pico) pico~made (271 "@src/subr.l" llvm pico) pico~make (260 "@src/subr.l" llvm pico) pico~map (89 "@src/apply.l" llvm pico) pico~mapc (112 "@src/apply.l" llvm pico) pico~mapcan (241 "@src/apply.l" llvm pico) pico~mapcar (172 "@src/apply.l" llvm pico) pico~mapcon (209 "@src/apply.l" llvm pico) pico~maplist (144 "@src/apply.l" llvm pico) pico~maps (44 "@src/apply.l" llvm pico) pico~mark (1121 "@src/db.l" llvm pico) pico~match (1227 "@src/subr.l" llvm pico) pico~max (799 "@src/subr.l" llvm pico) pico~maxi (543 "@src/apply.l" llvm pico) pico~member (851 "@src/subr.l" llvm pico) pico~memq (864 "@src/subr.l" llvm pico) pico~meta (1765 "@src/sym.l" llvm pico) pico~meth (301 "@src/flow.l" llvm pico) pico~method (401 "@src/flow.l" llvm pico) pico~min (808 "@src/subr.l" llvm pico) pico~mini (580 "@src/apply.l" llvm pico) pico~mix (344 "@src/subr.l" llvm pico) pico~mmeq (877 "@src/subr.l" llvm pico) pico~n0 (755 "@src/subr.l" llvm pico) pico~n== (722 "@src/subr.l" llvm pico) pico~nT (759 "@src/subr.l" llvm pico) pico~name (510 "@src/sym.l" llvm pico) pico~nand (508 "@src/flow.l" llvm pico) pico~native (1437 "@src/main.l" llvm pico) pico~need (199 "@src/subr.l" llvm pico) pico~new (315 "@src/flow.l" llvm pico) pico~next (1597 "@src/main.l" llvm pico) pico~nil (545 "@src/flow.l" llvm pico) pico~nond (630 "@src/flow.l" llvm pico) pico~nor (517 "@src/flow.l" llvm pico) pico~not (538 "@src/flow.l" llvm pico) pico~nsp (520 "@src/sym.l" llvm pico) pico~nth (109 "@src/subr.l" llvm pico) pico~num? (835 "@src/subr.l" llvm pico) pico~off (908 "@src/sym.l" llvm pico) pico~offset (943 "@src/subr.l" llvm pico) pico~on (901 "@src/sym.l" llvm pico) pico~onOff (915 "@src/sym.l" llvm pico) pico~one (932 "@src/sym.l" llvm pico) pico~open (2073 "@src/io.l" llvm pico) pico~opid (1544 "@src/flow.l" llvm pico) pico~opt (1181 "@src/main.l" llvm pico) pico~or (499 "@src/flow.l" llvm pico) pico~out (1889 "@src/io.l" llvm pico) pico~pack (754 "@src/sym.l" llvm pico) pico~pair (821 "@src/subr.l" llvm pico) pico~pass (24 "@src/apply.l" llvm pico) pico~pat? (538 "@src/sym.l" llvm pico) pico~path (668 "@src/io.l" llvm pico) pico~peek (1661 "@src/io.l" llvm pico) pico~pick (414 "@src/apply.l" llvm pico) pico~pipe (2029 "@src/io.l" llvm pico) pico~place (491 "@src/subr.l" llvm pico) pico~plio (2487 "@src/io.l" llvm pico) pico~poll (957 "@src/io.l" llvm pico) pico~pool (455 "@src/db.l" llvm pico) pico~pool2 (564 "@src/db.l" llvm pico) pico~pop (986 "@src/sym.l" llvm pico) pico~pr (2552 "@src/io.l" llvm pico) pico~pre? (829 "@src/sym.l" llvm pico) pico~prin (2409 "@src/io.l" llvm pico) pico~prinl (2417 "@src/io.l" llvm pico) pico~print (2432 "@src/io.l" llvm pico) pico~println (2445 "@src/io.l" llvm pico) pico~printsp (2441 "@src/io.l" llvm pico) pico~prior (956 "@src/subr.l" llvm pico) pico~prog (555 "@src/flow.l" llvm pico) pico~prog1 (559 "@src/flow.l" llvm pico) pico~prog2 (566 "@src/flow.l" llvm pico) pico~prop (1604 "@src/sym.l" llvm pico) pico~protect (506 "@src/main.l" llvm pico) pico~prove (1440 "@src/subr.l" llvm pico) pico~push (948 "@src/sym.l" llvm pico) pico~push1 (960 "@src/sym.l" llvm pico) pico~push1q (973 "@src/sym.l" llvm pico) pico~put (1568 "@src/sym.l" llvm pico) pico~putl (1675 "@src/sym.l" llvm pico) pico~pwd (1003 "@src/main.l" llvm pico) pico~queue (1055 "@src/sym.l" llvm pico) pico~quit (974 "@src/main.l" llvm pico) pico~quote (58 "@src/flow.l" llvm pico) pico~rand (1510 "@src/big.l" llvm pico) pico~range (231 "@src/subr.l" llvm pico) pico~rank (1181 "@src/subr.l" llvm pico) pico~rasoq (1169 "@src/subr.l" llvm pico) pico~rassoc (1145 "@src/subr.l" llvm pico) pico~raw (471 "@src/main.l" llvm pico) pico~rd (2513 "@src/io.l" llvm pico) pico~read (1614 "@src/io.l" llvm pico) pico~remove (472 "@src/subr.l" llvm pico) pico~replace (432 "@src/subr.l" llvm pico) pico~rest (1612 "@src/main.l" llvm pico) pico~rev (1301 "@src/big.l" llvm pico) pico~reverse (556 "@src/subr.l" llvm pico) pico~rewind (2453 "@src/io.l" llvm pico) pico~rid (1104 "@src/sym.l" llvm pico) pico~rollback (299 "@src/db.l" llvm pico) pico~rot (166 "@src/subr.l" llvm pico) pico~run (99 "@src/flow.l" llvm pico) pico~sect (893 "@src/subr.l" llvm pico) pico~seed (1494 "@src/big.l" llvm pico) pico~seek (358 "@src/apply.l" llvm pico) pico~send (411 "@src/flow.l" llvm pico) pico~seq (724 "@src/db.l" llvm pico) pico~set (857 "@src/sym.l" llvm pico) pico~setq (869 "@src/sym.l" llvm pico) pico~shift (1004 "@src/sym.l" llvm pico) pico~sigio (487 "@src/main.l" llvm pico) pico~size (1072 "@src/subr.l" llvm pico) pico~skip (1692 "@src/io.l" llvm pico) pico~sort (1642 "@src/subr.l" llvm pico) pico~sp? (532 "@src/sym.l" llvm pico) pico~space (2421 "@src/io.l" llvm pico) pico~split (519 "@src/subr.l" llvm pico) pico~sqrt (1419 "@src/big.l" llvm pico) pico~stack (527 "@src/main.l" llvm pico) pico~state (661 "@src/flow.l" llvm pico) pico~stem (679 "@src/subr.l" llvm pico) pico~str (2641 "@src/io.l" llvm pico) pico~str? (717 "@src/sym.l" llvm pico) pico~strip (511 "@src/subr.l" llvm pico) pico~struct (1464 "@src/main.l" llvm pico) pico~sub? (843 "@src/sym.l" llvm pico) pico~sum (509 "@src/apply.l" llvm pico) pico~super (441 "@src/flow.l" llvm pico) pico~swap (876 "@src/sym.l" llvm pico) pico~sym (2633 "@src/io.l" llvm pico) pico~sym? (839 "@src/subr.l" llvm pico) pico~symbols (640 "@src/sym.l" llvm pico) pico~sync (891 "@src/io.l" llvm pico) pico~sys (987 "@src/main.l" llvm pico) pico~t (550 "@src/flow.l" llvm pico) pico~tail (649 "@src/subr.l" llvm pico) pico~tell (932 "@src/io.l" llvm pico) pico~text (778 "@src/sym.l" llvm pico) pico~throw (1056 "@src/flow.l" llvm pico) pico~till (1761 "@src/io.l" llvm pico) pico~time (654 "@src/main.l" llvm pico) pico~touch (868 "@src/db.l" llvm pico) pico~trail (1683 "@src/main.l" llvm pico) pico~trim (605 "@src/subr.l" llvm pico) pico~try (424 "@src/flow.l" llvm pico) pico~tty (459 "@src/main.l" llvm pico) pico~type (348 "@src/flow.l" llvm pico) pico~unify (1583 "@src/subr.l" llvm pico) pico~unless (612 "@src/flow.l" llvm pico) pico~until (686 "@src/flow.l" llvm pico) pico~up (1705 "@src/main.l" llvm pico) pico~upp? (1787 "@src/sym.l" llvm pico) pico~uppc (1809 "@src/sym.l" llvm pico) pico~use (1007 "@src/flow.l" llvm pico) pico~usec (684 "@src/main.l" llvm pico) pico~val (850 "@src/sym.l" llvm pico) pico~version (1763 "@src/main.l" llvm pico) pico~wait (873 "@src/io.l" llvm pico) pico~when (604 "@src/flow.l" llvm pico) pico~while (678 "@src/flow.l" llvm pico) pico~wipe (1741 "@src/sym.l" llvm pico) pico~with (853 "@src/flow.l" llvm pico) pico~wr (2561 "@src/io.l" llvm pico) pico~xchg (887 "@src/sym.l" llvm pico) pico~xor (527 "@src/flow.l" llvm pico) pico~x| (1406 "@src/big.l" llvm pico) pico~yield (1210 "@src/flow.l" llvm pico) pico~yoke (313 "@src/subr.l" llvm pico) pico~zap (728 "@src/sym.l" llvm pico) pico~zero (925 "@src/sym.l" llvm pico) pico~| (1393 "@src/big.l" llvm pico) pil21/lib/net.l0000644000000000000000000001517414046410634010416 0ustar # 11may21 Software Lab. Alexander Burger (sysdefs "errno") (sysdefs "networking") (private) (ipErr A Type Sd Addr Port 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) ## (%@ "fcntlSetFl" 'I Sd2 0) # Non-Linux? (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 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 (sym 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.l0000644000000000000000000003567114144720652010572 0ustar # 16nov21 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 Lst) (setq Lst (split Lst " " "\n")) (pack (make (while Lst (if (> Max (length (car Lst))) (chain (make (link (++ Lst)) (loop (NIL Lst) (T (>= (+ (length (car Lst)) (sum length (made))) Max) (link "\n") ) (link " " (++ Lst)) ) ) ) (link (++ Lst)) (and Lst (link "\n")) ) ) ) ) ) ### 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 (setq C (- (char (++ X)) `(char "0"))) (and (> C 9) (dec 'C 7)) (and (> C 22) (dec 'C 32)) (NIL (>= 15 C 0)) (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) (let L (flip (chop F)) (while (= "/" (car L)) (++ L) ) (pack (flip (member "/" L))) ) ) (de basename (F) (let L (flip (chop F)) (while (= "/" (car L)) (++ L) ) (pack (stem (flip L) "/")) ) ) (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 (read)) (from "\r\n\r\n") (out F (echo)) (= Size (car (info F))) (=0 (%@ "rename" 'I F Dst)) ) ) ) ) # Print or eval (de prEval ("Prg" "Ofs") (default "Ofs" 1) (for "X" "Prg" (if (atom "X") (prinl (eval "X" "Ofs")) (eval "X" "Ofs") ) ) ) # Echo here-documents (de here (S) (line) (echo S) ) # 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)))) "^M")) (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 "^M") ) (prinl "^M") ) (pre? "235 " (in S (line T))) ) ) (out S (prinl "MAIL FROM:<" (fin From) ">^M")) (pre? "250 " (in S (line T))) (if (atom To) (_rcpt To) (find bool (mapcar _rcpt To)) ) (out S (prinl "DATA^M")) (pre? "354 " (in S (line T))) (out S (prinl "From: " (fin From) "^M") (prinl "To: " (or (fin To) (glue "," To)) "^M") (prin "Subject: ") (ifn (find > (chop Sub) '("~" .)) (prinl Sub "^M") (prin "=?utf-8?B?") (pipe (prin Sub) (prBase64 T "^M")) (prinl "?=^M") ) (when (pair From) (prinl "Reply-To: " (car From) "^M") ) (prinl "User-Agent: PicoLisp^M") (prinl "MIME-Version: 1.0^M") (when Att (prinl "Content-Type: multipart/mixed; boundary=\"" B "\"^M") (prinl "^M") (prinl "--" B "^M") (unless (cadr Att) (prinl "Content-Type: multipart/alternative; boundary=\"==" B "==\"^M") (prinl "^M") (prinl "--==" B "==^M") ) ) (prinl "Content-Type: text/plain; charset=utf-8^M") (prinl "Content-Transfer-Encoding: 8bit^M") (prinl "^M") (pipe (prEval Prg 2) (_nlCrnl) ) (prinl "^M") (when Att (loop (if (cadr Att) (prinl "--" B "^M") (prinl "--==" B "==^M") ) (prin "Content-Type: " (or (caddr Att) "application/octet-stream")) (and (cadr Att) (prin "; name=\"" @ "\"")) (prinl "^M") (prinl "Content-Transfer-Encoding: " (if (cadr Att) "base64" "8bit") "^M" ) (prinl "^M") (in (car Att) (ifn (cadr Att) (_nlCrnl) (prBase64 18 "^M") (prinl "^M") ) ) (prinl "^M") (unless (cadr Att) (prinl "--==" B "==--^M") (prinl "^M") ) (NIL (setq Att (cdddr Att))) ) (prinl "--" B "--^M") ) (prinl ".^M") ) (pre? "250 " (in S (line T))) (out S (prinl "QUIT^M")) (pre? "221 " (in S (line T))) T ) (close S) ) ) ) ) (de _rcpt (To) (out S (prinl "RCPT TO:<" To ">^M")) (pre? "250 " (in S (line T))) ) (de _nlCrnl () (let P NIL (for (C (rd 1) C (rd 1)) (and (= 10 C) (<> P 13) (wr 13)) # ^M before ^J (wr (setq P C)) ) ) ) ### 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.l0000644000000000000000000011643314145242413010213 0ustar # 17nov21 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) #> any | NIL (= 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)) # 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 ) ) (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) ) # (+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) ) # 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)) " " "^J") New NIL (split (cdr (chop New)) " " "^J") Hook ) (extra Obj Old New Hook) ) (dm rel?> (Obj Val Hook) (and (idxRel? Obj Val NIL (split (cdr (chop Val)) " " "^J") Hook ) (extra Obj Val Hook) ) ) (dm lose> (Obj Val Hook) (idxRel Obj Val NIL (split (cdr (chop Val)) " " "^J") NIL NIL NIL Hook ) (extra Obj Val Hook) ) (dm keep> (Obj Val Hook) (idxRel Obj NIL NIL NIL Val NIL (split (cdr (chop Val)) " " "^J") Hook ) (extra Obj Val Hook) ) # (+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) ) # (+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) ) # (+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)) " " "^J") ) New (fold New) (extract '((L) (extract fold L)) (split (cdr (chop New)) " " "^J") ) 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)) " " "^J") ) Hook ) ) ) (extra Obj Val Hook) ) ) (dm lose> (Obj Val Hook) (idxRel Obj Val (fold Val) (extract '((L) (extract fold L)) (split (cdr (chop Val)) " " "^J") ) 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)) " " "^J") ) Hook ) (extra Obj Val Hook) ) # (+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)) ) ) ) # 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 ) ) ) ) ### 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> (meta Obj Var) Obj V NIL) ) ) ) ) (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) (and Val (if (atom Val) (find '((X) (extra Val X)) X) (loop (NIL (extra (++ Val) (++ X))) (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) ) ) ) (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) (let? V (and Val (get This Var)) (when (has> (meta This Var) Val V) (let Old (get This Var) (rel> (meta This Var) This Old (put This Var (del> (meta This Var) This Old V)) ) (when (asoq Var (meta This 'Aux)) (relAux This Var Old (cdr @)) ) (upd> This Var Old) ) ) ) ) (dm del!> (Var Val) (let? V (and Val (get This Var)) (when (has> (meta This Var) Val V) (dbSync) (let Old (get This Var) (rel> (meta This Var) This Old (put This Var (del> (meta This Var) This Old V)) ) (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)) ) ) ) ) (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 ### (private) _dbs (de dbs Lst (default *Dbs (_dbs 1)) ) (de dbs+ (N . Lst) (unless (cdr (nth *Dbs N)) (conc *Dbs (_dbs N)) ) ) (de _dbs (N) (mapcar '((L) (let Dbf (cons N (>> (- (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)) ) ) ) ) ) ) (inc 'N) (car L) ) Lst ) ) (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)) ) ) ) ) ) ) ) # Iterate all objects of given class (de forall (Cls . Prg) (for (This (seq (or (; Cls Dbf 1) (meta Cls 'Dbf 1) 1 ) ) This (seq This) ) (and (isa Cls 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) (gc 200 200) (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 Val (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 (mapcan '((V) (unless (atom V) (close (cadr V)) (let (Var (car V) File (tmp (pack "create-" Var))) (later (cons) (off Vars) (gc 0 100) (setq V (mapcar '((Key) (let F (tmp (pack "create-" (inc (0)))) (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 ) (off Vars) (prune) (gc 0) (wait NIL (full Lst)) (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) pil21/lib/pilog.l0000644000000000000000000003636514105216031010736 0ustar # 12aug21 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)) (flush) ) (T (line)) (prinl) ) ) ) (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) (^ @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) (^ @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) (^ @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 (isa Cls (setq R @))) ) ) ) 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) ### Debug ### `*Dbg (load "@lib/sq.l") pil21/lib/dbgc.l0000644000000000000000000000272613732324526010533 0ustar # 22sep20 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 (replace @S '/)))) (get S (intern (pack @R))) ) (inc 'Cnt) (%@ "unlink" NIL (pack F)) ) (wipe S) ) ) ) ) ) ) (commit) (gt0 Cnt) ) pil21/lib/too.l0000644000000000000000000002756414120551006010427 0ustar # 16sep21 Software Lab. Alexander Burger (private) (Prg C Q X Y CL 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 (fish '((X) (== X Obj)) (getl This)) (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 '((X) (== X Obj)) B) (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 (dbMap '((This) (and (isa '+Entity This) (not (: T)) (dangle This) (link @) ) ) ) ) ) (de dangle (Obj) (and (make (for X (getl Obj) (let V (or (atom X) (++ X)) (unless (rel?> Obj X V) (link X) ) ) ) ) (cons Obj @) ) ) # 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) ) ### 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) ) ) ) ) ) ### 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 CL (let C (cons 0 10000) (for (Q (goal CL) (asoq '@@ (prove Q))) (let (Obj (cdr @) 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.l0000644000000000000000000002364414136505127010721 0ustar # 28oct21 Software Lab. Alexander Burger # Prompt (de *Prompt (casq (car (symbols)) (pico) (T @)) ) (private) (_who _match nest nst1 nst2 C D M S X Y Z Fun Prg Who dep1 dep2) # Browsing (de help (Sym Ex) (when (; Sym doc) (prinl "========================================") (in @ (from (pack "

")) (out '("w3m" "-T" "text/html" "-dump") (echo "") (echo "
") (prinl "
") (echo "\n
")
            (ifn Ex
               (prinl "

")
               (prin "
")
               (prinl (echo "\n
")) ) ) )
      (prinl "========================================") )
   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 "
 ((X Y) ($ foo (X Y) A B))
(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 X (set X (cddr (cadr (getd X))))
               (and
                  (== '@ (++ X))
                  (= 1 (length X))
                  (= 2 (length (car X)))
                  (== 'pass (caar X))
                  (sym? (cdadr X))
                  (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))
            (push 'S (cons (++ L)))
            (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))
                     (less (has (car X)))
                     (car X) )
                  (less (cdr X)) ) ) )
         (prinl)
         (while L
            (space 3)
            (println (caar L) (less (cdr (++ L)))) )
         (T (and (not Flg) (line)) T) ) ) )

# Source code
`(info "@lib/map")

(in "@lib/map"
   (symbols 'llvm 'pico)
   (while (read)
      (let Sym @
         (if (get Sym '*Dbg)
            (set @ (read))
            (put Sym '*Dbg (cons (read))) ) ) ) )
pil21/lib/lint.l0000644000000000000000000002062213732077035010575 0ustar  # 21sep20 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))
      (or (memq X *NoLint) (push '*NoLint X)) ) )

(de global? (S)
   (or
      (memq S '(NIL ^ @ @@ @@@ This T))
      (member (char S) '(`(char '*) `(char '+)))
      (== '\~ (car (pair (val S))))
      (and
         (>= (length S) 4)
         (fully upp? (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)
                     (memq X *Bnd)
                     (push '*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) ) )
            (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)) )
            ((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)
                        (memq (car X) *Def)
                        (push '*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))
         (or
            Flg
            (member (cons *X X) *NoLint)
            (memq X *Use)
            (push '*Use 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)
   (let A (and (pair Lst) (car Lst))
      (while (pair A)
         (lintDup (car A) (cdr A))
         (lintVar (++ A) T) )
      (when A
         (lintVar A) )
      (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)
                        (fun? (cdr Y))
                        (lint (car Y) X)
                        (link (cons (cons (car Y) X) @)) ) ) )
               ((and (not (global? X)) (pair (getd X)) (lint X))
                  (link (cons X @)) ) ) )
         (while (args)
            (let A (next)
               (and (lint A) (link (cons A @))) ) ) ) ) )
pil21/lib/sq.l0000644000000000000000000000555113753712241010254 0ustar  # 14nov20 Software Lab. Alexander Burger

# (select [var ..] cls [hook|T] [var val ..])
(de select Lst
   (let
      (Vars
         (make
            (until
               (or
                  (atom Lst)
                  (and
                     (sym? (car Lst))
                     (= `(char "+") (char (car Lst))) ) )
               (link (++ Lst)) ) )
         Cls (++ Lst)
         Hook (cond
            ((ext? (car Lst)) (++ Lst))
            ((=T (car Lst)) (++ Lst) *DB) ) )
      (default Lst
         (cons
            (or
               (car Vars)
               (and
                  (find
                     '((X) (isa '(+Need +index) (car X)))
                     (getl Cls) )
                  (get (car @) 'var) )
               (cdr
                  (maxi caar
                     (getl (get (or Hook *DB) Cls)) ) ) ) ) )
      (let Q
         (goal
            (cons
               (make
                  (link
                     'select
                     '(@@)
                     (make
                        (for (L Lst L)
                           (link
                              (make
                                 (link (++ L) Cls)
                                 (and Hook (link Hook))
                                 (link (if L (++ L) '(NIL . T))) ) ) ) ) )
                  (link (list 'isa Cls '@@))
                  (while Lst
                     (let (Var (++ Lst)  Val (if Lst (++ Lst) '(NIL . T)))
                        (link
                           (list
                              (cond
                                 ((pair Val) 'range)
                                 ((or (num? Val) (ext? Val)) 'same)
                                 ((=T Val) 'bool)
                                 ((isa '+Sn (get Cls Var)) 'tolr)
                                 ((isa '(+IdxFold) (get Cls Var)) 'part)
                                 ((isa '(+Fold +Idx) (get Cls Var)) 'part)
                                 ((isa '+Fold (get Cls Var)) 'fold)
                                 ((isa '+Idx (get Cls Var)) 'hold)
                                 (T 'head) )
                              Val '@@ Var ) ) ) ) ) ) )
         (use Obj
            (loop
               (NIL (setq Obj (cdr (asoq '@@ (prove Q)))))
               (ifn Vars
                  (show Obj)
                  (for Var Vars
                     (cond
                        ((pair Var)
                           (print (apply get Var Obj)) )
                        ((meta Obj Var)
                           (print> @ (get Obj Var)) )
                        (T (print (get Obj Var))) )
                     (space) )
                  (print Obj) )
               (T (line) Obj)
               (prinl) ) ) ) ) )

(dm (print> . +relation) (Val)
   (print Val) )

(dm (print> . +Number) (Val)
   (prin (format Val (: scl))) )

(dm (print> . +Date) (Val)
   (print (datStr 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.l0000644000000000000000000000511713737101166011754 0ustar  # 06oct20 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))


### 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 '(a b c d)
   (fish sym? '(a -2 (1 b (-3 c 2)) 3 d -1)) )


### 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.l0000644000000000000000000000214714070340337011210 0ustar  # 04jul21 Software Lab. Alexander Burger

(test T (pool (tmp "db")))

### 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 T)  Y (new T))
   (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)
(call "rm" (tmp "db"))
pil21/test/src/ext.l0000644000000000000000000000171313737116411011424 0ustar  # 06oct20 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 (77)
   (pipe
      (prinl "TQ==")
      (make (while (ext:Base64) (link @))) ) )
(test (1 2 3)
   (pipe
      (prinl "AQID")
      (make (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.l0000644000000000000000000002015213765605504011600 0ustar  # 14dec20 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))


### 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 @)))


### ifn ###
(test 2 (ifn (= 3 3) 1 2))
(test 1 (ifn (= 3 4) 1 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)) ) ) )


### catch throw ###
(test NIL (catch NIL (throw)))
(test 'b (catch 'a (throw 'a 'b)))
(test 123 (catch T (throw 'a 123)))
(test "Undefined"
   (catch '("Undefined") (mist)) )
(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.l0000644000000000000000000001136513737115333011241 0ustar  # 06oct20 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^Ja")
      (skip "#") ) )
(test "#"
   (pipe (prinl "# Comment^Ja")
      (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^J") (line)) )
(test "abc"
   (pipe (prin "abc") (line T)) )
(test '("abc" "def")
   (pipe (prin "abc^Jdef")
      (list (line T) (line T)) ) )
(test '("abc" "def")
   (pipe (prin "abc^Mdef")
      (list (line T) (line T)) ) )
(test '("abc" "def")
   (pipe (prin "abc^M^Jdef")
      (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^Jc 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^J2^J" (in Err (till NIL T))) )


### 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 "^J" " " 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.l0000644000000000000000000001012413737111373011546 0ustar  # 06oct20 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 (hex "12")
   (byte (adr (1))) )

(test "ABC"
   (let P (native "@" "malloc" 'N 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.l0000644000000000000000000003160614155676030011606 0ustar  # 13dec21 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 (<> '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 (>= '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 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 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 (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"))) )


### rassoc ###
(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"))) )


### asoq ###
(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"))) )


### rasoq ###
(test '(2 . b)
   (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))))


### 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.l0000644000000000000000000002135614144675342011447 0ustar  # 16nov21 Software Lab. Alexander Burger

### name ###
(test "abc" (name 'abc))
(test "A123" (name '{A123}))
(let X (box)
   (test NIL (name X)) )


### sp? ###
(test T (sp? " ^I^J"))
(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"))))


### ==== ###
(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.l0000644000000000000000000000413614072241665011175 0ustar  # 10jul21 Software Lab. Alexander Burger

### +Joint ###
(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 (has> A 'k "a"))
   (test T (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 (list B) (has> A 'b B))
   (test T (has> A 'b (list B)))
   (test T (has> A 'b (list (list B))))

   (test T (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 (has> A 's "a"))
   (test NIL (has> A 's "x"))
   (test T (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 (has> A 'b '((123 "def"))))
   (test NIL (has> A 'b '((123))))
   (test NIL (has> A 'b '(("def"))))
   (test T (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.l0000644000000000000000000001037613737571562011557 0ustar  # 08oct20 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^Jjumps over the lazy^Jdog"
   (wrap 20 (chop "The quick brown fox jumps over the lazy dog")) )
(test "The^Jquick^Jbrown^Jfox^Jjumps^Jover the^Jlazy dog"
   (wrap 8 (chop "The quick brown fox jumps over the lazy dog")) )
(test "The^Jquick^Jbrown^Jfox^Jjumps^Jover^Jthe^Jlazy^Jdog"
   (wrap 2 (chop "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.l0000644000000000000000000003521314016131566010604 0ustar  # 26feb21 Software Lab. Alexander Burger

# *HPorts *Home *Gate *Host *Port *Port1 *Port% *Http1 *Chunked
# *Sock *Agent *ContL *ContLen *MPartLim *MPartEnd "*HtSet"
# *Post *Url *Timeout *SesAdr *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 "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 "zip") "application/zip" 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^M")
               (prinl "POST /" (car How) " HTTP/1.0^M")
               (prinl "Content-Length: " (size (cdr How)) "^M") )
            (prinl "User-Agent: PicoLisp^M")
            (prinl "Host: " Host "^M")
            (prinl "Accept-Charset: utf-8^M")
            (prinl "^M")
            (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)
   (cond
      ((not Pw) (println *Port) (bye))
      ((<> Pw (pw)) (quit "Bad pw"))
      ((ctty Tty)
         (if *SesId
            (setq *Adr *SesAdr)
            (off *Run) )
         (println *Pid)
         (unless *Dbg
            (on *Dbg)
            (symbols '(pico)
               (and (info "~/.pil/rc") (load @@))
               (load "@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 (P H)
   (setq
      *Port P
      *Port1 (or (sys "NAME") P)
      *Home (cons H (chop H))
      P (port *Port) )
   (gc)
   (loop
      (setq *Sock (listen P))
      (NIL (fork) (close P))
      (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)
         (nor
            (and *Tmp (pre? *Tmp *Url))
            (find pre? (cdr *Allow) (circ *Url)) ) ) ) )

(de notAllowed (X)
   (unless (= X "favicon.ico")
      (msg X " [" *Adr "] not allowed") ) )

# Application startup
(de app ()
   (if *SesId
      (unless (= *Adr *SesAdr)
         (forbidden) )
      (setq
         *SesAdr *Adr
         *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
            (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 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 " ^M^J" 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 "=^M^J" T)))
               (setq
                  *MPartLim (append '(- -) (cdr (line)))
                  *MPartEnd (append *MPartLim '(- -)) )
               (line) ) )
         ("x-pil:"
            (char)
            (when (till "=^M^J")
               (_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 "^J") )
                              (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 "^M^J" *MPartLim)))
                           (%@ "unlink" NIL F) ) )
                     (out "/dev/null" (echo (pack "^M^J" *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^M")
   (prinl "Server: PicoLisp^M")
   (prin "Date: ")
   (httpDate (date T) (time T))
   (when Upd
      (prinl "Cache-Control: max-age=" Upd "^M")
      (when (=0 Upd)
         (prinl "Cache-Control: private, no-store, no-cache^M") ) )
   (prinl "Content-Type: " (or Typ "text/html; charset=utf-8") "^M")
   (when File
      (prinl
         "Content-Disposition: "
         (if Att "attachment" "inline")
         "; filename=\"" File "\"^M" ) ) )

(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) "^M^J^M")
   (prin S) )

(de httpHead (Typ Upd File Att)
   (http1 Typ Upd File Att)
   (and *Chunked (prinl "Transfer-Encoding: chunked^M"))
   (httpCookies)
   (prinl "^M") )

(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^M" ) ) )

# 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) "^M")
         (prin "Last-Modified: ")
         (httpDate (cadr I) (cddr I))
         (prinl "^M")
         (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 "^M")
      (prinl "Server: PicoLisp^M")
      (while (args)
         (prinl (next) "^M") )
      (prinl "Content-Type: text/html^M")
      (httpCookies)
      (prinl "Content-Length: " (+ 59 (length N) (length X) (length B)) "^M")
      (prinl "^M")
      (prinl "")
      (prinl "" N " " X "")
      (prinl "" B "")
      (prinl "") ) )

(de noContent ()
   (prinl "HTTP/1.0 204 No Content^M")
   (prinl "^M") )

(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.l0000644000000000000000000006172514136176646011003 0ustar  # 27oct21 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
      (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
      "').innerHTML = 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 (bool *Chunked)
            (prin "data: ")
            (htPrin Prg 2)
            (prinl "^J") ) ) ) )

(de ping (Min)
   (timeout (setq *Timeout (* Min `(* 60 1000))))
   (respond) )

(de  (Min)
   ( "onload=ping(" Min ")") )

(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 (
'((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 "^J" X)) Txt) ) (de (X . Prg) (let *Style (style (cons 'title (glue "^J" 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/table0000644000000000000000000000042314064314013011602 0ustar ¦(run PRG)¦ ¦(run PRG)¦
¦(run PRG)¦
pil21/lib/form.l0000644000000000000000000016600214146376143010577 0ustar # 21nov21 Software Lab. Alexander Burger # *PRG *Top *Gui *Btn *Get *Got *Form *FormIx *FormLst *Evt *Lock *Spans (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) (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 @)))) ) ) ) (queue (nth *FormLst (- *FormIx *Get)) *Top) ) ) (let Lst (get *FormLst (- *FormIx *Get) 1) (for (F . L) Lst (let *Form (- F (length Lst)) (cond ((and (== *PRG (car L)) (memq App (get *PRG 'top))) (apply "form" L) ) ((or (== *PRG App) (memq App (get *PRG 'top))) (if (get L 1 'top) (apply "form" L) (put (car L) 'top (cons *PRG (get *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 (get Fld 'chg) (get 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) (catch 'stop (postGui) (httpHead "text/plain; charset=utf-8") (if (and (= (car *Stat) *Err) (= (cdr *Stat) (get *FormLst (- *FormIx *Get))) ) (ht:Out *Chunked (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 (pack (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 ("Fun" NIL *Btn NIL) (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) (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) (and *Lock (with (caar *Err) (tryLock *Lock))) (finally (when *Lock (if (lock @) (=: able (off *Lock)) (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 *Url) ) # 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) ) # 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 '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 ": " 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)) ) (off *Msg) (println '-> "@1") ) ) (and *Msg (prinl @)) ) ) (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 (get *App 'top) (gui '(+Rid +Close +Button) Lbl Exe) ) ) (de okButton (Exe) (when (get *App 'top) (if (=T Exe) (gui '(+Force +Close +Button) T "OK") (gui '(+Close +Button) "OK" Exe) ) ) ) (de cancelButton () (when (get *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 window (X Y *DX *DY . Prg) (prinl "") (let *Pos 0 (prog1 (run Prg) (prinl "") ) ) ) (de ps @ (let A (arg 1) (if (member A (0 NIL T)) (next) (off A) ) (prin "") (while (args) (let X (next) (if (atom X) (ht:Prin 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 "") ) ) ) ) ) ) (prinl "") ) (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.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) ) ) 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) ) 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 ) Dst ) �������������pil21/lib/canvas.l����������������������������������������������������������������������������������0000644�0000000�0000000�00000004252�13760656504�011110� 0����������������������������������������������������������������������������������������������������ustar ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������# 29nov20 Software Lab. Alexander Burger (allow "!jsDraw" ) (push1 '*JS (allow "@lib/plio.js") (allow "@lib/canvas.js")) # Draw (drawCanvas Id Dly) # 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) "^M^J^M") (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) (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 "" ) ) ������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������pil21/lib/canvas.js���������������������������������������������������������������������������������0000644�0000000�0000000�00000020131�14146652277�011265� 0����������������������������������������������������������������������������������������������������ustar ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������/* 22nov21 Software Lab. Alexander Burger */ function renderCanvas(cvs, lst) { var ctx = cvs.getContext("2d"); var cmd, i, j; 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), (csDef Key) 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) var img = new Image(); img.src = cmd[1]; (function (img, cmd) { img.onload = function() { 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]); } } )(img, cmd); 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 len = arguments.length; for (var i = 2; i < len; ++i) { if (typeof arguments[i] == "undefined") return true; 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 (ele.dly == 0) requestAnimationFrame(function() {drawCanvas(id, dly)}); else if (ele.dly > 0) 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 (drawCanvas(cvs.id, cvs.dly, cvs.csMv? -1 : 0, cvs.csDnX, cvs.csDnY, x - r.left, y - r.top)) return true; cvs.csMv = 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 = false; return drawCanvas(cvs.id, cvs.dly, 2, cvs.csDnX, cvs.csDnY); } if (cvs.csMv) return drawCanvas(cvs.id, cvs.dly); cvs.clicked = setTimeout( function() { cvs.clicked = false; 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); return false; } function csLeave(cvs) { cvs.style.cursor = ""; cvs.csDn = cvs.csMv = false; if (cvs.clicked) { clearTimeout(cvs.clicked); cvs.clicked = false; } return drawCanvas(cvs.id, cvs.dly); } 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�00000025642�14156110240�011241� 0����������������������������������������������������������������������������������������������������ustar ��������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������# 14dec21 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 (sys "SSL_CERT_FILE" "tls/cert.pem") # (boss 'sym ['any ..]) (local) boss (de boss @ (out "BOSS" (pr (rest))) ) # 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 (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)) (out Rply (pr (and (get X Obj) (ext 0 (apply @ Lst))) ) ) ) ) ) ) (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) ) ) ) # Android device ID (local) dev (de dev () (java "android.provider.Settings$Secure" 'getString (java CONTEXT 'getContentResolver) "android_id" ) ) # Push-Load (local) (loadTxt loadUrl) (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)) ) ) # 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 "android.support.v4.content.ContextCompat" 'checkSelfPermission (; CONTEXT GUI) Str ) ) (java "android.support.v4.app.ActivityCompat" 'requestPermissions (; CONTEXT GUI) (list Str) 0 ) ) ) # Wake lock (local) (*Wake wake) (de wake @ (default *Wake # PowerManager.WakeLock (java (java CONTEXT 'getSystemService "power") # PowerManager 'newWakeLock 1 "PilWake" ) ) # PARTIAL_WAKE_LOCK = 1 (when (args) # (wake 'flg) (cond ((next) (java *Wake 'acquire)) ((java *Wake 'isHeld) (java *Wake 'release)) ) ) ) # 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 "android.support.v4.content.FileProvider" 'getUriForFile CONTEXT "de.software_lab.pilbox.fileprovider" (java "java.io.File" T File) ) ) # Update APK (local) update? (de update? () (gt0 # (java (java CONTEXT 'getPackageManager) 'canRequestPackageInstalls) (java "android.provider.Settings$Secure" 'getInt (java CONTEXT 'getContentResolver) "install_non_market_apps" ) ) ) (local) update (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) (let N (java CONTEXT 'getSystemService "notification") # NotificationManager (ifn Ttl (java N 'cancel Id) ~(as (>= (format (sys "SDK_INT")) 26) (unless *Notify (java N 'createNotificationChannel (java "android.app.NotificationChannel" T "pil" "PilBox" 2) ) # IMPORTANCE_LOW = 2 (on *Notify) ) ) (let B `(if (>= (format (sys "SDK_INT")) 26) '(java "android.app.Notification$Builder" T CONTEXT "pil") '(java "android.support.v4.app.NotificationCompat$Builder" T CONTEXT) ) (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 "LOAD" File) ) (java B 'setContentIntent (java "android.app.PendingIntent" 'getActivity CONTEXT 0 Intent `(hex "18000000") ) ) ) # FLAG_ACTIVITY_NEW_TASK | FLAG_UPDATE_CURRENT (prog1 (java B 'build) # Notification (java N 'notify Id @) ) ) ) ) ) # Service foreground state (local) (startForeground stopForeground) (de startForeground (Ttl Msg) (java CONTEXT 'startForeground 1 (notify 1 Ttl Msg) ) ) (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 *LocLsn location? gps) (de location? () (permit "android.permission.ACCESS_FINE_LOCATION") ) (de gps () (unless *LocMan (setq *LocMan (java CONTEXT 'getSystemService "location") *LocLsn (java T "android.location.LocationListener") ) ## (def 'onLocationChanged *LocLsn ## '((Loc)) ) ## (def 'onProviderDisabled *LocLsn ## '((Prov)) ) ## (def 'onProviderEnabled *LocLsn ## '((Prov)) ) ## (def 'onStatusChanged *LocLsn ## '((Prov Stat Extras)) ) #? (java *LocMan 'requestLocationUpdates "network" '(L . 10000) (-3 . 100) *LocLsn) (java *LocMan 'requestLocationUpdates "gps" '(L . 20000) (-3 . 100) *LocLsn) ) (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? (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") ) (local) takePicture (de takePicture (Dst Fun) (out Dst) (startActivityForResult Fun "android.media.action.IMAGE_CAPTURE" "output" (fileUri Dst) ) ) # ZXing QR-Codes (local) zxing? (de zxing? () (with (java (java CONTEXT 'getPackageManager) 'queryIntentActivities (java "android.content.Intent" T "com.google.zxing.client.android.SCAN") 65536 ) # MATCH_DEFAULT_ONLY (gt0 (: size)) ) ) ## '((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 (de alarm (N When File) (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 0) ) (java Intent 'putExtra "LOAD" File) (java Alarm 'setExactAndAllowWhileIdle (if (atom When) 2 0) # ELAPSED_REALTIME_WAKEUP RTC_WAKEUP (cons 'L (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) ) ) ) (java "android.app.PendingIntent" 'getBroadcast CONTEXT N Intent `(hex "18000000") ) ) ) ) ) # FLAG_ACTIVITY_NEW_TASK | FLAG_UPDATE_CURRENT # Restart PilBox (local) restart (de restart () (java (; CONTEXT GUI) 'restart) ) pil21/lib/gis.l0000644000000000000000000000745413761636227010427 0ustar # 02dec20 Software Lab. Alexander Burger (symbols 'gis 'pico) (push1 '*JS (allow "@lib/gis.js")) (local) nm (de nm (Lat Lon) (pack (round (- Lat 90.0)) ", " (round (- Lon 180.0)) ) ) (local) (lat lon fmt) (de lat (Lat) (format (- Lat 90.0) `*Scl) ) (de lon (Lon) (format (- Lon 180.0) `*Scl) ) (de fmt (Lat Str Lon) (when (or Lat Lon) (pack (lat Lat) Str (lon Lon)) ) ) # Short distance, assuming flat earth (local) distance (de distance (Lat1 Lon1 Lat2 Lon2) # [m] (let (DX (*/ (- Lon2 Lon1) 6378000 pi 180.0) DY (*/ (cos (*/ Lat1 pi 180.0)) (- Lat2 Lat1) 6378000 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 ", '" 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.l0000644000000000000000000000566414106416523010604 0ustar # 16aug21 Software Lab. Alexander Burger (de checkJson (X Item) (unless (= X Item) (quit "Bad JSON" Item) ) ) (de parseJson (Str) (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 (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)) ) (T X) ) ) ) ) ) ) ) (de readJson () (case (read "_") ("{" (make (for (X (readJson) (not (= "}" X)) (readJson)) (checkJson ":" (readJson)) (link (cons (intern X) (readJson))) (T (= "}" (setq X (readJson)))) (checkJson "," X) ) ) ) ("[" (make (for (X (readJson) (not (= "]" X)) (readJson)) (link X) (T (= "]" (setq X (readJson)))) (checkJson "," X) ) ) ) (T (let X @ (cond ((pair X) (pack X)) ((and (= "-" X) (format (peek))) (- (read)) ) (T X) ) ) ) ) ) (de packJson (Item) (pack (make (recur (Item) (cond ((atom Item) (link (if Item (sym @) "{}"))) ((atom (car Item)) (link "[") (map '((X) (recurse (car X)) (and (cdr X) (link ", ")) ) Item ) (link "]") ) (T (link "{") (map '((X) (link "\"") (link (sym (caar X))) (link "\": ") (recurse (cdar X)) (and (cdr X) (link ", ")) ) Item ) (link "}") ) ) ) ) ) ) (de printJson (Item) (cond ((atom Item) (if Item (print @) (prin "{}"))) ((atom (car Item)) (prin "[") (map '((X) (printJson (car X)) (and (cdr X) (prin ", ")) ) Item ) (prin "]") ) (T (prin "{") (map '((X) (prin "\"") (print (caar X)) (prin "\": ") (printJson (cdar 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/tinymce.l0000644000000000000000000001163014070277612011275 0ustar # 04jul21 Software Lab. Alexander Burger ### TinyMCE Interface ### (allow "@tinymce/" T) (de () (javascript "@tinymce/tinymce.min.js" " tinymce.init( { mode: 'specific_textareas', editor_selector: 'tinymce', plugins: 'textcolor colorpicker hr directionality paste', toolbar: 'forecolor bold italic superscript underline strikethrough | hr | removeformat', paste_as_text: true, nowrap: true, menubar: false, statusbar: false, min_height: 12, toolbar_items_size: 'small', language: '" (or *Lang "en") "', entity_encoding: 'raw', force_br_newlines : true, force_p_newlines : false, forced_root_block : '', setup: function(ed) { ed.on('init', function(e) { var fld = ed.getElement(); fld.pilSetValue = function(val) { ed.setContent(val); } fld.pilDisable = function(flg) { ed.getBody().setAttribute('contenteditable', !flg); } fld.pilDisable(fld.disabled); } ) ed.on('change', function(e) { ed.getElement().value = ed.getContent(); fldChg(ed.getElement()); } ) } } )" ) ) # Parse HTML text (de htmlText (Text) (let (Lst (split (chop Text) "<" ">") Tag) (make (recur (Tag) (loop (let? S (++ Lst) (unless (= S '("^J")) (link (ht:Pack S)) ) ) (NIL Lst) (T (and (= "/" (caar Lst)) (= Tag (cdar Lst))) (++ Lst) ) (let S (++ Lst) (cond ((= S '`(chop "br /")) (link 0) ) ((= S '`(chop "hr /")) (link T) ) ((and (= "p" (car S)) (sp? (cadr S))) (and (made) (link 0)) (recurse '("p")) (and (find bool Lst) (link 0)) ) ((= S '`(chop "strong")) (link '(B . T)) (recurse S) (link '(B)) ) ((= S '`(chop "em")) (link '(I . T)) (recurse S) (link '(I)) ) ((= S '`(chop "sup")) (link '(S . T)) (recurse S) (link '(S)) ) ((= S '`(chop "span style=\"text-decoration: underline;\"")) (link '(U . T)) (recurse '("s" "p" "a" "n")) (link '(U)) ) ((= S '`(chop "span style=\"text-decoration: line-through;\"")) (link '(L . T)) (recurse '("s" "p" "a" "n")) (link '(L)) ) ((head '`(chop "span style=\"color: ") S) (setq S (nth S 21)) (link (cons 'C (pack "#" (head 6 S)))) (recurse '("s" "p" "a" "n")) (link '(C)) ) (T (recurse (car (split S " ")))) ) ) ) ) ) ) ) # Remove markup (de unmarkup (Text) (let L (chop Text) (use (@A @X @Z) (while (match '(@A "<" @X ">" @Z) L) (setq L (conc @A (and @A @Z (head '("b" "r") @X) (cons " ")) @Z ) ) ) ) (extract pack (split L " " "^J")) ) ) # HTML text index relation (class +HtIdx +Fold +Idx) (dm has> (Val X) (or (= Val X) (member Val (mapcar fold (unmarkup X))) ) ) (dm rel> (Obj Old New Hook) (setq Old (unmarkup Old) New (unmarkup New)) (for O (diff Old New) (super Obj O NIL Hook) ) (for N (diff New Old) (super Obj NIL N Hook) ) ) (dm rel?> (Obj Val Hook) (for V (unmarkup Val) (NIL (super Obj V Hook)) T ) ) (dm lose> (Obj Val Hook) (for V (unmarkup Val) (super Obj V Hook) ) ) (dm keep> (Obj Val Hook) (for V (unmarkup Val) (super Obj V Hook) ) ) NIL ####### README ####### Using the TinyMCE 4.x Javascript/HTML WYSIWYG editor in PicoLisp applications 1. Get 'tinymce' $ (cd /some/path; unzip tinymce_4.1.7.zip) 2. In the application's runtime directory, create a link to the tinymce installation, e.g.: $ ln -s /some/path/tinymce 3. Load "@lib/tinymce.l" at startup (load .. "@lib/tinymce.l" ..) 4. On each page where you want to use tinymce in text areas, call () (action (html 0 "Title" "lib.css" NIL (form NIL .. () ... 5. and give each desired text area a style "tinymce": ... (gui '(+Style +Var +TextField) "tinymce" '*Text 60 8) # Textarea .. pil21/lib/xm.l0000644000000000000000000000637114021432254010246 0ustar # 08mar21 Software Lab. Alexander Burger # 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 "^J<"))))) ) ) ) ) ) ) ) ) (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) ) ) (cdr (asoq Key (cadr Lst))) ) pil21/img/go.png0000644000000000000000000000024010523275701010560 0ustar PNG  IHDR |lbKGD̿ pHYs  DIDATmA07z ̻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.l0000644000000000000000000001273514126001466010757 0ustar # 02oct21 Software Lab. Alexander Burger (symbols 'simul 'pico) (local) (subsets shuffle samples) (import pico~permute) (de permute (Lst) (ifn (cdr Lst) (cons Lst) (mapcan '((X) (mapcar '((Y) (cons X Y)) (permute (delete X Lst)) ) ) 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) ) ) ) ) ) ) ### 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) ) ) 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/lib/compat.l0000644000000000000000000000111714001002273011066 0ustar # 17jan21 Software Lab. Alexander Burger # Some pil64 compatibility (private) *Arg (redef next () (setq *Arg (next)) ) (redef arg (Cnt) (if Cnt (arg Cnt) *Arg ) ) (de ==== () (let X (all '(T)) (set X (con X)) ) (let X (all '(T . T)) (set X (con X)) ) ) (de pil @ (pass pack "~/.pil/") ) (de lines @ (let Cnt 0 (while (args) (in (next) (while (from "\n") (inc 'Cnt) ) ) ) Cnt ) ) (de tzo () (- (+ (* 86400 (date)) (time T)) (+ (* 86400 (date T)) (time T)) ) ) (def 'forked prog) pil21/vip0000755000000000000000000000010013730611270007406 0ustar #!/bin/sh exec ${0%/*}/bin/picolisp ${0%/*}/lib.l @bin/vip "$@" pil21/bin/vip0000755000000000000000000000131714066611123010171 0ustar #!/usr/bin/picolisp /usr/lib/picolisp/lib.l # 29jun21abu (unless *Dbg (load "@lib/vip.l") ) (de vip~*Ns pico) (bye (if (vip~vi ## [+ | +[]] [+[]] .. (make (while (opt) (let S @ (cond ((pre? "+" S) (link (cons (cond ((= "+" S) T) ((format S) @) (T (cdr (chop S))) ) (opt) ) ) ) ((pre? "-" S) (load S)) (T (link S)) ) ) ) ) ) 0 1 ) ) pil21/lib/vip.l0000644000000000000000000017224114154651343010431 0ustar # 10dec21 Software Lab. Alexander Burger (symbols 'vip 'pico) (local) (*Ns *Shell *CmdWin *StatNm *Chr *Complete *Repeat *Change *Count *Cnt *Search *Clip *Lines *Columns *TagStack *Spell *CmdMap *Keys *KeyMap *KeyMap-g *KeyMap-q *F7 *F8 *F9 *F10 *F11 *F12 *@) ### ANSI Terminal ### (sysdefs "terminal") (local) (getSize xterm ULINE U-OFF REVERS CYAN RED *AttrA *AttrU attr cup clreol hideCsr showCsr screen1 screen2) (de getSize () (use L (unless (=0 (%@ "ioctl" 'I 1 TIOCGWINSZ '(L (`winsize W W)))) (quit "Can't get terminal size") ) (setq *Lines (car L) *Columns (cadr L)) ) ) (de xterm () (member (sys "TERM") '("xterm" "screen")) ) (def '*Shell (or (sys "SHELL") "sh")) (de ULINE . 4) (de U-OFF . 24) (de REVERS . 7) (de CYAN . 36) (de RED . 31) (off *AttrA *AttrU) (de attr (A U) (if2 (<> A *AttrA) (<> U *AttrU) (prin "^[[" (or (setq *AttrA A) 0) ";" (if (setq *AttrU U) ULINE U-OFF) "m" ) (prin "^[[" (or (setq *AttrA A) 0) "m") (prin "^[[" (if (setq *AttrU U) ULINE U-OFF) "m") ) ) (de cup (Y X) (prin "^[[" Y ";" X "H") ) (de clreol () (prin "^[[0K") ) (de hideCsr () (prin "^[[?25l") ) (de showCsr () (prin "^[[?25h") ) (de screen1 () (if (xterm) (prin "^[[?1049l") (cup *Lines 1) ) (flush) ) (de screen2 () (and (xterm) (prin "^[[?1049h")) ) ### VIP Editor ### (local) (*Buffers +Buffer mkLoc fName prName rplFile fileBuffer rdLines delim? arkup min1 beep 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 tword word lword 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 reset posChar getText s-expr command vi) (class +Buffer) # text file 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 80) ) (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) (when (setq File (path File)) (use R (when (=0 (%@ "realpath" 'N File '(R (4096 C . 4096)))) (setq R (chop File)) ) (pack (mkLoc R)) ) ) ) (de prName (File) (if (pre? (sys "HOME") File) (pack "~/" (cddr (nth (chop File) (length (sys "HOME"))))) File ) ) (de rplFile (File) (pack (replace (chop 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 Str) (or (member C '`(cons NIL (chop " \t\n\r\"'(),[]`"))) (sub? C Str) ) ) (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)) ) (de beep () (pico~beep) NIL ) (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))) T) (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)) (pipe (in File (out '("ccrypt" "-d" "-ECCRYPT") (echo))) (rdLines) ) (in File (rdLines)) ) ) ) ) ) ) (=: symbols (symbols)) (=: undo (=: redo (=: dirt))) (=: posX (min1 (: posX) (length (get (: text) (=: posY (min1 (: posY) (length (: text)))) ) ) ) ) (when (head '`(chop "# VIP ") (: text 1)) (let? L (clip (: text 1 -6)) (evCmd (symbols '(vip pico) (if (= "(" (car L)) (run (str (pack L))) (setq L (split L " ")) (apply script (cdr L) (fName (pack (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? @) (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)) (commit 'pico~upd) (syms> This (: syms)) ) ) ) (on *StatNm) ) (dm syms> ("Lst") (out (: file) (for "S" (=: syms "Lst") (if (and (ext? "S") (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") (println "X" T) (printsp (cdr "X")) (pretty (setq "X" (car "X")) -3) (cond ((type "X") (prin " # ") (print @) ) ((>= 799999 "X" 700000) (prin " # ") (print (date "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)) (ifn (>= "^_" C "^A") (attr NIL T) (setq C (char (+ 64 (char C)))) (attr RED T) ) ) ((>= "^_" 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 (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) (cond ((ge0 (setq N (- *Columns (length A) (length F) (length Z)) ) ) (prin A F (need N " ") Z) ) ((onOff *StatNm) (prin (align (- *Columns) (tail *Columns (chop F)))) ) (T (prin A (need (- *Columns (length A) (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 (N) (and (> (: winX) 1) (>= (- (: posX) (dec (:: winX))) *Columns) (dec (:: posX)) ) ) (de scRight (N) (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 (= "^[" (setq *Chr (or (++ *Keys) (key)))) (when (or (++ *Keys) (key 120)) (loop (setq *Chr (pack *Chr @)) (T (member *Chr '("^[[A" "^[[B" "^[[C" "^[[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 (unless (== (=: last (: buffer)) (=: buffer (fileBuffer File)) ) (unmark) ) ) (load> (: buffer) This) (off *StatNm) (goto (or X (: buffer posX)) (or Y (: buffer posY)) ) (repaint) ) ) (de scratch (File Lst Y) (setq File (fName File)) (if (find '((This) (= File (: file))) *Buffers) (put @ 'text Lst) (=: last (: buffer)) (unmark) (put (=: buffer (new '(+Buffer) File Y)) 'text Lst ) (goto 1 (: buffer posY)) ) (repaint) ) (de syms ("Lst") (prog1 (tmp "syms") (syms> (fileBuffer @) "Lst") ) ) (de pushTag (File) (push '*TagStack (: posX) (: posY) File (symbols)) ) (de tag (S C) (ifn (if C (get @ '*Dbg -1 S) (get S '*Dbg 1) ) (beep) (pushTag (: buffer file)) (apply symbols (cddr @)) (reload (cadr @) (car @) 1) ) ) (de done (Flg) (and Flg (dirty> (: buffer) This) (save> (: buffer) This) ) (unmark) (nond ((; *CmdWin next next) (screen1) (rollback) (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 tword (L) (and (delim? (car L)) (or (sub? (cadr L) "\"()[]") (not (delim? (cadr L))) ) ) ) (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 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)) (when 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 ) ) ) (("^H" "^?") # [BACKSPACE] (when (and Chg (n0 (car Chg))) (_bs) (chgLine (car P)) ) T ) (T (let S (list @) (cond ((<> @ "\t") (off *Complete)) ((= '(":" " ") (get (: buffer text) (: posY))) (setq S (chop (car (rot (setq *Complete (history))))) ) ) ((or Rpl (nor *Complete (setq S (pack (getWord))))) (setq S (make (do (- 3 (% (dec (: posX)) 3)) (link (name " ")) ) ) ) ) (T (default *Complete (cons S (flip (all* S)))) (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)) (move 'goAbs (default X (car @)) (cdr @)) ) ) ) (de wordFun (W) (setq *Search (ifn (= '"@" (car (setq W (append W '("@Z"))))) (curry (W) (L C) (and (delim? C "~") (match W L) (delim? (car "@Z") "~") ) ) (++ W) (curry (W) (L C) (and (delim? C "~") (and (= '"@" (car L)) (match W (cdr L))) (delim? (car "@Z") "~") ) ) ) ) ) (de moveSearch (Fun1 Fun2) (move Fun1 (lit Fun2) *Cnt) ) (de patMatch (Fun Pat) (moveSearch Fun (setq *Search (if (= "\\" (car Pat)) (let @Pat (cdr Pat) (curry (@Pat) (L) (head '@Pat L) ) ) (let @Lst 'L (when (= "~" (car Pat)) (setq Pat (mapcar lowc (cdr Pat)) @Lst '(mapcar lowc L) ) ) (let @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)) ) ) ) ) ) ) ) ) (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 () (when (pipe (out *Spell (let Pos (nth (: buffer text) (: posY)) (prinl (seek '((L) (not (fold (car L)))) (nth (++ Pos) (: posX)) ) ) (mapc prinl Pos) ) ) (line) ) (let @W (conc @ '("@Z")) (moveSearch 'goForward (setq *Search (curry (@W) (L C) (and (not (fold C)) (match '@W L) (not (fold (car "@Z"))) ) ) ) ) ) ) ) (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) (=: last (: buffer)) (unmark) (=: buffer (nond (B (car (or (cdr M) *Buffers))) ((=T B) B) (NIL (car (or (prior M *Buffers) (tail 1 *Buffers))) ) ) ) (unless (: buffer text) (load> (: buffer) This) ) (off *StatNm) (goto (: buffer posX) (: buffer posY)) ) ) (de shell (S) (screen1) (do *Columns (prin "#")) (call *Shell "-c" S) (prin "[====] ") (flush) (getch) (prinl) (screen2) (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) (println '-> *@) ) ) (and *Msg (prinl @)) ) (in (tmp "repl") (prCmd (rdLines)) ) ) (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 '\"\") ) ### 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 (scratch (tmp "cmd") (in (list *Shell "-c" (rplFile L)) (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)) (prin V) ) ) ) ) ("ix.io" # Paste to http://ix.io (pipe (out '("curl" "-sF" "f:1=<-" "ix.io") (mapc prinl (: buffer text)) ) (prCmd (rdLines)) ) ) ("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 (fName (rplFile L)))) (in (: mark) (move 'goAbs (read) (read))) ) ) ("n" (nextBuf)) # Next buffer ("N" (nextBuf T)) # Previous buffer (("ta" "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 (fName (rplFile L)) (when (info F) (in F (paste (cons T (rdLines)) 1)) ) ) ) ("w" # (Write) Save buffer (if L (out (fName (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" (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 (: buffer) (for (This *CmdWin (setq This (: next))) (when (== Buf (: buffer)) (nextBuf) ) ) (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)) ) ) ### VIP Entry Point ### (de vi ("Lst") # (file (pat . file) (99 . file) (T . file) (sym [sym ..]) (getSize) (and "Lst" (co 'vip)) (co 'vip (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")) ) (screen2) (let (*Winch '((getSize) (eqwin) (flush)) *TStp1 '((screen1)) *TStp2 '((screen2) (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)) (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))))) # "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 (NIL) (("\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" "^[[B") (move 'goDown *Cnt)) # [DOWN] Move down (("^F" "^[[6~") (move 'goDown (: lines))) # [PGDOWN] Page down (("k" "^[[A") (move 'goUp *Cnt)) # [UP] Move up (("^B" "^[[5~") (move 'goUp (: lines))) # [PGUP] Page up ("h" (move 'goLeft *Cnt)) # Move left ("l" (move 'goRight *Cnt)) # Move right ("^[[D" (scLeft) (redraw)) # [LEFT] Scroll left ("^[[C" (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 ("G" (move 'goAbs 1 (or (format *Count) T))) # Go to end of text ("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 T) (moveSearch 'goForward (wordFun @))) ) ("#" # Search word under cursor backward (and (getWord T) (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)) (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 T))) ) ("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 T)) (ifn (: buffer syms) (tag S) (pushTag @) (syms> (: buffer) (cons S @)) (reload (: buffer file) 1 1) ) ) ) ("^]" # Edit symbol definition (tag (any (getWord T))) ) (("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)) ) ) ) (("^[OP" "^[[[A") # [F1] Highlight on/off (=: buffer flat (not (: buffer flat))) (repaint) ) (("^[OQ" "^[[[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" ) ) ) (("^[OR" "^[[[C") # [F3] Custom dif (shFile "dif @1 @2") ) (("^[OS" "^[[[D") # [F4] Format paragraph (and *Count (=: buffer fmt @)) (goPFore 1 -1) (pipeN (cnt@@) (pack "fmt -" (: buffer fmt))) ) (("^[[15~" "^[[[E") # [F5] Previous buffer (nextBuf T) ) ("^[[17~" # [F6] Next buffer (nextBuf) ) ("^[[18~" (run *F7)) # [F7] Custom key ("^[[19~" (run *F8)) # [F8] Custom key ("^[[20~" (run *F9)) # [F9] Custom key ("^[[21~" (run *F10)) # [F10] Custom key ("^[[23~" (run *F11)) # [F11] Custom key ("^[[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) (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) (and (symbols (setq *Ns (symbols)) (vi (list (cond ((pair "X") @) ((if C (get @ '*Dbg -1 "X") (get "X" '*Dbg 1) ) (apply symbols (cddr @)) (cons (car @) (cadr @)) ) (T "X") ) ) ) ) "X" ) ) (de pico~vf (Pat Dir Ext) (setq Pat (chop Pat)) (when (in (list "grep" "-Rl" (if Ext (pack "--include=*" @) "--exclude=*-") (cons "\\(\^\\|[[:space:]\"'(),`{}~]\\|\\[\\|\\]\\)" (replace Pat "@" ".*" "." "\\." "*" "\\*") "\\([[:space:]\"'(),`{}~]\\|\\[\\|\\]\\|$\\)" ) (or (fName Dir) ".") ) (make (while (line T) (link @))) ) (symbols (setq *Ns (symbols)) (vi (cons (cons Pat (car @)) (cdr @))) ) ) ) (de pico~v "Lst" (symbols (setq *Ns (symbols)) (cond ("Lst" (vi (list @))) ((asoq 'vip (stack)) (vi)) ) ) ) pil21/lib/vip/draw.l0000644000000000000000000002145114130320553011350 0ustar # 09oct21 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 save> (Win) (super Win) (view> This Win) ) (dm view> (Win) (off *Draw *Boxes) (symbols '(vip~draw vip pico) (evCmd (load (fName (: file)))) ) (mapc 'hv> *Boxes) (with Win (scratch (tmp "draw") *Draw) ) ) ) ### 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/psh0000755000000000000000000000054613734616422010200 0ustar #!bin/picolisp lib.l # 29sep20 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))) (ctty (read)) (line) (line) ) ) (bye) pil21/bin/pty0000755000000000000000000000106714123264246010215 0ustar #!/data/data/com.termux/files/home/pil21/pil # 24sep21abu # Pseudo Terminal (PilBox) (load "@lib/term.l") (unless (setq *Sock (connect (or (opt) "localhost") 8082)) (bye) ) (out *Sock (in "~/.pty" (echo))) (push '*Bye '(prinl)) (when (getTerm) (out *Sock (space) (println (cons 'setTerm "screen" @) '(off *Err) ) ) (in *Sock (till "-") (till "\n")) ) (raw T) (call "stty" "intr" NIL) (task *Sock (in @ (ifn (rd 1) (bye) (wr @) (flush) ) ) ) (loop (and (key) (out *Sock (prin @))) ) pil21/bin/watchdog0000755000000000000000000000446113740305022011172 0ustar #!bin/picolisp lib.l # 10oct20 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") ) (push1 '*Bye '(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/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/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/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/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/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/bigtest0000755000000000000000000000502512717125054011223 0ustar #!bin/picolisp lib.l # 18may16abu # 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 "^J" N ": (" S " " N1 ") -> " X) (bye) ) ) ) (de test2 (S N1 N2) (let (N (read) X (eval (list S N1 N2))) (unless (= N X) (prinl "^J" 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 "^J" 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.sample0000644000000000000000000000076614067522622011266 0ustar # 02jul21 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) (dbCheck) (vi (car (url> *ID))) (show *ID) # Initial commands (scl 2) (de x () (load "x.l") ) pil21/doc/tut.html0000644000000000000000000010510414004464252011144 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 show-mode-in-prompt on
set vi-ins-mode-string ""
set vi-cmd-mode-string "$"
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 @ (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) "^I")                # 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 @
               ("^M" NIL)                       # ignore CR
               ("^J" "^M")                      # 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.html0000644000000000000000000007513414112412467011111 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.html0000644000000000000000000006667713751247375011660 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 pointer in its value, so that subsequent calls evaluate to that pointer, 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.

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 pointer 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 (with strdup(3)), passes the pointer to the C function, and releases the memory (with free(3)) 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

As we know that the format string "%e\n" will be converted from a Lisp symbol to a C string with strdup - and then thrown away - on each call to prf, we might as well perform a little optimization and delegate this conversion to the program load time: 


: (de prf (Flt)
   (%@ "printf" NIL `(%@ "strdup" 'P "%e\n") (cons Flt 1.0)) )
-> prf

: (prf (exp 12.3))
2.196960e+05

If we look at the prf function, we see that it now contains the pointer to the allocated string memory: 


: (pp 'prf)
(de prf (Flt)
   (%@ "printf" NIL 24662032 (cons Flt 1000000)) )
-> prf

This pointer will be used by printf directly, without any further conversion or memory management.

Callbacks

Sometimes it is necessary to do the reverse: Call Lisp code from C code. This can be done in two ways - with certain limitations.

Call by Name

The first way is actually not a callback in the strict sense. It just allows to call a Lisp function with a given name.

The limitation is that this function can accept only maximally five numeric arguments, and must return a number.

The prerequisite is, of course, that you have access to the C source code. To use it from C, insert the following prototype somewhere before the first call: 


long lisp(char*,long,long,long,long,long);

Then you can call lisp from C: 


long n = lisp("myLispFun", a, b, 0, 0, 0);

The first argument should be the name of a Lisp function (built-in, or defined in Lisp). It is searched for at runtime, so it doesn't need to exist at the time the C library is compiled or loaded.

Be sure to pass dummy arguments (e.g. zero) if your function expects less than five arguments, to keep the C compiler happy.

This mechanism can generally be used for any type of argument and return value (not only long). On the C side, appropriate casts or an adapted prototype should be used. It is then up to the called Lisp function to prepare and/or extract the proper data with struct and memory management operations.

Function Pointer

This is a true callback mechanism. It uses the Lisp-level function lisp (not to confuse with the C-level function with the same name in the previous section). 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. Here, too, 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/select.html0000644000000000000000000004356313753712512011626 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" (see also "A Minimal Complete Application"). To get an interactive prompt, start it as 


$ pil app/main.l -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/httpGate.html0000644000000000000000000002116314006316726012116 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.

Building httpGate

httpGate is delivered in source code form with the picoLisp distribution. To build the program you need a c compiler and related header files. Development headers for OpenSSL are also needed. On Debian based systems, the prerequisites can be fulfilled by running apt-get install build-essential and apt-get install libssl-dev.

Next, go to the 'src' directory in the distribution and run make gate. When this is done, there should be an httpGate executable in the 'bin' directory.

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/microTemplates0000644000000000000000000000361114065067213012360 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