ISC56BABAX7OWLYZKYL2BR2EGLWEZ3AIBJA5KMSA3ID4WIRHF7TQC
(unless (== (val $OutFrames) (Ca: (env $OutFrames i8*)))
(loop
(popOutFiles)
(? (== (val $OutFrames) (Ca: (env $OutFrames i8*)))) ) )
(unless (== (val $InFrames) (Ca: (env $InFrames i8*)))
(loop
(popInFiles)
(? (== (val $InFrames) (Ca: (env $InFrames i8*)))) ) )
(until
(or
(== (val $OutFrames) (val $Stdout))
(== (val $OutFrames) (Ca: (env $OutFrames i8*))) )
(popOutFiles) )
(until
(or
(== (val $InFrames) (val $Stdin))
(== (val $InFrames) (Ca: (env $InFrames i8*))) )
(popInFiles) )
(unless (== (val $OutFrames) (val $Stdout))
(loop
(popOutFiles)
(? (== (val $OutFrames) (val $Stdout))) ) )
(unless (== (val $InFrames) (val $Stdin))
(loop
(popInFiles)
(? (== (val $InFrames) (val $Stdin))) ) )
(until (== (val $OutFrames) (val $Stdout))
(popOutFiles) )
(until (== (val $InFrames) (val $Stdin))
(popInFiles) )
(prog1
(run (cdr Exe))
(flush (val $OutFile))
(rlShow)
(set (i8** $Put) Put $OutFile Out) ) ) )
(run (cdr Exe))
(rlShow)
(popOutFiles) ) )
# (prompt 'any . prg) -> any
(de _Prompt (Exe)
(let (X (cdr Exe) Nm (xName (evSym X)))
(prog2
(set $LinePrmt (set $ContPrmt (bufString Nm (b8 (bufSize Nm)))))
(run (cdr X))
(set $LinePrmt (set $ContPrmt null)) ) ) )
(local) (uniChr testEsc anonymous rdAtom rdl rdList)
(de i32 uniChr ((i32 . Chr))
(when (and (>= Chr (char "0")) (>= (char "9") Chr))
(dec 'Chr (char "0"))
(until (== (call $Get) (char "\\"))
(unless
(and
(>= (val $Chr) (char "0"))
(>= (char "9") (val $Chr)) )
(badInput) )
(setq Chr
(+ (* Chr 10) (- (val $Chr) (char "0"))) ) ) )
Chr )
(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) ) )
(T (set $Chr (uniChr Chr))) )
(when
(or
(== B (char "\\"))
(strchr $Delim (i32 B)) )
(call $Put (char "\\")) ) # Escape backslash and delimiters
(call $Put B)
(if (or (== B 127) (> 32 B)) # DEL or Ctrl
(prog
(call $Put (char "\\")) # Unicode
(outWord (i64 B))
(call $Put (char "\\")) )
(when
(or
(== B (char "\\"))
(strchr $Delim (i32 B)) )
(call $Put (char "\\")) ) # Escape backslash and delimiters
(call $Put B) )
%54 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%54 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%55 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%55 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%56 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%56 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%57 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%57 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%59 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%59 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%64 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%64 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%69 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%69 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%74 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%74 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%1 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%1 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%14 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%14 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%10 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%10 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%15 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%15 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%20 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%20 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%25 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%25 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%6 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%6 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%12 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%12 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%29 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%29 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%57 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%57 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%23 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%23 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%64 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%64 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%72 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%72 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%77 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%77 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%82 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%82 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%87 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%87 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%92 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%92 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%128 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%128 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%129 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%129 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%158 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%158 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%51 = call i64 @cons(i64 %50, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%51 = call i64 @cons(i64 %50, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%113 = call i64 @cons(i64 %112, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%113 = call i64 @cons(i64 %112, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%119 = phi i64 [%51, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$31] ; # ->
%119 = phi i64 [%51, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$31] ; # ->
%126 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%119, %$20] ; # ->
%126 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%119, %$20] ; # ->
%129 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [%126, %$17] ; # ->
%129 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [%126, %$17] ; # ->
%0 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 64) to i32*)
; # (unless C (setq C (call $SvGet)))
%0 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 144) to i32*)
store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 64) to i32*)
br label %$14
$14:
%29 = phi i32 [%21, %$12], [%26, %$13] ; # C
br label %$11
$10:
%30 = phi i32 [%19, %$9] ; # C
store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 144) to i32*)
br label %$15
$15:
%28 = phi i32 [%20, %$13], [%25, %$14] ; # C
br label %$12
$11:
%29 = phi i32 [%18, %$10] ; # C
%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
%32 = load i32()*, i32()** @$SvGet
%33 = call i32 %32()
br label %$10
$12:
%34 = phi i32 [%28, %$15], [%29, %$11] ; # C
br label %$6
$6:
%35 = phi i32 [%4, %$4], [%34, %$12] ; # C
store i32()* @getChunked, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
store i32()* @getChunked, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%46 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%46 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
store void(i8)* @putChunked, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
store void(i8)* @putChunked, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%78 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%78 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
(de NIL runCo (Exe Tag (i8* . Src) (i8* . Dst) X)
(let (Src: (coroutine Src) Dst: (coroutine Dst))
(Dst: tag Tag)
(Dst: org (Src:))
(Dst: otg (Src: tag))
(Dst: prg X)
(let (Siz (val $StkSize) Stk (stack))
(memset
(Dst: lim (stack (ofs Dst (- Siz))))
7 (- Siz 256) T )
(stack Stk) )
(Dst: at 0)
(Dst: lnk (val $Link))
(set $Bind
(push (val $This) $This # [[This] This LINK]
(Dst: bnd (push ZERO $At (val $Bind) Exe)) ) ) # [0 @ LINK Expr]
(Dst: ca (val $Catch))
(Dst: in (val $InFrames))
(Dst: out (val $OutFrames))
(Dst: err (val $ErrFrames))
(Dst: ctl (val $CtlFrames))
(putCrtEnv (Dst:))
(set # Init local env
$Next $Nil
$Make 0
$Yoke 0
$Current (Dst:)
$StkLimit (+ (Dst: lim) 1024) )
(when (symb? Tag)
(put Tag ZERO (| (i64 (Dst:)) 2)) )
(set $Ret (run X))
(unless (== (hex "0707070707070707") (val (i64* (Dst: lim))))
(stkOverErr (Dst: tag)) )
(set $This (val -3 (Dst: bnd)))
(stop (Dst:)) # Stop coroutine
(let Org: (coroutine (Dst: org))
(unless (and (Org:) (== (Org: tag) (Dst: otg)))
(coErr Exe (Dst: otg)) )
(longjmp (Org: (rst)) 1) ) ) )
(if P
(stack P) # Use free slot
(stack ((coroutine Crt) lim)) # Found no free slot
(set $CrtLast
(setq P (b8+ (+ (val JmpBufSize) (coroutine T)))) )
((coroutine Crt) nxt P)
((coroutine P) nxt null) )
(let Dst: (coroutine P)
(Dst: tag Tag)
(Dst: org (Src:))
(Dst: otg (Src: tag))
(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))
(set $Bind
(push (val $This) $This # [[This] This LINK]
(Dst: bnd (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))
(putCrtEnv (Dst:) YES)
(set # Init local env
$Next $Nil
$Make 0
$Yoke 0
$Current (Dst:)
$StkLimit (+ (Dst: lim) 1024) )
(when (symb? Tag)
(put Tag ZERO (| (i64 (Dst:)) 2)) )
(set $Ret (run X))
(unless (== (hex "0707070707070707") (val (i64* (Dst: lim))))
(stkOverErr (Dst: tag)) )
(stop (Dst:)) # Stop coroutine
(let Org: (coroutine (Dst: org))
(unless (== (Org: tag) (Dst: otg))
(coErr Exe (Dst: otg)) )
(longjmp (Org: (rst)) 1) ) ) ) )
((t? Tag)
(err Exe 0 ($ "Can't stop main routine") null) )
(let P (val $CrtFree)
(if P
(set $CrtFree ((coroutine (stack P)) lim)) # Use free slot
(stack ((coroutine (setq Crt (val $CrtLast))) lim)) # Allocate new slot
(set $CrtLast
(setq P (b8+ (+ (val JmpBufSize) (coroutine T)))) )
((coroutine Crt) nxt P)
((coroutine P) nxt null) )
(runCo Exe Tag (Src:) P X) ) ) )
; # (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)
; # (let (P (push 0 (xName @) NIL) C (symChar P)) (while (> SNXBASE C...
; # (xName @)
%8 = call i64 @xName(i64 %4)
; # (push 0 (xName @) NIL)
%100 = phi i64 [%80, %$14], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
%100 = phi i64 [%80, %$14], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
%119 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%119 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%140 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%140 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%141 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%141 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%142 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%142 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%152 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%152 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%173 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%173 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%174 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%174 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%184 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%184 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%188 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%188 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%190 = phi i64 [%100, %$12], [%111, %$29], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$43] ; # ->
%190 = phi i64 [%100, %$12], [%111, %$29], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$43] ; # ->
(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) ) )
(let (N (* (shr (- TopA Acc) 3) 18) D (val TopA)) # Calculate length~1
(cond
(P # Build symbol
(when Sign
(byteSym (char "-") P) )
(while (setq D (/ D 10))
(inc 'N) )
(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))
(byteSym (char "0") P) ) )
(setq Scl (fmtScl (val TopA) Scl Sep Ign P)) # Pack highest word
(while (>= (dec 'TopA) Acc)
(let (N (val TopA) D 100000000000000000)
(loop
(cond
((=0 Scl) (byteSym Sep P))
((and Ign (gt0 Scl) (=0 (% Scl 3)))
(byteSym Ign P) ) )
(dec 'Scl)
(byteSym (+ (i8 (/ N D)) (char "0")) P)
(setq N (% N D))
(? (== 1 (setq D (/ D 10)))) )
(byteSym (+ (i8 N) (char "0")) P) ) )
0 )
((== Scl -1) # Calculate length
(cnt N) ) ) ) ) ) )
(cnt N) )
(T # Direct print
(when Sign
(call $Put (char "-")) ) # Output sign
(if (=0 Sep)
(outWord (val TopA)) # Output highest word
(while (setq D (/ D 10))
(inc 'N) )
(when (lt0 (setq Scl (- N Scl)))
(call $Put (char "0"))
(call $Put Sep)
(while (> -1 Scl)
(inc 'Scl)
(call $Put (char "0")) ) )
(setq Scl (outScl (val TopA) Scl Sep)) )
(while (>= (dec 'TopA) Acc)
(let (N (val TopA) D 100000000000000000)
(loop
(when (and Sep (=0 Scl))
(call $Put Sep) )
(dec 'Scl)
(call $Put (+ (i8 (/ N D)) (char "0"))) # Output next digit
(setq N (% N D))
(? (== 1 (setq D (/ D 10)))) )
(call $Put (+ (i8 N) (char "0"))) ) ) # Output last digit
0 ) ) ) ) ) )
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 40) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 40) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 48) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 40) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 40) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 48) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 64) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 88) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 40) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 64) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 88) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 40) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 852) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 852) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 96) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64)
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 96) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64)
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64),
i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
%3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%9 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%9 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
call void @put(i64 %3, i64 2, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
call void @put(i64 %3, i64 2, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%38 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 56) to i8**)
%38 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 56) to i8**)
%39 = icmp ne i8* %38, null
br i1 %39, label %$12, label %$11
$12:
%40 = phi i8* [%36, %$10] ; # Ca
%41 = phi i64 [%37, %$10] ; # Bnd
%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
%42 = getelementptr i8, i8* %7, i32 72
%43 = getelementptr i8, i8* %42, i32 56
%44 = bitcast i8* %43 to i8**
%45 = load i8*, i8** %44
; # (<> @ (Ca: (env $CtlFrames i8*)))
%46 = icmp ne i8* %38, %45
br label %$11
%44 = phi i8* [%36, %$10] ; # Ca
%45 = phi i64 [%37, %$10] ; # Bnd
%47 = phi i8* [%36, %$10], [%40, %$12] ; # Ca
%48 = phi i64 [%37, %$10], [%41, %$12] ; # Bnd
%49 = phi i1 [0, %$10], [%46, %$12] ; # ->
br i1 %49, label %$13, label %$14
$13:
%50 = phi i8* [%47, %$11] ; # Ca
%51 = phi i64 [%48, %$11] ; # Bnd
$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
$14:
%52 = phi i8* [%47, %$11] ; # Ca
%53 = phi i64 [%48, %$11] ; # Bnd
; # (while (and (val $ErrFrames) (<> @ (Ca: (env $ErrFrames i8*)))) (...
br label %$15
$15:
%54 = phi i8* [%52, %$14], [%68, %$18] ; # Ca
%55 = phi i64 [%53, %$14], [%69, %$18] ; # Bnd
; # (and (val $ErrFrames) (<> @ (Ca: (env $ErrFrames i8*))))
%50 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 48) to i8**)
%56 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 48) to i8**)
%57 = icmp ne i8* %56, null
br i1 %57, label %$17, label %$16
$17:
%58 = phi i8* [%54, %$15] ; # Ca
%59 = phi i64 [%55, %$15] ; # Bnd
%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
%60 = getelementptr i8, i8* %7, i32 72
%61 = getelementptr i8, i8* %60, i32 48
%62 = bitcast i8* %61 to i8**
%63 = load i8*, i8** %62
; # (<> @ (Ca: (env $ErrFrames i8*)))
%64 = icmp ne i8* %56, %63
br label %$16
$16:
%65 = phi i8* [%54, %$15], [%58, %$17] ; # Ca
%66 = phi i64 [%55, %$15], [%59, %$17] ; # Bnd
%67 = phi i1 [0, %$15], [%64, %$17] ; # ->
br i1 %67, label %$18, label %$19
$18:
%68 = phi i8* [%65, %$16] ; # Ca
%69 = phi i64 [%66, %$16] ; # Bnd
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...
br label %$15
$19:
%70 = phi i8* [%65, %$16] ; # Ca
%71 = phi i64 [%66, %$16] ; # Bnd
; # (until (or (== (val $OutFrames) (val $Stdout)) (== (val $OutFrame...
br label %$20
$20:
%72 = phi i8* [%70, %$19], [%88, %$23] ; # Ca
%73 = phi i64 [%71, %$19], [%89, %$23] ; # Bnd
; # (or (== (val $OutFrames) (val $Stdout)) (== (val $OutFrames) (Ca:...
%60 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 40) to i8**)
%74 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 40) to i8**)
; # (val $Stdout)
%75 = load i8*, i8** @$Stdout
; # (== (val $OutFrames) (val $Stdout))
%76 = icmp eq i8* %74, %75
br i1 %76, label %$21, label %$22
$22:
%77 = phi i8* [%72, %$20] ; # Ca
%78 = phi i64 [%73, %$20] ; # Bnd
; # (val $OutFrames)
%79 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 40) to 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
%80 = getelementptr i8, i8* %7, i32 72
%81 = getelementptr i8, i8* %80, i32 40
%82 = bitcast i8* %81 to i8**
%83 = load i8*, i8** %82
%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
%84 = icmp eq i8* %79, %83
br label %$21
$21:
%85 = phi i8* [%72, %$20], [%77, %$22] ; # Ca
%86 = phi i64 [%73, %$20], [%78, %$22] ; # Bnd
%87 = phi i1 [1, %$20], [%84, %$22] ; # ->
br i1 %87, label %$24, label %$23
$23:
%88 = phi i8* [%85, %$21] ; # Ca
%89 = phi i64 [%86, %$21] ; # Bnd
; # (? (== (val $OutFrames) (Ca: (env $OutFrames i8*))))
; # (val $OutFrames)
%70 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 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] ; # ->
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...
br label %$20
$24:
%90 = phi i8* [%85, %$21] ; # Ca
%91 = phi i64 [%86, %$21] ; # Bnd
; # (until (or (== (val $InFrames) (val $Stdin)) (== (val $InFrames) ...
br label %$25
$25:
%92 = phi i8* [%90, %$24], [%108, %$28] ; # Ca
%93 = phi i64 [%91, %$24], [%109, %$28] ; # Bnd
; # (or (== (val $InFrames) (val $Stdin)) (== (val $InFrames) (Ca: (e...
%83 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 32) to i8**)
%94 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 32) to i8**)
; # (val $Stdin)
%95 = load i8*, i8** @$Stdin
; # (== (val $InFrames) (val $Stdin))
%96 = icmp eq i8* %94, %95
br i1 %96, label %$26, label %$27
$27:
%97 = phi i8* [%92, %$25] ; # Ca
%98 = phi i64 [%93, %$25] ; # Bnd
; # (val $InFrames)
%99 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 32) to 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
%100 = getelementptr i8, i8* %7, i32 72
%101 = getelementptr i8, i8* %100, i32 32
%102 = bitcast i8* %101 to i8**
%103 = load i8*, i8** %102
%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
%104 = icmp eq i8* %99, %103
br label %$26
$26:
%105 = phi i8* [%92, %$25], [%97, %$27] ; # Ca
%106 = phi i64 [%93, %$25], [%98, %$27] ; # Bnd
%107 = phi i1 [1, %$25], [%104, %$27] ; # ->
br i1 %107, label %$29, label %$28
$28:
%108 = phi i8* [%105, %$26] ; # Ca
%109 = phi i64 [%106, %$26] ; # Bnd
; # (? (== (val $InFrames) (Ca: (env $InFrames i8*))))
; # (val $InFrames)
%93 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 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] ; # ->
br label %$22
$22:
%104 = phi i8* [%81, %$17], [%101, %$25] ; # Ca
%105 = phi i64 [%82, %$17], [%102, %$25] ; # Bnd
br label %$25
$29:
%110 = phi i8* [%105, %$26] ; # Ca
%111 = phi i64 [%106, %$26] ; # Bnd
%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
%116 = icmp ne i8* %115, null
br i1 %116, label %$31, label %$30
$30:
%117 = phi i8* [%110, %$29] ; # Ca
%118 = phi i64 [%111, %$29] ; # Bnd
%119 = phi i8* [%115, %$29] ; # Dst
%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
%120 = load i8*, i8** @$Coroutines
br label %$31
$31:
%121 = phi i8* [%110, %$29], [%117, %$30] ; # Ca
%122 = phi i64 [%111, %$29], [%118, %$30] ; # Bnd
%123 = phi i8* [%115, %$29], [%120, %$30] ; # Dst
%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
%124 = icmp eq i8* %112, %123
br i1 %124, label %$33, label %$32
$32:
%125 = phi i8* [%121, %$31] ; # Ca
%126 = phi i64 [%122, %$31] ; # Bnd
%127 = phi i8* [%123, %$31] ; # Dst
store i8* %121, i8** @$Current
; # (Crt:)
; # (getCrtEnv (Crt:))
%122 = getelementptr i8, i8* %121, i32 280
%123 = ptrtoint i8* %122 to i64
%124 = inttoptr i64 %123 to i64*
%125 = load i64, i64* %124
%126 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
store i64 %125, i64* %126
%127 = getelementptr i8, i8* %121, i32 288
%128 = ptrtoint i8* %127 to i64
%129 = inttoptr i64 %128 to i64*
%130 = load i64, i64* %129
%131 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
store i64 %130, i64* %131
%132 = getelementptr i8, i8* %121, i32 296
store i8* %127, i8** @$Current
; # (set $StkLimit (+ (Crt: lim) 1024))
; # (Crt: lim)
%128 = getelementptr i8, i8* %127, i32 40
%129 = bitcast i8* %128 to i8**
%130 = load i8*, i8** %129
; # (+ (Crt: lim) 1024)
%131 = getelementptr i8, i8* %130, i32 1024
store i8* %131, i8** @$StkLimit
; # (set $At (Crt: at))
; # (Crt: at)
%132 = getelementptr i8, i8* %127, i32 48
%136 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
%137 = getelementptr i64, i64* %136, i32 1
store i64 %135, i64* %137
%138 = getelementptr i8, i8* %121, i32 304
%139 = ptrtoint i8* %138 to i64
%140 = inttoptr i64 %139 to i64*
%141 = load i64, i64* %140
%142 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
store i64 %141, i64* %142
%143 = getelementptr i8, i8* %121, i32 312
%144 = ptrtoint i8* %143 to i64
%145 = inttoptr i64 %144 to i64*
%146 = load i64, i64* %145
%147 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%148 = getelementptr i64, i64* %147, i32 1
store i64 %146, i64* %148
; # (set $At (Crt: at))
; # (Crt: at)
%149 = getelementptr i8, i8* %121, i32 48
%150 = ptrtoint i8* %149 to i64
%151 = inttoptr i64 %150 to i64*
%152 = load i64, i64* %151
%153 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
store i64 %152, i64* %153
br label %$29
$29:
%154 = phi i8* [%115, %$27], [%119, %$28] ; # Ca
%155 = phi i64 [%116, %$27], [%120, %$28] ; # Bnd
%156 = phi i8* [%117, %$27], [%121, %$28] ; # Dst
%136 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
store i64 %135, i64* %136
; # (Crt: at 0)
%137 = getelementptr i8, i8* %127, i32 48
%138 = ptrtoint i8* %137 to i64
%139 = inttoptr i64 %138 to i64*
store i64 0, i64* %139
br label %$33
$33:
%140 = phi i8* [%121, %$31], [%125, %$32] ; # Ca
%141 = phi i64 [%122, %$31], [%126, %$32] ; # Bnd
%142 = phi i8* [%123, %$31], [%127, %$32] ; # Dst
%157 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i8*
%158 = getelementptr i8, i8* %7, i32 32
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %157, i8* %158, i64 168, i1 0)
%159 = getelementptr i8, i8* %7, i32 200
%160 = ptrtoint i8* %159 to i64
%161 = inttoptr i64 %160 to i64*
%162 = load i64, i64* %161
%163 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
store i64 %162, i64* %163
%164 = getelementptr i8, i8* %7, i32 208
%165 = ptrtoint i8* %164 to i64
%166 = inttoptr i64 %165 to i64*
%167 = load i64, i64* %166
%168 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
store i64 %167, i64* %168
%169 = getelementptr i8, i8* %7, i32 216
%170 = ptrtoint i8* %169 to i64
%171 = inttoptr i64 %170 to i64*
%172 = load i64, i64* %171
%173 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
%174 = getelementptr i64, i64* %173, i32 1
store i64 %172, i64* %174
%175 = getelementptr i8, i8* %7, i32 224
%176 = ptrtoint i8* %175 to i64
%177 = inttoptr i64 %176 to i64*
%178 = load i64, i64* %177
%179 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
store i64 %178, i64* %179
%180 = getelementptr i8, i8* %7, i32 232
%181 = ptrtoint i8* %180 to i64
%182 = inttoptr i64 %181 to i64*
%183 = load i64, i64* %182
%184 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%185 = getelementptr i64, i64* %184, i32 1
store i64 %183, i64* %185
%143 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i8*
%144 = getelementptr i8, i8* %7, i32 72
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %143, i8* %144, i64 176, i1 0)
%145 = getelementptr i8, i8* %7, i32 32
%146 = ptrtoint i8* %145 to i64
%147 = inttoptr i64 %146 to i64*
%148 = load i64, i64* %147
%149 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
store i64 %148, i64* %149
%150 = getelementptr i8, i8* %7, i32 40
%151 = ptrtoint i8* %150 to i64
%152 = inttoptr i64 %151 to i64*
%153 = load i64, i64* %152
%154 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
store i64 %153, i64* %154
%155 = getelementptr i8, i8* %7, i32 48
%156 = ptrtoint i8* %155 to i64
%157 = inttoptr i64 %156 to i64*
%158 = load i64, i64* %157
%159 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
%160 = getelementptr i64, i64* %159, i32 1
store i64 %158, i64* %160
%161 = getelementptr i8, i8* %7, i32 56
%162 = ptrtoint i8* %161 to i64
%163 = inttoptr i64 %162 to i64*
%164 = load i64, i64* %163
%165 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
store i64 %164, i64* %165
%166 = getelementptr i8, i8* %7, i32 64
%167 = ptrtoint i8* %166 to i64
%168 = inttoptr i64 %167 to i64*
%169 = load i64, i64* %168
%170 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%171 = getelementptr i64, i64* %170, i32 1
store i64 %169, i64* %171
%186 = getelementptr i8, i8* %7, i32 16
%187 = ptrtoint i8* %186 to i64
%188 = inttoptr i64 %187 to i64*
%189 = load i64, i64* %188
%172 = getelementptr i8, i8* %7, i32 16
%173 = ptrtoint i8* %172 to i64
%174 = inttoptr i64 %173 to i64*
%175 = load i64, i64* %174
%190 = and i64 %189, 6
%191 = icmp ne i64 %190, 0
br i1 %191, label %$32, label %$31
$32:
br label %$30
$31:
%192 = and i64 %189, 8
%193 = icmp ne i64 %192, 0
br i1 %193, label %$34, label %$33
%176 = and i64 %175, 6
%177 = icmp ne i64 %176, 0
br i1 %177, label %$36, label %$35
$36:
br label %$34
$35:
%178 = and i64 %175, 8
%179 = icmp ne i64 %178, 0
br i1 %179, label %$38, label %$37
$38:
%180 = inttoptr i64 %175 to i64*
%181 = load i64, i64* %180
br label %$34
$37:
%182 = call i64 @evList(i64 %175)
br label %$34
%194 = inttoptr i64 %189 to i64*
%195 = load i64, i64* %194
br label %$30
$33:
%196 = call i64 @evList(i64 %189)
br label %$30
$30:
%197 = phi i64 [%189, %$32], [%195, %$34], [%196, %$33] ; # ->
%183 = phi i64 [%175, %$36], [%181, %$38], [%182, %$37] ; # ->
%198 = bitcast i8* %7 to i8**
%199 = load i8*, i8** %198
store i8* %199, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 24) to i8**)
%184 = bitcast i8* %7 to i8**
%185 = load i8*, i8** %184
store i8* %185, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 24) to i8**)
%200 = icmp eq i8* %154, %0
br i1 %200, label %$35, label %$36
$35:
%201 = phi i8* [%154, %$30] ; # Ca
%202 = phi i64 [%155, %$30] ; # Bnd
%186 = icmp eq i8* %140, %0
br i1 %186, label %$39, label %$40
$39:
%187 = phi i8* [%140, %$34] ; # Ca
%188 = phi i64 [%141, %$34] ; # Bnd
br label %$37
$37:
%209 = phi i8* [%207, %$4], [%212, %$38] ; # Ca
%210 = phi i64 [%208, %$4], [%222, %$38] ; # Bnd
%211 = icmp ne i64 %210, 0
br i1 %211, label %$38, label %$39
$38:
%212 = phi i8* [%209, %$37] ; # Ca
%213 = phi i64 [%210, %$37] ; # Bnd
br label %$41
$41:
%195 = phi i8* [%193, %$4], [%198, %$42] ; # Ca
%196 = phi i64 [%194, %$4], [%208, %$42] ; # Bnd
%197 = icmp ne i64 %196, 0
br i1 %197, label %$42, label %$43
$42:
%198 = phi i8* [%195, %$41] ; # Ca
%199 = phi i64 [%196, %$41] ; # Bnd
%220 = inttoptr i64 %213 to i64*
%221 = getelementptr i64, i64* %220, i32 2
%222 = load i64, i64* %221
br label %$37
$39:
%223 = phi i8* [%209, %$37] ; # Ca
%224 = phi i64 [%210, %$37] ; # Bnd
%206 = inttoptr i64 %199 to i64*
%207 = getelementptr i64, i64* %206, i32 2
%208 = load i64, i64* %207
br label %$41
$43:
%209 = phi i8* [%195, %$41] ; # Ca
%210 = phi i64 [%196, %$41] ; # Bnd
%225 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 8) to i64) to i64*
store i64 0, i64* %225
%211 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 8) to i64) to i64*
store i64 0, i64* %211
%228 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 56) to i8**)
%229 = icmp ne i8* %228, null
br i1 %229, label %$41, label %$42
$41:
%230 = phi i8* [%226, %$40] ; # Ca
%231 = phi i64 [%227, %$40] ; # Bnd
%214 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 56) to i8**)
%215 = icmp ne i8* %214, null
br i1 %215, label %$45, label %$46
$45:
%216 = phi i8* [%212, %$44] ; # Ca
%217 = phi i64 [%213, %$44] ; # Bnd
%236 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 48) to i8**)
%237 = icmp ne i8* %236, null
br i1 %237, label %$44, label %$45
$44:
%238 = phi i8* [%234, %$43] ; # Ca
%239 = phi i64 [%235, %$43] ; # Bnd
%222 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 48) to i8**)
%223 = icmp ne i8* %222, null
br i1 %223, label %$48, label %$49
$48:
%224 = phi i8* [%220, %$47] ; # Ca
%225 = phi i64 [%221, %$47] ; # Bnd
br label %$43
$45:
%240 = phi i8* [%234, %$43] ; # Ca
%241 = phi i64 [%235, %$43] ; # Bnd
; # (unless (== (val $OutFrames) (val $Stdout)) (loop (popOutFiles) (...
br label %$47
$49:
%226 = phi i8* [%220, %$47] ; # Ca
%227 = phi i64 [%221, %$47] ; # Bnd
; # (until (== (val $OutFrames) (val $Stdout)) (popOutFiles))
br label %$50
$50:
%228 = phi i8* [%226, %$49], [%233, %$51] ; # Ca
%229 = phi i64 [%227, %$49], [%234, %$51] ; # Bnd
%244 = icmp eq i8* %242, %243
br i1 %244, label %$47, label %$46
$46:
%245 = phi i8* [%240, %$45] ; # Ca
%246 = phi i64 [%241, %$45] ; # Bnd
; # (loop (popOutFiles) (? (== (val $OutFrames) (val $Stdout))))
br label %$48
$48:
%247 = phi i8* [%245, %$46], [%252, %$49] ; # Ca
%248 = phi i64 [%246, %$46], [%253, %$49] ; # Bnd
%232 = icmp eq i8* %230, %231
br i1 %232, label %$52, label %$51
$51:
%233 = phi i8* [%228, %$50] ; # Ca
%234 = phi i64 [%229, %$50] ; # Bnd
; # (? (== (val $OutFrames) (val $Stdout)))
; # (val $OutFrames)
%249 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 40) to i8**)
; # (val $Stdout)
%250 = load i8*, i8** @$Stdout
; # (== (val $OutFrames) (val $Stdout))
%251 = icmp eq i8* %249, %250
br i1 %251, label %$50, label %$49
$49:
%252 = phi i8* [%247, %$48] ; # Ca
%253 = phi i64 [%248, %$48] ; # Bnd
br label %$48
$50:
%254 = phi i8* [%247, %$48] ; # Ca
%255 = phi i64 [%248, %$48] ; # Bnd
%256 = phi i64 [0, %$48] ; # ->
br label %$47
$47:
%257 = phi i8* [%240, %$45], [%254, %$50] ; # Ca
%258 = phi i64 [%241, %$45], [%255, %$50] ; # Bnd
; # (unless (== (val $InFrames) (val $Stdin)) (loop (popInFiles) (? (...
; # (val $InFrames)
%259 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 32) to i8**)
; # (val $Stdin)
%260 = load i8*, i8** @$Stdin
; # (== (val $InFrames) (val $Stdin))
%261 = icmp eq i8* %259, %260
br i1 %261, label %$52, label %$51
$51:
%262 = phi i8* [%257, %$47] ; # Ca
%263 = phi i64 [%258, %$47] ; # Bnd
; # (loop (popInFiles) (? (== (val $InFrames) (val $Stdin))))
br label %$50
$52:
%235 = phi i8* [%228, %$50] ; # Ca
%236 = phi i64 [%229, %$50] ; # Bnd
; # (until (== (val $InFrames) (val $Stdin)) (popInFiles))
%264 = phi i8* [%262, %$51], [%269, %$54] ; # Ca
%265 = phi i64 [%263, %$51], [%270, %$54] ; # Bnd
; # (popInFiles)
call void @popInFiles()
; # (? (== (val $InFrames) (val $Stdin)))
%237 = phi i8* [%235, %$52], [%242, %$54] ; # Ca
%238 = phi i64 [%236, %$52], [%243, %$54] ; # Bnd
%271 = phi i8* [%264, %$53] ; # Ca
%272 = phi i64 [%265, %$53] ; # Bnd
%273 = phi i64 [0, %$53] ; # ->
br label %$52
$52:
%274 = phi i8* [%257, %$47], [%271, %$55] ; # Ca
%275 = phi i64 [%258, %$47], [%272, %$55] ; # Bnd
%244 = phi i8* [%237, %$53] ; # Ca
%245 = phi i64 [%238, %$53] ; # Bnd
store i8* %277, i8** @$Current
store i8* %247, i8** @$Current
; # (set $StkLimit (+ (Crt: lim) 1024))
; # (Crt: lim)
%251 = getelementptr i8, i8* %247, i32 40
%252 = bitcast i8* %251 to i8**
%253 = load i8*, i8** %252
; # (+ (Crt: lim) 1024)
%254 = getelementptr i8, i8* %253, i32 1024
store i8* %254, i8** @$StkLimit
%281 = getelementptr i8, i8* %277, i32 280
%282 = ptrtoint i8* %281 to i64
%283 = inttoptr i64 %282 to i64*
%284 = load i64, i64* %283
%285 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
store i64 %284, i64* %285
%286 = getelementptr i8, i8* %277, i32 288
%287 = ptrtoint i8* %286 to i64
%288 = inttoptr i64 %287 to i64*
%289 = load i64, i64* %288
%290 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
store i64 %289, i64* %290
%291 = getelementptr i8, i8* %277, i32 296
%292 = ptrtoint i8* %291 to i64
%293 = inttoptr i64 %292 to i64*
%294 = load i64, i64* %293
%295 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
%296 = getelementptr i64, i64* %295, i32 1
store i64 %294, i64* %296
%297 = getelementptr i8, i8* %277, i32 304
%298 = ptrtoint i8* %297 to i64
%299 = inttoptr i64 %298 to i64*
%300 = load i64, i64* %299
%301 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
store i64 %300, i64* %301
%302 = getelementptr i8, i8* %277, i32 312
%303 = ptrtoint i8* %302 to i64
%304 = inttoptr i64 %303 to i64*
%305 = load i64, i64* %304
%306 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%307 = getelementptr i64, i64* %306, i32 1
store i64 %305, i64* %307
%255 = getelementptr i8, i8* %247, i32 112
%256 = ptrtoint i8* %255 to i64
%257 = inttoptr i64 %256 to i64*
%258 = load i64, i64* %257
%259 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
store i64 %258, i64* %259
%260 = getelementptr i8, i8* %247, i32 120
%261 = ptrtoint i8* %260 to i64
%262 = inttoptr i64 %261 to i64*
%263 = load i64, i64* %262
%264 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
store i64 %263, i64* %264
%265 = getelementptr i8, i8* %247, i32 128
%266 = ptrtoint i8* %265 to i64
%267 = inttoptr i64 %266 to i64*
%268 = load i64, i64* %267
%269 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
%270 = getelementptr i64, i64* %269, i32 1
store i64 %268, i64* %270
%271 = getelementptr i8, i8* %247, i32 136
%272 = ptrtoint i8* %271 to i64
%273 = inttoptr i64 %272 to i64*
%274 = load i64, i64* %273
%275 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
store i64 %274, i64* %275
%276 = getelementptr i8, i8* %247, i32 144
%277 = ptrtoint i8* %276 to i64
%278 = inttoptr i64 %277 to i64*
%279 = load i64, i64* %278
%280 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%281 = getelementptr i64, i64* %280, i32 1
store i64 %279, i64* %281
%308 = getelementptr i8, i8* %277, i32 48
%309 = ptrtoint i8* %308 to i64
%310 = inttoptr i64 %309 to i64*
%311 = load i64, i64* %310
%312 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
store i64 %311, i64* %312
%282 = getelementptr i8, i8* %247, i32 48
%283 = ptrtoint i8* %282 to i64
%284 = inttoptr i64 %283 to i64*
%285 = load i64, i64* %284
%286 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
store i64 %285, i64* %286
; # (Crt: at 0)
%287 = getelementptr i8, i8* %247, i32 48
%288 = ptrtoint i8* %287 to i64
%289 = inttoptr i64 %288 to i64*
store i64 0, i64* %289
; # (when (nil? (val $PPid)) (flushAll))
; # (val $PPid)
%19 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 216) to i64) to i64*
%20 = load i64, i64* %19
; # (nil? (val $PPid))
%21 = icmp eq i64 %20, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
br i1 %21, label %$9, label %$10
$9:
%72 = phi i64 [%0, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%72 = phi i64 [%0, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%5 = phi i64 [%0, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 728) to i64) to i64*
%5 = phi i64 [%0, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%6 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 728) to i64) to i64*
%83 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%83 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%86 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%86 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%91 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%91 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%116 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$7 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%116 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$7 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 152) to i32*)
%120 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 112) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %120
%121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 136) to i64) to i64*
store i32 0, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 152) to i32*)
%120 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 104) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %120
%121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 128) to i64) to i64*
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
store i32()* @_getStdin, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
store i32()* @_getStdin, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%2 = icmp eq i64 %1, ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64)
br i1 %2, label %$4, label %$3
%1 = icmp eq i64 %0, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
br i1 %1, label %$4, label %$3
%11 = ptrtoint i64* %10 to i64
%12 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
%13 = load i64, i64* %12
%14 = inttoptr i64 %11 to i64*
%15 = getelementptr i64, i64* %14, i32 1
store i64 %13, i64* %15
%16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %11, i64* %16
%10 = ptrtoint i64* %9 to i64
%11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
%12 = load i64, i64* %11
%13 = inttoptr i64 %10 to i64*
%14 = getelementptr i64, i64* %13, i32 1
store i64 %12, i64* %14
%15 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %10, i64* %15
%18 = phi i64 [%17, %$6], [%24, %$8] ; # Tail
%19 = and i64 %18, 6
%20 = icmp ne i64 %19, 0
br i1 %20, label %$9, label %$8
%17 = phi i64 [%16, %$6], [%23, %$8] ; # Tail
%18 = and i64 %17, 6
%19 = icmp ne i64 %18, 0
br i1 %19, label %$9, label %$8
%21 = phi i64 [%18, %$7] ; # Tail
%22 = inttoptr i64 %21 to i64*
%23 = getelementptr i64, i64* %22, i32 1
%24 = load i64, i64* %23
%20 = phi i64 [%17, %$7] ; # Tail
%21 = inttoptr i64 %20 to i64*
%22 = getelementptr i64, i64* %21, i32 1
%23 = load i64, i64* %22
%28 = inttoptr i64 %11 to i64*
%29 = getelementptr i64, i64* %28, i32 1
%30 = load i64, i64* %29
%31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %30, i64* %31
%27 = inttoptr i64 %10 to i64*
%28 = getelementptr i64, i64* %27, i32 1
%29 = load i64, i64* %28
%30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %29, i64* %30
%32 = phi i64 [%5, %$5], [%38, %$11] ; # Tail
%33 = and i64 %32, 6
%34 = icmp ne i64 %33, 0
br i1 %34, label %$12, label %$11
%31 = phi i64 [%4, %$5], [%37, %$11] ; # Tail
%32 = and i64 %31, 6
%33 = icmp ne i64 %32, 0
br i1 %33, label %$12, label %$11
%35 = phi i64 [%32, %$10] ; # Tail
%36 = inttoptr i64 %35 to i64*
%37 = getelementptr i64, i64* %36, i32 1
%38 = load i64, i64* %37
%34 = phi i64 [%31, %$10] ; # Tail
%35 = inttoptr i64 %34 to i64*
%36 = getelementptr i64, i64* %35, i32 1
%37 = load i64, i64* %36
%154 = phi i64 [0, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$19], [0, %$21], [0, %$23], [%151, %$26] ; # ->
%154 = phi i64 [0, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$19], [0, %$21], [0, %$23], [%151, %$26] ; # ->
; # (let (Out (val $OutFile) Put (val (i8** $Put))) (set $OutFile (va...
; # (val $OutFile)
%1 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 80) to i8**)
; # (i8** $Put)
%2 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
; # (val (i8** $Put))
%3 = load i8*, i8** %2
; # (set $OutFile (val 3 (val $OutFiles)) $Put (fun (void i8) _putStd...
; # (b8+ (ioFrame T))
%1 = alloca i8, i64 28, align 8
%5 = getelementptr i8*, i8** %4, i32 2
%6 = load i8*, i8** %5
store i8* %6, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 80) to i8**)
; # (fun (void i8) _putStdout)
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%3 = getelementptr i8*, i8** %2, i32 2
%4 = load i8*, i8** %3
; # (pushOutFile (b8+ (ioFrame T)) (val 3 (val $OutFiles)) 0)
call void @pushOutFile(i8* %1, i8* %4, i32 0)
; # (prog2 (rlHide) (run (cdr Exe)) (rlShow) (popOutFiles))
%34 = phi i64 [%17, %$6] ; # Prg
%35 = phi i64 [%25, %$6] ; # ->
; # (val $OutFile)
%36 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 80) to i8**)
; # (flush (val $OutFile))
%37 = call i1 @flush(i8* %36)
%32 = phi i64 [%15, %$6] ; # Prg
%33 = phi i64 [%23, %$6] ; # ->
; # (set (i8** $Put) Put $OutFile Out)
; # (i8** $Put)
%38 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
store i8* %3, i8** %38
store i8* %1, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 80) to i8**)
ret i64 %35
; # (popOutFiles)
call void @popOutFiles()
ret i64 %33
}
define i64 @_Prompt(i64) align 8 {
$1:
; # (let (X (cdr Exe) Nm (xName (evSym X))) (prog2 (set $LinePrmt (se...
; # (cdr Exe)
%1 = inttoptr i64 %0 to i64*
%2 = getelementptr i64, i64* %1, i32 1
%3 = load i64, i64* %2
; # (evSym X)
%4 = call i64 @evSym(i64 %3)
; # (xName (evSym X))
%5 = call i64 @xName(i64 %4)
; # (prog2 (set $LinePrmt (set $ContPrmt (bufString Nm (b8 (bufSize N...
; # (set $LinePrmt (set $ContPrmt (bufString Nm (b8 (bufSize Nm)))))
; # (set $ContPrmt (bufString Nm (b8 (bufSize Nm))))
; # (bufSize Nm)
%6 = call i64 @bufSize(i64 %5)
; # (b8 (bufSize Nm))
%7 = alloca i8, i64 %6
; # (bufString Nm (b8 (bufSize Nm)))
%8 = call i8* @bufString(i64 %5, i8* %7)
store i8* %8, i8** @$ContPrmt
store i8* %8, i8** @$LinePrmt
; # (cdr X)
%9 = inttoptr i64 %3 to i64*
%10 = getelementptr i64, i64* %9, i32 1
%11 = load i64, i64* %10
; # (run (cdr X))
br label %$2
$2:
%12 = phi i64 [%11, %$1], [%34, %$11] ; # Prg
%13 = inttoptr i64 %12 to i64*
%14 = load i64, i64* %13
%15 = getelementptr i64, i64* %13, i32 1
%16 = load i64, i64* %15
%17 = and i64 %16, 15
%18 = icmp ne i64 %17, 0
br i1 %18, label %$5, label %$3
$5:
%19 = phi i64 [%16, %$2] ; # Prg
%20 = and i64 %14, 6
%21 = icmp ne i64 %20, 0
br i1 %21, label %$8, label %$7
$8:
br label %$6
$7:
%22 = and i64 %14, 8
%23 = icmp ne i64 %22, 0
br i1 %23, label %$10, label %$9
$10:
%24 = inttoptr i64 %14 to i64*
%25 = load i64, i64* %24
br label %$6
$9:
%26 = call i64 @evList(i64 %14)
br label %$6
$6:
%27 = phi i64 [%14, %$8], [%25, %$10], [%26, %$9] ; # ->
br label %$4
$3:
%28 = phi i64 [%16, %$2] ; # Prg
%29 = and i64 %14, 15
%30 = icmp eq i64 %29, 0
br i1 %30, label %$12, label %$11
$12:
%31 = phi i64 [%28, %$3] ; # Prg
%32 = call i64 @evList(i64 %14)
%33 = icmp ne i64 %32, 0
br label %$11
$11:
%34 = phi i64 [%28, %$3], [%31, %$12] ; # Prg
%35 = phi i1 [0, %$3], [%33, %$12] ; # ->
br label %$2
$4:
%36 = phi i64 [%19, %$6] ; # Prg
%37 = phi i64 [%27, %$6] ; # ->
; # (set $LinePrmt (set $ContPrmt null))
; # (set $ContPrmt null)
store i8* null, i8** @$ContPrmt
store i8* null, i8** @$LinePrmt
ret i64 %37
%8 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$6] ; # ->
%8 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$6] ; # ->
%5 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%20, %$6] ; # X
%5 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%20, %$6] ; # X
%43 = phi i64 [%42, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$16] ; # ->
%43 = phi i64 [%42, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$16] ; # ->
%15 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%15 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%120 = call i64 @cons(i64 %119, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%120 = call i64 @cons(i64 %119, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%125 = phi i64 [%69, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$20], [%122, %$23] ; # ->
%125 = phi i64 [%69, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$20], [%122, %$23] ; # ->
%30 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%28, %$13] ; # ->
%30 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%28, %$13] ; # ->
%103 = call i64 @cons(i64 %102, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%103 = call i64 @cons(i64 %102, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%108 = phi i64 [%84, %$27], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$29], [%105, %$28] ; # ->
%108 = phi i64 [%84, %$27], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$29], [%105, %$28] ; # ->
; # (let (Nm (xName 0 Sym) S (bufString Nm (b8 (bufSize Nm))) P (strc...
; # (xName 0 Sym)
%1 = call i64 @xName(i64 0, i64 %0)
; # (let (Nm (xName Sym) S (bufString Nm (b8 (bufSize Nm))) P (strchr...
; # (xName Sym)
%1 = call i64 @xName(i64 %0)
%0 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %0
%0 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %0
%133 = icmp ne i64 %132, 0
br i1 %133, label %$30, label %$31
; # (mark (Crt: prg))
call void @mark(i64 %132)
; # (when (Crt: at) (mark (Crt: at)) (mark (Crt: intrn)) (mark (Crt: ...
; # (Crt: at)
%133 = getelementptr i8, i8* %116, i32 48
%134 = ptrtoint i8* %133 to i64
%135 = inttoptr i64 %134 to i64*
%136 = load i64, i64* %135
%137 = icmp ne i64 %136, 0
br i1 %137, label %$30, label %$31
%135 = getelementptr i8, i8* %116, i32 48
%136 = ptrtoint i8* %135 to i64
%137 = inttoptr i64 %136 to i64*
%138 = load i64, i64* %137
; # (mark (Crt: at))
call void @mark(i64 %138)
; # (Crt: intrn)
%139 = getelementptr i8, i8* %116, i32 280
%139 = getelementptr i8, i8* %116, i32 48
; # (mark (Crt: priv2))
call void @mark(i64 %162)
; # (let P (Crt: (env $Link any)) (while P (mark (val P)) (shift P)))...
; # (Crt: (env $Link any))
%163 = getelementptr i8, i8* %116, i32 152
%164 = ptrtoint i8* %163 to i64
%165 = inttoptr i64 %164 to i64*
%166 = load i64, i64* %165
%163 = phi i8* [%134, %$30], [%166, %$33] ; # Crt
%164 = phi i64 [%162, %$30], [%172, %$33] ; # P
%165 = icmp ne i64 %164, 0
br i1 %165, label %$33, label %$34
%167 = phi i8* [%138, %$30], [%170, %$33] ; # Crt
%168 = phi i64 [%166, %$30], [%176, %$33] ; # P
%169 = icmp ne i64 %168, 0
br i1 %169, label %$33, label %$34
%175 = getelementptr i8, i8* %116, i32 112
%176 = getelementptr i8, i8* %175, i32 8
%177 = ptrtoint i8* %176 to i64
%178 = inttoptr i64 %177 to i64*
%179 = load i64, i64* %178
%179 = getelementptr i8, i8* %116, i32 152
%180 = getelementptr i8, i8* %179, i32 8
%181 = ptrtoint i8* %180 to i64
%182 = inttoptr i64 %181 to i64*
%183 = load i64, i64* %182
%180 = phi i8* [%173, %$34], [%183, %$36] ; # Crt
%181 = phi i64 [%179, %$34], [%192, %$36] ; # P
%182 = icmp ne i64 %181, 0
br i1 %182, label %$36, label %$37
%184 = phi i8* [%177, %$34], [%187, %$36] ; # Crt
%185 = phi i64 [%183, %$34], [%196, %$36] ; # P
%186 = icmp ne i64 %185, 0
br i1 %186, label %$36, label %$37
%195 = getelementptr i8, i8* %116, i32 112
%196 = getelementptr i8, i8* %195, i32 24
%197 = bitcast i8* %196 to i8**
%198 = load i8*, i8** %197
%199 = getelementptr i8, i8* %116, i32 152
%200 = getelementptr i8, i8* %199, i32 24
%201 = bitcast i8* %200 to i8**
%202 = load i8*, i8** %201
%199 = phi i8* [%193, %$37], [%215, %$42] ; # Crt
%200 = phi i8* [%198, %$37], [%242, %$42] ; # Ca
%201 = icmp ne i8* %200, null
br i1 %201, label %$39, label %$40
%203 = phi i8* [%197, %$37], [%219, %$42] ; # Crt
%204 = phi i8* [%202, %$37], [%246, %$42] ; # Ca
%205 = icmp ne i8* %204, null
br i1 %205, label %$39, label %$40
%204 = getelementptr i8, i8* %203, i32 8
%205 = ptrtoint i8* %204 to i64
%206 = inttoptr i64 %205 to i64*
%207 = load i64, i64* %206
%208 = icmp ne i64 %207, 0
br i1 %208, label %$41, label %$42
%208 = getelementptr i8, i8* %207, i32 8
%209 = ptrtoint i8* %208 to i64
%210 = inttoptr i64 %209 to i64*
%211 = load i64, i64* %210
%212 = icmp ne i64 %211, 0
br i1 %212, label %$41, label %$42
%211 = getelementptr i8, i8* %203, i32 8
%212 = ptrtoint i8* %211 to i64
%213 = inttoptr i64 %212 to i64*
%214 = load i64, i64* %213
%215 = getelementptr i8, i8* %207, i32 8
%216 = ptrtoint i8* %215 to i64
%217 = inttoptr i64 %216 to i64*
%218 = load i64, i64* %217
%217 = getelementptr i8, i8* %203, i32 16
%218 = ptrtoint i8* %217 to i64
%219 = inttoptr i64 %218 to i64*
%220 = load i64, i64* %219
; # (mark (Ca: fin))
call void @mark(i64 %220)
; # (Ca: intrn)
%221 = getelementptr i8, i8* %203, i32 200
%221 = getelementptr i8, i8* %207, i32 16
%296 = phi i64 [%292, %$50], [%304, %$53] ; # Tos
%297 = phi i64 [%293, %$50], [%305, %$53] ; # P
%298 = phi i64 [%295, %$50], [%307, %$53] ; # Tail
%300 = phi i64 [%296, %$50], [%308, %$53] ; # Tos
%301 = phi i64 [%297, %$50], [%309, %$53] ; # P
%302 = phi i64 [%299, %$50], [%311, %$53] ; # Tail
%311 = phi i64 [%285, %$48], [%308, %$54] ; # Tos
%312 = phi i64 [%286, %$48], [%309, %$54] ; # P
%313 = phi i64 [%289, %$48], [%310, %$54] ; # Tail
%315 = phi i64 [%289, %$48], [%312, %$54] ; # Tos
%316 = phi i64 [%290, %$48], [%313, %$54] ; # P
%317 = phi i64 [%293, %$48], [%314, %$54] ; # Tail
%314 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %313, i64 %313)
%315 = extractvalue {i64, i1} %314, 1
%316 = extractvalue {i64, i1} %314, 0
%318 = call {i64, i1} @llvm.uadd.with.overflow.i64(i64 %317, i64 %317)
%319 = extractvalue {i64, i1} %318, 1
%320 = extractvalue {i64, i1} %318, 0
%320 = phi i64 [%311, %$51], [%317, %$55] ; # Tos
%321 = phi i64 [%312, %$51], [%318, %$55] ; # P
%322 = phi i64 [%313, %$51], [%319, %$55] ; # Tail
%324 = phi i64 [%315, %$51], [%321, %$55] ; # Tos
%325 = phi i64 [%316, %$51], [%322, %$55] ; # P
%326 = phi i64 [%317, %$51], [%323, %$55] ; # Tail
%374 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 408) to i64), i64* %374
%378 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 408) to i64), i64* %378
%375 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 408) to i64) to i64*
%376 = load i64, i64* %375
%379 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 408) to i64) to i64*
%380 = load i64, i64* %379
%379 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 408) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %379
%383 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 408) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %383
%380 = add i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 408) to i64), -8
%381 = inttoptr i64 %380 to i64*
store i64 26, i64* %381
%384 = add i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 408) to i64), -8
%385 = inttoptr i64 %384 to i64*
store i64 26, i64* %385
%424 = or i64 %423, 1
%425 = inttoptr i64 %422 to i64*
%426 = getelementptr i64, i64* %425, i32 1
store i64 %424, i64* %426
%428 = or i64 %427, 1
%429 = inttoptr i64 %426 to i64*
%430 = getelementptr i64, i64* %429, i32 1
store i64 %428, i64* %430
%437 = or i64 %436, 1
%438 = inttoptr i64 %435 to i64*
%439 = getelementptr i64, i64* %438, i32 1
store i64 %437, i64* %439
%441 = or i64 %440, 1
%442 = inttoptr i64 %439 to i64*
%443 = getelementptr i64, i64* %442, i32 1
store i64 %441, i64* %443
%443 = or i64 %442, 1
%444 = inttoptr i64 %436 to i64*
%445 = getelementptr i64, i64* %444, i32 1
store i64 %443, i64* %445
%447 = or i64 %446, 1
%448 = inttoptr i64 %440 to i64*
%449 = getelementptr i64, i64* %448, i32 1
store i64 %447, i64* %449
%457 = or i64 %456, 1
%458 = inttoptr i64 %455 to i64*
%459 = getelementptr i64, i64* %458, i32 1
store i64 %457, i64* %459
%461 = or i64 %460, 1
%462 = inttoptr i64 %459 to i64*
%463 = getelementptr i64, i64* %462, i32 1
store i64 %461, i64* %463
%481 = phi i64 [%468, %$83] ; # Tos
%482 = phi i64 [%469, %$83] ; # P
%483 = phi i64 [%473, %$83] ; # X
%484 = phi i64 [%476, %$83] ; # Y
%485 = phi i64 [%472, %$83] ; # Tos
%486 = phi i64 [%473, %$83] ; # P
%487 = phi i64 [%477, %$83] ; # X
%488 = phi i64 [%480, %$83] ; # Y
%491 = inttoptr i64 %484 to i64*
%492 = getelementptr i64, i64* %491, i32 1
%493 = load i64, i64* %492
%494 = inttoptr i64 %490 to i64*
%495 = getelementptr i64, i64* %494, i32 1
store i64 %493, i64* %495
%495 = inttoptr i64 %488 to i64*
%496 = getelementptr i64, i64* %495, i32 1
%497 = load i64, i64* %496
%498 = inttoptr i64 %494 to i64*
%499 = getelementptr i64, i64* %498, i32 1
store i64 %497, i64* %499
%496 = phi i64 [%468, %$83] ; # Tos
%497 = phi i64 [%469, %$83] ; # P
%498 = phi i64 [%473, %$83] ; # X
%499 = phi i64 [%476, %$83] ; # Y
%500 = phi i64 [%472, %$83] ; # Tos
%501 = phi i64 [%473, %$83] ; # P
%502 = phi i64 [%477, %$83] ; # X
%503 = phi i64 [%480, %$83] ; # Y
%502 = phi i64 [%496, %$85], [%530, %$87] ; # Tos
%503 = phi i64 [%497, %$85], [%531, %$87] ; # P
%504 = phi i64 [%498, %$85], [%533, %$87] ; # X
%505 = phi i64 [%501, %$85], [%510, %$87] ; # Y
%506 = phi i64 [%500, %$85], [%534, %$87] ; # Tos
%507 = phi i64 [%501, %$85], [%535, %$87] ; # P
%508 = phi i64 [%502, %$85], [%537, %$87] ; # X
%509 = phi i64 [%505, %$85], [%514, %$87] ; # Y
%506 = inttoptr i64 %505 to i64*
%507 = getelementptr i64, i64* %506, i32 1
%508 = load i64, i64* %507
%509 = inttoptr i64 %508 to i64*
%510 = load i64, i64* %509
%510 = inttoptr i64 %509 to i64*
%511 = getelementptr i64, i64* %510, i32 1
%512 = load i64, i64* %511
%513 = inttoptr i64 %512 to i64*
%514 = load i64, i64* %513
%513 = phi i64 [%502, %$86] ; # Tos
%514 = phi i64 [%503, %$86] ; # P
%515 = phi i64 [%504, %$86] ; # X
%516 = phi i64 [%505, %$86] ; # Y
%517 = phi i64 [%506, %$86] ; # Tos
%518 = phi i64 [%507, %$86] ; # P
%519 = phi i64 [%508, %$86] ; # X
%520 = phi i64 [%509, %$86] ; # Y
%523 = inttoptr i64 %516 to i64*
%524 = getelementptr i64, i64* %523, i32 1
%525 = load i64, i64* %524
%526 = inttoptr i64 %525 to i64*
%527 = getelementptr i64, i64* %526, i32 1
%528 = load i64, i64* %527
%529 = inttoptr i64 %522 to i64*
store i64 %528, i64* %529
%527 = inttoptr i64 %520 to i64*
%528 = getelementptr i64, i64* %527, i32 1
%529 = load i64, i64* %528
%530 = inttoptr i64 %529 to i64*
%531 = getelementptr i64, i64* %530, i32 1
%532 = load i64, i64* %531
%533 = inttoptr i64 %526 to i64*
store i64 %532, i64* %533
%530 = phi i64 [%502, %$86] ; # Tos
%531 = phi i64 [%503, %$86] ; # P
%532 = phi i64 [%504, %$86] ; # X
%533 = phi i64 [%505, %$86] ; # Y
%534 = phi i64 [%506, %$86] ; # Tos
%535 = phi i64 [%507, %$86] ; # P
%536 = phi i64 [%508, %$86] ; # X
%537 = phi i64 [%509, %$86] ; # Y
%534 = phi i64 [%513, %$89] ; # Tos
%535 = phi i64 [%514, %$89] ; # P
%536 = phi i64 [%515, %$89] ; # X
%537 = phi i64 [%516, %$89] ; # Y
%538 = phi i64 [%528, %$89] ; # ->
%538 = phi i64 [%517, %$89] ; # Tos
%539 = phi i64 [%518, %$89] ; # P
%540 = phi i64 [%519, %$89] ; # X
%541 = phi i64 [%520, %$89] ; # Y
%542 = phi i64 [%532, %$89] ; # ->
%556 = phi i64 [%421, %$78], [%434, %$80], [%554, %$90] ; # Tos
%557 = phi i64 [%423, %$78], [%442, %$80], [%555, %$90] ; # P
%560 = phi i64 [%425, %$78], [%438, %$80], [%558, %$90] ; # Tos
%561 = phi i64 [%427, %$78], [%446, %$80], [%559, %$90] ; # P
%601 = phi i64 [%597, %$100], [%669, %$112] ; # Avail
%602 = phi i64 [%598, %$100], [%670, %$112] ; # Heap
%603 = phi i64 [%599, %$100], [%671, %$112] ; # Cnt
%604 = phi i64 [%600, %$100], [%672, %$112] ; # H
%605 = phi i64 [%601, %$100], [%673, %$112] ; # Avail
%606 = phi i64 [%602, %$100], [%674, %$112] ; # Heap
%607 = phi i64 [%603, %$100], [%675, %$112] ; # Cnt
%608 = phi i64 [%604, %$100], [%676, %$112] ; # H
%606 = phi i64 [%601, %$103], [%629, %$107] ; # Avail
%607 = phi i64 [%602, %$103], [%630, %$107] ; # Heap
%608 = phi i64 [65536, %$103], [%631, %$107] ; # Cnt
%609 = phi i64 [%604, %$103], [%632, %$107] ; # H
%610 = phi i64 [%605, %$103], [%634, %$107] ; # P
%610 = phi i64 [%605, %$103], [%633, %$107] ; # Avail
%611 = phi i64 [%606, %$103], [%634, %$107] ; # Heap
%612 = phi i64 [65536, %$103], [%635, %$107] ; # Cnt
%613 = phi i64 [%608, %$103], [%636, %$107] ; # H
%614 = phi i64 [%609, %$103], [%638, %$107] ; # P
%616 = phi i64 [%606, %$104] ; # Avail
%617 = phi i64 [%607, %$104] ; # Heap
%618 = phi i64 [%608, %$104] ; # Cnt
%619 = phi i64 [%609, %$104] ; # H
%620 = phi i64 [%610, %$104] ; # P
%620 = phi i64 [%610, %$104] ; # Avail
%621 = phi i64 [%611, %$104] ; # Heap
%622 = phi i64 [%612, %$104] ; # Cnt
%623 = phi i64 [%613, %$104] ; # H
%624 = phi i64 [%614, %$104] ; # P
%623 = phi i64 [%606, %$104], [%620, %$105] ; # Avail
%624 = phi i64 [%607, %$104], [%617, %$105] ; # Heap
%625 = phi i64 [%608, %$104], [%622, %$105] ; # Cnt
%626 = phi i64 [%609, %$104], [%619, %$105] ; # H
%627 = phi i64 [%610, %$104], [%620, %$105] ; # P
%627 = phi i64 [%610, %$104], [%624, %$105] ; # Avail
%628 = phi i64 [%611, %$104], [%621, %$105] ; # Heap
%629 = phi i64 [%612, %$104], [%626, %$105] ; # Cnt
%630 = phi i64 [%613, %$104], [%623, %$105] ; # H
%631 = phi i64 [%614, %$104], [%624, %$105] ; # P
%629 = phi i64 [%623, %$106] ; # Avail
%630 = phi i64 [%624, %$106] ; # Heap
%631 = phi i64 [%625, %$106] ; # Cnt
%632 = phi i64 [%626, %$106] ; # H
%633 = phi i64 [%627, %$106] ; # P
%633 = phi i64 [%627, %$106] ; # Avail
%634 = phi i64 [%628, %$106] ; # Heap
%635 = phi i64 [%629, %$106] ; # Cnt
%636 = phi i64 [%630, %$106] ; # H
%637 = phi i64 [%631, %$106] ; # P
%635 = phi i64 [%623, %$106] ; # Avail
%636 = phi i64 [%624, %$106] ; # Heap
%637 = phi i64 [%625, %$106] ; # Cnt
%638 = phi i64 [%626, %$106] ; # H
%639 = phi i64 [%627, %$106] ; # P
%640 = phi i64 [0, %$106] ; # ->
%639 = phi i64 [%627, %$106] ; # Avail
%640 = phi i64 [%628, %$106] ; # Heap
%641 = phi i64 [%629, %$106] ; # Cnt
%642 = phi i64 [%630, %$106] ; # H
%643 = phi i64 [%631, %$106] ; # P
%644 = phi i64 [0, %$106] ; # ->
%642 = phi i64 [%635, %$108] ; # Avail
%643 = phi i64 [%636, %$108] ; # Heap
%644 = phi i64 [%637, %$108] ; # Cnt
%645 = phi i64 [%638, %$108] ; # H
%646 = phi i64 [%639, %$108] ; # P
%646 = phi i64 [%639, %$108] ; # Avail
%647 = phi i64 [%640, %$108] ; # Heap
%648 = phi i64 [%641, %$108] ; # Cnt
%649 = phi i64 [%642, %$108] ; # H
%650 = phi i64 [%643, %$108] ; # P
%650 = phi i64 [%635, %$108] ; # Avail
%651 = phi i64 [%636, %$108] ; # Heap
%652 = phi i64 [%637, %$108] ; # Cnt
%653 = phi i64 [%638, %$108] ; # H
%654 = phi i64 [%639, %$108] ; # P
%654 = phi i64 [%639, %$108] ; # Avail
%655 = phi i64 [%640, %$108] ; # Heap
%656 = phi i64 [%641, %$108] ; # Cnt
%657 = phi i64 [%642, %$108] ; # H
%658 = phi i64 [%643, %$108] ; # P
%662 = phi i64 [%642, %$109], [%601, %$110] ; # Avail
%663 = phi i64 [%649, %$109], [%657, %$110] ; # Heap
%664 = phi i64 [%644, %$109], [%652, %$110] ; # Cnt
%665 = phi i64 [%647, %$109], [%653, %$110] ; # H
%666 = phi i64 [%646, %$109], [%654, %$110] ; # P
%667 = phi i64 [%649, %$109], [%657, %$110] ; # ->
%666 = phi i64 [%646, %$109], [%605, %$110] ; # Avail
%667 = phi i64 [%653, %$109], [%661, %$110] ; # Heap
%668 = phi i64 [%648, %$109], [%656, %$110] ; # Cnt
%669 = phi i64 [%651, %$109], [%657, %$110] ; # H
%670 = phi i64 [%650, %$109], [%658, %$110] ; # P
%671 = phi i64 [%653, %$109], [%661, %$110] ; # ->
%669 = phi i64 [%662, %$111] ; # Avail
%670 = phi i64 [%663, %$111] ; # Heap
%671 = phi i64 [%664, %$111] ; # Cnt
%672 = phi i64 [%665, %$111] ; # H
%673 = phi i64 [%666, %$111] ; # Avail
%674 = phi i64 [%667, %$111] ; # Heap
%675 = phi i64 [%668, %$111] ; # Cnt
%676 = phi i64 [%669, %$111] ; # H
%673 = phi i64 [%662, %$111] ; # Avail
%674 = phi i64 [%663, %$111] ; # Heap
%675 = phi i64 [%664, %$111] ; # Cnt
%676 = phi i64 [%665, %$111] ; # H
%677 = phi i64 [0, %$111] ; # ->
%677 = phi i64 [%666, %$111] ; # Avail
%678 = phi i64 [%667, %$111] ; # Heap
%679 = phi i64 [%668, %$111] ; # Cnt
%680 = phi i64 [%669, %$111] ; # H
%681 = phi i64 [0, %$111] ; # ->
%681 = phi i64 [%678, %$101], [%719, %$120] ; # Avail
%682 = phi i64 [%679, %$101], [%720, %$120] ; # Heap
%683 = phi i64 [%680, %$101], [%721, %$120] ; # Cnt
%685 = phi i64 [%682, %$101], [%723, %$120] ; # Avail
%686 = phi i64 [%683, %$101], [%724, %$120] ; # Heap
%687 = phi i64 [%684, %$101], [%725, %$120] ; # Cnt
%685 = phi i64 [%681, %$114], [%705, %$118] ; # Avail
%686 = phi i64 [%682, %$114], [%706, %$118] ; # Heap
%687 = phi i64 [%683, %$114], [%707, %$118] ; # Cnt
%688 = phi i64 [%684, %$114], [%709, %$118] ; # P
%689 = phi i64 [%685, %$114], [%709, %$118] ; # Avail
%690 = phi i64 [%686, %$114], [%710, %$118] ; # Heap
%691 = phi i64 [%687, %$114], [%711, %$118] ; # Cnt
%692 = phi i64 [%688, %$114], [%713, %$118] ; # P
%694 = phi i64 [%685, %$115] ; # Avail
%695 = phi i64 [%686, %$115] ; # Heap
%696 = phi i64 [%687, %$115] ; # Cnt
%697 = phi i64 [%688, %$115] ; # P
%698 = phi i64 [%689, %$115] ; # Avail
%699 = phi i64 [%690, %$115] ; # Heap
%700 = phi i64 [%691, %$115] ; # Cnt
%701 = phi i64 [%692, %$115] ; # P
%700 = phi i64 [%685, %$115], [%697, %$116] ; # Avail
%701 = phi i64 [%686, %$115], [%695, %$116] ; # Heap
%702 = phi i64 [%687, %$115], [%699, %$116] ; # Cnt
%703 = phi i64 [%688, %$115], [%697, %$116] ; # P
%704 = phi i64 [%689, %$115], [%701, %$116] ; # Avail
%705 = phi i64 [%690, %$115], [%699, %$116] ; # Heap
%706 = phi i64 [%691, %$115], [%703, %$116] ; # Cnt
%707 = phi i64 [%692, %$115], [%701, %$116] ; # P
%705 = phi i64 [%700, %$117] ; # Avail
%706 = phi i64 [%701, %$117] ; # Heap
%707 = phi i64 [%702, %$117] ; # Cnt
%708 = phi i64 [%703, %$117] ; # P
%709 = phi i64 [%704, %$117] ; # Avail
%710 = phi i64 [%705, %$117] ; # Heap
%711 = phi i64 [%706, %$117] ; # Cnt
%712 = phi i64 [%707, %$117] ; # P
%710 = phi i64 [%700, %$117] ; # Avail
%711 = phi i64 [%701, %$117] ; # Heap
%712 = phi i64 [%702, %$117] ; # Cnt
%713 = phi i64 [%703, %$117] ; # P
%714 = phi i64 [0, %$117] ; # ->
%714 = phi i64 [%704, %$117] ; # Avail
%715 = phi i64 [%705, %$117] ; # Heap
%716 = phi i64 [%706, %$117] ; # Cnt
%717 = phi i64 [%707, %$117] ; # P
%718 = phi i64 [0, %$117] ; # ->
%722 = phi i64 [%710, %$119] ; # Avail
%723 = phi i64 [%717, %$119] ; # Heap
%724 = phi i64 [%712, %$119] ; # Cnt
%725 = phi i64 [0, %$119] ; # ->
%726 = phi i64 [%714, %$119] ; # Avail
%727 = phi i64 [%721, %$119] ; # Heap
%728 = phi i64 [%716, %$119] ; # Cnt
%729 = phi i64 [0, %$119] ; # ->
%726 = phi i64 [%722, %$121], [%730, %$123] ; # Avail
%727 = phi i64 [%723, %$121], [%731, %$123] ; # Heap
%728 = phi i64 [%724, %$121], [%733, %$123] ; # Cnt
%730 = phi i64 [%726, %$121], [%734, %$123] ; # Avail
%731 = phi i64 [%727, %$121], [%735, %$123] ; # Heap
%732 = phi i64 [%728, %$121], [%737, %$123] ; # Cnt
%737 = phi i64 [%673, %$113], [%734, %$124] ; # Avail
%738 = phi i64 [%674, %$113], [%735, %$124] ; # Heap
%739 = phi i64 [%675, %$113], [%736, %$124] ; # Cnt
%741 = phi i64 [%677, %$113], [%738, %$124] ; # Avail
%742 = phi i64 [%678, %$113], [%739, %$124] ; # Heap
%743 = phi i64 [%679, %$113], [%740, %$124] ; # Cnt
%3 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%2, %$3] ; # ->
%3 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%2, %$3] ; # ->
%4 = tail call i64 @consSym(i64 %3, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%4 = tail call i64 @consSym(i64 %3, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
}
define i64 @outScl(i64, i64, i8) align 8 {
$1:
; # (when (> N 9) (setq Scl (outScl (/ N 10) Scl Sep)) (when (=0 Scl)...
; # (> N 9)
%3 = icmp ugt i64 %0, 9
br i1 %3, label %$2, label %$3
$2:
%4 = phi i64 [%0, %$1] ; # N
%5 = phi i64 [%1, %$1] ; # Scl
; # (/ N 10)
%6 = udiv i64 %4, 10
; # (outScl (/ N 10) Scl Sep)
%7 = call i64 @outScl(i64 %6, i64 %5, i8 %2)
; # (when (=0 Scl) (call $Put Sep))
; # (=0 Scl)
%8 = icmp eq i64 %7, 0
br i1 %8, label %$4, label %$5
$4:
%9 = phi i64 [%4, %$2] ; # N
%10 = phi i64 [%7, %$2] ; # Scl
; # (call $Put Sep)
%11 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %11(i8 %2)
br label %$5
$5:
%12 = phi i64 [%4, %$2], [%9, %$4] ; # N
%13 = phi i64 [%7, %$2], [%10, %$4] ; # Scl
; # (dec 'Scl)
%14 = sub i64 %13, 1
; # (% N 10)
%15 = urem i64 %12, 10
br label %$3
$3:
%16 = phi i64 [%0, %$1], [%15, %$5] ; # N
%17 = phi i64 [%1, %$1], [%14, %$5] ; # Scl
; # (i8 N)
%18 = trunc i64 %16 to i8
; # (+ (i8 N) (char "0"))
%19 = add i8 %18, 48
; # (call $Put (+ (i8 N) (char "0")))
%20 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %20(i8 %19)
ret i64 %17
; # (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
; # (let (N (* (shr (- TopA Acc) 3) 18) D (val TopA)) (cond (P (when ...
; # (- TopA Acc)
%313 = ptrtoint i64* %310 to i64
%314 = ptrtoint i64* %27 to i64
%315 = sub i64 %313, %314
; # (shr (- TopA Acc) 3)
%316 = lshr i64 %315, 3
; # (* (shr (- TopA Acc) 3) 18)
%317 = mul i64 %316, 18
; # (val TopA)
%318 = load i64, i64* %310
; # (cond (P (when Sign (byteSym (char "-") P)) (while (setq D (/ D 1...
%319 = icmp ne i64* %4, null
br i1 %319, label %$35, label %$34
%314 = phi i64 [%307, %$32] ; # Num
%315 = phi i64 [%308, %$32] ; # Scl
%316 = phi i64 [%309, %$32] ; # Len
%317 = phi i64* [%310, %$32] ; # TopA
%320 = phi i64 [%307, %$32] ; # Num
%321 = phi i64 [%308, %$32] ; # Scl
%322 = phi i64 [%309, %$32] ; # Len
%323 = phi i64* [%310, %$32] ; # TopA
%324 = phi i64 [%317, %$32] ; # N
%325 = phi i64 [%318, %$32] ; # D
%318 = phi i64 [%314, %$35] ; # Num
%319 = phi i64 [%315, %$35] ; # Scl
%320 = phi i64 [%316, %$35] ; # Len
%321 = phi i64* [%317, %$35] ; # TopA
%326 = phi i64 [%320, %$35] ; # Num
%327 = phi i64 [%321, %$35] ; # Scl
%328 = phi i64 [%322, %$35] ; # Len
%329 = phi i64* [%323, %$35] ; # TopA
%330 = phi i64 [%324, %$35] ; # N
%331 = phi i64 [%325, %$35] ; # D
%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
%332 = phi i64 [%320, %$35], [%326, %$36] ; # Num
%333 = phi i64 [%321, %$35], [%327, %$36] ; # Scl
%334 = phi i64 [%322, %$35], [%328, %$36] ; # Len
%335 = phi i64* [%323, %$35], [%329, %$36] ; # TopA
%336 = phi i64 [%324, %$35], [%330, %$36] ; # N
%337 = phi i64 [%325, %$35], [%331, %$36] ; # D
%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
%338 = phi i64 [%332, %$37], [%346, %$39] ; # Num
%339 = phi i64 [%333, %$37], [%347, %$39] ; # Scl
%340 = phi i64 [%334, %$37], [%348, %$39] ; # Len
%341 = phi i64* [%335, %$37], [%349, %$39] ; # TopA
%342 = phi i64 [%336, %$37], [%352, %$39] ; # N
%343 = phi i64 [%337, %$37], [%351, %$39] ; # D
%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
%346 = phi i64 [%338, %$38] ; # Num
%347 = phi i64 [%339, %$38] ; # Scl
%348 = phi i64 [%340, %$38] ; # Len
%349 = phi i64* [%341, %$38] ; # TopA
%350 = phi i64 [%342, %$38] ; # N
%351 = phi i64 [%344, %$38] ; # D
%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
%353 = phi i64 [%338, %$38] ; # Num
%354 = phi i64 [%339, %$38] ; # Scl
%355 = phi i64 [%340, %$38] ; # Len
%356 = phi i64* [%341, %$38] ; # TopA
%357 = phi i64 [%342, %$38] ; # N
%358 = phi i64 [%344, %$38] ; # D
%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
%361 = phi i64 [%353, %$40] ; # Num
%362 = phi i64 [%359, %$40] ; # Scl
%363 = phi i64 [%355, %$40] ; # Len
%364 = phi i64* [%356, %$40] ; # TopA
%365 = phi i64 [%357, %$40] ; # N
%366 = phi i64 [%358, %$40] ; # D
%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
%367 = phi i64 [%361, %$41], [%374, %$44] ; # Num
%368 = phi i64 [%362, %$41], [%380, %$44] ; # Scl
%369 = phi i64 [%363, %$41], [%376, %$44] ; # Len
%370 = phi i64* [%364, %$41], [%377, %$44] ; # TopA
%371 = phi i64 [%365, %$41], [%378, %$44] ; # N
%372 = phi i64 [%366, %$41], [%379, %$44] ; # D
%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
%374 = phi i64 [%367, %$43] ; # Num
%375 = phi i64 [%368, %$43] ; # Scl
%376 = phi i64 [%369, %$43] ; # Len
%377 = phi i64* [%370, %$43] ; # TopA
%378 = phi i64 [%371, %$43] ; # N
%379 = phi i64 [%372, %$43] ; # D
%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
%381 = phi i64 [%367, %$43] ; # Num
%382 = phi i64 [%368, %$43] ; # Scl
%383 = phi i64 [%369, %$43] ; # Len
%384 = phi i64* [%370, %$43] ; # TopA
%385 = phi i64 [%371, %$43] ; # N
%386 = phi i64 [%372, %$43] ; # D
%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
%387 = phi i64 [%353, %$40], [%381, %$45] ; # Num
%388 = phi i64 [%359, %$40], [%382, %$45] ; # Scl
%389 = phi i64 [%355, %$40], [%383, %$45] ; # Len
%390 = phi i64* [%356, %$40], [%384, %$45] ; # TopA
%391 = phi i64 [%357, %$40], [%385, %$45] ; # N
%392 = phi i64 [%358, %$40], [%386, %$45] ; # D
%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)
%393 = load i64, i64* %390
; # (fmtScl (val TopA) Scl Sep Ign P)
%394 = call i64 @fmtScl(i64 %393, i64 %388, i8 %2, i8 %3, i64* %4)
%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
%395 = phi i64 [%387, %$42], [%483, %$59] ; # Num
%396 = phi i64 [%394, %$42], [%484, %$59] ; # Scl
%397 = phi i64 [%389, %$42], [%485, %$59] ; # Len
%398 = phi i64* [%390, %$42], [%486, %$59] ; # TopA
%399 = phi i64 [%391, %$42], [%407, %$59] ; # N
%400 = phi i64 [%392, %$42], [%408, %$59] ; # D
%390 = phi i64 [%384, %$46] ; # Num
%391 = phi i64 [%385, %$46] ; # Scl
%392 = phi i64 [%386, %$46] ; # Len
%393 = phi i64* [%388, %$46] ; # TopA
%403 = phi i64 [%395, %$46] ; # Num
%404 = phi i64 [%396, %$46] ; # Scl
%405 = phi i64 [%397, %$46] ; # Len
%406 = phi i64* [%401, %$46] ; # TopA
%407 = phi i64 [%399, %$46] ; # N
%408 = phi i64 [%400, %$46] ; # D
%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
%410 = phi i64 [%403, %$47], [%477, %$58] ; # Num
%411 = phi i64 [%404, %$47], [%478, %$58] ; # Scl
%412 = phi i64 [%405, %$47], [%479, %$58] ; # Len
%413 = phi i64* [%406, %$47], [%480, %$58] ; # TopA
%414 = phi i64 [%409, %$47], [%481, %$58] ; # N
%415 = phi i64 [100000000000000000, %$47], [%482, %$58] ; # D
%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
%417 = phi i64 [%410, %$49] ; # Num
%418 = phi i64 [%411, %$49] ; # Scl
%419 = phi i64 [%412, %$49] ; # Len
%420 = phi i64* [%413, %$49] ; # TopA
%421 = phi i64 [%414, %$49] ; # N
%422 = phi i64 [%415, %$49] ; # D
%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
%423 = phi i64 [%410, %$49] ; # Num
%424 = phi i64 [%411, %$49] ; # Scl
%425 = phi i64 [%412, %$49] ; # Len
%426 = phi i64* [%413, %$49] ; # TopA
%427 = phi i64 [%414, %$49] ; # N
%428 = phi i64 [%415, %$49] ; # D
%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
%430 = phi i64 [%423, %$51] ; # Num
%431 = phi i64 [%424, %$51] ; # Scl
%432 = phi i64 [%425, %$51] ; # Len
%433 = phi i64* [%426, %$51] ; # TopA
%434 = phi i64 [%427, %$51] ; # N
%435 = phi i64 [%428, %$51] ; # D
%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
%437 = phi i64 [%430, %$54] ; # Num
%438 = phi i64 [%431, %$54] ; # Scl
%439 = phi i64 [%432, %$54] ; # Len
%440 = phi i64* [%433, %$54] ; # TopA
%441 = phi i64 [%434, %$54] ; # N
%442 = phi i64 [%435, %$54] ; # D
%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
%445 = phi i64 [%423, %$51], [%430, %$54], [%437, %$55] ; # Num
%446 = phi i64 [%424, %$51], [%431, %$54], [%438, %$55] ; # Scl
%447 = phi i64 [%425, %$51], [%432, %$54], [%439, %$55] ; # Len
%448 = phi i64* [%426, %$51], [%433, %$54], [%440, %$55] ; # TopA
%449 = phi i64 [%427, %$51], [%434, %$54], [%441, %$55] ; # N
%450 = phi i64 [%428, %$51], [%435, %$54], [%442, %$55] ; # D
%451 = phi i1 [0, %$51], [0, %$54], [%444, %$55] ; # ->
br i1 %451, label %$57, label %$56
%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
%452 = phi i64 [%445, %$53] ; # Num
%453 = phi i64 [%446, %$53] ; # Scl
%454 = phi i64 [%447, %$53] ; # Len
%455 = phi i64* [%448, %$53] ; # TopA
%456 = phi i64 [%449, %$53] ; # N
%457 = phi i64 [%450, %$53] ; # D
%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
%458 = phi i64 [%445, %$53] ; # Num
%459 = phi i64 [%446, %$53] ; # Scl
%460 = phi i64 [%447, %$53] ; # Len
%461 = phi i64* [%448, %$53] ; # TopA
%462 = phi i64 [%449, %$53] ; # N
%463 = phi i64 [%450, %$53] ; # D
%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
%464 = phi i64 [%417, %$52], [%452, %$57], [%458, %$56] ; # Num
%465 = phi i64 [%418, %$52], [%453, %$57], [%459, %$56] ; # Scl
%466 = phi i64 [%419, %$52], [%454, %$57], [%460, %$56] ; # Len
%467 = phi i64* [%420, %$52], [%455, %$57], [%461, %$56] ; # TopA
%468 = phi i64 [%421, %$52], [%456, %$57], [%462, %$56] ; # N
%469 = phi i64 [%422, %$52], [%457, %$57], [%463, %$56] ; # D
%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
%470 = sub i64 %465, 1
%467 = udiv i64 %462, 10
%475 = udiv i64 %469, 10
; # (== 1 (setq D (/ D 10)))
%476 = icmp eq i64 1, %475
br i1 %476, label %$59, label %$58
$58:
%477 = phi i64 [%464, %$50] ; # Num
%478 = phi i64 [%470, %$50] ; # Scl
%479 = phi i64 [%466, %$50] ; # Len
%480 = phi i64* [%467, %$50] ; # TopA
%481 = phi i64 [%474, %$50] ; # N
%482 = phi i64 [%475, %$50] ; # D
%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] ; # ->
%483 = phi i64 [%464, %$50] ; # Num
%484 = phi i64 [%470, %$50] ; # Scl
%485 = phi i64 [%466, %$50] ; # Len
%486 = phi i64* [%467, %$50] ; # TopA
%487 = phi i64 [%474, %$50] ; # N
%488 = phi i64 [%475, %$50] ; # D
%489 = phi i64 [0, %$50] ; # ->
%477 = phi i64 [%384, %$46] ; # Num
%478 = phi i64 [%385, %$46] ; # Scl
%479 = phi i64 [%386, %$46] ; # Len
%480 = phi i64* [%388, %$46] ; # TopA
%492 = phi i64 [%395, %$46] ; # Num
%493 = phi i64 [%396, %$46] ; # Scl
%494 = phi i64 [%397, %$46] ; # Len
%495 = phi i64* [%401, %$46] ; # TopA
%496 = phi i64 [%399, %$46] ; # N
%497 = phi i64 [%400, %$46] ; # D
%481 = phi i64 [%307, %$32] ; # Num
%482 = phi i64 [%308, %$32] ; # Scl
%483 = phi i64 [%309, %$32] ; # Len
%484 = phi i64* [%310, %$32] ; # TopA
%498 = phi i64 [%307, %$32] ; # Num
%499 = phi i64 [%308, %$32] ; # Scl
%500 = phi i64 [%309, %$32] ; # Len
%501 = phi i64* [%310, %$32] ; # TopA
%502 = phi i64 [%317, %$32] ; # N
%503 = phi i64 [%318, %$32] ; # D
%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
%505 = phi i64 [%498, %$34] ; # Num
%506 = phi i64 [%499, %$34] ; # Scl
%507 = phi i64 [%500, %$34] ; # Len
%508 = phi i64* [%501, %$34] ; # TopA
%509 = phi i64 [%502, %$34] ; # N
%510 = phi i64 [%503, %$34] ; # D
; # (loop (inc 'N) (? (=0 (setq D (/ D 10)))))
br label %$62
%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)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
call void %494(i8 45)
br label %$63
%511 = phi i64 [%505, %$61], [%520, %$63] ; # Num
%512 = phi i64 [%506, %$61], [%521, %$63] ; # Scl
%513 = phi i64 [%507, %$61], [%522, %$63] ; # Len
%514 = phi i64* [%508, %$61], [%523, %$63] ; # TopA
%515 = phi i64 [%509, %$61], [%524, %$63] ; # N
%516 = phi i64 [%510, %$61], [%525, %$63] ; # D
; # (inc 'N)
%517 = add i64 %515, 1
; # (? (=0 (setq D (/ D 10))))
; # (/ D 10)
%518 = udiv i64 %516, 10
; # (=0 (setq D (/ D 10)))
%519 = icmp eq i64 %518, 0
br i1 %519, label %$64, label %$63
%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
%520 = phi i64 [%511, %$62] ; # Num
%521 = phi i64 [%512, %$62] ; # Scl
%522 = phi i64 [%513, %$62] ; # Len
%523 = phi i64* [%514, %$62] ; # TopA
%524 = phi i64 [%517, %$62] ; # N
%525 = phi i64 [%518, %$62] ; # D
br label %$62
$64:
%526 = phi i64 [%511, %$62] ; # Num
%527 = phi i64 [%512, %$62] ; # Scl
%528 = phi i64 [%513, %$62] ; # Len
%529 = phi i64* [%514, %$62] ; # TopA
%530 = phi i64 [%517, %$62] ; # N
%531 = phi i64 [%518, %$62] ; # D
%532 = phi i64 [0, %$62] ; # ->
; # (when Sign (inc 'N))
br i1 %6, label %$65, label %$66
$65:
%533 = phi i64 [%526, %$64] ; # Num
%534 = phi i64 [%527, %$64] ; # Scl
%535 = phi i64 [%528, %$64] ; # Len
%536 = phi i64* [%529, %$64] ; # TopA
%537 = phi i64 [%530, %$64] ; # N
%538 = phi i64 [%531, %$64] ; # D
; # (inc 'N)
%539 = add i64 %537, 1
br label %$66
$66:
%540 = phi i64 [%526, %$64], [%533, %$65] ; # Num
%541 = phi i64 [%527, %$64], [%534, %$65] ; # Scl
%542 = phi i64 [%528, %$64], [%535, %$65] ; # Len
%543 = phi i64* [%529, %$64], [%536, %$65] ; # TopA
%544 = phi i64 [%530, %$64], [%539, %$65] ; # N
%545 = phi i64 [%531, %$64], [%538, %$65] ; # D
; # (cnt N)
%546 = shl i64 %544, 4
%547 = or i64 %546, 2
br label %$33
$60:
%548 = phi i64 [%498, %$34] ; # Num
%549 = phi i64 [%499, %$34] ; # Scl
%550 = phi i64 [%500, %$34] ; # Len
%551 = phi i64* [%501, %$34] ; # TopA
%552 = phi i64 [%502, %$34] ; # N
%553 = phi i64 [%503, %$34] ; # D
; # (when Sign (call $Put (char "-")))
br i1 %6, label %$67, label %$68
$67:
%554 = phi i64 [%548, %$60] ; # Num
%555 = phi i64 [%549, %$60] ; # Scl
%556 = phi i64 [%550, %$60] ; # Len
%557 = phi i64* [%551, %$60] ; # TopA
%558 = phi i64 [%552, %$60] ; # N
%559 = phi i64 [%553, %$60] ; # D
; # (call $Put (char "-"))
%560 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %560(i8 45)
br label %$68
$68:
%561 = phi i64 [%548, %$60], [%554, %$67] ; # Num
%562 = phi i64 [%549, %$60], [%555, %$67] ; # Scl
%563 = phi i64 [%550, %$60], [%556, %$67] ; # Len
%564 = phi i64* [%551, %$60], [%557, %$67] ; # TopA
%565 = phi i64 [%552, %$60], [%558, %$67] ; # N
%566 = phi i64 [%553, %$60], [%559, %$67] ; # D
; # (if (=0 Sep) (outWord (val TopA)) (while (setq D (/ D 10)) (inc '...
; # (=0 Sep)
%567 = icmp eq i8 %2, 0
br i1 %567, label %$69, label %$70
$69:
%568 = phi i64 [%561, %$68] ; # Num
%569 = phi i64 [%562, %$68] ; # Scl
%570 = phi i64 [%563, %$68] ; # Len
%571 = phi i64* [%564, %$68] ; # TopA
%572 = phi i64 [%565, %$68] ; # N
%573 = phi i64 [%566, %$68] ; # D
call void @outWord(i64 %499)
call void @outWord(i64 %574)
br label %$71
$70:
%575 = phi i64 [%561, %$68] ; # Num
%576 = phi i64 [%562, %$68] ; # Scl
%577 = phi i64 [%563, %$68] ; # Len
%578 = phi i64* [%564, %$68] ; # TopA
%579 = phi i64 [%565, %$68] ; # N
%580 = phi i64 [%566, %$68] ; # D
; # (while (setq D (/ D 10)) (inc 'N))
br label %$72
$72:
%581 = phi i64 [%575, %$70], [%589, %$73] ; # Num
%582 = phi i64 [%576, %$70], [%590, %$73] ; # Scl
%583 = phi i64 [%577, %$70], [%591, %$73] ; # Len
%584 = phi i64* [%578, %$70], [%592, %$73] ; # TopA
%585 = phi i64 [%579, %$70], [%595, %$73] ; # N
%586 = phi i64 [%580, %$70], [%594, %$73] ; # D
; # (/ D 10)
%587 = udiv i64 %586, 10
%588 = icmp ne i64 %587, 0
br i1 %588, label %$73, label %$74
$73:
%589 = phi i64 [%581, %$72] ; # Num
%590 = phi i64 [%582, %$72] ; # Scl
%591 = phi i64 [%583, %$72] ; # Len
%592 = phi i64* [%584, %$72] ; # TopA
%593 = phi i64 [%585, %$72] ; # N
%594 = phi i64 [%587, %$72] ; # D
; # (inc 'N)
%595 = add i64 %593, 1
br label %$72
$74:
%596 = phi i64 [%581, %$72] ; # Num
%597 = phi i64 [%582, %$72] ; # Scl
%598 = phi i64 [%583, %$72] ; # Len
%599 = phi i64* [%584, %$72] ; # TopA
%600 = phi i64 [%585, %$72] ; # N
%601 = phi i64 [%587, %$72] ; # D
; # (when (lt0 (setq Scl (- N Scl))) (call $Put (char "0")) (call $Pu...
; # (- N Scl)
%602 = sub i64 %600, %597
; # (lt0 (setq Scl (- N Scl)))
%603 = icmp slt i64 %602, 0
br i1 %603, label %$75, label %$76
$75:
%604 = phi i64 [%596, %$74] ; # Num
%605 = phi i64 [%602, %$74] ; # Scl
%606 = phi i64 [%598, %$74] ; # Len
%607 = phi i64* [%599, %$74] ; # TopA
%608 = phi i64 [%600, %$74] ; # N
%609 = phi i64 [%601, %$74] ; # D
; # (call $Put (char "0"))
%610 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %610(i8 48)
; # (call $Put Sep)
%611 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %611(i8 %2)
; # (while (> -1 Scl) (inc 'Scl) (call $Put (char "0")))
br label %$77
$77:
%612 = phi i64 [%604, %$75], [%619, %$78] ; # Num
%613 = phi i64 [%605, %$75], [%625, %$78] ; # Scl
%614 = phi i64 [%606, %$75], [%621, %$78] ; # Len
%615 = phi i64* [%607, %$75], [%622, %$78] ; # TopA
%616 = phi i64 [%608, %$75], [%623, %$78] ; # N
%617 = phi i64 [%609, %$75], [%624, %$78] ; # D
; # (> -1 Scl)
%618 = icmp ugt i64 -1, %613
br i1 %618, label %$78, label %$79
$78:
%619 = phi i64 [%612, %$77] ; # Num
%620 = phi i64 [%613, %$77] ; # Scl
%621 = phi i64 [%614, %$77] ; # Len
%622 = phi i64* [%615, %$77] ; # TopA
%623 = phi i64 [%616, %$77] ; # N
%624 = phi i64 [%617, %$77] ; # D
; # (inc 'Scl)
%625 = add i64 %620, 1
; # (call $Put (char "0"))
%626 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %626(i8 48)
br label %$77
$79:
%627 = phi i64 [%612, %$77] ; # Num
%628 = phi i64 [%613, %$77] ; # Scl
%629 = phi i64 [%614, %$77] ; # Len
%630 = phi i64* [%615, %$77] ; # TopA
%631 = phi i64 [%616, %$77] ; # N
%632 = phi i64 [%617, %$77] ; # D
br label %$76
$76:
%633 = phi i64 [%596, %$74], [%627, %$79] ; # Num
%634 = phi i64 [%602, %$74], [%628, %$79] ; # Scl
%635 = phi i64 [%598, %$74], [%629, %$79] ; # Len
%636 = phi i64* [%599, %$74], [%630, %$79] ; # TopA
%637 = phi i64 [%600, %$74], [%631, %$79] ; # N
%638 = phi i64 [%601, %$74], [%632, %$79] ; # D
; # (val TopA)
%639 = load i64, i64* %636
; # (outScl (val TopA) Scl Sep)
%640 = call i64 @outScl(i64 %639, i64 %634, i8 %2)
br label %$71
$71:
%641 = phi i64 [%568, %$69], [%633, %$76] ; # Num
%642 = phi i64 [%569, %$69], [%640, %$76] ; # Scl
%643 = phi i64 [%570, %$69], [%635, %$76] ; # Len
%644 = phi i64* [%571, %$69], [%636, %$76] ; # TopA
%645 = phi i64 [%572, %$69], [%637, %$76] ; # N
%646 = phi i64 [%573, %$69], [%638, %$76] ; # D
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
br label %$80
$80:
%647 = phi i64 [%641, %$71], [%710, %$89] ; # Num
%648 = phi i64 [%642, %$71], [%711, %$89] ; # Scl
%649 = phi i64 [%643, %$71], [%712, %$89] ; # Len
%650 = phi i64* [%644, %$71], [%713, %$89] ; # TopA
%651 = phi i64 [%645, %$71], [%659, %$89] ; # N
%652 = phi i64 [%646, %$71], [%660, %$89] ; # D
%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 ...
%654 = icmp uge i64* %653, %27
br i1 %654, label %$81, label %$82
$81:
%655 = phi i64 [%647, %$80] ; # Num
%656 = phi i64 [%648, %$80] ; # Scl
%657 = phi i64 [%649, %$80] ; # Len
%658 = phi i64* [%653, %$80] ; # TopA
%659 = phi i64 [%651, %$80] ; # N
%660 = phi i64 [%652, %$80] ; # D
; # (let (N (val TopA) D 100000000000000000) (loop (when (and Sep (=0...
%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
%661 = load i64, i64* %658
; # (loop (when (and Sep (=0 Scl)) (call $Put Sep)) (dec 'Scl) (call ...
br label %$83
$83:
%662 = phi i64 [%655, %$81], [%704, %$88] ; # Num
%663 = phi i64 [%656, %$81], [%705, %$88] ; # Scl
%664 = phi i64 [%657, %$81], [%706, %$88] ; # Len
%665 = phi i64* [%658, %$81], [%707, %$88] ; # TopA
%666 = phi i64 [%661, %$81], [%708, %$88] ; # N
%667 = phi i64 [100000000000000000, %$81], [%709, %$88] ; # D
; # (when (and Sep (=0 Scl)) (call $Put Sep))
; # (and Sep (=0 Scl))
%668 = icmp ne i8 %2, 0
br i1 %668, label %$85, label %$84
$85:
%669 = phi i64 [%662, %$83] ; # Num
%670 = phi i64 [%663, %$83] ; # Scl
%671 = phi i64 [%664, %$83] ; # Len
%672 = phi i64* [%665, %$83] ; # TopA
%673 = phi i64 [%666, %$83] ; # N
%674 = phi i64 [%667, %$83] ; # D
; # (=0 Scl)
%675 = icmp eq i64 %670, 0
br label %$84
$84:
%676 = phi i64 [%662, %$83], [%669, %$85] ; # Num
%677 = phi i64 [%663, %$83], [%670, %$85] ; # Scl
%678 = phi i64 [%664, %$83], [%671, %$85] ; # Len
%679 = phi i64* [%665, %$83], [%672, %$85] ; # TopA
%680 = phi i64 [%666, %$83], [%673, %$85] ; # N
%681 = phi i64 [%667, %$83], [%674, %$85] ; # D
%682 = phi i1 [0, %$83], [%675, %$85] ; # ->
br i1 %682, label %$86, label %$87
$86:
%683 = phi i64 [%676, %$84] ; # Num
%684 = phi i64 [%677, %$84] ; # Scl
%685 = phi i64 [%678, %$84] ; # Len
%686 = phi i64* [%679, %$84] ; # TopA
%687 = phi i64 [%680, %$84] ; # N
%688 = phi i64 [%681, %$84] ; # D
; # (call $Put Sep)
%689 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %689(i8 %2)
br label %$87
$87:
%690 = phi i64 [%676, %$84], [%683, %$86] ; # Num
%691 = phi i64 [%677, %$84], [%684, %$86] ; # Scl
%692 = phi i64 [%678, %$84], [%685, %$86] ; # Len
%693 = phi i64* [%679, %$84], [%686, %$86] ; # TopA
%694 = phi i64 [%680, %$84], [%687, %$86] ; # N
%695 = phi i64 [%681, %$84], [%688, %$86] ; # D
; # (dec 'Scl)
%696 = sub i64 %691, 1
%520 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
call void %520(i8 %519)
%700 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %700(i8 %699)
%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] ; # ->
%703 = icmp eq i64 1, %702
br i1 %703, label %$89, label %$88
$88:
%704 = phi i64 [%690, %$87] ; # Num
%705 = phi i64 [%696, %$87] ; # Scl
%706 = phi i64 [%692, %$87] ; # Len
%707 = phi i64* [%693, %$87] ; # TopA
%708 = phi i64 [%701, %$87] ; # N
%709 = phi i64 [%702, %$87] ; # D
br label %$83
$89:
%710 = phi i64 [%690, %$87] ; # Num
%711 = phi i64 [%696, %$87] ; # Scl
%712 = phi i64 [%692, %$87] ; # Len
%713 = phi i64* [%693, %$87] ; # TopA
%714 = phi i64 [%701, %$87] ; # N
%715 = phi i64 [%702, %$87] ; # D
%716 = phi i64 [0, %$87] ; # ->
%539 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
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
%719 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %719(i8 %718)
br label %$80
$82:
%720 = phi i64 [%647, %$80] ; # Num
%721 = phi i64 [%648, %$80] ; # Scl
%722 = phi i64 [%649, %$80] ; # Len
%723 = phi i64* [%653, %$80] ; # TopA
%724 = phi i64 [%651, %$80] ; # N
%725 = phi i64 [%652, %$80] ; # D
%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
%726 = phi i64 [%492, %$48], [%540, %$66], [%720, %$82] ; # Num
%727 = phi i64 [%493, %$48], [%541, %$66], [%721, %$82] ; # Scl
%728 = phi i64 [%494, %$48], [%542, %$66], [%722, %$82] ; # Len
%729 = phi i64* [%495, %$48], [%543, %$66], [%723, %$82] ; # TopA
%730 = phi i64 [%496, %$48], [%544, %$66], [%724, %$82] ; # N
%731 = phi i64 [%497, %$48], [%545, %$66], [%725, %$82] ; # D
%732 = phi i64 [0, %$48], [%547, %$66], [0, %$82] ; # ->
ret i64 %732
%144 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$40], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$45], [%133, %$44] ; # ->
%144 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$40], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$45], [%133, %$44] ; # ->
%170 = phi i64 [%159, %$46], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$47] ; # ->
%170 = phi i64 [%159, %$46], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$47] ; # ->
%19 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%19 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%21 = phi i64 [%13, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
%21 = phi i64 [%13, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
%20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%21 = phi i64 [%13, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # ->
%21 = phi i64 [%13, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # ->
%120 = phi i64 [%18, %$12], [%46, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$32] ; # ->
%120 = phi i64 [%18, %$12], [%46, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$32] ; # ->
%47 = phi i64 [%41, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$13] ; # ->
%47 = phi i64 [%41, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$13] ; # ->
%27 = phi i64 [%20, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%27 = phi i64 [%20, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%53 = call i64 @cons(i64 %52, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%54 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %53)
%53 = call i64 @cons(i64 %52, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%54 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %53)
%76 = call i64 @cons(i64 %75, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%76 = call i64 @cons(i64 %75, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%97 = call i64 @cons(i64 %96, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%98 = call i64 @cons(i64 %97, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%97 = call i64 @cons(i64 %96, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%98 = call i64 @cons(i64 %97, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%119 = call i64 @cons(i64 %118, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%119 = call i64 @cons(i64 %118, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%138 = call i64 @cons(i64 %137, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%138 = call i64 @cons(i64 %137, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%191 = call i64 @cons(i64 %190, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%192 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %191)
%191 = call i64 @cons(i64 %190, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%192 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %191)
%214 = call i64 @cons(i64 %213, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%214 = call i64 @cons(i64 %213, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%235 = call i64 @cons(i64 %234, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%236 = call i64 @cons(i64 %235, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%235 = call i64 @cons(i64 %234, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%236 = call i64 @cons(i64 %235, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%257 = call i64 @cons(i64 %256, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%257 = call i64 @cons(i64 %256, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%276 = call i64 @cons(i64 %275, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%276 = call i64 @cons(i64 %275, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%1 = call i64 @isIntern(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64))
%1 = call i64 @isIntern(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64))
%15 = call i64 @intern(i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %0, i64 %11, i64 %14, i1 0)
%15 = call i64 @intern(i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %0, i64 %11, i64 %14, i1 0)
%39 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%39 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%40 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %39)
%40 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %39)
%57 = call i64 @cons(i64 %56, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%57 = call i64 @cons(i64 %56, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%75 = call i64 @cons(i64 %74, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%75 = call i64 @cons(i64 %74, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%76 = call i64 @cons(i64 %75, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%76 = call i64 @cons(i64 %75, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%92 = call i64 @cons(i64 %91, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%92 = call i64 @cons(i64 %91, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%30 = call i64 @isIntern(i64 %29, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64))
%30 = call i64 @isIntern(i64 %29, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64))
%54 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21], [%40, %$23] ; # ->
%54 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21], [%40, %$23] ; # ->
%55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 152) to i64), %$15], [%54, %$20] ; # ->
%55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 152) to i64), %$15], [%54, %$20] ; # ->
%56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%55, %$17] ; # ->
%56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%55, %$17] ; # ->
%15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%16 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%16 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%33 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%22, %$11], [%31, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$14] ; # ->
%33 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%22, %$11], [%31, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$14] ; # ->
%53 = call i64 @consTree(i64 %52, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%53 = call i64 @consTree(i64 %52, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%60 = call i64 @consTree(i64 %59, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%60 = call i64 @consTree(i64 %59, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%78 = call i64 @consTree(i64 %77, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%78 = call i64 @consTree(i64 %77, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%82 = phi i64 [%79, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%82 = phi i64 [%79, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%129 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%129 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%130 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 40) to i64), i64 %129)
%130 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 40) to i64), i64 %129)
%145 = call i64 @cons(i64 %143, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%145 = call i64 @cons(i64 %143, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%183 = call i64 @cons(i64 %171, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%183 = call i64 @cons(i64 %171, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%70 = call i64 @intern(i64 %4, i64 0, i64 %25, i64 %69, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
%70 = call i64 @intern(i64 %4, i64 0, i64 %25, i64 %69, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
%72 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%71, %$17] ; # ->
%72 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%71, %$17] ; # ->
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %3
ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64)
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %3
ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
%33 = phi i64 [%13, %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$14] ; # ->
%33 = phi i64 [%13, %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$14] ; # ->
%35 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%13, %$15] ; # ->
%35 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%13, %$15] ; # ->
%56 = call i64 @cons(i64 %55, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%56 = call i64 @cons(i64 %55, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%72 = call i64 @cons(i64 %71, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%72 = call i64 @cons(i64 %71, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%83 = phi i64 [%56, %$26], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
%83 = phi i64 [%56, %$26], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
; # (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)
; # (let (P (push 0 (xName Y) NIL) Q (link (ofs P 1) T) R (push 4 NIL...
; # (xName Y)
%8 = call i64 @xName(i64 %4)
; # (push 0 (xName Y) NIL)
; # (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))
; # (let (P (push 0 (xName Y)) B T) (loop (? (=0 (setq B (symByte P))...
; # (xName Y)
%7 = call i64 @xName(i64 %1)
; # (push 0 (xName Y))
; # (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))
; # (let P (push 0 (xName Z)) (cond ((=0 (symByte P)) $Nil) ((preStr ...
; # (xName Z)
%24 = call i64 @xName(i64 %16)
; # (push 0 (xName Z))
%35 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%16, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%35 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%16, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%18 = phi i64 [%16, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%18 = phi i64 [%16, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%20 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$11] ; # ->
%20 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$11] ; # ->
%20 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%20 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%56 = call i64 @cons(i64 %53, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%56 = call i64 @cons(i64 %53, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%86 = call i64 @cons(i64 %83, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%86 = call i64 @cons(i64 %83, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%100 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%98, %$22] ; # ->
%100 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%98, %$22] ; # ->
%83 = call i64 @cons(i64 %82, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%83 = call i64 @cons(i64 %82, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%114 = call i64 @cons(i64 %112, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%114 = call i64 @cons(i64 %112, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%47 = call i64 @cons(i64 %46, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%47 = call i64 @cons(i64 %46, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%137 = phi i64 [%107, %$30], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$37], [%125, %$39], [%134, %$38] ; # ->
%137 = phi i64 [%107, %$30], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$37], [%125, %$39], [%134, %$38] ; # ->
%126 = phi i64 [%52, %$38], [%111, %$40], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$39] ; # ->
%126 = phi i64 [%52, %$38], [%111, %$40], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$39] ; # ->
%164 = phi i64 [%157, %$27], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$45], [%52, %$44] ; # ->
%164 = phi i64 [%157, %$27], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$45], [%52, %$44] ; # ->
%65 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%65 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%88 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%88 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%89 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %88)
%89 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %88)
%105 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%105 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%119 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$32], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$34], [%115, %$33] ; # P
%119 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$32], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$34], [%115, %$33] ; # P
%131 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%131 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%132 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %131)
%132 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %131)
%147 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%147 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%159 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$37], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$39], [%155, %$38] ; # P
%159 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$37], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$39], [%155, %$38] ; # P
%185 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$19], [%177, %$41] ; # ->
%185 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$19], [%177, %$41] ; # ->
%97 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%87, %$20] ; # ->
%97 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%87, %$20] ; # ->
%34 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%34 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%35 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %34)
%35 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %34)
%42 = call i64 @cons(i64 %41, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%42 = call i64 @cons(i64 %41, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%43 = call i64 @cons(i64 %42, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%43 = call i64 @cons(i64 %42, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%71 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%71 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%86 = call i64 @cons(i64 %85, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%86 = call i64 @cons(i64 %85, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%175 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%175 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%176 = call i64 @cons(i64 %175, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%176 = call i64 @cons(i64 %175, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%183 = call i64 @cons(i64 %182, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%183 = call i64 @cons(i64 %182, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%184 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %183)
%184 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %183)
%211 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%211 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%226 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %225)
%226 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %225)
%306 = phi i64 [%13, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$39], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$46] ; # ->
%306 = phi i64 [%13, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$39], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$46] ; # ->
%308 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%308 = call i64 @cons(i64 %1, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%311 = phi i64 [%306, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%311 = phi i64 [%306, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%40, %$18] ; # ->
%56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%40, %$18] ; # ->
%130 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%4, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
%130 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%4, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
%26 = call i64 @consTree(i64 %25, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%26 = call i64 @consTree(i64 %25, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%109 = phi i64 [%79, %$26], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$31] ; # ->
%109 = phi i64 [%79, %$26], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$31] ; # ->
%155 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$32], [%305, %$53] ; # R
%155 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$32], [%305, %$53] ; # R
%37 = phi i64 [%27, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%37 = phi i64 [%27, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%69 = phi i64 [%37, %$14], [%66, %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$18] ; # ->
%69 = phi i64 [%37, %$14], [%66, %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$18] ; # ->
%109 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %1)
%109 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %1)
%69 = call i64 @cons(i64 %68, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%69 = call i64 @cons(i64 %68, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%89 = call i64 @cons(i64 %88, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%89 = call i64 @cons(i64 %88, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%96 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$19], [%69, %$24] ; # ->
%96 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$19], [%69, %$24] ; # ->
%40 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%20, %$12], [%30, %$16] ; # ->
%40 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%20, %$12], [%30, %$16] ; # ->
%20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%20 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$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)
; # (let (P (push 0 (xName X) NIL) Q (link (ofs P 1) T) R (push 4 NIL...
; # (xName X)
%20 = call i64 @xName(i64 %13)
; # (push 0 (xName X) NIL)
; # (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)
; # (let (P (push 0 (xName X) NIL) Q (link (ofs P 1) T) R (push 4 NIL...
; # (xName X)
%20 = call i64 @xName(i64 %13)
; # (push 0 (xName X) NIL)
}
define i8* @dirString(i64, i8*) align 8 {
$1:
; # (let S (pathString Nm P) (if (val P) P ($ ".")))
; # (pathString Nm P)
%2 = call i8* @pathString(i64 %0, i8* %1)
; # (if (val P) P ($ "."))
; # (val P)
%3 = load i8, i8* %1
%4 = icmp ne i8 %3, 0
br i1 %4, label %$2, label %$3
$2:
br label %$4
$3:
br label %$4
$4:
%5 = phi i8* [%1, %$2], [bitcast ([2 x i8]* @$28 to i8*), %$3] ; # ->
ret i8* %5
%99 = phi i64 [%86, %$22], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$23] ; # ->
%99 = phi i64 [%86, %$22], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$23] ; # ->
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %231
%232 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 112) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %231
%232 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 104) to i64) to i64*
%297 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 112) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %297
%297 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 104) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %297
%4 = call i64 @cons(i64 %2, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%4 = call i64 @cons(i64 %2, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%37 = call i64 @cons(i64 %14, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%37 = call i64 @cons(i64 %14, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%209 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%46, %$10], [10, %$6], [%47, %$7], [%208, %$27] ; # ->
%209 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%46, %$10], [10, %$6], [%47, %$7], [%208, %$27] ; # ->
%19 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**) to i8**
%19 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**) to i8**
store i32()* @getIn, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
store i32()* @getIn, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%33 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%33 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
%49 = phi i64 [%48, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 472) to i64) to i64*
%49 = phi i64 [%48, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%50 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 472) to i64) to i64*
store void(i8)* @putOut, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 472) to i64) to i64*
store void(i8)* @putOut, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%63 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 472) to i64) to i64*
%17 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**) to i8**
%17 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**) to i8**
store i32()* @_getStdin, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
store i32()* @_getStdin, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%9 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%9 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%27 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**) to i8**
%27 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**) to i8**
%27 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%27 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
%269 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %269
%269 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %269
%760 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%760 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%802 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%802 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%872 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
%872 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
%879 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%879 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%35 = phi i64 [%32, %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$14] ; # ->
%35 = phi i64 [%32, %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$14] ; # ->
%38 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$21] ; # ->
%38 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$21] ; # ->
%77 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%74, %$25] ; # ->
%77 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%74, %$25] ; # ->
%45 = phi i64 [%13, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$26], [%13, %$28] ; # ->
%45 = phi i64 [%13, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$26], [%13, %$28] ; # ->
%46 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%45, %$18] ; # ->
%46 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%45, %$18] ; # ->
; # (let (Nm (xName Exe X) S (pathString Nm (b8 (pathSize Nm))) Fd T)...
; # (xName Exe X)
%65 = call i64 @xName(i64 %0, i64 %64)
; # (let (Nm (xName X) S (pathString Nm (b8 (pathSize Nm))) Fd T) (wh...
; # (xName X)
%65 = call i64 @xName(i64 %64)
; # (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 (...
; # (let A Av (while (pair (shift X)) (let Nm (xName (xSym (car X))) ...
; # (while (pair (shift X)) (let Nm (xName (xSym (car X))) (set (inc ...
; # (let (Nm (xName Exe X) S (pathString Nm (b8 (pathSize Nm))) Flg (...
; # (xName Exe X)
%66 = call i64 @xName(i64 %0, i64 %65)
; # (let (Nm (xName X) S (pathString Nm (b8 (pathSize Nm))) Flg (== (...
; # (xName X)
%66 = call i64 @xName(i64 %65)
; # (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 (...
; # (let A Av (while (pair (shift X)) (let Nm (xName (xSym (car X))) ...
; # (while (pair (shift X)) (let Nm (xName (xSym (car X))) (set (inc ...
; # (let (Nm (xName Exe X) S (pathString Nm (b8 (pathSize Nm))) Flg (...
; # (xName Exe X)
%14 = call i64 @xName(i64 %0, i64 %1)
; # (let (Nm (xName X) S (pathString Nm (b8 (pathSize Nm))) Flg (== (...
; # (xName X)
%14 = call i64 @xName(i64 %1)
; # (let (Nm (xName Exe X) S (pathString Nm (b8 (pathSize Nm))) Flg (...
; # (xName Exe X)
%14 = call i64 @xName(i64 %0, i64 %1)
; # (let (Nm (xName X) S (pathString Nm (b8 (pathSize Nm))) Flg (== (...
; # (xName X)
%14 = call i64 @xName(i64 %1)
br label %$2
}
define i32 @uniChr(i32) align 8 {
$1:
; # (when (and (>= Chr (char "0")) (>= (char "9") Chr)) (dec 'Chr (ch...
; # (and (>= Chr (char "0")) (>= (char "9") Chr))
; # (>= Chr (char "0"))
%1 = icmp sge i32 %0, 48
br i1 %1, label %$3, label %$2
$3:
%2 = phi i32 [%0, %$1] ; # Chr
; # (>= (char "9") Chr)
%3 = icmp sge i32 57, %2
$2:
%4 = phi i32 [%0, %$1], [%2, %$3] ; # Chr
%5 = phi i1 [0, %$1], [%3, %$3] ; # ->
br i1 %5, label %$4, label %$5
$4:
%6 = phi i32 [%4, %$2] ; # Chr
; # (dec 'Chr (char "0"))
%7 = sub i32 %6, 48
; # (until (== (call $Get) (char "\\")) (unless (and (>= (val $Chr) (...
br label %$6
$6:
%8 = phi i32 [%7, %$4], [%25, %$12] ; # Chr
; # (call $Get)
%9 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%10 = call i32 %9()
; # (== (call $Get) (char "\\"))
%11 = icmp eq i32 %10, 92
br i1 %11, label %$8, label %$7
$7:
%12 = phi i32 [%8, %$6] ; # Chr
; # (unless (and (>= (val $Chr) (char "0")) (>= (char "9") (val $Chr)...
; # (and (>= (val $Chr) (char "0")) (>= (char "9") (val $Chr)))
; # (val $Chr)
%13 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 144) to i32*)
; # (>= (val $Chr) (char "0"))
%14 = icmp sge i32 %13, 48
br i1 %14, label %$10, label %$9
$10:
%15 = phi i32 [%12, %$7] ; # Chr
; # (val $Chr)
%16 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 144) to i32*)
; # (>= (char "9") (val $Chr))
%17 = icmp sge i32 57, %16
br label %$9
$9:
%18 = phi i32 [%12, %$7], [%15, %$10] ; # Chr
%19 = phi i1 [0, %$7], [%17, %$10] ; # ->
br i1 %19, label %$12, label %$11
$11:
%20 = phi i32 [%18, %$9] ; # Chr
; # (badInput)
call void @badInput()
unreachable
$12:
%21 = phi i32 [%18, %$9] ; # Chr
; # (* Chr 10)
%22 = mul i32 %21, 10
; # (val $Chr)
%23 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 144) to i32*)
; # (- (val $Chr) (char "0"))
%24 = sub i32 %23, 48
; # (+ (* Chr 10) (- (val $Chr) (char "0")))
%25 = add i32 %22, %24
br label %$6
$8:
%26 = phi i32 [%8, %$6] ; # Chr
br label %$5
$5:
%27 = phi i32 [%4, %$2], [%26, %$8] ; # Chr
ret i32 %27
; # (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()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%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* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 64) to i32*)
; # (>= (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* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 64) to i32*)
; # (>= (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* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 64) to i32*)
; # (- (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* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 64) to i32*)
; # (set $Chr (uniChr Chr))
; # (uniChr Chr)
%33 = call i32 @uniChr(i32 %32)
store i32 %33, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 144) to i32*)
%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] ; # ->
%34 = phi i32 [%27, %$19], [%28, %$20], [%29, %$21], [%30, %$22], [%31, %$23], [%32, %$17] ; # Chr
%35 = phi i32 [8, %$19], [27, %$20], [10, %$21], [13, %$22], [9, %$23], [%33, %$17] ; # ->
%64 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%65 = call i32 %64()
%38 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%39 = call i32 %38()
%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] ; # ->
%42 = icmp ne i32 %41, 9
br label %$25
$25:
%43 = phi i32 [%39, %$24], [%41, %$26] ; # Chr
%44 = phi i1 [0, %$24], [%42, %$26] ; # ->
br i1 %44, label %$28, label %$27
$27:
%45 = phi i32 [%43, %$25] ; # Chr
br label %$24
$28:
%46 = phi i32 [%43, %$25] ; # Chr
%47 = phi i64 [0, %$25] ; # ->
%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
%48 = phi i32 [%3, %$5], [%16, %$12], [%20, %$14], [%34, %$18] ; # Chr
%49 = phi i1 [0, %$5], [1, %$12], [1, %$14], [1, %$18] ; # ->
ret i1 %49
call void @symNspErr(i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 1016) to i64))
call void @symNspErr(i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 1032) to i64))
%85 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%86 = call i32 %85()
%86 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%87 = call i32 %86()
%91 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
%92 = load i64, i64* %91
%92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
%93 = load i64, i64* %92
%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
%105 = inttoptr i64 %104 to i64*
%106 = load i64, i64* %105
%107 = inttoptr i64 %106 to i64*
%108 = getelementptr i64, i64* %107, i32 1
%109 = load i64, i64* %108
%109 = call i64 @intern(i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %90, i64 %108, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
%110 = call i64 @intern(i64 0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %91, i64 %109, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
%112 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 552) to i64) to i64*
%113 = load i64, i64* %112
%113 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 552) to i64) to i64*
%114 = load i64, i64* %113
%129 = icmp eq i64 %128, ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 152) to i64)
br i1 %129, label %$31, label %$30
%130 = icmp eq i64 %129, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 152) to i64)
br i1 %130, label %$31, label %$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
%137 = phi i32 [%126, %$28], [%131, %$31] ; # Chr
%138 = phi i32 [%127, %$28], [%132, %$31] ; # C
%139 = phi i1 [0, %$28], [%136, %$31] ; # ->
br i1 %139, label %$33, label %$32
%141 = call i64 @consSym(i64 %90, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%142 = call i64 @consSym(i64 %91, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%142 = call i64 @intern(i64 %141, i64 0, i64 %90, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i1 1)
%143 = call i64 @intern(i64 %142, i64 0, i64 %91, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i1 1)
%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] ; # ->
%147 = phi i32 [%101, %$25], [%118, %$27], [%124, %$29], [%140, %$33], [%144, %$32] ; # Chr
%148 = phi i32 [%102, %$25], [%119, %$27], [%125, %$29], [%141, %$33], [%145, %$32] ; # C
%149 = phi i64 [%110, %$25], [%116, %$27], [%122, %$29], [%143, %$33], [%146, %$32] ; # ->
%149 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
store i64 %2, i64* %149
%150 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
store i64 %2, i64* %150
%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 ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %152, i64* %153
ret i64 %148
%151 = inttoptr i64 %6 to i64*
%152 = getelementptr i64, i64* %151, i32 1
%153 = load i64, i64* %152
%154 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %153, i64* %154
ret i64 %149
%45 = call i64 @cons(i64 %44, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%45 = call i64 @cons(i64 %44, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%75 = call i64 @cons(i64 %69, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%75 = call i64 @cons(i64 %69, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%102 = call i64 @cons(i64 %101, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%102 = call i64 @cons(i64 %101, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%20 = call i64 @cons(i64 %19, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%20 = call i64 @cons(i64 %19, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%41 = call i64 @cons(i64 %40, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%41 = call i64 @cons(i64 %40, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%57 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%20, %$11], [%55, %$21] ; # ->
%57 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%20, %$11], [%55, %$21] ; # ->
%43 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 264) to i64), i64 %42)
%43 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 264) to i64), i64 %42)
%87 = call i64 @idxPut(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 776) to i64), i64 %73, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64))
%87 = call i64 @idxPut(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 776) to i64), i64 %73, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64))
%172 = call i64 @intern(i64 0, i64 0, i64 %171, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
%172 = call i64 @intern(i64 0, i64 0, i64 %171, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
%178 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$37], [%172, %$44] ; # ->
%178 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$37], [%172, %$44] ; # ->
%186 = call i64 @consSym(i64 2, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%186 = call i64 @consSym(i64 2, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%263 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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] ; # ->
%263 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 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] ; # ->
%8 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%7, %$5] ; # ->
%8 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%7, %$5] ; # ->
%2 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 64) to i32*)
; # (unless C (setq C (call $Get)))
%2 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 144) to i32*)
%7 = phi i32 [%2, %$1], [%6, %$2] ; # C
; # (call $Get)
%4 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%5 = call i32 %4()
br label %$4
$4:
%6 = phi i32 [%2, %$2], [%5, %$3] ; # ->
%14 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%15 = call i32 %14()
%13 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%14 = call i32 %13()
%18 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%19 = call i32 %18()
br label %$9
$10:
%20 = phi i32 [%15, %$8] ; # C
%17 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%18 = call i32 %17()
br label %$10
$11:
%19 = phi i32 [%14, %$9] ; # C
%27 = call i64 @cons(i64 %26, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%26 = call i64 @cons(i64 %25, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%28 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 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 ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %31, i64* %35
%27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 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 ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %30, i64* %34
%38 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%39 = call i32 %38()
%37 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%38 = call i32 %37()
%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
%39 = icmp eq i32 %38, 34
br i1 %39, label %$18, label %$16
$18:
%40 = phi i32 [%38, %$15] ; # C
%41 = phi i64 [%36, %$15] ; # Y
%43 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%44 = call i32 %43()
br label %$16
$15:
%45 = phi i32 [%39, %$14] ; # C
%46 = phi i64 [%37, %$14] ; # Y
%42 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%43 = call i32 %42()
br label %$17
$16:
%44 = phi i32 [%38, %$15] ; # C
%45 = phi i64 [%36, %$15] ; # Y
%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
%47 = icmp eq i1 %46, 0
br i1 %47, label %$17, label %$19
$19:
%48 = phi i32 [%44, %$16] ; # C
%49 = phi i64 [%45, %$16] ; # Y
%53 = call i64 @cons(i64 %52, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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] ; # ->
%52 = call i64 @cons(i64 %51, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%53 = inttoptr i64 %49 to i64*
%54 = getelementptr i64, i64* %53, i32 1
store i64 %52, i64* %54
br label %$15
$17:
%55 = phi i32 [%40, %$18], [%44, %$16] ; # C
%56 = phi i64 [%41, %$18], [%45, %$16] ; # Y
%57 = phi i32 [%43, %$18], [0, %$16] ; # ->
%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 ([21 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 ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%27, %$16] ; # ->
br label %$4
$7:
%65 = phi i32 [%8, %$5] ; # C
%58 = inttoptr i64 %30 to i64*
%59 = getelementptr i64, i64* %58, i32 1
%60 = load i64, i64* %59
%61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %60, i64* %61
br label %$10
$10:
%62 = phi i32 [%16, %$12], [%22, %$14], [%55, %$17] ; # C
%63 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%26, %$17] ; # ->
br label %$5
$8:
%64 = phi i32 [%7, %$6] ; # C
%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
%67 = icmp sge i32 %66, 48
br label %$20
$20:
%68 = phi i32 [%64, %$8], [%66, %$21] ; # C
%69 = phi i1 [0, %$8], [%67, %$21] ; # ->
br i1 %69, label %$23, label %$22
$23:
%70 = phi i32 [%68, %$20] ; # C
%75 = ptrtoint i64* %74 to i64
%76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 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 ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %75, i64* %80
%74 = ptrtoint i64* %73 to i64
%75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
%76 = load i64, i64* %75
%77 = inttoptr i64 %74 to i64*
%78 = getelementptr i64, i64* %77, i32 1
store i64 %76, i64* %78
%79 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %74, i64* %79
%83 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%84 = call i32 %83()
%82 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%83 = call i32 %82()
%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
%86 = icmp sgt i32 48, %85
br i1 %86, label %$27, label %$28
%94 = phi i32 [%92, %$24] ; # C
br label %$23
%87 = phi i32 [%85, %$26] ; # C
; # (> C (char "9"))
%88 = icmp sgt i32 %87, 57
br label %$27
$27:
%89 = phi i32 [%85, %$26], [%87, %$28] ; # C
%90 = phi i1 [1, %$26], [%88, %$28] ; # ->
br label %$25
$25:
%91 = phi i32 [%83, %$24], [%89, %$27] ; # C
%92 = phi i1 [0, %$24], [%90, %$27] ; # ->
br i1 %92, label %$30, label %$29
%99 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 552) to i64) to i64*
%100 = load i64, i64* %99
%98 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 552) to i64) to i64*
%99 = load i64, i64* %98
%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 ([21 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)
%102 = inttoptr i64 %74 to i64*
%103 = getelementptr i64, i64* %102, i32 1
%104 = load i64, i64* %103
%105 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %104, i64* %105
br label %$5
$22:
%106 = phi i32 [%68, %$20] ; # C
; # (let (Nm (xName Set) S (bufString Nm (b8 (bufSize Nm)))) (if (or ...
; # (xName Set)
%107 = call i64 @xName(i64 %0)
%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
%111 = icmp eq i32 %106, 43
br i1 %111, label %$31, label %$32
%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
%115 = icmp eq i32 %114, 92
br i1 %115, label %$34, label %$35
%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
%120 = icmp sge i32 %114, 65
br label %$39
$39:
%121 = phi i1 [0, %$38], [%120, %$40] ; # ->
br i1 %121, label %$34, label %$41
%129 = phi i32 [%127, %$30] ; # C
%122 = call i8* @strchr(i8* %110, i32 %114)
%123 = icmp ne i8* %122, null
br label %$34
$34:
%124 = phi i1 [1, %$33], [1, %$36], [1, %$39], [%123, %$41] ; # ->
%125 = icmp eq i1 %124, 0
br label %$31
$31:
%126 = phi i32 [%106, %$22], [%112, %$32], [%114, %$34] ; # C
%127 = phi i1 [1, %$22], [1, %$32], [%125, %$34] ; # ->
br i1 %127, label %$42, label %$43
$42:
%128 = phi i32 [%126, %$31] ; # C
%132 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%133 = call i32 %132()
br label %$43
$42:
%134 = phi i32 [%127, %$30] ; # C
%131 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%132 = call i32 %131()
br label %$44
$43:
%133 = phi i32 [%126, %$31] ; # C
%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()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%138 = call i32 %137()
br label %$45
%134 = icmp eq i32 %133, 92
br i1 %134, label %$45, label %$46
%139 = phi i32 [%134, %$42], [%136, %$44] ; # C
%135 = phi i32 [%133, %$43] ; # C
; # (call $Get)
%136 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%137 = call i32 %136()
br label %$46
$46:
%138 = phi i32 [%133, %$43], [%135, %$45] ; # C
%140 = alloca i64, i64 4, align 16
store i64 4, i64* %140
%141 = getelementptr i64, i64* %140, i32 2
store i64 2, i64* %141
%139 = alloca i64, i64 4, align 16
store i64 4, i64* %139
%140 = getelementptr i64, i64* %139, i32 2
store i64 2, i64* %140
%143 = ptrtoint i64* %142 to i64
%144 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 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 ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %143, i64* %148
%142 = ptrtoint i64* %141 to i64
%143 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
%144 = load i64, i64* %143
%145 = inttoptr i64 %142 to i64*
%146 = getelementptr i64, i64* %145, i32 1
store i64 %144, i64* %146
%147 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %142, i64* %147
%151 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%152 = call i32 %151()
%150 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%151 = call i32 %150()
%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
%152 = icmp eq i32 %151, 92
br i1 %152, label %$49, label %$50
%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
%157 = icmp sge i32 %151, 65
br label %$54
$54:
%158 = phi i1 [0, %$53], [%157, %$55] ; # ->
br i1 %158, label %$49, label %$56
%164 = phi i32 [%152, %$48] ; # C
%159 = call i8* @strchr(i8* %110, i32 %151)
%160 = icmp ne i8* %159, null
br label %$49
$49:
%161 = phi i1 [1, %$47], [1, %$51], [1, %$54], [%160, %$56] ; # ->
%162 = icmp eq i1 %161, 0
br i1 %162, label %$57, label %$48
$57:
%163 = phi i32 [%151, %$49] ; # C
%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
%164 = icmp sgt i32 48, %163
br i1 %164, label %$58, label %$59
%172 = phi i32 [%170, %$47] ; # C
%165 = phi i32 [%163, %$57] ; # C
; # (> C (char "9"))
%166 = icmp sgt i32 %165, 57
br label %$58
$58:
%167 = phi i32 [%163, %$57], [%165, %$59] ; # C
%168 = phi i1 [1, %$57], [%166, %$59] ; # ->
br label %$48
$48:
%169 = phi i32 [%151, %$49], [%167, %$58] ; # C
%170 = phi i1 [0, %$49], [%168, %$58] ; # ->
br i1 %170, label %$61, label %$60
$60:
%171 = phi i32 [%169, %$48] ; # C
%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()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%176 = call i32 %175()
br label %$62
%172 = icmp eq i32 %171, 92
br i1 %172, label %$62, label %$63
%177 = phi i32 [%172, %$59], [%174, %$61] ; # C
br label %$46
$60:
%178 = phi i32 [%170, %$47] ; # C
%179 = phi i64 [0, %$47] ; # ->
%173 = phi i32 [%171, %$60] ; # C
; # (call $Get)
%174 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%175 = call i32 %174()
br label %$63
$63:
%176 = phi i32 [%171, %$60], [%173, %$62] ; # C
br label %$47
$61:
%177 = phi i32 [%169, %$48] ; # C
%178 = phi i64 [0, %$48] ; # ->
%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 ([21 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
%182 = inttoptr i64 %142 to i64*
%183 = getelementptr i64, i64* %182, i32 1
%184 = load i64, i64* %183
%185 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %184, i64* %185
br label %$44
$44:
%186 = phi i32 [%128, %$42], [%177, %$61] ; # C
%187 = phi i64 [%130, %$42], [%181, %$61] ; # ->
br label %$5
$5:
%188 = phi i32 [%9, %$7], [%62, %$10], [%94, %$30], [%186, %$44] ; # C
%189 = phi i64 [0, %$7], [%63, %$10], [%101, %$30], [%187, %$44] ; # ->
ret i64 %189
%51 = phi i64 [%46, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
%51 = phi i64 [%46, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
%77 = phi i64 [%76, %$29], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
%77 = phi i64 [%76, %$29], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
%1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 64) to i32*)
; # (unless Chr (setq Chr (call $Get)))
%1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 144) to i32*)
%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
; # (call $Get)
%3 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%4 = call i32 %3()
br label %$4
%11 = phi i32 [%8, %$4], [%9, %$5] ; # Chr
%12 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%10, %$5] ; # ->
ret i64 %12
; # (mkChar C)
%7 = call i64 @mkChar(i32 %5)
br label %$7
$7:
%8 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%7, %$6] ; # ->
ret i64 %8
%6 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 64) to i32*)
; # (unless Chr (setq Chr (call $Get)))
%6 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 144) to i32*)
%11 = phi i32 [%6, %$4], [%10, %$5] ; # Chr
; # (call $Get)
%8 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%9 = call i32 %8()
br label %$7
$7:
%10 = phi i32 [%6, %$5], [%9, %$6] ; # ->
%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 ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%16, %$8] ; # ->
%13 = call i64 @mkChar(i32 %12)
br label %$10
$10:
%14 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%13, %$9] ; # ->
%19 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%20 = call i32 %19()
%15 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%16 = call i32 %15()
br label %$10
$11:
%25 = and i64 %22, 8
%26 = icmp ne i64 %25, 0
br i1 %26, label %$14, label %$13
%21 = and i64 %18, 8
%22 = icmp ne i64 %21, 0
br i1 %22, label %$15, label %$14
$15:
%23 = inttoptr i64 %18 to i64*
%24 = load i64, i64* %23
br label %$11
%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] ; # ->
%25 = call i64 @evList(i64 %18)
br label %$11
$11:
%26 = phi i64 [%18, %$13], [%24, %$15], [%25, %$14] ; # ->
%37 = phi i64 [%36, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$18] ; # ->
br label %$20
$20:
%33 = phi i64 [%32, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$19] ; # ->
%38 = icmp eq i64 %30, ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64)
br i1 %38, label %$21, label %$20
$21:
%34 = icmp eq i64 %26, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64)
br i1 %34, label %$22, label %$21
$22:
%9 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%8, %$3] ; # ->
%9 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%8, %$3] ; # ->
%9 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%9 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%18 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$13] ; # ->
%18 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$13] ; # ->
%22 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$16] ; # ->
%22 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$16] ; # ->
%23 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [%18, %$14], [%22, %$17] ; # ->
%23 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [%18, %$14], [%22, %$17] ; # ->
%39 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%39 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%64 = call i64 @cons(i64 %63, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%64 = call i64 @cons(i64 %63, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%102 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%39, %$21], [%96, %$24] ; # ->
%102 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%39, %$21], [%96, %$24] ; # ->
%1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 64) to i32*)
; # (unless C (setq C (call $Get)))
%1 = load i32, i32* bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 144) to i32*)
%6 = phi i32 [%1, %$1], [%5, %$2] ; # C
; # (call $Get)
%3 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%4 = call i32 %3()
br label %$4
$4:
%5 = phi i32 [%1, %$2], [%4, %$3] ; # ->
%13 = inttoptr i64 %12 to i64*
%14 = load i64, i64* %13
%15 = getelementptr i64, i64* %13, i32 1
%16 = load i64, i64* %15
%12 = inttoptr i64 %11 to i64*
%13 = load i64, i64* %12
%14 = getelementptr i64, i64* %12, i32 1
%15 = load i64, i64* %14
br label %$8
$9:
%19 = and i64 %14, 8
%20 = icmp ne i64 %19, 0
br i1 %20, label %$12, label %$11
%18 = and i64 %13, 8
%19 = icmp ne i64 %18, 0
br i1 %19, label %$13, label %$12
$13:
%20 = inttoptr i64 %13 to i64*
%21 = load i64, i64* %20
br label %$9
%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] ; # ->
%22 = call i64 @evList(i64 %13)
br label %$9
$9:
%23 = phi i64 [%13, %$11], [%21, %$13], [%22, %$12] ; # ->
%25 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
%24 = icmp eq i64 %23, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
br i1 %24, label %$15, label %$14
$15:
%25 = phi i32 [%8, %$9] ; # C
%26 = phi i64 [%15, %$9] ; # X
%30 = call i64 @cons(i64 %29, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%29 = call i64 @cons(i64 %28, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%31 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 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 ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %34, i64* %38
%30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
%31 = load i64, i64* %30
%32 = alloca i64, i64 2, align 16
%33 = ptrtoint i64* %32 to i64
%34 = inttoptr i64 %33 to i64*
store i64 %29, i64* %34
%35 = add i64 %33, 8
%36 = inttoptr i64 %35 to i64*
store i64 %31, i64* %36
%37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %33, i64* %37
%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
%38 = and i64 %26, 15
%39 = icmp eq i64 %38, 0
br i1 %39, label %$16, label %$17
$16:
%40 = phi i32 [%25, %$15] ; # C
%41 = phi i64 [%26, %$15] ; # X
%42 = phi i64 [%29, %$15] ; # Y
%46 = call i64 @cons(i64 %45, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%47 = inttoptr i64 %43 to i64*
store i64 %46, i64* %47
%45 = call i64 @cons(i64 %44, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%46 = inttoptr i64 %42 to i64*
store i64 %45, i64* %46
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
br label %$18
$18:
%47 = phi i32 [%40, %$16], [%111, %$27] ; # C
%48 = phi i64 [%41, %$16], [%112, %$27] ; # X
%49 = phi i64 [%42, %$16], [%118, %$27] ; # Y
%50 = phi i64 [%45, %$16], [%117, %$27] ; # Z
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
br label %$19
$19:
%52 = phi i32 [%47, %$18], [%76, %$23] ; # C
%53 = phi i64 [%48, %$18], [%77, %$23] ; # X
%54 = phi i64 [%49, %$18], [%78, %$23] ; # Y
%55 = phi i64 [%50, %$18], [%83, %$23] ; # Z
%56 = phi i64 [%51, %$18], [%80, %$23] ; # N
%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
%58 = icmp sgt i64 %57, 0
br i1 %58, label %$20, label %$21
$20:
%59 = phi i32 [%52, %$19] ; # C
%60 = phi i64 [%53, %$19] ; # X
%61 = phi i64 [%54, %$19] ; # Y
%62 = phi i64 [%55, %$19] ; # Z
%63 = phi i64 [%57, %$19] ; # N
%65 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%66 = call i32 %65()
%64 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%65 = call i32 %64()
%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
%66 = call i1 @eol(i32 %65)
br i1 %66, label %$22, label %$23
$22:
%67 = phi i32 [%65, %$20] ; # C
%68 = phi i64 [%60, %$20] ; # X
%69 = phi i64 [%61, %$20] ; # Y
%70 = phi i64 [%62, %$20] ; # Z
%71 = phi i64 [%63, %$20] ; # N
%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 ([21 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
%72 = inttoptr i64 %33 to i64*
%73 = getelementptr i64, i64* %72, i32 1
%74 = load i64, i64* %73
%75 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %74, i64* %75
ret i64 %29
$23:
%76 = phi i32 [%65, %$20] ; # C
%77 = phi i64 [%60, %$20] ; # X
%78 = phi i64 [%61, %$20] ; # Y
%79 = phi i64 [%62, %$20] ; # Z
%80 = phi i64 [%63, %$20] ; # N
%84 = call i64 @cons(i64 %83, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
%83 = call i64 @cons(i64 %82, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%84 = inttoptr i64 %79 to i64*
%85 = getelementptr i64, i64* %84, i32 1
store i64 %83, i64* %85
br label %$19
$21:
%86 = phi i32 [%52, %$19] ; # C
%87 = phi i64 [%53, %$19] ; # X
%88 = phi i64 [%54, %$19] ; # Y
%89 = phi i64 [%55, %$19] ; # Z
%90 = phi i64 [%57, %$19] ; # N
%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
%94 = and i64 %93, 15
%95 = icmp ne i64 %94, 0
br i1 %95, label %$25, label %$24
$24:
%96 = phi i32 [%86, %$21] ; # C
%97 = phi i64 [%93, %$21] ; # X
%98 = phi i64 [%88, %$21] ; # Y
%99 = phi i64 [%89, %$21] ; # Z
%101 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%102 = call i32 %101()
%100 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%101 = call i32 %100()
%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
%102 = call i1 @eol(i32 %101)
br i1 %102, label %$26, label %$27
$26:
%103 = phi i32 [%101, %$24] ; # C
%104 = phi i64 [%97, %$24] ; # X
%105 = phi i64 [%98, %$24] ; # Y
%106 = phi i64 [%99, %$24] ; # Z
%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 ([21 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
%107 = inttoptr i64 %33 to i64*
%108 = getelementptr i64, i64* %107, i32 1
%109 = load i64, i64* %108
%110 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %109, i64* %110
ret i64 %29
$27:
%111 = phi i32 [%101, %$24] ; # C
%112 = phi i64 [%97, %$24] ; # X
%113 = phi i64 [%98, %$24] ; # Y
%114 = phi i64 [%99, %$24] ; # Z
%118 = call i64 @cons(i64 %117, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%117 = call i64 @cons(i64 %116, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%119 = call i64 @cons(i64 %118, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
%118 = call i64 @cons(i64 %117, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%119 = inttoptr i64 %113 to i64*
%120 = getelementptr i64, i64* %119, i32 1
store i64 %118, i64* %120
br label %$18
$25:
%121 = phi i32 [%86, %$21] ; # C
%122 = phi i64 [%93, %$21] ; # X
%123 = phi i64 [%88, %$21] ; # Y
%124 = phi i64 [%89, %$21] ; # Z
%125 = phi i64 [0, %$21] ; # ->
$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
$17:
%126 = phi i32 [%25, %$15], [%121, %$25] ; # C
%127 = phi i64 [%26, %$15], [%122, %$25] ; # X
%128 = phi i64 [%29, %$15], [%123, %$25] ; # Y
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
br label %$28
$28:
%129 = phi i32 [%126, %$17], [%135, %$29] ; # C
%130 = phi i64 [%127, %$17], [%136, %$29] ; # X
%131 = phi i64 [%128, %$17], [%140, %$29] ; # Y
%133 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%134 = call i32 %133()
%132 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%133 = call i32 %132()
%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
%134 = call i1 @eol(i32 %133)
br i1 %134, label %$30, label %$29
$29:
%135 = phi i32 [%133, %$28] ; # C
%136 = phi i64 [%130, %$28] ; # X
%137 = phi i64 [%131, %$28] ; # Y
%141 = call i64 @cons(i64 %140, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
%140 = call i64 @cons(i64 %139, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%141 = inttoptr i64 %137 to i64*
%142 = getelementptr i64, i64* %141, i32 1
store i64 %140, i64* %142
br label %$28
$30:
%143 = phi i32 [%133, %$28] ; # C
%144 = phi i64 [%130, %$28] ; # X
%145 = phi i64 [%131, %$28] ; # Y
%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 ([21 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
%146 = inttoptr i64 %33 to i64*
%147 = getelementptr i64, i64* %146, i32 1
%148 = load i64, i64* %147
%149 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %148, i64* %149
br label %$8
$14:
%150 = phi i32 [%8, %$9] ; # C
%151 = phi i64 [%15, %$9] ; # X
%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
%152 = and i64 %151, 15
%153 = icmp ne i64 %152, 0
br i1 %153, label %$32, label %$31
$32:
%154 = phi i32 [%150, %$14] ; # C
%155 = phi i64 [%151, %$14] ; # X
%157 = alloca i64, i64 4, align 16
store i64 4, i64* %157
%158 = getelementptr i64, i64* %157, i32 2
store i64 2, i64* %158
%156 = alloca i64, i64 4, align 16
store i64 4, i64* %156
%157 = getelementptr i64, i64* %156, i32 2
store i64 2, i64* %157
%160 = ptrtoint i64* %159 to i64
%161 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 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 ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %160, i64* %165
%159 = ptrtoint i64* %158 to i64
%160 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
%161 = load i64, i64* %160
%162 = inttoptr i64 %159 to i64*
%163 = getelementptr i64, i64* %162, i32 1
store i64 %161, i64* %163
%164 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %159, i64* %164
%169 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%170 = call i32 %169()
%168 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%169 = call i32 %168()
%174 = phi i32 [%170, %$32] ; # C
%175 = phi i64 [%167, %$32] ; # X
%176 = phi i64 [0, %$32] ; # ->
%171 = phi i32 [%169, %$33] ; # C
%172 = phi i64 [%166, %$33] ; # X
br label %$33
$35:
%173 = phi i32 [%169, %$33] ; # C
%174 = phi i64 [%166, %$33] ; # X
%175 = phi i64 [0, %$33] ; # ->
%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 ([21 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
%178 = call i64 @consStr(i64 %177)
%179 = inttoptr i64 %159 to i64*
%180 = getelementptr i64, i64* %179, i32 1
%181 = load i64, i64* %180
%182 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %181, i64* %182
br label %$8
$31:
%183 = phi i32 [%150, %$14] ; # C
%184 = phi i64 [%151, %$14] ; # X
%187 = alloca i64, i64 4, align 16
store i64 4, i64* %187
%188 = getelementptr i64, i64* %187, i32 2
store i64 2, i64* %188
%186 = alloca i64, i64 4, align 16
store i64 4, i64* %186
%187 = getelementptr i64, i64* %186, i32 2
store i64 2, i64* %187
%190 = ptrtoint i64* %189 to i64
%191 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 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 ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %190, i64* %195
%189 = ptrtoint i64* %188 to i64
%190 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 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 ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %189, i64* %194
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
br label %$36
$36:
%195 = phi i32 [%183, %$31], [%218, %$39] ; # C
%196 = phi i64 [%184, %$31], [%219, %$39] ; # X
%197 = phi i64 [%185, %$31], [%220, %$39] ; # N
%200 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%201 = call i32 %200()
%199 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%200 = call i32 %199()
%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
%201 = call i1 @eol(i32 %200)
br i1 %201, label %$37, label %$38
$37:
%202 = phi i32 [%200, %$36] ; # C
%203 = phi i64 [%196, %$36] ; # X
%204 = phi i64 [%197, %$36] ; # N
%209 = call i64 @cons(i64 %208, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%208 = call i64 @cons(i64 %207, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%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 ([21 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
%209 = inttoptr i64 %189 to i64*
%210 = getelementptr i64, i64* %209, i32 1
%211 = load i64, i64* %210
%212 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %211, i64* %212
ret i64 %208
$38:
%213 = phi i32 [%200, %$36] ; # C
%214 = phi i64 [%196, %$36] ; # X
%215 = phi i64 [%197, %$36] ; # N
%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
%217 = icmp eq i64 %216, 0
br i1 %217, label %$40, label %$39
%222 = phi i32 [%214, %$37] ; # C
%223 = phi i64 [%215, %$37] ; # X
%224 = phi i64 [%217, %$37] ; # N
%225 = phi i64 [0, %$37] ; # ->
%218 = phi i32 [%213, %$38] ; # C
%219 = phi i64 [%214, %$38] ; # X
%220 = phi i64 [%216, %$38] ; # N
br label %$36
$40:
%221 = phi i32 [%213, %$38] ; # C
%222 = phi i64 [%214, %$38] ; # X
%223 = phi i64 [%216, %$38] ; # N
%224 = phi i64 [0, %$38] ; # ->
%229 = call i64 @cons(i64 %228, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%228 = call i64 @cons(i64 %227, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%230 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 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 ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %233, i64* %237
%229 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
%230 = load i64, i64* %229
%231 = alloca i64, i64 2, align 16
%232 = ptrtoint i64* %231 to i64
%233 = inttoptr i64 %232 to i64*
store i64 %228, i64* %233
%234 = add i64 %232, 8
%235 = inttoptr i64 %234 to i64*
store i64 %230, i64* %235
%236 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %232, i64* %236
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
br label %$41
$41:
%237 = phi i32 [%221, %$40], [%284, %$48] ; # C
%238 = phi i64 [%222, %$40], [%285, %$48] ; # X
%239 = phi i64 [%223, %$40], [%286, %$48] ; # N
%240 = phi i64 [%228, %$40], [%292, %$48] ; # Y
%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
%244 = and i64 %243, 15
%245 = icmp eq i64 %244, 0
br i1 %245, label %$42, label %$43
$42:
%246 = phi i32 [%237, %$41] ; # C
%247 = phi i64 [%243, %$41] ; # X
%248 = phi i64 [%239, %$41] ; # N
%249 = phi i64 [%240, %$41] ; # Y
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
br label %$44
$44:
%252 = phi i32 [%246, %$42], [%280, %$47] ; # C
%253 = phi i64 [%247, %$42], [%281, %$47] ; # X
%254 = phi i64 [%250, %$42], [%282, %$47] ; # N
%255 = phi i64 [%249, %$42], [%283, %$47] ; # Y
%258 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%259 = call i32 %258()
%257 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%258 = call i32 %257()
%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
%259 = call i1 @eol(i32 %258)
br i1 %259, label %$45, label %$46
$45:
%260 = phi i32 [%258, %$44] ; # C
%261 = phi i64 [%253, %$44] ; # X
%262 = phi i64 [%254, %$44] ; # N
%263 = phi i64 [%255, %$44] ; # Y
%268 = call i64 @cons(i64 %267, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
%267 = call i64 @cons(i64 %266, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%268 = inttoptr i64 %263 to i64*
%269 = getelementptr i64, i64* %268, i32 1
store i64 %267, i64* %269
%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 ([21 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
%270 = inttoptr i64 %189 to i64*
%271 = getelementptr i64, i64* %270, i32 1
%272 = load i64, i64* %271
%273 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %272, i64* %273
ret i64 %228
$46:
%274 = phi i32 [%258, %$44] ; # C
%275 = phi i64 [%253, %$44] ; # X
%276 = phi i64 [%254, %$44] ; # N
%277 = phi i64 [%255, %$44] ; # Y
%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
%279 = icmp eq i64 %278, 0
br i1 %279, label %$48, label %$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] ; # ->
%280 = phi i32 [%274, %$46] ; # C
%281 = phi i64 [%275, %$46] ; # X
%282 = phi i64 [%278, %$46] ; # N
%283 = phi i64 [%277, %$46] ; # Y
br label %$44
$48:
%284 = phi i32 [%274, %$46] ; # C
%285 = phi i64 [%275, %$46] ; # X
%286 = phi i64 [%278, %$46] ; # N
%287 = phi i64 [%277, %$46] ; # Y
%288 = phi i64 [0, %$46] ; # ->
%293 = call i64 @cons(i64 %292, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
%292 = call i64 @cons(i64 %291, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%293 = inttoptr i64 %287 to i64*
%294 = getelementptr i64, i64* %293, i32 1
store i64 %292, i64* %294
br label %$41
$43:
%295 = phi i32 [%237, %$41] ; # C
%296 = phi i64 [%243, %$41] ; # X
%297 = phi i64 [%239, %$41] ; # N
%298 = phi i64 [%240, %$41] ; # Y
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
br label %$49
$49:
%299 = phi i32 [%295, %$43], [%311, %$50] ; # C
%300 = phi i64 [%296, %$43], [%312, %$50] ; # X
%301 = phi i64 [%297, %$43], [%313, %$50] ; # N
%302 = phi i64 [%298, %$43], [%314, %$50] ; # Y
%306 = call i64 @cons(i64 %305, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
%305 = call i64 @cons(i64 %304, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%306 = inttoptr i64 %302 to i64*
%307 = getelementptr i64, i64* %306, i32 1
store i64 %305, i64* %307
%309 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
%310 = call i32 %309()
%308 = load i32()*, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%309 = call i32 %308()
%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
%310 = call i1 @eol(i32 %309)
br i1 %310, label %$51, label %$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] ; # ->
%311 = phi i32 [%309, %$49] ; # C
%312 = phi i64 [%300, %$49] ; # X
%313 = phi i64 [%301, %$49] ; # N
%314 = phi i64 [%305, %$49] ; # Y
br label %$49
$51:
%315 = phi i32 [%309, %$49] ; # C
%316 = phi i64 [%300, %$49] ; # X
%317 = phi i64 [%301, %$49] ; # N
%318 = phi i64 [%305, %$49] ; # Y
%319 = phi i64 [0, %$49] ; # ->
%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 ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %323, i64* %324
%320 = inttoptr i64 %189 to i64*
%321 = getelementptr i64, i64* %320, i32 1
%322 = load i64, i64* %321
%323 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %322, i64* %323
br label %$8
$8:
%324 = phi i32 [%143, %$30], [%173, %$35], [%315, %$51] ; # C
%325 = phi i64 [%144, %$30], [%174, %$35], [%316, %$51] ; # X
%326 = phi i64 [%29, %$30], [%178, %$35], [%228, %$51] ; # ->
%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 ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%327, %$7] ; # ->
ret i64 %329
%327 = phi i32 [%7, %$5], [%324, %$8] ; # C
%328 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%326, %$8] ; # ->
ret i64 %328
%8 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%8 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
store void(i8)* @putOut, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
store void(i8)* @putOut, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%181 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
%181 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
%211 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 808) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %211
%211 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 808) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %211
%212 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %212
%212 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %212
%215 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 200) to i64) to i64*
%215 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 200) to i64) to i64*
%217 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 216) to i64) to i64*
%217 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 216) to i64) to i64*
%222 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 200) to i64) to i64*
%222 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 200) to i64) to i64*
%223 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 792) to i64) to i64*
%223 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 792) to i64) to i64*
%226 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 792) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %226
%226 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 792) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %226
%37 = phi i64 [%32, %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15] ; # ->
%37 = phi i64 [%32, %$13], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15] ; # ->
%22 = phi i64 [%13, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
%22 = phi i64 [%13, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
%45 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%45 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%105 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%105 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%387 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%387 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%696 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%696 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%732 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%732 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%780 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%780 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%825 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$29], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$41] ; # ->
%825 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$29], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$41] ; # ->
%0 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%0 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%0 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%0 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%3 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%3 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%8 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%5 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%5 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%5 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%5 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%7 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%7 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%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
%9 = phi i8 [%8, %$6], [%34, %$17] ; # B
; # (if (or (== B 127) (> 32 B)) (prog (call $Put (char "\\")) (outWo...
; # (or (== B 127) (> 32 B))
; # (== B 127)
%10 = icmp eq i8 %9, 127
%18 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%16 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %16(i8 92)
; # (i64 B)
%17 = zext i8 %15 to i64
; # (outWord (i64 B))
call void @outWord(i64 %17)
; # (call $Put (char "\\"))
%18 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%19 = phi i8 [%15, %$8], [%17, %$10] ; # B
%19 = phi i8 [%13, %$8] ; # B
; # (when (or (== B (char "\\")) (strchr $Delim (i32 B))) (call $Put ...
; # (or (== B (char "\\")) (strchr $Delim (i32 B)))
; # (== B (char "\\"))
%20 = icmp eq i8 %19, 92
br i1 %20, label %$13, label %$14
$14:
%21 = phi i8 [%19, %$11] ; # B
; # (i32 B)
%22 = zext i8 %21 to i32
; # (strchr $Delim (i32 B))
%23 = call i8* @strchr(i8* bitcast ([16 x i8]* @$Delim to i8*), i32 %22)
%24 = icmp ne i8* %23, null
br label %$13
$13:
%25 = phi i8 [%19, %$11], [%21, %$14] ; # B
%26 = phi i1 [1, %$11], [%24, %$14] ; # ->
br i1 %26, label %$15, label %$16
$15:
%27 = phi i8 [%25, %$13] ; # B
; # (call $Put (char "\\"))
%28 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %28(i8 92)
br label %$16
$16:
%29 = phi i8 [%25, %$13], [%27, %$15] ; # B
%20 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
call void %20(i8 %19)
%30 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %30(i8 %29)
br label %$12
$12:
%31 = phi i8 [%15, %$10], [%29, %$16] ; # B
%26 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
call void %26(i8 92)
%37 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %37(i8 92)
%27 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
call void %27(i8 46)
%38 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
call void %38(i8 46)
%21 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%21 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%31 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%31 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%43 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%43 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%46 = call i64 @isIntern(i64 %40, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64))
%46 = call i64 @isIntern(i64 %40, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64))
%59 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%59 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%87 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%87 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%97 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%97 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%107 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%107 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%117 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%117 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%129 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%129 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%160 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%160 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%191 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%191 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%199 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%199 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%225 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%225 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%230 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%230 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%247 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%247 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%40 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%40 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%50 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%50 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%3 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%3 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%11 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7] ; # ->
%11 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$6], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$7] ; # ->
%62 = phi i64 [%57, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%62 = phi i64 [%57, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%101 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%70, %$24], [%99, %$32] ; # ->
%101 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%70, %$24], [%99, %$32] ; # ->
%106 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%101, %$12], [%105, %$35] ; # ->
%106 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%101, %$12], [%105, %$35] ; # ->
store i32()* @getParse, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**)
store i32()* @getParse, i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**)
%26 = call i64 @cons(i64 %24, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%26 = call i64 @cons(i64 %24, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%39 = call i64 @cons(i64 %36, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%39 = call i64 @cons(i64 %36, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%43 = phi i64 [%21, %$6], [%23, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%26, %$13] ; # ->
%43 = phi i64 [%21, %$6], [%23, %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%26, %$13] ; # ->
%44 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 96) to i32()**) to i8**
%44 = bitcast i32()** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 88) to i32()**) to i8**
%11 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i64*
%11 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i64*
store void(i8)* @putString, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
store void(i8)* @putString, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i64*
%3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i64*
%2 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i64*
%2 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i64*
%27 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%26, %$7] ; # ->
%27 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%26, %$7] ; # ->
%106 = phi i64 [%16, %$9], [%44, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%71, %$23], [%99, %$26] ; # ->
%106 = phi i64 [%16, %$9], [%44, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%71, %$23], [%99, %$26] ; # ->
; # (unless (nil? (val $Remark)) (let (V (push NIL $Nil ZERO NIL NIL)...
; # (val $Remark)
%24 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 872) to i64) to i64*
%25 = load i64, i64* %24
; # (nil? (val $Remark))
%26 = icmp eq i64 %25, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
br i1 %26, label %$8, label %$7
$7:
; # (let (V (push NIL $Nil ZERO NIL NIL) E (push NIL V ZERO @ NIL)) (...
; # (push NIL $Nil ZERO NIL NIL)
%27 = alloca i64, i64 5, align 16
%28 = ptrtoint i64* %27 to i64
%29 = add i64 %28, 8
%30 = inttoptr i64 %29 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %30
%31 = add i64 %28, 16
%32 = inttoptr i64 %31 to i64*
store i64 2, i64* %32
; # (push NIL V ZERO @ NIL)
%33 = alloca i64, i64 5, align 16
%34 = ptrtoint i64* %33 to i64
%35 = add i64 %34, 8
%36 = inttoptr i64 %35 to i64*
store i64 %28, i64* %36
%37 = add i64 %34, 16
%38 = inttoptr i64 %37 to i64*
store i64 2, i64* %38
%39 = add i64 %34, 24
%40 = inttoptr i64 %39 to i64*
store i64 %25, i64* %40
; # (set 4 V X)
%41 = inttoptr i64 %28 to i64*
%42 = getelementptr i64, i64* %41, i32 3
store i64 %18, i64* %42
; # (set V (link (ofs V 3) T) E (link (ofs E 3)))
; # (ofs V 3)
%43 = add i64 %28, 24
; # (link (ofs V 3) T)
%44 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
%45 = load i64, i64* %44
%46 = inttoptr i64 %43 to i64*
%47 = getelementptr i64, i64* %46, i32 1
store i64 %45, i64* %47
%48 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %43, i64* %48
%49 = inttoptr i64 %28 to i64*
store i64 %43, i64* %49
; # (ofs E 3)
%50 = add i64 %34, 24
; # (link (ofs E 3))
%51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
%52 = load i64, i64* %51
%53 = inttoptr i64 %50 to i64*
%54 = getelementptr i64, i64* %53, i32 1
store i64 %52, i64* %54
%55 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %50, i64* %55
%56 = inttoptr i64 %34 to i64*
store i64 %50, i64* %56
; # (evList E)
%57 = call i64 @evList(i64 %34)
br label %$8
$8:
%24 = inttoptr i64 %6 to i64*
%25 = getelementptr i64, i64* %24, i32 1
%26 = load i64, i64* %25
%27 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %26, i64* %27
%58 = inttoptr i64 %6 to i64*
%59 = getelementptr i64, i64* %58, i32 1
%60 = load i64, i64* %59
%61 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %60, i64* %61
; # (let E (save (parse (xName Exe X) YES (hex "5D0A") 0)) (evList E)...
; # (xName Exe X)
%12 = call i64 @xName(i64 %0, i64 %11)
; # (parse (xName Exe X) YES (hex "5D0A") 0)
; # (let E (save (parse (xName X) YES (hex "5D0A") 0)) (evList E))
; # (xName X)
%12 = call i64 @xName(i64 %11)
; # (parse (xName X) YES (hex "5D0A") 0)
; # (save (parse (xName Exe X) YES (hex "5D0A") 0))
%14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
; # (save (parse (xName X) YES (hex "5D0A") 0))
%14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %100
%101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %101
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %100
%101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %101
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %104
%105 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 568) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %105
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %104
%105 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 568) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %105
%155 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%155 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%157 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%157 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%1 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%19, %$7] ; # X
%1 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%19, %$7] ; # X
%10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), i64* %10
%10 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), i64* %10
%14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %14
%14 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 424) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %14
%15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [0, %$9] ; # ->
%15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$8], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [0, %$9] ; # ->
%46 = phi i64 [%15, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$18] ; # ->
%46 = phi i64 [%15, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$18] ; # ->
%112 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 520) to i64) to i64*
%112 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 520) to i64) to i64*
%119 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$30] ; # ->
%119 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$30] ; # ->
%127 = phi i64 [%115, %$30], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$31] ; # ->
%127 = phi i64 [%115, %$30], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$31] ; # ->
%74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %74
%74 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %74
; # (let (Nm (xName Exe Sym1) Len (pathSize Nm) Buf (pathString Nm (b...
; # (xName Exe Sym1)
%88 = call i64 @xName(i64 %0, i64 %4)
; # (let (Nm (xName Sym1) Len (pathSize Nm) Buf (pathString Nm (b8 (+...
; # (xName Sym1)
%88 = call i64 @xName(i64 %4)
%297 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 408) to i64), i64* %297
%297 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 232) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 408) to i64), i64* %297
; # (let Nm (xName Exe Sym2) (unless (fopen (pathString Nm (b8 (pathS...
; # (xName Exe Sym2)
%303 = call i64 @xName(i64 %0, i64 %28)
; # (let Nm (xName Sym2) (unless (fopen (pathString Nm (b8 (pathSize ...
; # (xName Sym2)
%303 = call i64 @xName(i64 %28)
; # (let Nm (xName Exe Sym3) (unless (fopen (pathString Nm (b8 (pathS...
; # (xName Exe Sym3)
%315 = call i64 @xName(i64 %0, i64 %40)
; # (let Nm (xName Sym3) (unless (fopen (pathString Nm (b8 (pathSize ...
; # (xName Sym3)
%315 = call i64 @xName(i64 %40)
; # (let (Nm (xName Exe Sym) Fp (fopen (pathString Nm (b8 (pathSize N...
; # (xName Exe Sym)
%24 = call i64 @xName(i64 %0, i64 %23)
; # (let (Nm (xName Sym) Fp (fopen (pathString Nm (b8 (pathSize Nm)))...
; # (xName Sym)
%24 = call i64 @xName(i64 %23)
%72 = call i64 @cons(i64 %71, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%72 = call i64 @cons(i64 %71, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%87 = call i64 @cons(i64 %83, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%87 = call i64 @cons(i64 %83, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%107 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%72, %$19] ; # ->
%107 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%72, %$19] ; # ->
%86 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21], [%81, %$23] ; # ->
%86 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21], [%81, %$23] ; # ->
%44 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%13, %$19] ; # ->
%44 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%13, %$19] ; # ->
%52 = phi i64 [%13, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
%52 = phi i64 [%13, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
%55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$11], [%54, %$15] ; # ->
%55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$11], [%54, %$15] ; # ->
%58 = phi i64 [%57, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
%58 = phi i64 [%57, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
%793 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 520) to i64) to i64*
%793 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 520) to i64) to i64*
%126 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$34], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$36] ; # ->
%126 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$34], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$36] ; # ->
%127 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$20], [%126, %$30] ; # ->
%127 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$20], [%126, %$30] ; # ->
%128 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%127, %$22] ; # ->
%128 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%127, %$22] ; # ->
%19 = call i64 @cons(i64 %18, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%19 = call i64 @cons(i64 %18, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%35 = call i64 @cons(i64 %34, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%35 = call i64 @cons(i64 %34, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%120, %$23] ; # R
%56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%120, %$23] ; # R
%30 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%38, %$10] ; # R
%30 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%38, %$10] ; # R
%34 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%93, %$15] ; # R
%34 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%93, %$15] ; # R
%38 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%47, %$10] ; # R
%38 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%47, %$10] ; # R
%97 = call i64 @cons(i64 %96, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%97 = call i64 @cons(i64 %96, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%129 = call i64 @cons(i64 %128, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%129 = call i64 @cons(i64 %128, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%38 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%47, %$10] ; # R
%38 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%47, %$10] ; # R
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%137 = call i64 @cons(i64 %136, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%137 = call i64 @cons(i64 %136, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%133 = call i64 @cons(i64 %128, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%133 = call i64 @cons(i64 %128, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%118 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%88, %$20] ; # ->
%118 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$18], [%88, %$20] ; # ->
%111 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
%111 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
%182 = phi i64 [%115, %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
%182 = phi i64 [%115, %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
%184 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17], [%182, %$22] ; # ->
%184 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17], [%182, %$22] ; # ->
%177 = phi i64 [%107, %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
%177 = phi i64 [%107, %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
%179 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17], [%177, %$22] ; # ->
%179 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17], [%177, %$22] ; # ->
%176 = phi i64 [%107, %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$25] ; # ->
%176 = phi i64 [%107, %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$25] ; # ->
%178 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$17], [%176, %$22] ; # ->
%178 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$17], [%176, %$22] ; # ->
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%43 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%105, %$15] ; # R2
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%43 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%105, %$15] ; # R2
%230 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
%230 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%43 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [%105, %$15] ; # R2
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%104, %$15] ; # R
%43 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [%105, %$15] ; # R2
%230 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
%230 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
%62 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%124, %$20] ; # R
%62 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%124, %$20] ; # R
%154 = call i64 @cons(i64 %153, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%154 = call i64 @cons(i64 %153, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%22 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [%21, %$8] ; # ->
%22 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [%21, %$8] ; # ->
%3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%9 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%9 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
%17 = call i64 @get(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 824) to i64))
%17 = call i64 @get(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 824) to i64))
%33 = call i64 @cons(i64 %30, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%33 = call i64 @cons(i64 %30, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
call void @put(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 824) to i64), i64 %33)
call void @put(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 824) to i64), i64 %33)
%37 = call i64 @cons(i64 %36, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%37 = call i64 @cons(i64 %36, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%38 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %37)
%38 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %37)
call void @put(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 824) to i64), i64 %38)
call void @put(i64 %0, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 824) to i64), i64 %38)
%26 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 264) to i64), i64 %13)
%26 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 264) to i64), i64 %13)
%104 = phi i64 [%91, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%104 = phi i64 [%91, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %236
%237 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 112) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %236
%237 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 104) to i64) to i64*
%310 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 112) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %310
%310 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 104) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %310
%77 = call i64 @method(i64 %51, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64))
%77 = call i64 @method(i64 %51, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64))
%81 = call i64 @evMethod(i64 %51, i64 %80, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), i64 %77, i64 %79)
%81 = call i64 @evMethod(i64 %51, i64 %80, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), i64 %77, i64 %79)
%53 = phi i64 [%33, %$24], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
%53 = phi i64 [%33, %$24], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$25] ; # ->
%59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21], [%53, %$26], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$28] ; # ->
%59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21], [%53, %$26], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$28] ; # ->
%68 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%59, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$30] ; # ->
%68 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%59, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$30] ; # ->
%69 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%68, %$14] ; # ->
%69 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%68, %$14] ; # ->
%64 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$23], [%33, %$25] ; # ->
%64 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$23], [%33, %$25] ; # ->
%70 = phi i64 [%64, %$22], [%33, %$27], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$26] ; # ->
%70 = phi i64 [%64, %$22], [%33, %$27], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$26] ; # ->
%72 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%70, %$17] ; # ->
%72 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%70, %$17] ; # ->
%44 = phi i64 [%42, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%44 = phi i64 [%42, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%58 = phi i64 [%57, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$-1] ; # ->
%58 = phi i64 [%57, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$-1] ; # ->
%59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%58, %$21] ; # ->
%59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%58, %$21] ; # ->
%27 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
%27 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
%28 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$12] ; # ->
%28 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$12] ; # ->
%32 = phi i64 [%27, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$16] ; # ->
%32 = phi i64 [%27, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$16] ; # ->
%48 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$24] ; # ->
%48 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$23], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$24] ; # ->
%15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$8] ; # ->
%15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$8] ; # ->
%16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%117 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%117 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
}
define i64 @_IfAt2(i64) align 8 {
$1:
; # (let X (cdr Exe) (set $At (eval (++ X))) (if (nil? (val $At2)) (r...
; # (cdr Exe)
%1 = inttoptr i64 %0 to i64*
%2 = getelementptr i64, i64* %1, i32 1
%3 = load i64, i64* %2
; # (set $At (eval (++ X)))
; # (++ X)
%4 = inttoptr i64 %3 to i64*
%5 = load i64, i64* %4
%6 = getelementptr i64, i64* %4, i32 1
%7 = load i64, i64* %6
; # (eval (++ X))
%8 = and i64 %5, 6
%9 = icmp ne i64 %8, 0
br i1 %9, label %$4, label %$3
$4:
br label %$2
$3:
%10 = and i64 %5, 8
%11 = icmp ne i64 %10, 0
br i1 %11, label %$6, label %$5
$6:
%12 = inttoptr i64 %5 to i64*
%13 = load i64, i64* %12
br label %$2
$5:
%14 = call i64 @evList(i64 %5)
br label %$2
$2:
%15 = phi i64 [%5, %$4], [%13, %$6], [%14, %$5] ; # ->
%16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
store i64 %15, i64* %16
; # (if (nil? (val $At2)) (run (cdr X)) (eval (car X)))
; # (val $At2)
%17 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
%18 = load i64, i64* %17
; # (nil? (val $At2))
%19 = icmp eq i64 %18, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
br i1 %19, label %$7, label %$8
$7:
%20 = phi i64 [%7, %$2] ; # X
; # (cdr X)
%21 = inttoptr i64 %20 to i64*
%22 = getelementptr i64, i64* %21, i32 1
%23 = load i64, i64* %22
; # (run (cdr X))
br label %$10
$10:
%24 = phi i64 [%23, %$7], [%46, %$19] ; # Prg
%25 = inttoptr i64 %24 to i64*
%26 = load i64, i64* %25
%27 = getelementptr i64, i64* %25, i32 1
%28 = load i64, i64* %27
%29 = and i64 %28, 15
%30 = icmp ne i64 %29, 0
br i1 %30, label %$13, label %$11
$13:
%31 = phi i64 [%28, %$10] ; # Prg
%32 = and i64 %26, 6
%33 = icmp ne i64 %32, 0
br i1 %33, label %$16, label %$15
$16:
br label %$14
$15:
%34 = and i64 %26, 8
%35 = icmp ne i64 %34, 0
br i1 %35, label %$18, label %$17
$18:
%36 = inttoptr i64 %26 to i64*
%37 = load i64, i64* %36
br label %$14
$17:
%38 = call i64 @evList(i64 %26)
br label %$14
$14:
%39 = phi i64 [%26, %$16], [%37, %$18], [%38, %$17] ; # ->
br label %$12
$11:
%40 = phi i64 [%28, %$10] ; # Prg
%41 = and i64 %26, 15
%42 = icmp eq i64 %41, 0
br i1 %42, label %$20, label %$19
$20:
%43 = phi i64 [%40, %$11] ; # Prg
%44 = call i64 @evList(i64 %26)
%45 = icmp ne i64 %44, 0
br label %$19
$19:
%46 = phi i64 [%40, %$11], [%43, %$20] ; # Prg
%47 = phi i1 [0, %$11], [%45, %$20] ; # ->
br label %$10
$12:
%48 = phi i64 [%31, %$14] ; # Prg
%49 = phi i64 [%39, %$14] ; # ->
br label %$9
$8:
%50 = phi i64 [%7, %$2] ; # X
; # (car X)
%51 = inttoptr i64 %50 to i64*
%52 = load i64, i64* %51
; # (eval (car X))
%53 = and i64 %52, 6
%54 = icmp ne i64 %53, 0
br i1 %54, label %$23, label %$22
$23:
br label %$21
$22:
%55 = and i64 %52, 8
%56 = icmp ne i64 %55, 0
br i1 %56, label %$25, label %$24
$25:
%57 = inttoptr i64 %52 to i64*
%58 = load i64, i64* %57
br label %$21
$24:
%59 = call i64 @evList(i64 %52)
br label %$21
$21:
%60 = phi i64 [%52, %$23], [%58, %$25], [%59, %$24] ; # ->
br label %$9
$9:
%61 = phi i64 [%20, %$12], [%50, %$21] ; # X
%62 = phi i64 [%49, %$12], [%60, %$21] ; # ->
ret i64 %62
%47 = phi i64 [%43, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%47 = phi i64 [%43, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%53, %$15] ; # ->
%56 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%53, %$15] ; # ->
%55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%51, %$15] ; # ->
%55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%51, %$15] ; # ->
%85 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%82, %$26] ; # ->
%85 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%82, %$26] ; # ->
%80 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%77, %$24] ; # ->
%80 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [%77, %$24] ; # ->
%123 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%117, %$38] ; # ->
%123 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$16], [%117, %$38] ; # ->
%16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%53, %$12] ; # R
%16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%53, %$12] ; # R
%16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%52, %$12] ; # R
%16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$1], [%52, %$12] ; # R
%55 = phi i64 [%18, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%54, %$16] ; # ->
%55 = phi i64 [%18, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%54, %$16] ; # ->
%130 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%88, %$36], [%127, %$29] ; # ->
%130 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%88, %$36], [%127, %$29] ; # ->
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%40, %$19] ; # ->
%42 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$14], [%40, %$19] ; # ->
%338 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%338 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%498 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%498 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%9 = phi i64 [%3, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # Val
%9 = phi i64 [%3, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # Val
%33 = getelementptr i8, i8* %6, i32 32
%34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %33, i8* %34, i64 168, i1 0)
%35 = getelementptr i8, i8* %6, i32 200
%33 = getelementptr i8, i8* %6, i32 72
%34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %33, i8* %34, i64 176, i1 0)
%35 = getelementptr i8, i8* %6, i32 32
; # (prog1 (if (setjmp (Ca: (rst))) (val $Ret) (run X)) (set $Catch (...
; # (if (setjmp (Ca: (rst))) (val $Ret) (run X))
; # (prog1 (ifn (setjmp (Ca: (rst))) (prog1 (run X) (set $At2 $Nil)) ...
; # (ifn (setjmp (Ca: (rst))) (prog1 (run X) (set $At2 $Nil)) (set $A...
%92 = phi i64 [%75, %$16] ; # Prg
%93 = phi i64 [%83, %$16] ; # ->
%90 = phi i64 [%73, %$16] ; # Prg
%91 = phi i64 [%81, %$16] ; # ->
; # (set $At2 $Nil)
%92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %92
br label %$11
$10:
%93 = phi i64 [%15, %$4] ; # X
; # (set $At2 $T)
%94 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), i64* %94
; # (val $Ret)
%95 = load i64, i64* @$Ret
%96 = bitcast i8* %6 to i8**
%97 = load i8*, i8** %96
store i8* %97, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 24) to i8**)
ret i64 %95
%98 = bitcast i8* %6 to i8**
%99 = load i8*, i8** %98
store i8* %99, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 24) to i8**)
ret i64 %97
%25 = getelementptr i8, i8* %6, i32 32
%26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %25, i8* %26, i64 168, i1 0)
%27 = getelementptr i8, i8* %6, i32 200
%25 = getelementptr i8, i8* %6, i32 72
%26 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %25, i8* %26, i64 176, i1 0)
%27 = getelementptr i8, i8* %6, i32 32
call void @err(i64 %0, i64 %1, i8* bitcast ([20 x i8]* @$76 to i8*), i8* null)
call void @err(i64 %0, i64 %1, i8* bitcast ([20 x i8]* @$77 to i8*), i8* null)
unreachable
}
define void @reentErr(i64, i64) align 8 {
$1:
; # (err Exe Tag ($ "Reentrant coroutine") null)
call void @err(i64 %0, i64 %1, i8* bitcast ([20 x i8]* @$78 to i8*), i8* null)
%3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%3 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
; # (putCrtEnv (Crt:) YES)
br i1 1, label %$4, label %$5
$4:
%15 = getelementptr i8, i8* %0, i32 112
%16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %15, i8* %16, i64 168, i1 0)
br label %$5
$5:
%17 = getelementptr i8, i8* %0, i32 280
; # (putCrtEnv (Crt:))
%15 = getelementptr i8, i8* %0, i32 152
%16 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %15, i8* %16, i64 176, i1 0)
%17 = getelementptr i8, i8* %0, i32 112
define void @runCo(i64, i64, i8*, i8*, i64) align 8 {
$1:
; # (let (Src: (coroutine Src) Dst: (coroutine Dst)) (Dst: tag Tag) (...
; # (Dst: tag Tag)
%5 = ptrtoint i8* %3 to i64
%6 = inttoptr i64 %5 to i64*
store i64 %1, i64* %6
; # (Dst: org (Src:))
%7 = getelementptr i8, i8* %3, i32 16
%8 = bitcast i8* %7 to i8**
store i8* %2, i8** %8
; # (Dst: otg (Src: tag))
%9 = getelementptr i8, i8* %3, i32 24
%10 = ptrtoint i8* %9 to i64
%11 = ptrtoint i8* %2 to i64
%12 = inttoptr i64 %11 to i64*
%13 = load i64, i64* %12
%14 = inttoptr i64 %10 to i64*
store i64 %13, i64* %14
; # (Dst: prg X)
%15 = getelementptr i8, i8* %3, i32 32
%16 = ptrtoint i8* %15 to i64
%17 = inttoptr i64 %16 to i64*
store i64 %4, i64* %17
; # (let (Siz (val $StkSize) Stk (stack)) (memset (Dst: lim (stack (o...
; # (val $StkSize)
%18 = load i64, i64* @$StkSize
; # (stack)
%19 = call i8* @llvm.stacksave()
; # (Dst: lim (stack (ofs Dst (- Siz))))
%20 = getelementptr i8, i8* %3, i32 40
%21 = bitcast i8* %20 to i8**
%22 = sub i64 0, %18
%23 = getelementptr i8, i8* %3, i64 %22
call void @llvm.stackrestore(i8* %23)
store i8* %23, i8** %21
; # (- Siz 256)
%24 = sub i64 %18, 256
; # (memset (Dst: lim (stack (ofs Dst (- Siz)))) 7 (- Siz 256) T)
call void @llvm.memset.p0i8.i64(i8* align 8 %23, i8 7, i64 %24, i1 0)
; # (stack Stk)
call void @llvm.stackrestore(i8* %19)
; # (Dst: at 0)
%25 = getelementptr i8, i8* %3, i32 48
%26 = ptrtoint i8* %25 to i64
%27 = inttoptr i64 %26 to i64*
store i64 0, i64* %27
; # (Dst: lnk (val $Link))
%28 = getelementptr i8, i8* %3, i32 56
%29 = ptrtoint i8* %28 to i64
%30 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
%31 = load i64, i64* %30
%32 = inttoptr i64 %29 to i64*
store i64 %31, i64* %32
; # (set $Bind (push (val $This) $This (Dst: bnd (push ZERO $At (val ...
; # (val $This)
%33 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
%34 = load i64, i64* %33
; # (Dst: bnd (push ZERO $At (val $Bind) Exe))
%35 = getelementptr i8, i8* %3, i32 64
%36 = ptrtoint i8* %35 to i64
%37 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 8) to i64) to i64*
%38 = load i64, i64* %37
%39 = alloca i64, i64 4, align 16
%40 = ptrtoint i64* %39 to i64
%41 = inttoptr i64 %40 to i64*
store i64 2, i64* %41
%42 = add i64 %40, 8
%43 = inttoptr i64 %42 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64), i64* %43
%44 = add i64 %40, 16
%45 = inttoptr i64 %44 to i64*
store i64 %38, i64* %45
%46 = add i64 %40, 24
%47 = inttoptr i64 %46 to i64*
store i64 %0, i64* %47
%48 = inttoptr i64 %36 to i64*
store i64 %40, i64* %48
; # (push (val $This) $This (Dst: bnd (push ZERO $At (val $Bind) Exe)...
%49 = alloca i64, i64 3, align 16
%50 = ptrtoint i64* %49 to i64
%51 = inttoptr i64 %50 to i64*
store i64 %34, i64* %51
%52 = add i64 %50, 8
%53 = inttoptr i64 %52 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 488) to i64), i64* %53
%54 = add i64 %50, 16
%55 = inttoptr i64 %54 to i64*
store i64 %40, i64* %55
%56 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 8) to i64) to i64*
store i64 %50, i64* %56
; # (Dst: ca (val $Catch))
%57 = getelementptr i8, i8* %3, i32 72
%58 = bitcast i8* %57 to i8**
%59 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 24) to i8**)
store i8* %59, i8** %58
; # (Dst: in (val $InFrames))
%60 = getelementptr i8, i8* %3, i32 80
%61 = bitcast i8* %60 to i8**
%62 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 32) to i8**)
store i8* %62, i8** %61
; # (Dst: out (val $OutFrames))
%63 = getelementptr i8, i8* %3, i32 88
%64 = bitcast i8* %63 to i8**
%65 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 40) to i8**)
store i8* %65, i8** %64
; # (Dst: err (val $ErrFrames))
%66 = getelementptr i8, i8* %3, i32 96
%67 = bitcast i8* %66 to i8**
%68 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 48) to i8**)
store i8* %68, i8** %67
; # (Dst: ctl (val $CtlFrames))
%69 = getelementptr i8, i8* %3, i32 104
%70 = bitcast i8* %69 to i8**
%71 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 56) to i8**)
store i8* %71, i8** %70
; # (Dst:)
; # (putCrtEnv (Dst:))
%72 = getelementptr i8, i8* %3, i32 152
%73 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %72, i8* %73, i64 176, i1 0)
%74 = getelementptr i8, i8* %3, i32 112
%75 = ptrtoint i8* %74 to i64
%76 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
%77 = load i64, i64* %76
%78 = inttoptr i64 %75 to i64*
store i64 %77, i64* %78
%79 = getelementptr i8, i8* %3, i32 120
%80 = ptrtoint i8* %79 to i64
%81 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
%82 = load i64, i64* %81
%83 = inttoptr i64 %80 to i64*
store i64 %82, i64* %83
%84 = getelementptr i8, i8* %3, i32 128
%85 = ptrtoint i8* %84 to i64
%86 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
%87 = getelementptr i64, i64* %86, i32 1
%88 = load i64, i64* %87
%89 = inttoptr i64 %85 to i64*
store i64 %88, i64* %89
%90 = getelementptr i8, i8* %3, i32 136
%91 = ptrtoint i8* %90 to i64
%92 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%93 = load i64, i64* %92
%94 = inttoptr i64 %91 to i64*
store i64 %93, i64* %94
%95 = getelementptr i8, i8* %3, i32 144
%96 = ptrtoint i8* %95 to i64
%97 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%98 = getelementptr i64, i64* %97, i32 1
%99 = load i64, i64* %98
%100 = inttoptr i64 %96 to i64*
store i64 %99, i64* %100
; # (set $Next $Nil $Make 0 $Yoke 0 $Current (Dst:) $StkLimit (+ (Dst...
%101 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 104) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %101
%102 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 128) to i64) to i64*
store i64 0, i64* %102
%103 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 136) to i64) to i64*
store i64 0, i64* %103
; # (Dst:)
store i8* %3, i8** @$Current
; # (Dst: lim)
%104 = getelementptr i8, i8* %3, i32 40
%105 = bitcast i8* %104 to i8**
%106 = load i8*, i8** %105
; # (+ (Dst: lim) 1024)
%107 = getelementptr i8, i8* %106, i32 1024
store i8* %107, i8** @$StkLimit
; # (when (symb? Tag) (put Tag ZERO (| (i64 (Dst:)) 2)))
; # (symb? Tag)
%108 = xor i64 %1, 8
%109 = and i64 %108, 14
%110 = icmp eq i64 %109, 0
br i1 %110, label %$2, label %$3
$2:
; # (Dst:)
; # (i64 (Dst:))
%111 = ptrtoint i8* %3 to i64
; # (| (i64 (Dst:)) 2)
%112 = or i64 %111, 2
; # (put Tag ZERO (| (i64 (Dst:)) 2))
call void @put(i64 %1, i64 2, i64 %112)
br label %$3
$3:
; # (set $Ret (run X))
; # (run X)
br label %$4
$4:
%113 = phi i64 [%4, %$3], [%135, %$13] ; # Prg
%114 = inttoptr i64 %113 to i64*
%115 = load i64, i64* %114
%116 = getelementptr i64, i64* %114, i32 1
%117 = load i64, i64* %116
%118 = and i64 %117, 15
%119 = icmp ne i64 %118, 0
br i1 %119, label %$7, label %$5
$7:
%120 = phi i64 [%117, %$4] ; # Prg
%121 = and i64 %115, 6
%122 = icmp ne i64 %121, 0
br i1 %122, label %$10, label %$9
$10:
br label %$8
$9:
%123 = and i64 %115, 8
%124 = icmp ne i64 %123, 0
br i1 %124, label %$12, label %$11
$12:
%125 = inttoptr i64 %115 to i64*
%126 = load i64, i64* %125
br label %$8
$11:
%127 = call i64 @evList(i64 %115)
br label %$8
$8:
%128 = phi i64 [%115, %$10], [%126, %$12], [%127, %$11] ; # ->
br label %$6
$5:
%129 = phi i64 [%117, %$4] ; # Prg
%130 = and i64 %115, 15
%131 = icmp eq i64 %130, 0
br i1 %131, label %$14, label %$13
$14:
%132 = phi i64 [%129, %$5] ; # Prg
%133 = call i64 @evList(i64 %115)
%134 = icmp ne i64 %133, 0
br label %$13
$13:
%135 = phi i64 [%129, %$5], [%132, %$14] ; # Prg
%136 = phi i1 [0, %$5], [%134, %$14] ; # ->
br label %$4
$6:
%137 = phi i64 [%120, %$8] ; # Prg
%138 = phi i64 [%128, %$8] ; # ->
store i64 %138, i64* @$Ret
; # (unless (== (hex "0707070707070707") (val (i64* (Dst: lim)))) (st...
; # (Dst: lim)
%139 = getelementptr i8, i8* %3, i32 40
%140 = bitcast i8* %139 to i8**
%141 = load i8*, i8** %140
; # (i64* (Dst: lim))
%142 = bitcast i8* %141 to i64*
; # (val (i64* (Dst: lim)))
%143 = load i64, i64* %142
; # (== (hex "0707070707070707") (val (i64* (Dst: lim))))
%144 = icmp eq i64 506381209866536711, %143
br i1 %144, label %$16, label %$15
$15:
; # (Dst: tag)
%145 = ptrtoint i8* %3 to i64
%146 = inttoptr i64 %145 to i64*
%147 = load i64, i64* %146
; # (stkOverErr (Dst: tag))
call void @stkOverErr(i64 %147)
unreachable
$16:
; # (set $This (val -3 (Dst: bnd)))
; # (Dst: bnd)
%148 = getelementptr i8, i8* %3, i32 64
%149 = ptrtoint i8* %148 to i64
%150 = inttoptr i64 %149 to i64*
%151 = load i64, i64* %150
; # (val -3 (Dst: bnd))
%152 = inttoptr i64 %151 to i64*
%153 = getelementptr i64, i64* %152, i32 -4
%154 = load i64, i64* %153
%155 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
store i64 %154, i64* %155
; # (Dst:)
; # (stop (Dst:))
call void @stop(i8* %3)
; # (let Org: (coroutine (Dst: org)) (unless (and (Org:) (== (Org: ta...
; # (Dst: org)
%156 = getelementptr i8, i8* %3, i32 16
%157 = bitcast i8* %156 to i8**
%158 = load i8*, i8** %157
; # (unless (and (Org:) (== (Org: tag) (Dst: otg))) (coErr Exe (Dst: ...
; # (and (Org:) (== (Org: tag) (Dst: otg)))
; # (Org:)
%159 = icmp ne i8* %158, null
br i1 %159, label %$18, label %$17
$18:
; # (Org: tag)
%160 = ptrtoint i8* %158 to i64
%161 = inttoptr i64 %160 to i64*
%162 = load i64, i64* %161
; # (Dst: otg)
%163 = getelementptr i8, i8* %3, i32 24
%164 = ptrtoint i8* %163 to i64
%165 = inttoptr i64 %164 to i64*
%166 = load i64, i64* %165
; # (== (Org: tag) (Dst: otg))
%167 = icmp eq i64 %162, %166
br label %$17
$17:
%168 = phi i1 [0, %$16], [%167, %$18] ; # ->
br i1 %168, label %$20, label %$19
$19:
; # (Dst: otg)
%169 = getelementptr i8, i8* %3, i32 24
%170 = ptrtoint i8* %169 to i64
%171 = inttoptr i64 %170 to i64*
%172 = load i64, i64* %171
; # (coErr Exe (Dst: otg))
call void @coErr(i64 %0, i64 %172)
unreachable
$20:
; # (Org: (rst))
%173 = getelementptr i8, i8* %158, i32 328
; # (longjmp (Org: (rst)) 1)
call void @longjmp(i8* %173, i32 1)
unreachable
}
%15 = phi i64 [%12, %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$6] ; # ->
%15 = phi i64 [%12, %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$6] ; # ->
; # (cond ((nil? Tag) (tagErr Exe)) ((pair X) (unless (val $Coroutine...
; # (nil? Tag)
%29 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64)
br i1 %29, label %$15, label %$14
; # (let Crt (val $Current) (loop (? (=0 Crt)) (when (== Tag ((corout...
; # (val $Current)
%29 = load i8*, i8** @$Current
; # (loop (? (=0 Crt)) (when (== Tag ((coroutine Crt) tag)) (reentErr...
br label %$13
$13:
%30 = phi i64 [%20, %$8], [%41, %$17] ; # X
%31 = phi i8* [%29, %$8], [%45, %$17] ; # Crt
; # (? (=0 Crt))
; # (=0 Crt)
%32 = icmp eq i8* %31, null
br i1 %32, label %$15, label %$14
$14:
%33 = phi i64 [%30, %$13] ; # X
%34 = phi i8* [%31, %$13] ; # Crt
; # (when (== Tag ((coroutine Crt) tag)) (reentErr Exe Tag))
; # ((coroutine Crt) tag)
%35 = ptrtoint i8* %34 to i64
%36 = inttoptr i64 %35 to i64*
%37 = load i64, i64* %36
; # (== Tag ((coroutine Crt) tag))
%38 = icmp eq i64 %28, %37
br i1 %38, label %$16, label %$17
$16:
%39 = phi i64 [%33, %$14] ; # X
%40 = phi i8* [%34, %$14] ; # Crt
; # (reentErr Exe Tag)
call void @reentErr(i64 %0, i64 %28)
unreachable
$17:
%41 = phi i64 [%33, %$14] ; # X
%42 = phi i8* [%34, %$14] ; # Crt
; # ((coroutine Crt) org)
%43 = getelementptr i8, i8* %42, i32 16
%44 = bitcast i8* %43 to i8**
%45 = load i8*, i8** %44
br label %$13
%30 = phi i64 [%20, %$8] ; # X
%46 = phi i64 [%30, %$13] ; # X
%47 = phi i8* [%31, %$13] ; # Crt
%48 = phi i64 [0, %$13] ; # ->
; # (cond ((nil? Tag) (tagErr Exe)) ((t? Tag) (reentErr Exe Tag)) ((p...
; # (nil? Tag)
%49 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
br i1 %49, label %$20, label %$19
$20:
%50 = phi i64 [%46, %$15] ; # X
$14:
%31 = phi i64 [%20, %$8] ; # X
$19:
%51 = phi i64 [%46, %$15] ; # X
; # (t? Tag)
%52 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64)
br i1 %52, label %$22, label %$21
$22:
%53 = phi i64 [%51, %$19] ; # X
; # (reentErr Exe Tag)
call void @reentErr(i64 %0, i64 %28)
unreachable
$21:
%54 = phi i64 [%51, %$19] ; # X
%35 = load i8*, i8** @$Coroutines
%36 = icmp ne i8* %35, null
br i1 %36, label %$19, label %$18
$18:
%37 = phi i64 [%34, %$17] ; # X
%58 = load i8*, i8** @$Coroutines
%59 = icmp ne i8* %58, null
br i1 %59, label %$26, label %$25
$25:
%60 = phi i64 [%57, %$24] ; # X
%41 = ptrtoint i8* %40 to i64
%42 = inttoptr i64 %41 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), i64* %42
%64 = ptrtoint i8* %63 to i64
%65 = inttoptr i64 %64 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), i64* %65
%47 = getelementptr i8, i8* %40, i32 24
%48 = ptrtoint i8* %47 to i64
%49 = inttoptr i64 %48 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %49
%70 = getelementptr i8, i8* %63, i32 24
%71 = ptrtoint i8* %70 to i64
%72 = inttoptr i64 %71 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %72
%50 = getelementptr i8, i8* %40, i32 32
%51 = ptrtoint i8* %50 to i64
%52 = inttoptr i64 %51 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %52
%73 = getelementptr i8, i8* %63, i32 32
%74 = ptrtoint i8* %73 to i64
%75 = inttoptr i64 %74 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %75
%55 = getelementptr i8, i8* %40, i32 40
%56 = bitcast i8* %55 to i8**
%57 = sub i64 0, %53
%58 = getelementptr i8, i8* %54, i64 %57
call void @llvm.stackrestore(i8* %58)
store i8* %58, i8** %56
%78 = getelementptr i8, i8* %63, i32 40
%79 = bitcast i8* %78 to i8**
%80 = sub i64 0, %76
%81 = getelementptr i8, i8* %77, i64 %80
call void @llvm.stackrestore(i8* %81)
store i8* %81, i8** %79
%60 = getelementptr i8, i8* %40, i32 48
%61 = ptrtoint i8* %60 to i64
%62 = inttoptr i64 %61 to i64*
store i64 0, i64* %62
%83 = getelementptr i8, i8* %63, i32 48
%84 = ptrtoint i8* %83 to i64
%85 = inttoptr i64 %84 to i64*
store i64 0, i64* %85
store i8* %40, i8** @$CrtLast
store i8* %40, i8** @$Current
store i8* %40, i8** @$Coroutines
br label %$19
$19:
%63 = phi i64 [%34, %$17], [%37, %$18] ; # X
; # (let (Src: (coroutine (val $Current)) Crt (val $Coroutines) P (i8...
store i8* %63, i8** @$CrtLast
store i8* %63, i8** @$Current
store i8* %63, i8** @$Coroutines
br label %$26
$26:
%86 = phi i64 [%57, %$24], [%60, %$25] ; # X
; # (let (Src: (coroutine (val $Current)) Crt (val $Coroutines)) (sav...
%70 = icmp eq i1 %69, 0
br i1 %70, label %$22, label %$21
$22:
%71 = phi i64 [%63, %$19] ; # X
%72 = phi i8* [%65, %$19] ; # Crt
%73 = phi i8* [%66, %$19] ; # P
%92 = icmp eq i1 %91, 0
br i1 %92, label %$29, label %$28
$29:
%93 = phi i64 [%86, %$26] ; # X
%94 = phi i8* [%88, %$26] ; # Crt
br label %$23
$23:
%74 = phi i64 [%71, %$22], [%126, %$31] ; # X
%75 = phi i8* [%72, %$22], [%124, %$31] ; # Crt
%76 = phi i8* [%73, %$22], [%128, %$31] ; # P
br label %$30
$30:
%95 = phi i64 [%93, %$29], [%126, %$35] ; # X
%96 = phi i8* [%94, %$29], [%124, %$35] ; # Crt
%80 = icmp eq i64 %28, %79
br i1 %80, label %$24, label %$25
$24:
%81 = phi i64 [%74, %$23] ; # X
%82 = phi i8* [%75, %$23] ; # Crt
%83 = phi i8* [%76, %$23] ; # P
%100 = icmp eq i64 %28, %99
br i1 %100, label %$31, label %$32
$31:
%101 = phi i64 [%95, %$30] ; # X
%102 = phi i8* [%96, %$30] ; # Crt
%85 = call i32 @setjmp(i8* %84)
%86 = icmp ne i32 %85, 0
br i1 %86, label %$26, label %$27
$26:
%87 = phi i64 [%81, %$24] ; # X
%88 = phi i8* [%82, %$24] ; # Crt
%89 = phi i8* [%83, %$24] ; # P
%104 = call i32 @setjmp(i8* %103)
%105 = icmp ne i32 %104, 0
br i1 %105, label %$33, label %$34
$33:
%106 = phi i64 [%101, %$31] ; # X
%107 = phi i8* [%102, %$31] ; # Crt
%96 = getelementptr i8, i8* %75, i32 24
%97 = ptrtoint i8* %96 to i64
%98 = ptrtoint i8* %64 to i64
%99 = inttoptr i64 %98 to i64*
%100 = load i64, i64* %99
%101 = inttoptr i64 %97 to i64*
store i64 %100, i64* %101
%113 = getelementptr i8, i8* %96, i32 24
%114 = ptrtoint i8* %113 to i64
%115 = ptrtoint i8* %87 to i64
%116 = inttoptr i64 %115 to i64*
%117 = load i64, i64* %116
%118 = inttoptr i64 %114 to i64*
store i64 %117, i64* %118
$25:
%103 = phi i64 [%74, %$23] ; # X
%104 = phi i8* [%75, %$23] ; # Crt
%105 = phi i8* [%76, %$23] ; # P
; # (or P (Crt: tag) (setq P Crt))
%106 = icmp ne i8* %105, null
br i1 %106, label %$28, label %$29
$29:
%107 = phi i64 [%103, %$25] ; # X
%108 = phi i8* [%104, %$25] ; # Crt
%109 = phi i8* [%105, %$25] ; # P
; # (Crt: tag)
%110 = ptrtoint i8* %75 to i64
%111 = inttoptr i64 %110 to i64*
%112 = load i64, i64* %111
%113 = icmp ne i64 %112, 0
br i1 %113, label %$28, label %$30
$30:
%114 = phi i64 [%107, %$29] ; # X
%115 = phi i8* [%108, %$29] ; # Crt
%116 = phi i8* [%109, %$29] ; # P
%117 = icmp ne i8* %115, null
br label %$28
$28:
%118 = phi i64 [%103, %$25], [%107, %$29], [%114, %$30] ; # X
%119 = phi i8* [%104, %$25], [%108, %$29], [%115, %$30] ; # Crt
%120 = phi i8* [%105, %$25], [%109, %$29], [%115, %$30] ; # P
%121 = phi i1 [1, %$25], [1, %$29], [%117, %$30] ; # ->
$32:
%120 = phi i64 [%95, %$30] ; # X
%121 = phi i8* [%96, %$30] ; # Crt
br i1 %125, label %$32, label %$31
$31:
%126 = phi i64 [%118, %$28] ; # X
%127 = phi i8* [%119, %$28] ; # Crt
%128 = phi i8* [%120, %$28] ; # P
br label %$23
$32:
%129 = phi i64 [%118, %$28] ; # X
%130 = phi i8* [%119, %$28] ; # Crt
%131 = phi i8* [%120, %$28] ; # P
%132 = phi i64 [0, %$28] ; # ->
br label %$20
$21:
%133 = phi i64 [%63, %$19] ; # X
%134 = phi i8* [%65, %$19] ; # Crt
%135 = phi i8* [%66, %$19] ; # P
br i1 %125, label %$36, label %$35
$35:
%126 = phi i64 [%120, %$32] ; # X
%127 = phi i8* [%121, %$32] ; # Crt
br label %$30
$36:
%128 = phi i64 [%120, %$32] ; # X
%129 = phi i8* [%121, %$32] ; # Crt
%130 = phi i64 [0, %$32] ; # ->
br label %$27
$28:
%131 = phi i64 [%86, %$26] ; # X
%132 = phi i8* [%88, %$26] ; # Crt
%137 = and i64 %136, 2
%138 = icmp ne i64 %137, 0
br i1 %138, label %$34, label %$33
$34:
%139 = phi i64 [%133, %$21] ; # X
%140 = phi i8* [%134, %$21] ; # Crt
%141 = phi i8* [%135, %$21] ; # P
%134 = and i64 %133, 2
%135 = icmp ne i64 %134, 0
br i1 %135, label %$38, label %$37
$38:
%136 = phi i64 [%131, %$28] ; # X
%137 = phi i8* [%132, %$28] ; # Crt
%147 = icmp eq i64 %28, %146
br i1 %147, label %$36, label %$35
$35:
%148 = phi i64 [%139, %$34] ; # X
%149 = phi i8* [%140, %$34] ; # Crt
%150 = phi i8* [%141, %$34] ; # P
%143 = icmp eq i64 %28, %142
br i1 %143, label %$40, label %$39
$39:
%144 = phi i64 [%136, %$38] ; # X
%145 = phi i8* [%137, %$38] ; # Crt
%155 = call i32 @setjmp(i8* %154)
%156 = icmp ne i32 %155, 0
br i1 %156, label %$37, label %$38
$37:
%157 = phi i64 [%151, %$36] ; # X
%158 = phi i8* [%152, %$36] ; # Crt
%159 = phi i8* [%153, %$36] ; # P
%149 = call i32 @setjmp(i8* %148)
%150 = icmp ne i32 %149, 0
br i1 %150, label %$41, label %$42
$41:
%151 = phi i64 [%146, %$40] ; # X
%152 = phi i8* [%147, %$40] ; # Crt
%166 = getelementptr i8, i8* %143, i32 24
%167 = ptrtoint i8* %166 to i64
%168 = ptrtoint i8* %64 to i64
%169 = inttoptr i64 %168 to i64*
%170 = load i64, i64* %169
%171 = inttoptr i64 %167 to i64*
store i64 %170, i64* %171
%158 = getelementptr i8, i8* %139, i32 24
%159 = ptrtoint i8* %158 to i64
%160 = ptrtoint i8* %87 to i64
%161 = inttoptr i64 %160 to i64*
%162 = load i64, i64* %161
%163 = inttoptr i64 %159 to i64*
store i64 %162, i64* %163
$33:
%173 = phi i64 [%133, %$21] ; # X
%174 = phi i8* [%134, %$21] ; # Crt
%175 = phi i8* [%135, %$21] ; # P
; # (val $CrtFree)
%176 = load i8*, i8** @$CrtFree
%177 = icmp ne i8* %176, null
br i1 %177, label %$40, label %$39
$40:
%178 = phi i64 [%173, %$33] ; # X
%179 = phi i8* [%174, %$33] ; # Crt
%180 = phi i8* [%175, %$33] ; # P
; # (set $CrtFree ((coroutine (setq P @)) lim))
; # ((coroutine (setq P @)) lim)
%181 = getelementptr i8, i8* %176, i32 40
%182 = bitcast i8* %181 to i8**
%183 = load i8*, i8** %182
store i8* %183, i8** @$CrtFree
br label %$20
$39:
%184 = phi i64 [%173, %$33] ; # X
%185 = phi i8* [%174, %$33] ; # Crt
%186 = phi i8* [%175, %$33] ; # P
; # (val $CrtLast)
%187 = load i8*, i8** @$CrtLast
br label %$20
$20:
%188 = phi i64 [%129, %$32], [%178, %$40], [%184, %$39] ; # X
%189 = phi i8* [%130, %$32], [%179, %$40], [%187, %$39] ; # Crt
%190 = phi i8* [%131, %$32], [%176, %$40], [%186, %$39] ; # P
$37:
%165 = phi i64 [%131, %$28] ; # X
%166 = phi i8* [%132, %$28] ; # Crt
br label %$27
$27:
%167 = phi i64 [%128, %$36], [%165, %$37] ; # X
%168 = phi i8* [%129, %$36], [%166, %$37] ; # Crt
%169 = phi i64 [%130, %$36], [0, %$37] ; # ->
%192 = call i32 @setjmp(i8* %191)
%193 = icmp ne i32 %192, 0
br i1 %193, label %$41, label %$42
$41:
%194 = phi i64 [%188, %$20] ; # X
%195 = phi i8* [%189, %$20] ; # Crt
%196 = phi i8* [%190, %$20] ; # P
%171 = call i32 @setjmp(i8* %170)
%172 = icmp ne i32 %171, 0
br i1 %172, label %$43, label %$44
$43:
%173 = phi i64 [%167, %$27] ; # X
%174 = phi i8* [%168, %$27] ; # Crt
ret i64 %197
$42:
%198 = phi i64 [%188, %$20] ; # X
%199 = phi i8* [%189, %$20] ; # Crt
%200 = phi i8* [%190, %$20] ; # P
; # (if P (stack P) (stack ((coroutine Crt) lim)) (set $CrtLast (setq...
%201 = icmp ne i8* %200, null
br i1 %201, label %$43, label %$44
$43:
%202 = phi i64 [%198, %$42] ; # X
%203 = phi i8* [%199, %$42] ; # Crt
%204 = phi i8* [%200, %$42] ; # P
; # (stack P)
call void @llvm.stackrestore(i8* %204)
br label %$45
ret i64 %175
%205 = phi i64 [%198, %$42] ; # X
%206 = phi i8* [%199, %$42] ; # Crt
%207 = phi i8* [%200, %$42] ; # P
; # ((coroutine Crt) lim)
%208 = getelementptr i8, i8* %206, i32 40
%209 = bitcast i8* %208 to i8**
%210 = load i8*, i8** %209
; # (stack ((coroutine Crt) lim))
call void @llvm.stackrestore(i8* %210)
%176 = phi i64 [%167, %$27] ; # X
%177 = phi i8* [%168, %$27] ; # Crt
; # (let P (val $CrtFree) (if P (set $CrtFree ((coroutine (stack P)) ...
; # (val $CrtFree)
%178 = load i8*, i8** @$CrtFree
; # (if P (set $CrtFree ((coroutine (stack P)) lim)) (stack ((corouti...
%179 = icmp ne i8* %178, null
br i1 %179, label %$45, label %$46
$45:
%180 = phi i64 [%176, %$44] ; # X
%181 = phi i8* [%177, %$44] ; # Crt
%182 = phi i8* [%178, %$44] ; # P
; # (set $CrtFree ((coroutine (stack P)) lim))
; # (stack P)
call void @llvm.stackrestore(i8* %182)
; # ((coroutine (stack P)) lim)
%183 = getelementptr i8, i8* %182, i32 40
%184 = bitcast i8* %183 to i8**
%185 = load i8*, i8** %184
store i8* %185, i8** @$CrtFree
br label %$47
$46:
%186 = phi i64 [%176, %$44] ; # X
%187 = phi i8* [%177, %$44] ; # Crt
%188 = phi i8* [%178, %$44] ; # P
; # (val $CrtLast)
%189 = load i8*, i8** @$CrtLast
; # ((coroutine (setq Crt (val $CrtLast))) lim)
%190 = getelementptr i8, i8* %189, i32 40
%191 = bitcast i8* %190 to i8**
%192 = load i8*, i8** %191
; # (stack ((coroutine (setq Crt (val $CrtLast))) lim))
call void @llvm.stackrestore(i8* %192)
%216 = getelementptr i8, i8* %213, i32 8
%217 = bitcast i8* %216 to i8**
store i8* null, i8** %217
br label %$45
$45:
%218 = phi i64 [%202, %$43], [%205, %$44] ; # X
%219 = phi i8* [%203, %$43], [%206, %$44] ; # Crt
%220 = phi i8* [%204, %$43], [%213, %$44] ; # P
%221 = phi i8* [%204, %$43], [null, %$44] ; # ->
; # (let Dst: (coroutine P) (Dst: tag Tag) (Dst: org (Src:)) (Dst: ot...
; # (Dst: tag Tag)
%222 = ptrtoint i8* %220 to i64
%223 = inttoptr i64 %222 to i64*
store i64 %28, i64* %223
; # (Dst: org (Src:))
%224 = getelementptr i8, i8* %220, i32 16
%225 = bitcast i8* %224 to i8**
store i8* %64, i8** %225
; # (Dst: otg (Src: tag))
%226 = getelementptr i8, i8* %220, i32 24
%227 = ptrtoint i8* %226 to i64
%228 = ptrtoint i8* %64 to i64
%229 = inttoptr i64 %228 to i64*
%230 = load i64, i64* %229
%231 = inttoptr i64 %227 to i64*
store i64 %230, i64* %231
; # (Dst: prg X)
%232 = getelementptr i8, i8* %220, i32 32
%233 = ptrtoint i8* %232 to i64
%234 = inttoptr i64 %233 to i64*
store i64 %218, i64* %234
; # (let (Siz (val $StkSize) Stk (stack)) (memset (Dst: lim (stack (o...
; # (val $StkSize)
%235 = load i64, i64* @$StkSize
; # (stack)
%236 = call i8* @llvm.stacksave()
; # (Dst: lim (stack (ofs P (- Siz))))
%237 = getelementptr i8, i8* %220, i32 40
%238 = bitcast i8* %237 to i8**
%239 = sub i64 0, %235
%240 = getelementptr i8, i8* %220, i64 %239
call void @llvm.stackrestore(i8* %240)
store i8* %240, i8** %238
; # (- Siz 256)
%241 = sub i64 %235, 256
; # (memset (Dst: lim (stack (ofs P (- Siz)))) 7 (- Siz 256) T)
call void @llvm.memset.p0i8.i64(i8* align 8 %240, i8 7, i64 %241, i1 0)
; # (stack Stk)
call void @llvm.stackrestore(i8* %236)
; # (Dst: at 0)
%242 = getelementptr i8, i8* %220, i32 48
%243 = ptrtoint i8* %242 to i64
%244 = inttoptr i64 %243 to i64*
store i64 0, i64* %244
; # (Dst: lnk (val $Link))
%245 = getelementptr i8, i8* %220, i32 56
%246 = ptrtoint i8* %245 to i64
%247 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
%248 = load i64, i64* %247
%249 = inttoptr i64 %246 to i64*
store i64 %248, i64* %249
; # (set $Bind (push (val $This) $This (Dst: bnd (push ZERO $At (val ...
; # (val $This)
%250 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 488) to i64) to i64*
%251 = load i64, i64* %250
; # (Dst: bnd (push ZERO $At (val $Bind) Exe))
%252 = getelementptr i8, i8* %220, i32 64
%253 = ptrtoint i8* %252 to i64
%254 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 8) to i64) to i64*
%255 = load i64, i64* %254
%256 = alloca i64, i64 4, align 16
%257 = ptrtoint i64* %256 to i64
%258 = inttoptr i64 %257 to i64*
store i64 2, i64* %258
%259 = add i64 %257, 8
%260 = inttoptr i64 %259 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64), i64* %260
%261 = add i64 %257, 16
%262 = inttoptr i64 %261 to i64*
store i64 %255, i64* %262
%263 = add i64 %257, 24
%264 = inttoptr i64 %263 to i64*
store i64 %0, i64* %264
%265 = inttoptr i64 %253 to i64*
store i64 %257, i64* %265
; # (push (val $This) $This (Dst: bnd (push ZERO $At (val $Bind) Exe)...
%266 = alloca i64, i64 3, align 16
%267 = ptrtoint i64* %266 to i64
%268 = inttoptr i64 %267 to i64*
store i64 %251, i64* %268
%269 = add i64 %267, 8
%270 = inttoptr i64 %269 to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 488) to i64), i64* %270
%271 = add i64 %267, 16
%272 = inttoptr i64 %271 to i64*
store i64 %257, i64* %272
%273 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 8) to i64) to i64*
store i64 %267, i64* %273
; # (Dst: ca (val $Catch))
%274 = getelementptr i8, i8* %220, i32 72
%275 = bitcast i8* %274 to i8**
%276 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 24) to i8**)
store i8* %276, i8** %275
; # (Dst: in (val $InFrames))
%277 = getelementptr i8, i8* %220, i32 80
%278 = bitcast i8* %277 to i8**
%279 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 32) to i8**)
store i8* %279, i8** %278
; # (Dst: out (val $OutFrames))
%280 = getelementptr i8, i8* %220, i32 88
%281 = bitcast i8* %280 to i8**
%282 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 40) to i8**)
store i8* %282, i8** %281
; # (Dst: err (val $ErrFrames))
%283 = getelementptr i8, i8* %220, i32 96
%284 = bitcast i8* %283 to i8**
%285 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 48) to i8**)
store i8* %285, i8** %284
; # (Dst: ctl (val $CtlFrames))
%286 = getelementptr i8, i8* %220, i32 104
%287 = bitcast i8* %286 to i8**
%288 = load i8*, i8** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 56) to i8**)
store i8* %288, i8** %287
; # (Dst:)
; # (putCrtEnv (Dst:) YES)
br i1 1, label %$46, label %$47
$46:
%289 = getelementptr i8, i8* %220, i32 112
%290 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %289, i8* %290, i64 168, i1 0)
%198 = getelementptr i8, i8* %195, i32 8
%199 = bitcast i8* %198 to i8**
store i8* null, i8** %199
%291 = getelementptr i8, i8* %220, i32 280
%292 = ptrtoint i8* %291 to i64
%293 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 0) to i64) to i64*
%294 = load i64, i64* %293
%295 = inttoptr i64 %292 to i64*
store i64 %294, i64* %295
%296 = getelementptr i8, i8* %220, i32 288
%297 = ptrtoint i8* %296 to i64
%298 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
%299 = load i64, i64* %298
%300 = inttoptr i64 %297 to i64*
store i64 %299, i64* %300
%301 = getelementptr i8, i8* %220, i32 296
%302 = ptrtoint i8* %301 to i64
%303 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([53 x i64]* @gcData to i8*), i32 8) to i64) to i64*
%304 = getelementptr i64, i64* %303, i32 1
%305 = load i64, i64* %304
%306 = inttoptr i64 %302 to i64*
store i64 %305, i64* %306
%307 = getelementptr i8, i8* %220, i32 304
%308 = ptrtoint i8* %307 to i64
%309 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%310 = load i64, i64* %309
%311 = inttoptr i64 %308 to i64*
store i64 %310, i64* %311
%312 = getelementptr i8, i8* %220, i32 312
%313 = ptrtoint i8* %312 to i64
%314 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 112) to i64) to i64*
%315 = getelementptr i64, i64* %314, i32 1
%316 = load i64, i64* %315
%317 = inttoptr i64 %313 to i64*
store i64 %316, i64* %317
; # (set $Next $Nil $Make 0 $Yoke 0 $Current (Dst:) $StkLimit (+ (Dst...
%318 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 112) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %318
%319 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 136) to i64) to i64*
store i64 0, i64* %319
%320 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 144) to i64) to i64*
store i64 0, i64* %320
; # (Dst:)
store i8* %220, i8** @$Current
; # (Dst: lim)
%321 = getelementptr i8, i8* %220, i32 40
%322 = bitcast i8* %321 to i8**
%323 = load i8*, i8** %322
; # (+ (Dst: lim) 1024)
%324 = getelementptr i8, i8* %323, i32 1024
store i8* %324, i8** @$StkLimit
; # (when (symb? Tag) (put Tag ZERO (| (i64 (Dst:)) 2)))
; # (symb? Tag)
%325 = xor i64 %28, 8
%326 = and i64 %325, 14
%327 = icmp eq i64 %326, 0
br i1 %327, label %$48, label %$49
$48:
%328 = phi i64 [%218, %$47] ; # X
%329 = phi i8* [%219, %$47] ; # Crt
%330 = phi i8* [%220, %$47] ; # P
; # (Dst:)
; # (i64 (Dst:))
%331 = ptrtoint i8* %220 to i64
; # (| (i64 (Dst:)) 2)
%332 = or i64 %331, 2
; # (put Tag ZERO (| (i64 (Dst:)) 2))
call void @put(i64 %28, i64 2, i64 %332)
br label %$49
$49:
%333 = phi i64 [%218, %$47], [%328, %$48] ; # X
%334 = phi i8* [%219, %$47], [%329, %$48] ; # Crt
%335 = phi i8* [%220, %$47], [%330, %$48] ; # P
; # (set $Ret (run X))
; # (run X)
br label %$50
$50:
%336 = phi i64 [%333, %$49], [%358, %$59] ; # Prg
%337 = inttoptr i64 %336 to i64*
%338 = load i64, i64* %337
%339 = getelementptr i64, i64* %337, i32 1
%340 = load i64, i64* %339
%341 = and i64 %340, 15
%342 = icmp ne i64 %341, 0
br i1 %342, label %$53, label %$51
$53:
%343 = phi i64 [%340, %$50] ; # Prg
%344 = and i64 %338, 6
%345 = icmp ne i64 %344, 0
br i1 %345, label %$56, label %$55
$56:
br label %$54
$55:
%346 = and i64 %338, 8
%347 = icmp ne i64 %346, 0
br i1 %347, label %$58, label %$57
$58:
%348 = inttoptr i64 %338 to i64*
%349 = load i64, i64* %348
br label %$54
$57:
%350 = call i64 @evList(i64 %338)
br label %$54
$54:
%351 = phi i64 [%338, %$56], [%349, %$58], [%350, %$57] ; # ->
br label %$52
$51:
%352 = phi i64 [%340, %$50] ; # Prg
%353 = and i64 %338, 15
%354 = icmp eq i64 %353, 0
br i1 %354, label %$60, label %$59
$60:
%355 = phi i64 [%352, %$51] ; # Prg
%356 = call i64 @evList(i64 %338)
%357 = icmp ne i64 %356, 0
br label %$59
$59:
%358 = phi i64 [%352, %$51], [%355, %$60] ; # Prg
%359 = phi i1 [0, %$51], [%357, %$60] ; # ->
br label %$50
$52:
%360 = phi i64 [%343, %$54] ; # Prg
%361 = phi i64 [%351, %$54] ; # ->
store i64 %361, i64* @$Ret
; # (unless (== (hex "0707070707070707") (val (i64* (Dst: lim)))) (st...
; # (Dst: lim)
%362 = getelementptr i8, i8* %220, i32 40
%363 = bitcast i8* %362 to i8**
%364 = load i8*, i8** %363
; # (i64* (Dst: lim))
%365 = bitcast i8* %364 to i64*
; # (val (i64* (Dst: lim)))
%366 = load i64, i64* %365
; # (== (hex "0707070707070707") (val (i64* (Dst: lim))))
%367 = icmp eq i64 506381209866536711, %366
br i1 %367, label %$62, label %$61
$61:
%368 = phi i64 [%333, %$52] ; # X
%369 = phi i8* [%334, %$52] ; # Crt
%370 = phi i8* [%335, %$52] ; # P
; # (Dst: tag)
%371 = ptrtoint i8* %220 to i64
%372 = inttoptr i64 %371 to i64*
%373 = load i64, i64* %372
; # (stkOverErr (Dst: tag))
call void @stkOverErr(i64 %373)
unreachable
$62:
%374 = phi i64 [%333, %$52] ; # X
%375 = phi i8* [%334, %$52] ; # Crt
%376 = phi i8* [%335, %$52] ; # P
; # (Dst:)
; # (stop (Dst:))
call void @stop(i8* %220)
; # (let Org: (coroutine (Dst: org)) (unless (== (Org: tag) (Dst: otg...
; # (Dst: org)
%377 = getelementptr i8, i8* %220, i32 16
%378 = bitcast i8* %377 to i8**
%379 = load i8*, i8** %378
; # (unless (== (Org: tag) (Dst: otg)) (coErr Exe (Dst: otg)))
; # (Org: tag)
%380 = ptrtoint i8* %379 to i64
%381 = inttoptr i64 %380 to i64*
%382 = load i64, i64* %381
; # (Dst: otg)
%383 = getelementptr i8, i8* %220, i32 24
%384 = ptrtoint i8* %383 to i64
%385 = inttoptr i64 %384 to i64*
%386 = load i64, i64* %385
; # (== (Org: tag) (Dst: otg))
%387 = icmp eq i64 %382, %386
br i1 %387, label %$64, label %$63
$63:
%388 = phi i64 [%374, %$62] ; # X
%389 = phi i8* [%375, %$62] ; # Crt
%390 = phi i8* [%376, %$62] ; # P
; # (Dst: otg)
%391 = getelementptr i8, i8* %220, i32 24
%392 = ptrtoint i8* %391 to i64
%393 = inttoptr i64 %392 to i64*
%394 = load i64, i64* %393
; # (coErr Exe (Dst: otg))
call void @coErr(i64 %0, i64 %394)
unreachable
$64:
%395 = phi i64 [%374, %$62] ; # X
%396 = phi i8* [%375, %$62] ; # Crt
%397 = phi i8* [%376, %$62] ; # P
; # (Org: (rst))
%398 = getelementptr i8, i8* %379, i32 320
; # (longjmp (Org: (rst)) 1)
call void @longjmp(i8* %398, i32 1)
unreachable
$16:
%399 = phi i64 [%31, %$14] ; # X
; # (t? Tag)
%400 = icmp eq i64 %28, ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64)
br i1 %400, label %$66, label %$65
$66:
%401 = phi i64 [%399, %$16] ; # X
; # (err Exe 0 ($ "Can't stop main routine") null)
call void @err(i64 %0, i64 0, i8* bitcast ([24 x i8]* @$79 to i8*), i8* null)
%200 = phi i64 [%180, %$45], [%186, %$46] ; # X
%201 = phi i8* [%181, %$45], [%189, %$46] ; # Crt
%202 = phi i8* [%182, %$45], [%195, %$46] ; # P
%203 = phi i8* [%185, %$45], [null, %$46] ; # ->
; # (Src:)
; # (runCo Exe Tag (Src:) P X)
call void @runCo(i64 %0, i64 %28, i8* %87, i8* %202, i64 %200)
%403 = load i8*, i8** @$Coroutines
%404 = icmp ne i8* %403, null
br i1 %404, label %$68, label %$67
$68:
%405 = phi i64 [%402, %$65] ; # X
%205 = load i8*, i8** @$Coroutines
%206 = icmp ne i8* %205, null
br i1 %206, label %$49, label %$48
$49:
%207 = phi i64 [%204, %$23] ; # X
%406 = xor i64 %28, 8
%407 = and i64 %406, 14
%408 = icmp eq i64 %407, 0
br i1 %408, label %$69, label %$70
$69:
%409 = phi i64 [%405, %$68] ; # X
%410 = phi i8* [%403, %$68] ; # Crt
%208 = xor i64 %28, 8
%209 = and i64 %208, 14
%210 = icmp eq i64 %209, 0
br i1 %210, label %$50, label %$51
$50:
%211 = phi i64 [%207, %$49] ; # X
%212 = phi i8* [%205, %$49] ; # Crt
%412 = and i64 %411, 2
%413 = icmp ne i64 %412, 0
br i1 %413, label %$72, label %$73
$72:
%414 = phi i64 [%409, %$69] ; # X
%415 = phi i8* [%410, %$69] ; # Crt
%214 = and i64 %213, 2
%215 = icmp ne i64 %214, 0
br i1 %215, label %$53, label %$54
$53:
%216 = phi i64 [%211, %$50] ; # X
%217 = phi i8* [%212, %$50] ; # Crt
%421 = icmp eq i64 %28, %420
br i1 %421, label %$75, label %$74
$74:
%422 = phi i64 [%414, %$72] ; # X
%423 = phi i8* [%417, %$72] ; # Crt
%223 = icmp eq i64 %28, %222
br i1 %223, label %$56, label %$55
$55:
%224 = phi i64 [%216, %$53] ; # X
%225 = phi i8* [%219, %$53] ; # Crt
%428 = getelementptr i8, i8* %427, i32 112
%429 = getelementptr i8, i8* %428, i32 48
%430 = bitcast i8* %429 to i8**
%431 = load i8*, i8** %430
%230 = getelementptr i8, i8* %229, i32 152
%231 = getelementptr i8, i8* %230, i32 48
%232 = bitcast i8* %231 to i8**
%233 = load i8*, i8** %232
br label %$76
$76:
%432 = phi i64 [%426, %$-1], [%447, %$80] ; # X
%433 = phi i8* [%427, %$-1], [%448, %$80] ; # Crt
%434 = phi i8* [%431, %$-1], [%451, %$80] ; # P
%435 = icmp ne i8* %434, null
br i1 %435, label %$77, label %$78
$77:
%436 = phi i64 [%432, %$76] ; # X
%437 = phi i8* [%433, %$76] ; # Crt
%438 = phi i8* [%434, %$76] ; # P
br label %$57
$57:
%234 = phi i64 [%228, %$-1], [%249, %$61] ; # X
%235 = phi i8* [%229, %$-1], [%250, %$61] ; # Crt
%236 = phi i8* [%233, %$-1], [%253, %$61] ; # P
%237 = icmp ne i8* %236, null
br i1 %237, label %$58, label %$59
$58:
%238 = phi i64 [%234, %$57] ; # X
%239 = phi i8* [%235, %$57] ; # Crt
%240 = phi i8* [%236, %$57] ; # P
%442 = icmp sge i32 %441, 0
br i1 %442, label %$79, label %$80
$79:
%443 = phi i64 [%436, %$77] ; # X
%444 = phi i8* [%437, %$77] ; # Crt
%445 = phi i8* [%438, %$77] ; # P
%244 = icmp sge i32 %243, 0
br i1 %244, label %$60, label %$61
$60:
%245 = phi i64 [%238, %$58] ; # X
%246 = phi i8* [%239, %$58] ; # Crt
%247 = phi i8* [%240, %$58] ; # P
%446 = call i32 @close(i32 %441)
br label %$80
$80:
%447 = phi i64 [%436, %$77], [%443, %$79] ; # X
%448 = phi i8* [%437, %$77], [%444, %$79] ; # Crt
%449 = phi i8* [%438, %$77], [%445, %$79] ; # P
%248 = call i32 @close(i32 %243)
br label %$61
$61:
%249 = phi i64 [%238, %$58], [%245, %$60] ; # X
%250 = phi i8* [%239, %$58], [%246, %$60] ; # Crt
%251 = phi i8* [%240, %$58], [%247, %$60] ; # P
%450 = bitcast i8* %438 to i8**
%451 = load i8*, i8** %450
br label %$76
$78:
%452 = phi i64 [%432, %$76] ; # X
%453 = phi i8* [%433, %$76] ; # Crt
%454 = phi i8* [%434, %$76] ; # P
%252 = bitcast i8* %240 to i8**
%253 = load i8*, i8** %252
br label %$57
$59:
%254 = phi i64 [%234, %$57] ; # X
%255 = phi i8* [%235, %$57] ; # Crt
%256 = phi i8* [%236, %$57] ; # P
%455 = getelementptr i8, i8* %453, i32 112
%456 = getelementptr i8, i8* %455, i32 40
%457 = bitcast i8* %456 to i8**
%458 = load i8*, i8** %457
%257 = getelementptr i8, i8* %255, i32 152
%258 = getelementptr i8, i8* %257, i32 40
%259 = bitcast i8* %258 to i8**
%260 = load i8*, i8** %259
br label %$81
$81:
%459 = phi i64 [%452, %$78], [%510, %$85] ; # X
%460 = phi i8* [%453, %$78], [%511, %$85] ; # Crt
%461 = phi i8* [%458, %$78], [%514, %$85] ; # P
br label %$62
$62:
%261 = phi i64 [%254, %$59], [%312, %$66] ; # X
%262 = phi i8* [%255, %$59], [%313, %$66] ; # Crt
%263 = phi i8* [%260, %$59], [%316, %$66] ; # P
%463 = icmp eq i8* %461, %462
br i1 %463, label %$83, label %$82
$82:
%464 = phi i64 [%459, %$81] ; # X
%465 = phi i8* [%460, %$81] ; # Crt
%466 = phi i8* [%461, %$81] ; # P
%265 = icmp eq i8* %263, %264
br i1 %265, label %$64, label %$63
$63:
%266 = phi i64 [%261, %$62] ; # X
%267 = phi i8* [%262, %$62] ; # Crt
%268 = phi i8* [%263, %$62] ; # P
%467 = getelementptr i8, i8* %466, i32 8
%468 = bitcast i8* %467 to i8**
%469 = load i8*, i8** %468
%470 = icmp ne i8* %469, null
br i1 %470, label %$84, label %$85
$84:
%471 = phi i64 [%464, %$82] ; # X
%472 = phi i8* [%465, %$82] ; # Crt
%473 = phi i8* [%466, %$82] ; # P
%269 = getelementptr i8, i8* %268, i32 8
%270 = bitcast i8* %269 to i8**
%271 = load i8*, i8** %270
%272 = icmp ne i8* %271, null
br i1 %272, label %$65, label %$66
$65:
%273 = phi i64 [%266, %$63] ; # X
%274 = phi i8* [%267, %$63] ; # Crt
%275 = phi i8* [%268, %$63] ; # P
%477 = icmp sge i32 %476, 0
br i1 %477, label %$87, label %$86
$87:
%478 = phi i64 [%471, %$84] ; # X
%479 = phi i8* [%472, %$84] ; # Crt
%480 = phi i8* [%473, %$84] ; # P
%279 = icmp sge i32 %278, 0
br i1 %279, label %$68, label %$67
$68:
%280 = phi i64 [%273, %$65] ; # X
%281 = phi i8* [%274, %$65] ; # Crt
%282 = phi i8* [%275, %$65] ; # P
%481 = getelementptr i8, i8* %466, i32 24
%482 = bitcast i8* %481 to i32*
%483 = load i32, i32* %482
%484 = icmp ne i32 %483, 0
br label %$86
$86:
%485 = phi i64 [%471, %$84], [%478, %$87] ; # X
%486 = phi i8* [%472, %$84], [%479, %$87] ; # Crt
%487 = phi i8* [%473, %$84], [%480, %$87] ; # P
%488 = phi i1 [0, %$84], [%484, %$87] ; # ->
br i1 %488, label %$88, label %$89
$88:
%489 = phi i64 [%485, %$86] ; # X
%490 = phi i8* [%486, %$86] ; # Crt
%491 = phi i8* [%487, %$86] ; # P
%283 = getelementptr i8, i8* %268, i32 24
%284 = bitcast i8* %283 to i32*
%285 = load i32, i32* %284
%286 = icmp ne i32 %285, 0
br label %$67
$67:
%287 = phi i64 [%273, %$65], [%280, %$68] ; # X
%288 = phi i8* [%274, %$65], [%281, %$68] ; # Crt
%289 = phi i8* [%275, %$65], [%282, %$68] ; # P
%290 = phi i1 [0, %$65], [%286, %$68] ; # ->
br i1 %290, label %$69, label %$70
$69:
%291 = phi i64 [%287, %$67] ; # X
%292 = phi i8* [%288, %$67] ; # Crt
%293 = phi i8* [%289, %$67] ; # P
%500 = icmp sgt i32 %499, 1
br i1 %500, label %$90, label %$91
$90:
%501 = phi i64 [%489, %$88] ; # X
%502 = phi i8* [%490, %$88] ; # Crt
%503 = phi i8* [%491, %$88] ; # P
%302 = icmp sgt i32 %301, 1
br i1 %302, label %$71, label %$72
$71:
%303 = phi i64 [%291, %$69] ; # X
%304 = phi i8* [%292, %$69] ; # Crt
%305 = phi i8* [%293, %$69] ; # P
call void @waitFile(i32 %499)
br label %$91
$91:
%504 = phi i64 [%489, %$88], [%501, %$90] ; # X
%505 = phi i8* [%490, %$88], [%502, %$90] ; # Crt
%506 = phi i8* [%491, %$88], [%503, %$90] ; # P
br label %$89
$89:
%507 = phi i64 [%485, %$86], [%504, %$91] ; # X
%508 = phi i8* [%486, %$86], [%505, %$91] ; # Crt
%509 = phi i8* [%487, %$86], [%506, %$91] ; # P
br label %$85
$85:
%510 = phi i64 [%464, %$82], [%507, %$89] ; # X
%511 = phi i8* [%465, %$82], [%508, %$89] ; # Crt
%512 = phi i8* [%466, %$82], [%509, %$89] ; # P
call void @waitFile(i32 %301)
br label %$72
$72:
%306 = phi i64 [%291, %$69], [%303, %$71] ; # X
%307 = phi i8* [%292, %$69], [%304, %$71] ; # Crt
%308 = phi i8* [%293, %$69], [%305, %$71] ; # P
br label %$70
$70:
%309 = phi i64 [%287, %$67], [%306, %$72] ; # X
%310 = phi i8* [%288, %$67], [%307, %$72] ; # Crt
%311 = phi i8* [%289, %$67], [%308, %$72] ; # P
br label %$66
$66:
%312 = phi i64 [%266, %$63], [%309, %$70] ; # X
%313 = phi i8* [%267, %$63], [%310, %$70] ; # Crt
%314 = phi i8* [%268, %$63], [%311, %$70] ; # P
%513 = bitcast i8* %466 to i8**
%514 = load i8*, i8** %513
br label %$81
$83:
%515 = phi i64 [%459, %$81] ; # X
%516 = phi i8* [%460, %$81] ; # Crt
%517 = phi i8* [%461, %$81] ; # P
%315 = bitcast i8* %268 to i8**
%316 = load i8*, i8** %315
br label %$62
$64:
%317 = phi i64 [%261, %$62] ; # X
%318 = phi i8* [%262, %$62] ; # Crt
%319 = phi i8* [%263, %$62] ; # P
%518 = getelementptr i8, i8* %516, i32 112
%519 = getelementptr i8, i8* %518, i32 32
%520 = bitcast i8* %519 to i8**
%521 = load i8*, i8** %520
%320 = getelementptr i8, i8* %318, i32 152
%321 = getelementptr i8, i8* %320, i32 32
%322 = bitcast i8* %321 to i8**
%323 = load i8*, i8** %322
br label %$92
$92:
%522 = phi i64 [%515, %$83], [%575, %$96] ; # X
%523 = phi i8* [%516, %$83], [%576, %$96] ; # Crt
%524 = phi i8* [%521, %$83], [%579, %$96] ; # P
br label %$73
$73:
%324 = phi i64 [%317, %$64], [%377, %$77] ; # X
%325 = phi i8* [%318, %$64], [%378, %$77] ; # Crt
%326 = phi i8* [%323, %$64], [%381, %$77] ; # P
%526 = icmp eq i8* %524, %525
br i1 %526, label %$94, label %$93
$93:
%527 = phi i64 [%522, %$92] ; # X
%528 = phi i8* [%523, %$92] ; # Crt
%529 = phi i8* [%524, %$92] ; # P
%328 = icmp eq i8* %326, %327
br i1 %328, label %$75, label %$74
$74:
%329 = phi i64 [%324, %$73] ; # X
%330 = phi i8* [%325, %$73] ; # Crt
%331 = phi i8* [%326, %$73] ; # P
%530 = getelementptr i8, i8* %529, i32 8
%531 = bitcast i8* %530 to i8**
%532 = load i8*, i8** %531
%533 = icmp ne i8* %532, null
br i1 %533, label %$95, label %$96
$95:
%534 = phi i64 [%527, %$93] ; # X
%535 = phi i8* [%528, %$93] ; # Crt
%536 = phi i8* [%529, %$93] ; # P
%332 = getelementptr i8, i8* %331, i32 8
%333 = bitcast i8* %332 to i8**
%334 = load i8*, i8** %333
%335 = icmp ne i8* %334, null
br i1 %335, label %$76, label %$77
$76:
%336 = phi i64 [%329, %$74] ; # X
%337 = phi i8* [%330, %$74] ; # Crt
%338 = phi i8* [%331, %$74] ; # P
%540 = icmp sge i32 %539, 0
br i1 %540, label %$98, label %$97
$98:
%541 = phi i64 [%534, %$95] ; # X
%542 = phi i8* [%535, %$95] ; # Crt
%543 = phi i8* [%536, %$95] ; # P
%342 = icmp sge i32 %341, 0
br i1 %342, label %$79, label %$78
$79:
%343 = phi i64 [%336, %$76] ; # X
%344 = phi i8* [%337, %$76] ; # Crt
%345 = phi i8* [%338, %$76] ; # P
%544 = getelementptr i8, i8* %529, i32 24
%545 = bitcast i8* %544 to i32*
%546 = load i32, i32* %545
%547 = icmp ne i32 %546, 0
br label %$97
$97:
%548 = phi i64 [%534, %$95], [%541, %$98] ; # X
%549 = phi i8* [%535, %$95], [%542, %$98] ; # Crt
%550 = phi i8* [%536, %$95], [%543, %$98] ; # P
%551 = phi i1 [0, %$95], [%547, %$98] ; # ->
br i1 %551, label %$99, label %$100
$99:
%552 = phi i64 [%548, %$97] ; # X
%553 = phi i8* [%549, %$97] ; # Crt
%554 = phi i8* [%550, %$97] ; # P
%346 = getelementptr i8, i8* %331, i32 24
%347 = bitcast i8* %346 to i32*
%348 = load i32, i32* %347
%349 = icmp ne i32 %348, 0
br label %$78
$78:
%350 = phi i64 [%336, %$76], [%343, %$79] ; # X
%351 = phi i8* [%337, %$76], [%344, %$79] ; # Crt
%352 = phi i8* [%338, %$76], [%345, %$79] ; # P
%353 = phi i1 [0, %$76], [%349, %$79] ; # ->
br i1 %353, label %$80, label %$81
$80:
%354 = phi i64 [%350, %$78] ; # X
%355 = phi i8* [%351, %$78] ; # Crt
%356 = phi i8* [%352, %$78] ; # P
%565 = icmp sgt i32 %564, 1
br i1 %565, label %$101, label %$102
$101:
%566 = phi i64 [%552, %$99] ; # X
%567 = phi i8* [%553, %$99] ; # Crt
%568 = phi i8* [%554, %$99] ; # P
%367 = icmp sgt i32 %366, 1
br i1 %367, label %$82, label %$83
$82:
%368 = phi i64 [%354, %$80] ; # X
%369 = phi i8* [%355, %$80] ; # Crt
%370 = phi i8* [%356, %$80] ; # P
call void @waitFile(i32 %564)
br label %$102
$102:
%569 = phi i64 [%552, %$99], [%566, %$101] ; # X
%570 = phi i8* [%553, %$99], [%567, %$101] ; # Crt
%571 = phi i8* [%554, %$99], [%568, %$101] ; # P
br label %$100
$100:
%572 = phi i64 [%548, %$97], [%569, %$102] ; # X
%573 = phi i8* [%549, %$97], [%570, %$102] ; # Crt
%574 = phi i8* [%550, %$97], [%571, %$102] ; # P
br label %$96
$96:
%575 = phi i64 [%527, %$93], [%572, %$100] ; # X
%576 = phi i8* [%528, %$93], [%573, %$100] ; # Crt
%577 = phi i8* [%529, %$93], [%574, %$100] ; # P
call void @waitFile(i32 %366)
br label %$83
$83:
%371 = phi i64 [%354, %$80], [%368, %$82] ; # X
%372 = phi i8* [%355, %$80], [%369, %$82] ; # Crt
%373 = phi i8* [%356, %$80], [%370, %$82] ; # P
br label %$81
$81:
%374 = phi i64 [%350, %$78], [%371, %$83] ; # X
%375 = phi i8* [%351, %$78], [%372, %$83] ; # Crt
%376 = phi i8* [%352, %$78], [%373, %$83] ; # P
br label %$77
$77:
%377 = phi i64 [%329, %$74], [%374, %$81] ; # X
%378 = phi i8* [%330, %$74], [%375, %$81] ; # Crt
%379 = phi i8* [%331, %$74], [%376, %$81] ; # P
%578 = bitcast i8* %529 to i8**
%579 = load i8*, i8** %578
br label %$92
$94:
%580 = phi i64 [%522, %$92] ; # X
%581 = phi i8* [%523, %$92] ; # Crt
%582 = phi i8* [%524, %$92] ; # P
; # (stop Crt)
call void @stop(i8* %581)
%380 = bitcast i8* %331 to i8**
%381 = load i8*, i8** %380
$73:
%583 = phi i64 [%409, %$69], [%580, %$94] ; # X
%584 = phi i8* [%410, %$69], [%581, %$94] ; # Crt
br label %$71
$70:
%585 = phi i64 [%405, %$68] ; # X
%586 = phi i8* [%403, %$68] ; # Crt
$75:
%382 = phi i64 [%324, %$73] ; # X
%383 = phi i8* [%325, %$73] ; # Crt
%384 = phi i8* [%326, %$73] ; # P
; # (stop Crt)
call void @stop(i8* %383)
br label %$54
$54:
%385 = phi i64 [%211, %$50], [%382, %$75] ; # X
%386 = phi i8* [%212, %$50], [%383, %$75] ; # Crt
br label %$52
$51:
%387 = phi i64 [%207, %$49] ; # X
%388 = phi i8* [%205, %$49] ; # Crt
%592 = icmp eq i64 %28, %591
br i1 %592, label %$104, label %$105
$104:
%593 = phi i64 [%587, %$103] ; # X
%594 = phi i8* [%588, %$103] ; # Crt
%394 = icmp eq i64 %28, %393
br i1 %394, label %$85, label %$86
$85:
%395 = phi i64 [%389, %$84] ; # X
%396 = phi i8* [%390, %$84] ; # Crt
%600 = icmp eq i8* %599, null
br i1 %600, label %$107, label %$106
$106:
%601 = phi i64 [%595, %$105] ; # X
%602 = phi i8* [%599, %$105] ; # Crt
br label %$103
$107:
%603 = phi i64 [%595, %$105] ; # X
%604 = phi i8* [%599, %$105] ; # Crt
%605 = phi i64 [0, %$105] ; # ->
br label %$71
$71:
%606 = phi i64 [%583, %$73], [%603, %$107] ; # X
%607 = phi i8* [%584, %$73], [%604, %$107] ; # Crt
br label %$13
$67:
%608 = phi i64 [%402, %$65] ; # X
br label %$13
$13:
%609 = phi i64 [%606, %$71], [%608, %$67] ; # X
%610 = phi i64 [%28, %$71], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$67] ; # ->
%402 = icmp eq i8* %401, null
br i1 %402, label %$88, label %$87
$87:
%403 = phi i64 [%397, %$86] ; # X
%404 = phi i8* [%401, %$86] ; # Crt
br label %$84
$88:
%405 = phi i64 [%397, %$86] ; # X
%406 = phi i8* [%401, %$86] ; # Crt
%407 = phi i64 [0, %$86] ; # ->
br label %$52
$52:
%408 = phi i64 [%385, %$54], [%405, %$88] ; # X
%409 = phi i8* [%386, %$54], [%406, %$88] ; # Crt
br label %$18
$48:
%410 = phi i64 [%204, %$23] ; # X
br label %$18
$18:
%411 = phi i64 [%408, %$52], [%410, %$48] ; # X
%412 = phi i64 [%28, %$52], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$48] ; # ->
; # (unless (and ((setq Org: (coroutine (Src: org)))) (== (Org: tag) ...
; # (and ((setq Org: (coroutine (Src: org)))) (== (Org: tag) (Src: ot...
; # (Src: org)
%428 = getelementptr i8, i8* %40, i32 16
%429 = bitcast i8* %428 to i8**
%430 = load i8*, i8** %429
; # ((setq Org: (coroutine (Src: org))))
%431 = icmp ne i8* %430, null
br i1 %431, label %$64, label %$63
$64:
%432 = phi i8* [%420, %$61] ; # Crt
%433 = phi i64 [%421, %$61] ; # Lnk
%434 = phi i64 [%422, %$61] ; # Bnd
%435 = phi i8* [%423, %$61] ; # Ca
%436 = phi i8* [%424, %$61] ; # In
%437 = phi i8* [%425, %$61] ; # Out
%438 = phi i8* [%426, %$61] ; # Err
%439 = phi i8* [%427, %$61] ; # Ctl
; # (Org: tag)
%440 = ptrtoint i8* %430 to i64
%441 = inttoptr i64 %440 to i64*
%442 = load i64, i64* %441
; # (Src: otg)
%443 = getelementptr i8, i8* %40, i32 24
%444 = ptrtoint i8* %443 to i64
%445 = inttoptr i64 %444 to i64*
%446 = load i64, i64* %445
; # (== (Org: tag) (Src: otg))
%447 = icmp eq i64 %442, %446
br label %$63
$63:
%448 = phi i8* [%420, %$61], [%432, %$64] ; # Crt
%449 = phi i64 [%421, %$61], [%433, %$64] ; # Lnk
%450 = phi i64 [%422, %$61], [%434, %$64] ; # Bnd
%451 = phi i8* [%423, %$61], [%435, %$64] ; # Ca
%452 = phi i8* [%424, %$61], [%436, %$64] ; # In
%453 = phi i8* [%425, %$61], [%437, %$64] ; # Out
%454 = phi i8* [%426, %$61], [%438, %$64] ; # Err
%455 = phi i8* [%427, %$61], [%439, %$64] ; # Ctl
%456 = phi i1 [0, %$61], [%447, %$64] ; # ->
br i1 %456, label %$66, label %$65
$65:
%457 = phi i8* [%448, %$63] ; # Crt
%458 = phi i64 [%449, %$63] ; # Lnk
%459 = phi i64 [%450, %$63] ; # Bnd
%460 = phi i8* [%451, %$63] ; # Ca
%461 = phi i8* [%452, %$63] ; # In
%462 = phi i8* [%453, %$63] ; # Out
%463 = phi i8* [%454, %$63] ; # Err
%464 = phi i8* [%455, %$63] ; # Ctl
; # (Src:)
; # (loadCoEnv (Src:))
%465 = call i64 @loadCoEnv(i8* %40)
; # (Src: otg)
%466 = getelementptr i8, i8* %40, i32 24
%467 = ptrtoint i8* %466 to i64
%468 = inttoptr i64 %467 to i64*
%469 = load i64, i64* %468
; # (coErr Exe (Src: otg))
call void @coErr(i64 %0, i64 %469)
unreachable
$66:
%470 = phi i8* [%448, %$63] ; # Crt
%471 = phi i64 [%449, %$63] ; # Lnk
%472 = phi i64 [%450, %$63] ; # Bnd
%473 = phi i8* [%451, %$63] ; # Ca
%474 = phi i8* [%452, %$63] ; # In
%475 = phi i8* [%453, %$63] ; # Out
%476 = phi i8* [%454, %$63] ; # Err
%477 = phi i8* [%455, %$63] ; # Ctl
%428 = getelementptr i8, i8* %43, i32 112
%429 = getelementptr i8, i8* %428, i32 56
%430 = bitcast i8* %429 to i8**
%431 = load i8*, i8** %430
%478 = getelementptr i8, i8* %430, i32 152
%479 = getelementptr i8, i8* %478, i32 56
%480 = bitcast i8* %479 to i8**
%481 = load i8*, i8** %480
br label %$63
$63:
%434 = phi i8* [%420, %$61], [%444, %$64] ; # Crt
%435 = phi i64 [%421, %$61], [%445, %$64] ; # Lnk
%436 = phi i64 [%422, %$61], [%446, %$64] ; # Bnd
%437 = phi i8* [%423, %$61], [%447, %$64] ; # Ca
%438 = phi i8* [%424, %$61], [%448, %$64] ; # In
%439 = phi i8* [%425, %$61], [%449, %$64] ; # Out
%440 = phi i8* [%426, %$61], [%450, %$64] ; # Err
%441 = phi i8* [%427, %$61], [%454, %$64] ; # Ctl
%442 = phi i8* [%431, %$61], [%451, %$64] ; # P
%443 = icmp ne i8* %441, null
br i1 %443, label %$64, label %$65
$64:
%444 = phi i8* [%434, %$63] ; # Crt
%445 = phi i64 [%435, %$63] ; # Lnk
%446 = phi i64 [%436, %$63] ; # Bnd
%447 = phi i8* [%437, %$63] ; # Ca
%448 = phi i8* [%438, %$63] ; # In
%449 = phi i8* [%439, %$63] ; # Out
%450 = phi i8* [%440, %$63] ; # Err
%451 = phi i8* [%441, %$63] ; # Ctl
%452 = phi i8* [%442, %$63] ; # P
br label %$67
$67:
%484 = phi i8* [%470, %$66], [%494, %$68] ; # Crt
%485 = phi i64 [%471, %$66], [%495, %$68] ; # Lnk
%486 = phi i64 [%472, %$66], [%496, %$68] ; # Bnd
%487 = phi i8* [%473, %$66], [%497, %$68] ; # Ca
%488 = phi i8* [%474, %$66], [%498, %$68] ; # In
%489 = phi i8* [%475, %$66], [%499, %$68] ; # Out
%490 = phi i8* [%476, %$66], [%500, %$68] ; # Err
%491 = phi i8* [%477, %$66], [%504, %$68] ; # Ctl
%492 = phi i8* [%481, %$66], [%501, %$68] ; # P
%493 = icmp ne i8* %491, null
br i1 %493, label %$68, label %$69
$68:
%494 = phi i8* [%484, %$67] ; # Crt
%495 = phi i64 [%485, %$67] ; # Lnk
%496 = phi i64 [%486, %$67] ; # Bnd
%497 = phi i8* [%487, %$67] ; # Ca
%498 = phi i8* [%488, %$67] ; # In
%499 = phi i8* [%489, %$67] ; # Out
%500 = phi i8* [%490, %$67] ; # Err
%501 = phi i8* [%491, %$67] ; # Ctl
%502 = phi i8* [%492, %$67] ; # P
br label %$63
$65:
%456 = phi i8* [%434, %$63] ; # Crt
%457 = phi i64 [%435, %$63] ; # Lnk
%458 = phi i64 [%436, %$63] ; # Bnd
%459 = phi i8* [%437, %$63] ; # Ca
%460 = phi i8* [%438, %$63] ; # In
%461 = phi i8* [%439, %$63] ; # Out
%462 = phi i8* [%440, %$63] ; # Err
%463 = phi i8* [%441, %$63] ; # Ctl
%464 = phi i8* [%442, %$63] ; # P
br label %$67
$69:
%506 = phi i8* [%484, %$67] ; # Crt
%507 = phi i64 [%485, %$67] ; # Lnk
%508 = phi i64 [%486, %$67] ; # Bnd
%509 = phi i8* [%487, %$67] ; # Ca
%510 = phi i8* [%488, %$67] ; # In
%511 = phi i8* [%489, %$67] ; # Out
%512 = phi i8* [%490, %$67] ; # Err
%513 = phi i8* [%491, %$67] ; # Ctl
%514 = phi i8* [%492, %$67] ; # P
%465 = getelementptr i8, i8* %40, i32 112
%466 = getelementptr i8, i8* %465, i32 56
%467 = bitcast i8* %466 to i8**
store i8* %464, i8** %467
%515 = getelementptr i8, i8* %40, i32 152
%516 = getelementptr i8, i8* %515, i32 56
%517 = bitcast i8* %516 to i8**
store i8* %514, i8** %517
%468 = getelementptr i8, i8* %43, i32 112
%469 = getelementptr i8, i8* %468, i32 48
%470 = bitcast i8* %469 to i8**
%471 = load i8*, i8** %470
%518 = getelementptr i8, i8* %430, i32 152
%519 = getelementptr i8, i8* %518, i32 48
%520 = bitcast i8* %519 to i8**
%521 = load i8*, i8** %520
br label %$66
$66:
%474 = phi i8* [%456, %$65], [%484, %$67] ; # Crt
%475 = phi i64 [%457, %$65], [%485, %$67] ; # Lnk
%476 = phi i64 [%458, %$65], [%486, %$67] ; # Bnd
%477 = phi i8* [%459, %$65], [%487, %$67] ; # Ca
%478 = phi i8* [%460, %$65], [%488, %$67] ; # In
%479 = phi i8* [%461, %$65], [%489, %$67] ; # Out
%480 = phi i8* [%462, %$65], [%494, %$67] ; # Err
%481 = phi i8* [%463, %$65], [%491, %$67] ; # Ctl
%482 = phi i8* [%471, %$65], [%490, %$67] ; # P
%483 = icmp ne i8* %480, null
br i1 %483, label %$67, label %$68
$67:
%484 = phi i8* [%474, %$66] ; # Crt
%485 = phi i64 [%475, %$66] ; # Lnk
%486 = phi i64 [%476, %$66] ; # Bnd
%487 = phi i8* [%477, %$66] ; # Ca
%488 = phi i8* [%478, %$66] ; # In
%489 = phi i8* [%479, %$66] ; # Out
%490 = phi i8* [%480, %$66] ; # Err
%491 = phi i8* [%481, %$66] ; # Ctl
%492 = phi i8* [%482, %$66] ; # P
br label %$70
$70:
%524 = phi i8* [%506, %$69], [%534, %$71] ; # Crt
%525 = phi i64 [%507, %$69], [%535, %$71] ; # Lnk
%526 = phi i64 [%508, %$69], [%536, %$71] ; # Bnd
%527 = phi i8* [%509, %$69], [%537, %$71] ; # Ca
%528 = phi i8* [%510, %$69], [%538, %$71] ; # In
%529 = phi i8* [%511, %$69], [%539, %$71] ; # Out
%530 = phi i8* [%512, %$69], [%544, %$71] ; # Err
%531 = phi i8* [%513, %$69], [%541, %$71] ; # Ctl
%532 = phi i8* [%521, %$69], [%540, %$71] ; # P
%533 = icmp ne i8* %530, null
br i1 %533, label %$71, label %$72
$71:
%534 = phi i8* [%524, %$70] ; # Crt
%535 = phi i64 [%525, %$70] ; # Lnk
%536 = phi i64 [%526, %$70] ; # Bnd
%537 = phi i8* [%527, %$70] ; # Ca
%538 = phi i8* [%528, %$70] ; # In
%539 = phi i8* [%529, %$70] ; # Out
%540 = phi i8* [%530, %$70] ; # Err
%541 = phi i8* [%531, %$70] ; # Ctl
%542 = phi i8* [%532, %$70] ; # P
br label %$66
$68:
%496 = phi i8* [%474, %$66] ; # Crt
%497 = phi i64 [%475, %$66] ; # Lnk
%498 = phi i64 [%476, %$66] ; # Bnd
%499 = phi i8* [%477, %$66] ; # Ca
%500 = phi i8* [%478, %$66] ; # In
%501 = phi i8* [%479, %$66] ; # Out
%502 = phi i8* [%480, %$66] ; # Err
%503 = phi i8* [%481, %$66] ; # Ctl
%504 = phi i8* [%482, %$66] ; # P
br label %$70
$72:
%546 = phi i8* [%524, %$70] ; # Crt
%547 = phi i64 [%525, %$70] ; # Lnk
%548 = phi i64 [%526, %$70] ; # Bnd
%549 = phi i8* [%527, %$70] ; # Ca
%550 = phi i8* [%528, %$70] ; # In
%551 = phi i8* [%529, %$70] ; # Out
%552 = phi i8* [%530, %$70] ; # Err
%553 = phi i8* [%531, %$70] ; # Ctl
%554 = phi i8* [%532, %$70] ; # P
%505 = getelementptr i8, i8* %40, i32 112
%506 = getelementptr i8, i8* %505, i32 48
%507 = bitcast i8* %506 to i8**
store i8* %504, i8** %507
%555 = getelementptr i8, i8* %40, i32 152
%556 = getelementptr i8, i8* %555, i32 48
%557 = bitcast i8* %556 to i8**
store i8* %554, i8** %557
%508 = getelementptr i8, i8* %43, i32 112
%509 = getelementptr i8, i8* %508, i32 40
%510 = bitcast i8* %509 to i8**
%511 = load i8*, i8** %510
%558 = getelementptr i8, i8* %430, i32 152
%559 = getelementptr i8, i8* %558, i32 40
%560 = bitcast i8* %559 to i8**
%561 = load i8*, i8** %560
br label %$69
$69:
%514 = phi i8* [%496, %$68], [%525, %$70] ; # Crt
%515 = phi i64 [%497, %$68], [%526, %$70] ; # Lnk
%516 = phi i64 [%498, %$68], [%527, %$70] ; # Bnd
%517 = phi i8* [%499, %$68], [%528, %$70] ; # Ca
%518 = phi i8* [%500, %$68], [%529, %$70] ; # In
%519 = phi i8* [%501, %$68], [%535, %$70] ; # Out
%520 = phi i8* [%502, %$68], [%531, %$70] ; # Err
%521 = phi i8* [%503, %$68], [%532, %$70] ; # Ctl
%522 = phi i8* [%511, %$68], [%530, %$70] ; # P
br label %$73
$73:
%564 = phi i8* [%546, %$72], [%575, %$74] ; # Crt
%565 = phi i64 [%547, %$72], [%576, %$74] ; # Lnk
%566 = phi i64 [%548, %$72], [%577, %$74] ; # Bnd
%567 = phi i8* [%549, %$72], [%578, %$74] ; # Ca
%568 = phi i8* [%550, %$72], [%579, %$74] ; # In
%569 = phi i8* [%551, %$72], [%585, %$74] ; # Out
%570 = phi i8* [%552, %$72], [%581, %$74] ; # Err
%571 = phi i8* [%553, %$72], [%582, %$74] ; # Ctl
%572 = phi i8* [%561, %$72], [%580, %$74] ; # P
%524 = icmp eq i8* %519, %523
br i1 %524, label %$71, label %$70
$70:
%525 = phi i8* [%514, %$69] ; # Crt
%526 = phi i64 [%515, %$69] ; # Lnk
%527 = phi i64 [%516, %$69] ; # Bnd
%528 = phi i8* [%517, %$69] ; # Ca
%529 = phi i8* [%518, %$69] ; # In
%530 = phi i8* [%519, %$69] ; # Out
%531 = phi i8* [%520, %$69] ; # Err
%532 = phi i8* [%521, %$69] ; # Ctl
%533 = phi i8* [%522, %$69] ; # P
%574 = icmp eq i8* %569, %573
br i1 %574, label %$75, label %$74
$74:
%575 = phi i8* [%564, %$73] ; # Crt
%576 = phi i64 [%565, %$73] ; # Lnk
%577 = phi i64 [%566, %$73] ; # Bnd
%578 = phi i8* [%567, %$73] ; # Ca
%579 = phi i8* [%568, %$73] ; # In
%580 = phi i8* [%569, %$73] ; # Out
%581 = phi i8* [%570, %$73] ; # Err
%582 = phi i8* [%571, %$73] ; # Ctl
%583 = phi i8* [%572, %$73] ; # P
br label %$69
$71:
%537 = phi i8* [%514, %$69] ; # Crt
%538 = phi i64 [%515, %$69] ; # Lnk
%539 = phi i64 [%516, %$69] ; # Bnd
%540 = phi i8* [%517, %$69] ; # Ca
%541 = phi i8* [%518, %$69] ; # In
%542 = phi i8* [%519, %$69] ; # Out
%543 = phi i8* [%520, %$69] ; # Err
%544 = phi i8* [%521, %$69] ; # Ctl
%545 = phi i8* [%522, %$69] ; # P
br label %$73
$75:
%587 = phi i8* [%564, %$73] ; # Crt
%588 = phi i64 [%565, %$73] ; # Lnk
%589 = phi i64 [%566, %$73] ; # Bnd
%590 = phi i8* [%567, %$73] ; # Ca
%591 = phi i8* [%568, %$73] ; # In
%592 = phi i8* [%569, %$73] ; # Out
%593 = phi i8* [%570, %$73] ; # Err
%594 = phi i8* [%571, %$73] ; # Ctl
%595 = phi i8* [%572, %$73] ; # P
%546 = getelementptr i8, i8* %40, i32 112
%547 = getelementptr i8, i8* %546, i32 40
%548 = bitcast i8* %547 to i8**
store i8* %545, i8** %548
%596 = getelementptr i8, i8* %40, i32 152
%597 = getelementptr i8, i8* %596, i32 40
%598 = bitcast i8* %597 to i8**
store i8* %595, i8** %598
%549 = getelementptr i8, i8* %43, i32 112
%550 = getelementptr i8, i8* %549, i32 32
%551 = bitcast i8* %550 to i8**
%552 = load i8*, i8** %551
%599 = getelementptr i8, i8* %430, i32 152
%600 = getelementptr i8, i8* %599, i32 32
%601 = bitcast i8* %600 to i8**
%602 = load i8*, i8** %601
br label %$72
$72:
%555 = phi i8* [%537, %$71], [%566, %$73] ; # Crt
%556 = phi i64 [%538, %$71], [%567, %$73] ; # Lnk
%557 = phi i64 [%539, %$71], [%568, %$73] ; # Bnd
%558 = phi i8* [%540, %$71], [%569, %$73] ; # Ca
%559 = phi i8* [%541, %$71], [%576, %$73] ; # In
%560 = phi i8* [%542, %$71], [%571, %$73] ; # Out
%561 = phi i8* [%543, %$71], [%572, %$73] ; # Err
%562 = phi i8* [%544, %$71], [%573, %$73] ; # Ctl
%563 = phi i8* [%552, %$71], [%570, %$73] ; # P
br label %$76
$76:
%605 = phi i8* [%587, %$75], [%616, %$77] ; # Crt
%606 = phi i64 [%588, %$75], [%617, %$77] ; # Lnk
%607 = phi i64 [%589, %$75], [%618, %$77] ; # Bnd
%608 = phi i8* [%590, %$75], [%619, %$77] ; # Ca
%609 = phi i8* [%591, %$75], [%626, %$77] ; # In
%610 = phi i8* [%592, %$75], [%621, %$77] ; # Out
%611 = phi i8* [%593, %$75], [%622, %$77] ; # Err
%612 = phi i8* [%594, %$75], [%623, %$77] ; # Ctl
%613 = phi i8* [%602, %$75], [%620, %$77] ; # P
%565 = icmp eq i8* %559, %564
br i1 %565, label %$74, label %$73
$73:
%566 = phi i8* [%555, %$72] ; # Crt
%567 = phi i64 [%556, %$72] ; # Lnk
%568 = phi i64 [%557, %$72] ; # Bnd
%569 = phi i8* [%558, %$72] ; # Ca
%570 = phi i8* [%559, %$72] ; # In
%571 = phi i8* [%560, %$72] ; # Out
%572 = phi i8* [%561, %$72] ; # Err
%573 = phi i8* [%562, %$72] ; # Ctl
%574 = phi i8* [%563, %$72] ; # P
%615 = icmp eq i8* %609, %614
br i1 %615, label %$78, label %$77
$77:
%616 = phi i8* [%605, %$76] ; # Crt
%617 = phi i64 [%606, %$76] ; # Lnk
%618 = phi i64 [%607, %$76] ; # Bnd
%619 = phi i8* [%608, %$76] ; # Ca
%620 = phi i8* [%609, %$76] ; # In
%621 = phi i8* [%610, %$76] ; # Out
%622 = phi i8* [%611, %$76] ; # Err
%623 = phi i8* [%612, %$76] ; # Ctl
%624 = phi i8* [%613, %$76] ; # P
br label %$72
$74:
%578 = phi i8* [%555, %$72] ; # Crt
%579 = phi i64 [%556, %$72] ; # Lnk
%580 = phi i64 [%557, %$72] ; # Bnd
%581 = phi i8* [%558, %$72] ; # Ca
%582 = phi i8* [%559, %$72] ; # In
%583 = phi i8* [%560, %$72] ; # Out
%584 = phi i8* [%561, %$72] ; # Err
%585 = phi i8* [%562, %$72] ; # Ctl
%586 = phi i8* [%563, %$72] ; # P
br label %$76
$78:
%628 = phi i8* [%605, %$76] ; # Crt
%629 = phi i64 [%606, %$76] ; # Lnk
%630 = phi i64 [%607, %$76] ; # Bnd
%631 = phi i8* [%608, %$76] ; # Ca
%632 = phi i8* [%609, %$76] ; # In
%633 = phi i8* [%610, %$76] ; # Out
%634 = phi i8* [%611, %$76] ; # Err
%635 = phi i8* [%612, %$76] ; # Ctl
%636 = phi i8* [%613, %$76] ; # P
%587 = getelementptr i8, i8* %40, i32 112
%588 = getelementptr i8, i8* %587, i32 32
%589 = bitcast i8* %588 to i8**
store i8* %586, i8** %589
%637 = getelementptr i8, i8* %40, i32 152
%638 = getelementptr i8, i8* %637, i32 32
%639 = bitcast i8* %638 to i8**
store i8* %636, i8** %639
%590 = getelementptr i8, i8* %43, i32 112
%591 = getelementptr i8, i8* %590, i32 24
%592 = bitcast i8* %591 to i8**
%593 = load i8*, i8** %592
%640 = getelementptr i8, i8* %430, i32 152
%641 = getelementptr i8, i8* %640, i32 24
%642 = bitcast i8* %641 to i8**
%643 = load i8*, i8** %642
br label %$75
$75:
%596 = phi i8* [%578, %$74], [%606, %$76] ; # Crt
%597 = phi i64 [%579, %$74], [%607, %$76] ; # Lnk
%598 = phi i64 [%580, %$74], [%608, %$76] ; # Bnd
%599 = phi i8* [%581, %$74], [%616, %$76] ; # Ca
%600 = phi i8* [%582, %$74], [%610, %$76] ; # In
%601 = phi i8* [%583, %$74], [%611, %$76] ; # Out
%602 = phi i8* [%584, %$74], [%612, %$76] ; # Err
%603 = phi i8* [%585, %$74], [%613, %$76] ; # Ctl
%604 = phi i8* [%593, %$74], [%609, %$76] ; # P
%605 = icmp ne i8* %599, null
br i1 %605, label %$76, label %$77
$76:
%606 = phi i8* [%596, %$75] ; # Crt
%607 = phi i64 [%597, %$75] ; # Lnk
%608 = phi i64 [%598, %$75] ; # Bnd
%609 = phi i8* [%599, %$75] ; # Ca
%610 = phi i8* [%600, %$75] ; # In
%611 = phi i8* [%601, %$75] ; # Out
%612 = phi i8* [%602, %$75] ; # Err
%613 = phi i8* [%603, %$75] ; # Ctl
%614 = phi i8* [%604, %$75] ; # P
br label %$79
$79:
%646 = phi i8* [%628, %$78], [%656, %$80] ; # Crt
%647 = phi i64 [%629, %$78], [%657, %$80] ; # Lnk
%648 = phi i64 [%630, %$78], [%658, %$80] ; # Bnd
%649 = phi i8* [%631, %$78], [%666, %$80] ; # Ca
%650 = phi i8* [%632, %$78], [%660, %$80] ; # In
%651 = phi i8* [%633, %$78], [%661, %$80] ; # Out
%652 = phi i8* [%634, %$78], [%662, %$80] ; # Err
%653 = phi i8* [%635, %$78], [%663, %$80] ; # Ctl
%654 = phi i8* [%643, %$78], [%659, %$80] ; # P
%655 = icmp ne i8* %649, null
br i1 %655, label %$80, label %$81
$80:
%656 = phi i8* [%646, %$79] ; # Crt
%657 = phi i64 [%647, %$79] ; # Lnk
%658 = phi i64 [%648, %$79] ; # Bnd
%659 = phi i8* [%649, %$79] ; # Ca
%660 = phi i8* [%650, %$79] ; # In
%661 = phi i8* [%651, %$79] ; # Out
%662 = phi i8* [%652, %$79] ; # Err
%663 = phi i8* [%653, %$79] ; # Ctl
%664 = phi i8* [%654, %$79] ; # P
br label %$75
$77:
%618 = phi i8* [%596, %$75] ; # Crt
%619 = phi i64 [%597, %$75] ; # Lnk
%620 = phi i64 [%598, %$75] ; # Bnd
%621 = phi i8* [%599, %$75] ; # Ca
%622 = phi i8* [%600, %$75] ; # In
%623 = phi i8* [%601, %$75] ; # Out
%624 = phi i8* [%602, %$75] ; # Err
%625 = phi i8* [%603, %$75] ; # Ctl
%626 = phi i8* [%604, %$75] ; # P
br label %$79
$81:
%668 = phi i8* [%646, %$79] ; # Crt
%669 = phi i64 [%647, %$79] ; # Lnk
%670 = phi i64 [%648, %$79] ; # Bnd
%671 = phi i8* [%649, %$79] ; # Ca
%672 = phi i8* [%650, %$79] ; # In
%673 = phi i8* [%651, %$79] ; # Out
%674 = phi i8* [%652, %$79] ; # Err
%675 = phi i8* [%653, %$79] ; # Ctl
%676 = phi i8* [%654, %$79] ; # P
%627 = getelementptr i8, i8* %40, i32 112
%628 = getelementptr i8, i8* %627, i32 24
%629 = bitcast i8* %628 to i8**
store i8* %626, i8** %629
%677 = getelementptr i8, i8* %40, i32 152
%678 = getelementptr i8, i8* %677, i32 24
%679 = bitcast i8* %678 to i8**
store i8* %676, i8** %679
%630 = getelementptr i8, i8* %40, i32 64
%631 = ptrtoint i8* %630 to i64
%632 = inttoptr i64 %631 to i64*
%633 = load i64, i64* %632
%680 = getelementptr i8, i8* %40, i32 64
%681 = ptrtoint i8* %680 to i64
%682 = inttoptr i64 %681 to i64*
%683 = load i64, i64* %682
%634 = getelementptr i8, i8* %43, i32 112
%635 = getelementptr i8, i8* %634, i32 8
%636 = ptrtoint i8* %635 to i64
%637 = inttoptr i64 %636 to i64*
%638 = load i64, i64* %637
%639 = inttoptr i64 %633 to i64*
%640 = getelementptr i64, i64* %639, i32 2
store i64 %638, i64* %640
%684 = getelementptr i8, i8* %430, i32 152
%685 = getelementptr i8, i8* %684, i32 8
%686 = ptrtoint i8* %685 to i64
%687 = inttoptr i64 %686 to i64*
%688 = load i64, i64* %687
%689 = inttoptr i64 %683 to i64*
%690 = getelementptr i64, i64* %689, i32 2
store i64 %688, i64* %690
br label %$78
$78:
%641 = phi i8* [%618, %$77], [%651, %$79] ; # Crt
%642 = phi i64 [%619, %$77], [%652, %$79] ; # Lnk
%643 = phi i64 [%620, %$77], [%669, %$79] ; # Bnd
%644 = phi i8* [%621, %$77], [%654, %$79] ; # Ca
%645 = phi i8* [%622, %$77], [%655, %$79] ; # In
%646 = phi i8* [%623, %$77], [%656, %$79] ; # Out
%647 = phi i8* [%624, %$77], [%657, %$79] ; # Err
%648 = phi i8* [%625, %$77], [%658, %$79] ; # Ctl
%649 = phi i64 [%633, %$77], [%653, %$79] ; # P
%650 = icmp ne i64 %643, 0
br i1 %650, label %$79, label %$80
$79:
%651 = phi i8* [%641, %$78] ; # Crt
%652 = phi i64 [%642, %$78] ; # Lnk
%653 = phi i64 [%643, %$78] ; # Bnd
%654 = phi i8* [%644, %$78] ; # Ca
%655 = phi i8* [%645, %$78] ; # In
%656 = phi i8* [%646, %$78] ; # Out
%657 = phi i8* [%647, %$78] ; # Err
%658 = phi i8* [%648, %$78] ; # Ctl
%659 = phi i64 [%649, %$78] ; # P
br label %$82
$82:
%691 = phi i8* [%668, %$81], [%701, %$83] ; # Crt
%692 = phi i64 [%669, %$81], [%702, %$83] ; # Lnk
%693 = phi i64 [%670, %$81], [%719, %$83] ; # Bnd
%694 = phi i8* [%671, %$81], [%704, %$83] ; # Ca
%695 = phi i8* [%672, %$81], [%705, %$83] ; # In
%696 = phi i8* [%673, %$81], [%706, %$83] ; # Out
%697 = phi i8* [%674, %$81], [%707, %$83] ; # Err
%698 = phi i8* [%675, %$81], [%708, %$83] ; # Ctl
%699 = phi i64 [%683, %$81], [%703, %$83] ; # P
%700 = icmp ne i64 %693, 0
br i1 %700, label %$83, label %$84
$83:
%701 = phi i8* [%691, %$82] ; # Crt
%702 = phi i64 [%692, %$82] ; # Lnk
%703 = phi i64 [%693, %$82] ; # Bnd
%704 = phi i8* [%694, %$82] ; # Ca
%705 = phi i8* [%695, %$82] ; # In
%706 = phi i8* [%696, %$82] ; # Out
%707 = phi i8* [%697, %$82] ; # Err
%708 = phi i8* [%698, %$82] ; # Ctl
%709 = phi i64 [%699, %$82] ; # P
%663 = inttoptr i64 %662 to i64*
%664 = load i64, i64* %663
%665 = inttoptr i64 %653 to i64*
%666 = load i64, i64* %665
store i64 %666, i64* %663
store i64 %664, i64* %665
%713 = inttoptr i64 %712 to i64*
%714 = load i64, i64* %713
%715 = inttoptr i64 %703 to i64*
%716 = load i64, i64* %715
store i64 %716, i64* %713
store i64 %714, i64* %715
%670 = inttoptr i64 %653 to i64*
%671 = getelementptr i64, i64* %670, i32 2
store i64 %659, i64* %671
br label %$78
$80:
%672 = phi i8* [%641, %$78] ; # Crt
%673 = phi i64 [%642, %$78] ; # Lnk
%674 = phi i64 [%643, %$78] ; # Bnd
%675 = phi i8* [%644, %$78] ; # Ca
%676 = phi i8* [%645, %$78] ; # In
%677 = phi i8* [%646, %$78] ; # Out
%678 = phi i8* [%647, %$78] ; # Err
%679 = phi i8* [%648, %$78] ; # Ctl
%680 = phi i64 [%649, %$78] ; # P
%720 = inttoptr i64 %703 to i64*
%721 = getelementptr i64, i64* %720, i32 2
store i64 %709, i64* %721
br label %$82
$84:
%722 = phi i8* [%691, %$82] ; # Crt
%723 = phi i64 [%692, %$82] ; # Lnk
%724 = phi i64 [%693, %$82] ; # Bnd
%725 = phi i8* [%694, %$82] ; # Ca
%726 = phi i8* [%695, %$82] ; # In
%727 = phi i8* [%696, %$82] ; # Out
%728 = phi i8* [%697, %$82] ; # Err
%729 = phi i8* [%698, %$82] ; # Ctl
%730 = phi i64 [%699, %$82] ; # P
%681 = getelementptr i8, i8* %40, i32 112
%682 = getelementptr i8, i8* %681, i32 8
%683 = ptrtoint i8* %682 to i64
%684 = inttoptr i64 %683 to i64*
store i64 %680, i64* %684
%731 = getelementptr i8, i8* %40, i32 152
%732 = getelementptr i8, i8* %731, i32 8
%733 = ptrtoint i8* %732 to i64
%734 = inttoptr i64 %733 to i64*
store i64 %730, i64* %734
%685 = getelementptr i8, i8* %43, i32 112
%686 = ptrtoint i8* %685 to i64
%687 = inttoptr i64 %686 to i64*
%688 = load i64, i64* %687
%735 = getelementptr i8, i8* %430, i32 152
%736 = ptrtoint i8* %735 to i64
%737 = inttoptr i64 %736 to i64*
%738 = load i64, i64* %737
%689 = getelementptr i8, i8* %40, i32 56
%690 = ptrtoint i8* %689 to i64
%691 = inttoptr i64 %690 to i64*
store i64 %688, i64* %691
%739 = getelementptr i8, i8* %40, i32 56
%740 = ptrtoint i8* %739 to i64
%741 = inttoptr i64 %740 to i64*
store i64 %738, i64* %741
br label %$81
$81:
%692 = phi i8* [%672, %$80], [%702, %$82] ; # Crt
%693 = phi i64 [%673, %$80], [%713, %$82] ; # Lnk
%694 = phi i64 [%674, %$80], [%704, %$82] ; # Bnd
%695 = phi i8* [%675, %$80], [%705, %$82] ; # Ca
%696 = phi i8* [%676, %$80], [%706, %$82] ; # In
%697 = phi i8* [%677, %$80], [%707, %$82] ; # Out
%698 = phi i8* [%678, %$80], [%708, %$82] ; # Err
%699 = phi i8* [%679, %$80], [%709, %$82] ; # Ctl
%700 = phi i64 [%688, %$80], [%703, %$82] ; # P
%701 = icmp ne i64 %693, 0
br i1 %701, label %$82, label %$83
$82:
%702 = phi i8* [%692, %$81] ; # Crt
%703 = phi i64 [%693, %$81] ; # Lnk
%704 = phi i64 [%694, %$81] ; # Bnd
%705 = phi i8* [%695, %$81] ; # Ca
%706 = phi i8* [%696, %$81] ; # In
%707 = phi i8* [%697, %$81] ; # Out
%708 = phi i8* [%698, %$81] ; # Err
%709 = phi i8* [%699, %$81] ; # Ctl
%710 = phi i64 [%700, %$81] ; # P
br label %$85
$85:
%742 = phi i8* [%722, %$84], [%752, %$86] ; # Crt
%743 = phi i64 [%723, %$84], [%763, %$86] ; # Lnk
%744 = phi i64 [%724, %$84], [%754, %$86] ; # Bnd
%745 = phi i8* [%725, %$84], [%755, %$86] ; # Ca
%746 = phi i8* [%726, %$84], [%756, %$86] ; # In
%747 = phi i8* [%727, %$84], [%757, %$86] ; # Out
%748 = phi i8* [%728, %$84], [%758, %$86] ; # Err
%749 = phi i8* [%729, %$84], [%759, %$86] ; # Ctl
%750 = phi i64 [%738, %$84], [%753, %$86] ; # P
%751 = icmp ne i64 %743, 0
br i1 %751, label %$86, label %$87
$86:
%752 = phi i8* [%742, %$85] ; # Crt
%753 = phi i64 [%743, %$85] ; # Lnk
%754 = phi i64 [%744, %$85] ; # Bnd
%755 = phi i8* [%745, %$85] ; # Ca
%756 = phi i8* [%746, %$85] ; # In
%757 = phi i8* [%747, %$85] ; # Out
%758 = phi i8* [%748, %$85] ; # Err
%759 = phi i8* [%749, %$85] ; # Ctl
%760 = phi i64 [%750, %$85] ; # P
%714 = inttoptr i64 %703 to i64*
%715 = getelementptr i64, i64* %714, i32 1
store i64 %710, i64* %715
br label %$81
$83:
%716 = phi i8* [%692, %$81] ; # Crt
%717 = phi i64 [%693, %$81] ; # Lnk
%718 = phi i64 [%694, %$81] ; # Bnd
%719 = phi i8* [%695, %$81] ; # Ca
%720 = phi i8* [%696, %$81] ; # In
%721 = phi i8* [%697, %$81] ; # Out
%722 = phi i8* [%698, %$81] ; # Err
%723 = phi i8* [%699, %$81] ; # Ctl
%724 = phi i64 [%700, %$81] ; # P
%764 = inttoptr i64 %753 to i64*
%765 = getelementptr i64, i64* %764, i32 1
store i64 %760, i64* %765
br label %$85
$87:
%766 = phi i8* [%742, %$85] ; # Crt
%767 = phi i64 [%743, %$85] ; # Lnk
%768 = phi i64 [%744, %$85] ; # Bnd
%769 = phi i8* [%745, %$85] ; # Ca
%770 = phi i8* [%746, %$85] ; # In
%771 = phi i8* [%747, %$85] ; # Out
%772 = phi i8* [%748, %$85] ; # Err
%773 = phi i8* [%749, %$85] ; # Ctl
%774 = phi i64 [%750, %$85] ; # P
%725 = getelementptr i8, i8* %40, i32 112
%726 = ptrtoint i8* %725 to i64
%727 = inttoptr i64 %726 to i64*
store i64 %724, i64* %727
%775 = getelementptr i8, i8* %40, i32 152
%776 = ptrtoint i8* %775 to i64
%777 = inttoptr i64 %776 to i64*
store i64 %774, i64* %777
%728 = phi i8* [%408, %$60], [%716, %$83] ; # Crt
%729 = phi i64 [%409, %$60], [%717, %$83] ; # Lnk
%730 = phi i64 [%410, %$60], [%718, %$83] ; # Bnd
%731 = phi i8* [%411, %$60], [%719, %$83] ; # Ca
%732 = phi i8* [%412, %$60], [%720, %$83] ; # In
%733 = phi i8* [%413, %$60], [%721, %$83] ; # Out
%734 = phi i8* [%414, %$60], [%722, %$83] ; # Err
%735 = phi i8* [%415, %$60], [%723, %$83] ; # Ctl
%778 = phi i8* [%408, %$60], [%766, %$87] ; # Crt
%779 = phi i64 [%409, %$60], [%767, %$87] ; # Lnk
%780 = phi i64 [%410, %$60], [%768, %$87] ; # Bnd
%781 = phi i8* [%411, %$60], [%769, %$87] ; # Ca
%782 = phi i8* [%412, %$60], [%770, %$87] ; # In
%783 = phi i8* [%413, %$60], [%771, %$87] ; # Out
%784 = phi i8* [%414, %$60], [%772, %$87] ; # Err
%785 = phi i8* [%415, %$60], [%773, %$87] ; # Ctl
%737 = inttoptr i64 %19 to i64*
%738 = getelementptr i64, i64* %737, i32 1
%739 = load i64, i64* %738
%740 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %739, i64* %740
ret i64 %736
%787 = inttoptr i64 %19 to i64*
%788 = getelementptr i64, i64* %787, i32 1
%789 = load i64, i64* %788
%790 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %789, i64* %790
ret i64 %786
%54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %54
%54 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %54
%59 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$81 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%59 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$82 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %34
%34 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %34
%119 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
%119 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 600) to i64) to i64*
%120 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%120 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
%121 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
%42 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%42 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%101 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%101 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
store void(i8)* @_putStdout, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%133 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**) to i8**
%133 = bitcast void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**) to i8**
; # (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 '...
; # (let A Av (while (pair (shift X)) (let Nm (xName (evSym X)) (set ...
; # (while (pair (shift X)) (let Nm (xName (evSym X)) (set (inc 'A) (...
; # (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 '...
; # (let A Av (while (pair (shift X)) (let Nm (xName (evSym X)) (set ...
; # (while (pair (shift X)) (let Nm (xName (evSym X)) (set (inc 'A) (...
%104 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$36], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$37] ; # ->
%104 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$36], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$37] ; # ->
%106 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$86 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%106 = call i64 @repl(i64 0, i8* bitcast ([3 x i8]* @$87 to i8*), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%17 = phi i64 [%16, %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$5] ; # ->
%17 = phi i64 [%16, %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5] ; # ->
%17 = phi i64 [%16, %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$5] ; # ->
%17 = phi i64 [%16, %$4], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5] ; # ->
%24 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$6] ; # ->
%24 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$6] ; # ->
%6 = phi i64 [%5, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%6 = phi i64 [%5, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 216) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64* %4
%4 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 216) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64* %4
%68 = phi i64 [%29, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%61, %$17] ; # ->
%68 = phi i64 [%29, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%61, %$17] ; # ->
%14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%45 = call i64 @cons(i64 %44, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%45 = call i64 @cons(i64 %44, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%42 = call i64 @cons(i64 %41, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%42 = call i64 @cons(i64 %41, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%42 = call i64 @cons(i64 %41, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%42 = call i64 @cons(i64 %41, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%52 = phi i64 [%35, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # R
%52 = phi i64 [%35, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # R
%106 = call i64 @cons(i64 %53, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%106 = call i64 @cons(i64 %53, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%140 = call i64 @cons(i64 %53, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%140 = call i64 @cons(i64 %53, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%18 = call i64 @cons(i64 %15, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%18 = call i64 @cons(i64 %15, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%93 = call i64 @cons(i64 %91, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%93 = call i64 @cons(i64 %91, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%107 = call i64 @cons(i64 %105, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%107 = call i64 @cons(i64 %105, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%28 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
%28 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12] ; # ->
%40 = phi i64 [%39, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
%40 = phi i64 [%39, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%41 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 456) to i64) to i64*
%24 = call i64 @cons(i64 %21, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%24 = call i64 @cons(i64 %21, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%79 = call i64 @cons(i64 %78, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%79 = call i64 @cons(i64 %78, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%142 = call i64 @cons(i64 %141, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%142 = call i64 @cons(i64 %141, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%152 = phi i64 [%13, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%79, %$30] ; # ->
%152 = phi i64 [%13, %$11], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%79, %$30] ; # ->
%71 = call i64 @cons(i64 %70, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%71 = call i64 @cons(i64 %70, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%100 = call i64 @cons(i64 %99, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%100 = call i64 @cons(i64 %99, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%70 = call i64 @cons(i64 %69, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%70 = call i64 @cons(i64 %69, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%99 = call i64 @cons(i64 %98, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%99 = call i64 @cons(i64 %98, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%32 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%74, %$18] ; # A
%32 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%74, %$18] ; # A
%141 = call i64 @cons(i64 %133, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%141 = call i64 @cons(i64 %133, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%216 = call i64 @cons(i64 %212, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%216 = call i64 @cons(i64 %212, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%59 = call i64 @cons(i64 %58, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%59 = call i64 @cons(i64 %58, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%94 = call i64 @cons(i64 %93, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%94 = call i64 @cons(i64 %93, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%49 = call i64 @cons(i64 %48, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%49 = call i64 @cons(i64 %48, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%89 = call i64 @cons(i64 %88, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%89 = call i64 @cons(i64 %88, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%51 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%51 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%66 = call i64 @cons(i64 %65, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%66 = call i64 @cons(i64 %65, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%108 = call i64 @cons(i64 %107, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%108 = call i64 @cons(i64 %107, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%30 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%52, %$13] ; # A
%30 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8], [%52, %$13] ; # A
%84 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%215, %$31] ; # P
%85 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%216, %$31] ; # Q
%84 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%215, %$31] ; # P
%85 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$12], [%216, %$31] ; # Q
%108 = call i64 @cons(i64 %87, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%108 = call i64 @cons(i64 %87, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%161 = call i64 @cons(i64 %160, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%161 = call i64 @cons(i64 %160, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%205 = phi i64 [%137, %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$30] ; # Q
%205 = phi i64 [%137, %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$30] ; # Q
%208 = phi i64 [%137, %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$30] ; # ->
%208 = phi i64 [%137, %$25], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$30] ; # ->
%226 = call i64 @cons(i64 %225, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%226 = call i64 @cons(i64 %225, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%23 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%32, %$8] ; # Z
%23 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%32, %$8] ; # Z
%18 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%17, %$10] ; # ->
%18 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$9], [%17, %$10] ; # ->
%70 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$22], [%15, %$24] ; # ->
%70 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$22], [%15, %$24] ; # ->
%127 = call i64 @cons(i64 %126, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%127 = call i64 @cons(i64 %126, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%158 = call i64 @cons(i64 %157, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%158 = call i64 @cons(i64 %157, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%170 = phi i64 [%90, %$34], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$41], [%127, %$46] ; # ->
%170 = phi i64 [%90, %$34], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$41], [%127, %$46] ; # ->
%171 = phi i64 [%15, %$9], [%70, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$26], [%170, %$32] ; # ->
%171 = phi i64 [%15, %$9], [%70, %$21], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$26], [%170, %$32] ; # ->
%53 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$20], [%15, %$22], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$24] ; # ->
%53 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$20], [%15, %$22], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$24] ; # ->
%135 = phi i64 [%15, %$9], [%53, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$26], [%134, %$32] ; # ->
%135 = phi i64 [%15, %$9], [%53, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$26], [%134, %$32] ; # ->
%44 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%44 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%44 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$17] ; # ->
%44 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$17] ; # ->
%45 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%45 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%45 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$17] ; # ->
%45 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$17] ; # ->
%15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%15 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$8] ; # ->
%15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$8] ; # ->
%15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$8] ; # ->
%15 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$8] ; # ->
%52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%52 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%16 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%16 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%16 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%16 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%16 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%18 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%18 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%16 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%16 = phi i64 [%13, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%17 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%17 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%17 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%17 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$10] ; # ->
%42 = phi i64 [%39, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%42 = phi i64 [%39, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%56 = phi i64 [%42, %$18], [%47, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
%56 = phi i64 [%42, %$18], [%47, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
%42 = phi i64 [%39, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%42 = phi i64 [%39, %$16], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17] ; # ->
%56 = phi i64 [%42, %$18], [%47, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
%56 = phi i64 [%42, %$18], [%47, %$20], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$22] ; # ->
%77 = call i64 @cons(i64 %57, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%77 = call i64 @cons(i64 %57, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%77 = call i64 @cons(i64 %57, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%77 = call i64 @cons(i64 %57, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%62 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%48, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$19] ; # ->
%62 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%48, %$17], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$19] ; # ->
%55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%46, %$17] ; # ->
%55 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%46, %$17] ; # ->
%107 = phi i64 [%52, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$26] ; # ->
%107 = phi i64 [%52, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$26] ; # ->
%58 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%58 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%58 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%58 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%59 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%40, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$21] ; # ->
%72 = call i64 @cons(i64 %71, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%72 = call i64 @cons(i64 %71, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%46 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$13] ; # ->
%46 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$13] ; # ->
%104 = call i64 @cons(i64 %103, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%104 = call i64 @cons(i64 %103, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%14 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%12, %$5] ; # ->
%14 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%12, %$5] ; # ->
%130 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%130 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%278 = call i64 @get(i64 %277, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64))
%278 = call i64 @get(i64 %277, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64))
%604 = call i64 @get(i64 %603, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64))
%604 = call i64 @get(i64 %603, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64))
%704 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%704 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 440) to i64) to i64*
%728 = phi i64 [%706, %$78], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$80], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$79] ; # ->
%728 = phi i64 [%706, %$78], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$80], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$79] ; # ->
%734 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%728, %$76] ; # ->
%734 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%728, %$76] ; # ->
%42 = phi i64 [%39, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # ->
%42 = phi i64 [%39, %$10], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # ->
%31 = call i64 @cons(i64 %30, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%31 = call i64 @cons(i64 %30, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%38 = call i64 @cons(i64 %37, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%38 = call i64 @cons(i64 %37, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%63 = call i64 @cons(i64 %62, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%63 = call i64 @cons(i64 %62, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%99 = call i64 @cons(i64 %98, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%99 = call i64 @cons(i64 %98, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%138 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%38, %$21] ; # ->
%138 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%38, %$21] ; # ->
%21 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$11], [%376, %$47] ; # Out1
%21 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$11], [%376, %$47] ; # Out1
%65 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$17], [%350, %$46] ; # Out1
%65 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$17], [%350, %$46] ; # Out1
%28 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%18, %$6] ; # ->
%28 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%18, %$6] ; # ->
%4 = phi i64 [%3, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%4 = phi i64 [%3, %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
; # (prog1 (if (lt0 (chdir (pathString Nm (b8 (pathSize Nm))))) $Nil ...
; # (if (lt0 (chdir (pathString Nm (b8 (pathSize Nm))))) $Nil (mkStr ...
; # (prog1 (if (lt0 (chdir (dirString Nm (b8 (pathSize Nm))))) $Nil (...
; # (if (lt0 (chdir (dirString Nm (b8 (pathSize Nm))))) $Nil (mkStr P...
; # (pathString Nm (b8 (pathSize Nm)))
%10 = call i8* @pathString(i64 %5, i8* %9)
; # (chdir (pathString Nm (b8 (pathSize Nm))))
; # (dirString Nm (b8 (pathSize Nm)))
%10 = call i8* @dirString(i64 %5, i8* %9)
; # (chdir (dirString Nm (b8 (pathSize Nm))))
%14 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%13, %$6] ; # ->
%14 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$5], [%13, %$6] ; # ->
%15 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%15 = phi i64 [%14, %$7], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%104 = phi i64 [%13, %$31], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$32] ; # ->
%104 = phi i64 [%13, %$31], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$32] ; # ->
%105 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$14], [%104, %$33] ; # ->
%105 = phi i64 [%13, %$9], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$14], [%104, %$33] ; # ->
; # (if (getDir (if (nil? (evSym X)) ($ ".") (let Nm (xName Exe @) (p...
; # (if (nil? (evSym X)) ($ ".") (let Nm (xName Exe @) (pathString Nm...
; # (if (getDir (let Nm (xName (evSym X)) (dirString Nm (b8 (pathSize...
; # (let Nm (xName (evSym X)) (dirString Nm (b8 (pathSize Nm))))
; # (nil? (evSym X))
%5 = icmp eq i64 %4, ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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)
; # (xName (evSym X))
%5 = call i64 @xName(i64 %4)
%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]* @$90 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
%7 = alloca i8, i64 %6
; # (dirString Nm (b8 (pathSize Nm)))
%8 = call i8* @dirString(i64 %5, i8* %7)
; # (getDir (let Nm (xName (evSym X)) (dirString Nm (b8 (pathSize Nm)...
%9 = call i8* @getDir(i8* %8)
%10 = icmp ne i8* %9, null
br i1 %10, label %$2, label %$3
$2:
%11 = phi i64 [%3, %$1] ; # X
%22 = and i64 %21, 6
%23 = icmp ne i64 %22, 0
br i1 %23, label %$10, label %$9
$10:
br label %$8
%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
%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
%21 = inttoptr i64 %16 to i64*
%22 = load i64, i64* %21
br label %$5
%30 = icmp eq i64 %29, ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
%25 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
br i1 %25, label %$10, label %$11
$10:
%26 = phi i64 [%14, %$5] ; # X
%27 = phi i8* [%9, %$5] ; # P
%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
%31 = icmp eq i8 %30, 46
br i1 %31, label %$13, label %$14
$13:
%32 = phi i64 [%28, %$12] ; # X
%33 = phi i8* [%29, %$12] ; # P
%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
%34 = call i8* @getDir(i8* null)
%35 = icmp ne i8* %34, null
br i1 %35, label %$16, label %$15
$15:
%36 = phi i64 [%32, %$13] ; # X
%37 = phi i8* [%34, %$13] ; # P
ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
ret i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
$16:
%38 = phi i64 [%32, %$13] ; # X
%39 = phi i8* [%34, %$13] ; # P
br label %$12
%47 = phi i64 [%19, %$8], [%45, %$17] ; # X
%48 = phi i8* [%14, %$8], [%46, %$17] ; # P
%40 = phi i64 [%28, %$12] ; # X
%41 = phi i8* [%29, %$12] ; # P
br label %$11
$11:
%42 = phi i64 [%14, %$5], [%40, %$14] ; # X
%43 = phi i8* [%9, %$5], [%41, %$14] ; # P
%50 = call i64 @cons(i64 %49, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%45 = call i64 @cons(i64 %44, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%51 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([21 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 ([21 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %54, i64* %58
%46 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 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 ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %49, i64* %53
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
br label %$17
$17:
%54 = phi i64 [%42, %$11], [%79, %$23] ; # X
%55 = phi i8* [%43, %$11], [%80, %$23] ; # P
%56 = phi i64 [%45, %$11], [%81, %$23] ; # Y
%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
%57 = call i8* @getDir(i8* null)
%58 = icmp ne i8* %57, null
br i1 %58, label %$18, label %$19
$18:
%59 = phi i64 [%54, %$17] ; # X
%60 = phi i8* [%57, %$17] ; # P
%61 = phi i64 [%56, %$17] ; # Y
%67 = icmp eq i64 %29, ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
%62 = icmp eq i64 %24, ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64)
br i1 %62, label %$21, label %$20
$21:
%63 = phi i64 [%59, %$18] ; # X
%64 = phi i8* [%60, %$18] ; # P
%65 = phi i64 [%61, %$18] ; # Y
%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
%67 = icmp eq i8 %66, 46
br label %$20
$20:
%68 = phi i64 [%59, %$18], [%63, %$21] ; # X
%69 = phi i8* [%60, %$18], [%64, %$21] ; # P
%70 = phi i64 [%61, %$18], [%65, %$21] ; # Y
%71 = phi i1 [0, %$18], [%67, %$21] ; # ->
br i1 %71, label %$23, label %$22
$22:
%72 = phi i64 [%68, %$20] ; # X
%73 = phi i8* [%69, %$20] ; # P
%74 = phi i64 [%70, %$20] ; # Y
%81 = call i64 @cons(i64 %80, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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
%76 = call i64 @cons(i64 %75, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%77 = inttoptr i64 %74 to i64*
%78 = getelementptr i64, i64* %77, i32 1
store i64 %76, i64* %78
br label %$23
$23:
%79 = phi i64 [%68, %$20], [%72, %$22] ; # X
%80 = phi i8* [%69, %$20], [%73, %$22] ; # P
%81 = phi i64 [%70, %$20], [%76, %$22] ; # Y
br label %$17
$19:
%82 = phi i64 [%54, %$17] ; # X
%83 = phi i8* [%57, %$17] ; # P
%84 = phi i64 [%56, %$17] ; # Y
%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 ([21 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 ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$6] ; # ->
ret i64 %96
%85 = inttoptr i64 %49 to i64*
%86 = getelementptr i64, i64* %85, i32 1
%87 = load i64, i64* %86
%88 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 0) to i64) to i64*
store i64 %87, i64* %88
br label %$4
$3:
%89 = phi i64 [%3, %$1] ; # X
br label %$4
$4:
%90 = phi i64 [%82, %$19], [%89, %$3] ; # X
%91 = phi i64 [%45, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
ret i64 %91
; # (pathString Nm (b8 (pathSize Nm)))
%25 = call i8* @pathString(i64 %6, i8* %24)
; # (fileInfo (nil? (eval (car (shift X)))) (== ZERO @) (pathString N...
; # (dirString Nm (b8 (pathSize Nm)))
%25 = call i8* @dirString(i64 %6, i8* %24)
; # (fileInfo (nil? (eval (car (shift X)))) (== ZERO @) (dirString Nm...
%46 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%43, %$16] ; # ->
%46 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%43, %$16] ; # ->
%60 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%58, %$11] ; # ->
%60 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$7], [%58, %$11] ; # ->
%38 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i64 %37)
%38 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i64 %37)
%41 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%40, %$9] ; # ->
%41 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$4], [%40, %$9] ; # ->
%39 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%39 = call i64 @cons(i64 %38, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%60 = call i64 @cons(i64 %59, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%60 = call i64 @cons(i64 %59, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%77 = phi i64 [%39, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # ->
%77 = phi i64 [%39, %$15], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$11] ; # ->
%100 = call i64 @cons(i64 %99, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%100 = call i64 @cons(i64 %99, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%121 = call i64 @cons(i64 %120, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%121 = call i64 @cons(i64 %120, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%138 = phi i64 [%100, %$31], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$27] ; # ->
%138 = phi i64 [%100, %$31], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$27] ; # ->
%156 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$32], [%152, %$33] ; # ->
%156 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$32], [%152, %$33] ; # ->
%13 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [%12, %$7] ; # ->
%13 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$6], [%12, %$7] ; # ->
%62 = phi i64 [%59, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
%62 = phi i64 [%59, %$19], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$20] ; # ->
%147 = call i64 @cons(i64 %146, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%147 = call i64 @cons(i64 %146, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%198 = call i64 @cons(i64 %179, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%198 = call i64 @cons(i64 %179, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%236 = call i64 @cons(i64 %220, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%236 = call i64 @cons(i64 %220, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
; # (let Nm (xName Exe Fun) (unless (ffiPrep Lib (bufString Nm (b8 (b...
; # (xName Exe Fun)
%24 = call i64 @xName(i64 %0, i64 %2)
; # (let Nm (xName Fun) (unless (ffiPrep Lib (bufString Nm (b8 (bufSi...
; # (xName Fun)
%24 = call i64 @xName(i64 %2)
%90 = phi i64 [%87, %$33], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$34] ; # ->
%90 = phi i64 [%87, %$33], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$34] ; # ->
%162 = call i64 @cons(i64 %161, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%162 = call i64 @cons(i64 %161, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%213 = call i64 @cons(i64 %194, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%213 = call i64 @cons(i64 %194, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%251 = call i64 @cons(i64 %235, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%251 = call i64 @cons(i64 %235, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%267 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 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] ; # ->
%267 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 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] ; # ->
%36 = call i64 @cons(i64 %35, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%36 = call i64 @cons(i64 %35, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%89 = call i64 @cons(i64 %88, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%89 = call i64 @cons(i64 %88, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%5 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%5 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), %$2], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$3] ; # ->
%21 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%20, %$7] ; # ->
%21 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%20, %$7] ; # ->
%10 = call i64 @cons(i64 %9, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%10 = call i64 @cons(i64 %9, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%30 = call i64 @cons(i64 %29, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%30 = call i64 @cons(i64 %29, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%19 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%52, %$10] ; # R
%19 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$2], [%52, %$10] ; # R
%82 = phi i64 [%68, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$19] ; # ->
%82 = phi i64 [%68, %$18], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$19] ; # ->
%94 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%82, %$20] ; # ->
%94 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$13], [%82, %$20] ; # ->
%103 = phi i64 [%94, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%103 = phi i64 [%94, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%14 = call i64 @cons(i64 %13, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%33 = call i64 @cons(i64 %32, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%33 = call i64 @cons(i64 %32, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%42 = phi i64 [%14, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%42 = phi i64 [%14, %$12], [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$8] ; # ->
%18 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%18 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%22 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([21 x i64]* @env to i8*), i32 88) to void(i8)**)
%22 = load void(i8)*, void(i8)** bitcast (i8* getelementptr (i8, i8* bitcast ([22 x i64]* @env to i8*), i32 80) to void(i8)**)
%32 = call i64 @cons(i64 %31, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%32 = call i64 @cons(i64 %31, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
%11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 280) to i64), i64* %11
%11 = inttoptr i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 824) to i64) to i64*
store i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 280) to i64), i64* %11
%49 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%73, %$18] ; # P
%49 = phi i64 [ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), %$15], [%73, %$18] ; # P
%60 = call i64 @intern(i64 %56, i64 0, i64 %52, i64 %59, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
%60 = call i64 @intern(i64 %56, i64 0, i64 %52, i64 %59, i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64), i1 0)
%88 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 408) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([876 x i64]* @SymTab to i8*), i32 8) to i64))
%88 = call i64 @cons(i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 408) to i64), i64 ptrtoint (i8* getelementptr (i8, i8* bitcast ([882 x i64]* @SymTab to i8*), i32 8) to i64))
@$90 = private constant [2 x i8] c".\00"
@$89 = private constant [19 x i8] c"Can't open PTY: %s\00"
@$88 = private constant [3 x i8] c"%s\00"
@$87 = private constant [11 x i8] c"Not making\00"
@$86 = private constant [3 x i8] c"+ \00"
@$85 = private constant [9 x i8] c"wait pid\00"
@$84 = private constant [4 x i8] c" = \00"
@$83 = private constant [3 x i8] c" :\00"
@$82 = private constant [9 x i8] c"No Break\00"
@$81 = private constant [3 x i8] c"! \00"
@$80 = private constant [14 x i8] c"No coroutines\00"
@$79 = private constant [24 x i8] c"Can't stop main routine\00"
@$78 = private constant [18 x i8] c"Stack overwritten\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"Tag not found\00"
@$74 = private constant [10 x i8] c"Bad extra\00"
@$73 = private constant [10 x i8] c"Bad super\00"
@$72 = private constant [12 x i8] c"Bad message\00"
@$71 = private constant [12 x i8] c" redefined\0A\00"
@$70 = private constant [3 x i8] c"# \00"
@$69 = private constant [10 x i8] c"Bad count\00"
@$68 = private constant [10 x i8] c"Bad chain\00"
@$67 = private constant [19 x i8] c"Circular free list\00"
@$66 = private constant [28 x i8] c"Transaction fsync error: %s\00"
@$65 = private constant [7 x i8] c"Bad ID\00"
@$64 = private constant [2 x i8] c"r\00"
@$63 = private constant [3 x i8] c"a+\00"
@$62 = private constant [2 x i8] c"a\00"
@$61 = private constant [23 x i8] c"Log truncate error: %s\00"
@$60 = private constant [42 x i8] c"Last transaction not completed: Rollback\0A\00"
@$59 = private constant [35 x i8] c"Discarding incomplete transaction\0A\00"
@$58 = private constant [12 x i8] c"DB Oversize\00"
@$57 = private constant [14 x i8] c"Log write: %s\00"
@$56 = private constant [18 x i8] c"Journal write: %s\00"
@$55 = private constant [19 x i8] c"DB fsync error: %s\00"
@$54 = private constant [12 x i8] c"Bad Journal\00"
@$53 = private constant [13 x i8] c"DB write: %s\00"
@$52 = private constant [12 x i8] c"DB read: %s\00"
@$51 = private constant [12 x i8] c"Bad DB file\00"
@$50 = private constant [3 x i8] c"> \00"
@$49 = private constant [4 x i8] c"-> \00"
@$48 = private constant [4 x i8] c" \00"
@$47 = private constant [4 x i8] c". (\00"
@$46 = private constant [4 x i8] c" . \00"
@$45 = private constant [6 x i8] c"priv~\00"
@$44 = private constant [27 x i8] c"Super parentheses mismatch\00"
@$43 = private constant [16 x i8] c"Bad dotted pair\00"
@$42 = private constant [15 x i8] c"sync write: %s\00"
@$41 = private constant [14 x i8] c"No current fd\00"
@$40 = private constant [14 x i8] c"Tell PIPE_BUF\00"
@$39 = private constant [16 x i8] c"child write: %s\00"
@$38 = private constant [16 x i8] c"bytes write: %s\00"
@$37 = private constant [9 x i8] c"SETFD %s\00"
@$36 = private constant [17 x i8] c"Select error: %s\00"
@$35 = private constant [7 x i8] c"Bad FD\00"
@$34 = private constant [15 x i8] c"Bad input '%s'\00"
@$33 = private constant [12 x i8] c"EOF Overrun\00"
@$32 = private constant [14 x i8] c"Size overflow\00"
@$31 = private constant [15 x i8] c"Pipe error: %s\00"
@$30 = private constant [16 x i8] c"Close error: %s\00"
@$29 = private constant [15 x i8] c"Open error: %s\00"
@$28 = private constant [10 x i8] c"Undefined\00"
@$90 = private constant [19 x i8] c"Can't open PTY: %s\00"
@$89 = private constant [3 x i8] c"%s\00"
@$88 = private constant [11 x i8] c"Not making\00"
@$87 = private constant [3 x i8] c"+ \00"
@$86 = private constant [9 x i8] c"wait pid\00"
@$85 = private constant [4 x i8] c" = \00"
@$84 = private constant [3 x i8] c" :\00"
@$83 = private constant [9 x i8] c"No Break\00"
@$82 = private constant [3 x i8] c"! \00"
@$81 = private constant [14 x i8] c"No coroutines\00"
@$80 = private constant [18 x i8] c"Stack overwritten\00"
@$79 = private constant [13 x i8] c"Tag expected\00"
@$78 = private constant [20 x i8] c"Reentrant coroutine\00"
@$77 = private constant [20 x i8] c"Coroutine not found\00"
@$76 = private constant [14 x i8] c"Tag not found\00"
@$75 = private constant [10 x i8] c"Bad extra\00"
@$74 = private constant [10 x i8] c"Bad super\00"
@$73 = private constant [12 x i8] c"Bad message\00"
@$72 = private constant [12 x i8] c" redefined\0A\00"
@$71 = private constant [3 x i8] c"# \00"
@$70 = private constant [10 x i8] c"Bad count\00"
@$69 = private constant [10 x i8] c"Bad chain\00"
@$68 = private constant [19 x i8] c"Circular free list\00"
@$67 = private constant [28 x i8] c"Transaction fsync error: %s\00"
@$66 = private constant [7 x i8] c"Bad ID\00"
@$65 = private constant [2 x i8] c"r\00"
@$64 = private constant [3 x i8] c"a+\00"
@$63 = private constant [2 x i8] c"a\00"
@$62 = private constant [23 x i8] c"Log truncate error: %s\00"
@$61 = private constant [42 x i8] c"Last transaction not completed: Rollback\0A\00"
@$60 = private constant [35 x i8] c"Discarding incomplete transaction\0A\00"
@$59 = private constant [12 x i8] c"DB Oversize\00"
@$58 = private constant [14 x i8] c"Log write: %s\00"
@$57 = private constant [18 x i8] c"Journal write: %s\00"
@$56 = private constant [19 x i8] c"DB fsync error: %s\00"
@$55 = private constant [12 x i8] c"Bad Journal\00"
@$54 = private constant [13 x i8] c"DB write: %s\00"
@$53 = private constant [12 x i8] c"DB read: %s\00"
@$52 = private constant [12 x i8] c"Bad DB file\00"
@$51 = private constant [3 x i8] c"> \00"
@$50 = private constant [4 x i8] c"-> \00"
@$49 = private constant [4 x i8] c" \00"
@$48 = private constant [4 x i8] c". (\00"
@$47 = private constant [4 x i8] c" . \00"
@$46 = private constant [6 x i8] c"priv~\00"
@$45 = private constant [27 x i8] c"Super parentheses mismatch\00"
@$44 = private constant [16 x i8] c"Bad dotted pair\00"
@$43 = private constant [15 x i8] c"sync write: %s\00"
@$42 = private constant [14 x i8] c"No current fd\00"
@$41 = private constant [14 x i8] c"Tell PIPE_BUF\00"
@$40 = private constant [16 x i8] c"child write: %s\00"
@$39 = private constant [16 x i8] c"bytes write: %s\00"
@$38 = private constant [9 x i8] c"SETFD %s\00"
@$37 = private constant [17 x i8] c"Select error: %s\00"
@$36 = private constant [7 x i8] c"Bad FD\00"
@$35 = private constant [15 x i8] c"Bad input '%s'\00"
@$34 = private constant [12 x i8] c"EOF Overrun\00"
@$33 = private constant [14 x i8] c"Size overflow\00"
@$32 = private constant [15 x i8] c"Pipe error: %s\00"
@$31 = private constant [16 x i8] c"Close error: %s\00"
@$30 = private constant [15 x i8] c"Open error: %s\00"
@$29 = private constant [10 x i8] c"Undefined\00"
@$28 = private constant [2 x i8] c".\00"
(de remark ("X")
(let? Lst
(recur ("X")
(make
(cond
((num? "X")
(when (>= 799999 "X" 700000)
(link (dat$ "X" "-")) )
(unless (=0 *Scl)
(link (format "X" *Scl)) ) )
((sym? "X")
(let? Nsp (nsp "X")
(or
(== 'pico Nsp)
(== 'priv Nsp)
(link (pack (sym Nsp) "~" (sym "X"))) ) )
(when (type "X")
(link (sym @)) ) )
(T (and (recurse (car "X")) (chain @))) ) ) )
(prin
" "
(and (=1 (%@ "isatty" 'I (fd))) "\e[0;36m")
"#" )
(for X Lst
(prin " " X) )
(when (=1 (%@ "isatty" 'I (fd)))
(prin "\e[0m") ) ) )
(when *JS
(when JS
(prinl "<script type=\"text/javascript\" src=\"" (srcUrl JS) "\"></script>") )
(and (rest) (<javascript> @)) ) )
(when JS
(prinl "<script type=\"text/javascript\" src=\"" (srcUrl JS) "\"></script>") )
(and (rest) (<javascript> @)) )
(ifn (>= "^_" C "^A")
(attr NIL T)
(setq C (char (+ 64 (char C))))
(attr RED T) ) )
(cond
((= "^?" C)
(setq C "?")
(attr RED T) )
((>= "^_" C "^A")
(setq C (char (+ 64 (char C))))
(attr RED T) )
(T (attr NIL T)) ) )
((= "^?" C)
(setq C "?")
(attr RED) )
("G" (move 'goAbs 1 (or (format *Count) T))) # Go to end of text
(("\e[1~" "\e[H") (move 'goAbs 1 1)) # [HOME] Go to beginning of text
(("\e[4~" "\e[F") (move 'goAbs 1 T)) # [END] Go to end of text
("G" (move 'goAbs 1 (or (format *Count) T))) # [G] Go to end of text or line number
(de permute (Lst)
(ifn (cdr Lst)
(cons Lst)
(mapcan
'((X)
(mapcar
'((Y) (cons X Y))
(permute (delete X Lst)) ) )
Lst ) ) )
(private) (Lst Fun L)
(de permute (Lst Fun)
(let L Lst
(recur (L)
(if (cdr L)
(do (length L)
(recurse (cdr L))
(rot L) )
(Fun Lst) ) ) ) )
llvm~$Jam (679 "@src/glob.l" llvm pico)
llvm~$Key (650 "@src/glob.l" llvm pico)
llvm~$LastSym (535 "@src/glob.l" llvm pico)
llvm~$Jam (683 "@src/glob.l" llvm pico)
llvm~$Key (652 "@src/glob.l" llvm pico)
llvm~$LastSym (538 "@src/glob.l" llvm pico)
llvm~$Link (634 "@src/glob.l" llvm pico)
llvm~$Lisp (555 "@src/glob.l" llvm pico)
llvm~$LispEnd (602 "@src/glob.l" llvm pico)
llvm~$M (664 "@src/glob.l" llvm pico)
llvm~$Make (651 "@src/glob.l" llvm pico)
llvm~$Link (637 "@src/glob.l" llvm pico)
llvm~$Lisp (558 "@src/glob.l" llvm pico)
llvm~$LispEnd (605 "@src/glob.l" llvm pico)
llvm~$M (668 "@src/glob.l" llvm pico)
llvm~$Make (653 "@src/glob.l" llvm pico)
llvm~_Abs (1349 "@src/big.l" llvm pico)
llvm~_Add (1103 "@src/big.l" llvm pico)
llvm~_Adr (1646 "@src/main.l" llvm pico)
llvm~_Alarm (501 "@src/main.l" llvm pico)
llvm~_Abs (1370 "@src/big.l" llvm pico)
llvm~_Add (1124 "@src/big.l" llvm pico)
llvm~_Adr (1663 "@src/main.l" llvm pico)
llvm~_Alarm (514 "@src/main.l" llvm pico)
llvm~_Arg (1626 "@src/main.l" llvm pico)
llvm~_Args (1616 "@src/main.l" llvm pico)
llvm~_Argv (1170 "@src/main.l" llvm pico)
llvm~_Arg (1643 "@src/main.l" llvm pico)
llvm~_Args (1633 "@src/main.l" llvm pico)
llvm~_Argv (1187 "@src/main.l" llvm pico)
llvm~_Bind (872 "@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~_Bind (880 "@src/flow.l" llvm pico)
llvm~_BitAnd (1401 "@src/big.l" llvm pico)
llvm~_BitOr (1414 "@src/big.l" llvm pico)
llvm~_BitQ (1377 "@src/big.l" llvm pico)
llvm~_BitXor (1427 "@src/big.l" llvm pico)
llvm~_Case (646 "@src/flow.l" llvm pico)
llvm~_Casq (658 "@src/flow.l" llvm pico)
llvm~_Catch (1048 "@src/flow.l" llvm pico)
llvm~_Cb1 (1526 "@src/main.l" llvm pico)
llvm~_Cb10 (1553 "@src/main.l" llvm pico)
llvm~_Cb11 (1556 "@src/main.l" llvm pico)
llvm~_Cb12 (1559 "@src/main.l" llvm pico)
llvm~_Cb13 (1562 "@src/main.l" llvm pico)
llvm~_Cb14 (1565 "@src/main.l" llvm pico)
llvm~_Cb15 (1568 "@src/main.l" llvm pico)
llvm~_Cb16 (1571 "@src/main.l" llvm pico)
llvm~_Cb17 (1574 "@src/main.l" llvm pico)
llvm~_Cb18 (1577 "@src/main.l" llvm pico)
llvm~_Cb19 (1580 "@src/main.l" llvm pico)
llvm~_Cb2 (1529 "@src/main.l" llvm pico)
llvm~_Cb20 (1583 "@src/main.l" llvm pico)
llvm~_Cb21 (1586 "@src/main.l" llvm pico)
llvm~_Cb22 (1589 "@src/main.l" llvm pico)
llvm~_Cb23 (1592 "@src/main.l" llvm pico)
llvm~_Cb24 (1595 "@src/main.l" llvm pico)
llvm~_Cb3 (1532 "@src/main.l" llvm pico)
llvm~_Cb4 (1535 "@src/main.l" llvm pico)
llvm~_Cb5 (1538 "@src/main.l" llvm pico)
llvm~_Cb6 (1541 "@src/main.l" llvm pico)
llvm~_Cb7 (1544 "@src/main.l" llvm pico)
llvm~_Cb8 (1547 "@src/main.l" llvm pico)
llvm~_Cb9 (1550 "@src/main.l" llvm pico)
llvm~_Cd (1032 "@src/main.l" llvm pico)
llvm~_Case (654 "@src/flow.l" llvm pico)
llvm~_Casq (666 "@src/flow.l" llvm pico)
llvm~_Catch (1056 "@src/flow.l" llvm pico)
llvm~_Cb1 (1543 "@src/main.l" llvm pico)
llvm~_Cb10 (1570 "@src/main.l" llvm pico)
llvm~_Cb11 (1573 "@src/main.l" llvm pico)
llvm~_Cb12 (1576 "@src/main.l" llvm pico)
llvm~_Cb13 (1579 "@src/main.l" llvm pico)
llvm~_Cb14 (1582 "@src/main.l" llvm pico)
llvm~_Cb15 (1585 "@src/main.l" llvm pico)
llvm~_Cb16 (1588 "@src/main.l" llvm pico)
llvm~_Cb17 (1591 "@src/main.l" llvm pico)
llvm~_Cb18 (1594 "@src/main.l" llvm pico)
llvm~_Cb19 (1597 "@src/main.l" llvm pico)
llvm~_Cb2 (1546 "@src/main.l" llvm pico)
llvm~_Cb20 (1600 "@src/main.l" llvm pico)
llvm~_Cb21 (1603 "@src/main.l" llvm pico)
llvm~_Cb22 (1606 "@src/main.l" llvm pico)
llvm~_Cb23 (1609 "@src/main.l" llvm pico)
llvm~_Cb24 (1612 "@src/main.l" llvm pico)
llvm~_Cb3 (1549 "@src/main.l" llvm pico)
llvm~_Cb4 (1552 "@src/main.l" llvm pico)
llvm~_Cb5 (1555 "@src/main.l" llvm pico)
llvm~_Cb6 (1558 "@src/main.l" llvm pico)
llvm~_Cb7 (1561 "@src/main.l" llvm pico)
llvm~_Cb8 (1564 "@src/main.l" llvm pico)
llvm~_Cb9 (1567 "@src/main.l" llvm pico)
llvm~_Cd (1051 "@src/main.l" llvm pico)
llvm~_For (776 "@src/flow.l" llvm pico)
llvm~_Fork (1660 "@src/flow.l" llvm pico)
llvm~_Format (1067 "@src/big.l" llvm pico)
llvm~_For (784 "@src/flow.l" llvm pico)
llvm~_Fork (1679 "@src/flow.l" llvm pico)
llvm~_Format (1088 "@src/big.l" llvm pico)
llvm~_Prin (2530 "@src/io.l" llvm pico)
llvm~_Prinl (2538 "@src/io.l" llvm pico)
llvm~_Print (2553 "@src/io.l" llvm pico)
llvm~_Println (2566 "@src/io.l" llvm pico)
llvm~_Printsp (2562 "@src/io.l" llvm pico)
llvm~_Prin (2531 "@src/io.l" llvm pico)
llvm~_Prinl (2539 "@src/io.l" llvm pico)
llvm~_Print (2554 "@src/io.l" llvm pico)
llvm~_Println (2567 "@src/io.l" llvm pico)
llvm~_Printsp (2563 "@src/io.l" llvm pico)
llvm~_Raw (492 "@src/main.l" llvm pico)
llvm~_Rd (2634 "@src/io.l" llvm pico)
llvm~_Read (1692 "@src/io.l" llvm pico)
llvm~_Rem (1245 "@src/big.l" llvm pico)
llvm~_Raw (505 "@src/main.l" llvm pico)
llvm~_Rd (2635 "@src/io.l" llvm pico)
llvm~_Read (1694 "@src/io.l" llvm pico)
llvm~_Rem (1266 "@src/big.l" llvm pico)
llvm~_Sqrt (1419 "@src/big.l" llvm pico)
llvm~_Stack (548 "@src/main.l" llvm pico)
llvm~_State (667 "@src/flow.l" llvm pico)
llvm~_Sqrt (1440 "@src/big.l" llvm pico)
llvm~_Stack (561 "@src/main.l" llvm pico)
llvm~_State (675 "@src/flow.l" llvm pico)
llvm~_Throw (1066 "@src/flow.l" llvm pico)
llvm~_Till (1848 "@src/io.l" llvm pico)
llvm~_Time (675 "@src/main.l" llvm pico)
llvm~_Throw (1075 "@src/flow.l" llvm pico)
llvm~_Till (1846 "@src/io.l" llvm pico)
llvm~_Time (688 "@src/main.l" llvm pico)
llvm~_Unless (618 "@src/flow.l" llvm pico)
llvm~_Until (692 "@src/flow.l" llvm pico)
llvm~_Up (1728 "@src/main.l" llvm pico)
llvm~_Unless (626 "@src/flow.l" llvm pico)
llvm~_Until (700 "@src/flow.l" llvm pico)
llvm~_Up (1745 "@src/main.l" llvm pico)
llvm~atomErr (349 "@src/main.l" llvm pico)
llvm~b32 (1192 "@src/lib/llvm.l" llvm pico)
llvm~b64 (1192 "@src/lib/llvm.l" llvm pico)
llvm~b8 (1192 "@src/lib/llvm.l" llvm pico)
llvm~b8* (1192 "@src/lib/llvm.l" llvm pico)
llvm~b8+ (1192 "@src/lib/llvm.l" llvm pico)
llvm~atomErr (355 "@src/main.l" llvm pico)
llvm~b32 (1199 "@src/lib/llvm.l" llvm pico)
llvm~b64 (1199 "@src/lib/llvm.l" llvm pico)
llvm~b8 (1199 "@src/lib/llvm.l" llvm pico)
llvm~b8* (1199 "@src/lib/llvm.l" llvm pico)
llvm~b8+ (1199 "@src/lib/llvm.l" llvm pico)
llvm~case (1338 "@src/lib/llvm.l" llvm pico)
llvm~cbFuns (604 "@src/glob.l" llvm pico)
llvm~cbl (1507 "@src/main.l" llvm pico)
llvm~case (1345 "@src/lib/llvm.l" llvm pico)
llvm~cbFuns (607 "@src/glob.l" llvm pico)
llvm~cbl (1524 "@src/main.l" llvm pico)
llvm~compare (815 "@src/main.l" llvm pico)
llvm~cond (1307 "@src/lib/llvm.l" llvm pico)
llvm~cons (286 "@src/gc.l" llvm pico)
llvm~cons2 (297 "@src/gc.l" llvm pico)
llvm~cons3 (319 "@src/gc.l" llvm pico)
llvm~consExt (367 "@src/gc.l" llvm pico)
llvm~consNum (381 "@src/gc.l" llvm pico)
llvm~consStr (362 "@src/gc.l" llvm pico)
llvm~consSym (347 "@src/gc.l" llvm pico)
llvm~compare (834 "@src/main.l" llvm pico)
llvm~cond (1314 "@src/lib/llvm.l" llvm pico)
llvm~cons (287 "@src/gc.l" llvm pico)
llvm~cons2 (298 "@src/gc.l" llvm pico)
llvm~cons3 (320 "@src/gc.l" llvm pico)
llvm~consExt (368 "@src/gc.l" llvm pico)
llvm~consNum (382 "@src/gc.l" llvm pico)
llvm~consStr (363 "@src/gc.l" llvm pico)
llvm~consSym (348 "@src/gc.l" llvm pico)
llvm~evCnt (383 "@src/main.l" llvm pico)
llvm~evExpr (893 "@src/main.l" llvm pico)
llvm~evList (964 "@src/main.l" llvm pico)
llvm~evLst (386 "@src/main.l" llvm pico)
llvm~evCnt (389 "@src/main.l" llvm pico)
llvm~evExpr (912 "@src/main.l" llvm pico)
llvm~evList (983 "@src/main.l" llvm pico)
llvm~evLst (392 "@src/main.l" llvm pico)
llvm~fmtNum (965 "@src/big.l" llvm pico)
llvm~fmtWord (952 "@src/big.l" llvm pico)
llvm~forkErr (370 "@src/main.l" llvm pico)
llvm~forkLisp (2047 "@src/io.l" llvm pico)
llvm~fmtNum (975 "@src/big.l" llvm pico)
llvm~fmtScl (952 "@src/big.l" llvm pico)
llvm~forkErr (376 "@src/main.l" llvm pico)
llvm~forkLisp (2043 "@src/io.l" llvm pico)
llvm~let (1159 "@src/lib/llvm.l" llvm pico)
llvm~link (1472 "@src/lib/llvm.l" llvm pico)
llvm~loadAll (2867 "@src/io.l" llvm pico)
llvm~loadCoEnv (1127 "@src/flow.l" llvm pico)
llvm~lockErr (367 "@src/main.l" llvm pico)
llvm~let (1166 "@src/lib/llvm.l" llvm pico)
llvm~link (1479 "@src/lib/llvm.l" llvm pico)
llvm~loadAll (2877 "@src/io.l" llvm pico)
llvm~loadCoEnv (1139 "@src/flow.l" llvm pico)
llvm~lockErr (373 "@src/main.l" llvm pico)
llvm~loop (1409 "@src/lib/llvm.l" llvm pico)
llvm~loop1 (716 "@src/flow.l" llvm pico)
llvm~loop2 (736 "@src/flow.l" llvm pico)
llvm~lstErr (355 "@src/main.l" llvm pico)
llvm~loop (1416 "@src/lib/llvm.l" llvm pico)
llvm~loop1 (724 "@src/flow.l" llvm pico)
llvm~loop2 (744 "@src/flow.l" llvm pico)
llvm~lstErr (361 "@src/main.l" llvm pico)
llvm~natBuf (1254 "@src/main.l" llvm pico)
llvm~natErr (1295 "@src/main.l" llvm pico)
llvm~natRetBuf (1316 "@src/main.l" llvm pico)
llvm~natRetDouble (1307 "@src/main.l" llvm pico)
llvm~natRetFloat (1298 "@src/main.l" llvm pico)
llvm~need3 (265 "@src/gc.l" llvm pico)
llvm~natBuf (1271 "@src/main.l" llvm pico)
llvm~natErr (1312 "@src/main.l" llvm pico)
llvm~natRetBuf (1333 "@src/main.l" llvm pico)
llvm~natRetDouble (1324 "@src/main.l" llvm pico)
llvm~natRetFloat (1315 "@src/main.l" llvm pico)
llvm~need3 (266 "@src/gc.l" llvm pico)
llvm~outNum (2368 "@src/io.l" llvm pico)
llvm~outOct (2374 "@src/io.l" llvm pico)
llvm~outString (2405 "@src/io.l" llvm pico)
llvm~outWord (2362 "@src/io.l" llvm pico)
llvm~outNum (2364 "@src/io.l" llvm pico)
llvm~outOct (2370 "@src/io.l" llvm pico)
llvm~outScl (964 "@src/big.l" llvm pico)
llvm~outString (2401 "@src/io.l" llvm pico)
llvm~outWord (2358 "@src/io.l" llvm pico)
llvm~prin (2511 "@src/io.l" llvm pico)
llvm~print (2439 "@src/io.l" llvm pico)
llvm~printName (2418 "@src/io.l" llvm pico)
llvm~printSym (2434 "@src/io.l" llvm pico)
llvm~prog1 (1262 "@src/lib/llvm.l" llvm pico)
llvm~prog2 (1269 "@src/lib/llvm.l" llvm pico)
llvm~prin (2512 "@src/io.l" llvm pico)
llvm~print (2440 "@src/io.l" llvm pico)
llvm~printName (2414 "@src/io.l" llvm pico)
llvm~printSym (2435 "@src/io.l" llvm pico)
llvm~prog1 (1269 "@src/lib/llvm.l" llvm pico)
llvm~prog2 (1276 "@src/lib/llvm.l" llvm pico)
llvm~safe (1531 "@src/lib/llvm.l" llvm pico)
llvm~save (1501 "@src/lib/llvm.l" llvm pico)
llvm~save2 (1516 "@src/lib/llvm.l" llvm pico)
llvm~saveCoEnv (1120 "@src/flow.l" llvm pico)
llvm~saveCoIO (1112 "@src/flow.l" llvm pico)
llvm~runCo (1148 "@src/flow.l" llvm pico)
llvm~safe (1538 "@src/lib/llvm.l" llvm pico)
llvm~save (1508 "@src/lib/llvm.l" llvm pico)
llvm~save2 (1523 "@src/lib/llvm.l" llvm pico)
llvm~saveCoEnv (1132 "@src/flow.l" llvm pico)
llvm~saveCoIO (1124 "@src/flow.l" llvm pico)
llvm~stack (1182 "@src/lib/llvm.l" llvm pico)
llvm~stdEval (2817 "@src/io.l" llvm pico)
llvm~stdRead (2785 "@src/io.l" llvm pico)
llvm~stack (1189 "@src/lib/llvm.l" llvm pico)
llvm~stdEval (2818 "@src/io.l" llvm pico)
llvm~stdRead (2786 "@src/io.l" llvm pico)
llvm~testEsc (1362 "@src/io.l" llvm pico)
llvm~tglString (2738 "@src/io.l" llvm pico)
llvm~tmDate (580 "@src/main.l" llvm pico)
llvm~tmTime (608 "@src/main.l" llvm pico)
llvm~token (1628 "@src/io.l" llvm pico)
llvm~trace (1514 "@src/flow.l" llvm pico)
llvm~testEsc (1377 "@src/io.l" llvm pico)
llvm~tglString (2739 "@src/io.l" llvm pico)
llvm~tmDate (593 "@src/main.l" llvm pico)
llvm~tmTime (621 "@src/main.l" llvm pico)
llvm~token (1632 "@src/io.l" llvm pico)
llvm~trace (1533 "@src/flow.l" llvm pico)
llvm~xCnt (379 "@src/main.l" llvm pico)
llvm~xName (405 "@src/main.l" llvm pico)
llvm~xSym (392 "@src/main.l" llvm pico)
llvm~xchg (1124 "@src/lib/llvm.l" llvm pico)
llvm~xCnt (385 "@src/main.l" llvm pico)
llvm~xName (411 "@src/main.l" llvm pico)
llvm~xSym (398 "@src/main.l" llvm pico)
llvm~xchg (1131 "@src/lib/llvm.l" llvm pico)
llvm~reopenTty (300 "@src/lib.c" llvm pico)
llvm~getUsec (311 "@src/lib.c" llvm pico)
llvm~getMsec (322 "@src/lib.c" llvm pico)
llvm~getDate (330 "@src/lib.c" llvm pico)
llvm~getGmDate (337 "@src/lib.c" llvm pico)
llvm~getTime (344 "@src/lib.c" llvm pico)
llvm~getGmTime (353 "@src/lib.c" llvm pico)
llvm~ulimStk (357 "@src/lib.c" llvm pico)
llvm~fileInfo (367 "@src/lib.c" llvm pico)
llvm~pollIn (386 "@src/lib.c" llvm pico)
llvm~pollOut (391 "@src/lib.c" llvm pico)
llvm~pollIgn (396 "@src/lib.c" llvm pico)
llvm~gPoll (400 "@src/lib.c" llvm pico)
llvm~readyIn (436 "@src/lib.c" llvm pico)
llvm~readyOut (443 "@src/lib.c" llvm pico)
llvm~rdLock (451 "@src/lib.c" llvm pico)
llvm~wrLock (461 "@src/lib.c" llvm pico)
llvm~unLock (471 "@src/lib.c" llvm pico)
llvm~getLock (481 "@src/lib.c" llvm pico)
llvm~JmpBufSize (494 "@src/lib.c" llvm pico)
llvm~QuitRst (495 "@src/lib.c" llvm pico)
llvm~Fdigit (526 "@src/lib.c" llvm pico)
llvm~boxFloat (533 "@src/lib.c" llvm pico)
llvm~boxFlt (551 "@src/lib.c" llvm pico)
llvm~boxDouble (559 "@src/lib.c" llvm pico)
llvm~boxDbl (577 "@src/lib.c" llvm pico)
llvm~bufFloat (585 "@src/lib.c" llvm pico)
llvm~bufDouble (601 "@src/lib.c" llvm pico)
llvm~dlOpen (629 "@src/lib.c" llvm pico)
llvm~ffiPrep (633 "@src/lib.c" llvm pico)
llvm~ffiCall (678 "@src/lib.c" llvm pico)
llvm~arg (739 "@src/lib.c" llvm pico)
llvm~chance (744 "@src/lib.c" llvm pico)
llvm~isLowc (1278 "@src/lib.c" llvm pico)
llvm~isUppc (1284 "@src/lib.c" llvm pico)
llvm~isLetterOrDigit (1290 "@src/lib.c" llvm pico)
llvm~toUpperCase (1296 "@src/lib.c" llvm pico)
llvm~toLowerCase (1302 "@src/lib.c" llvm pico)
pico~! (1478 "@src/flow.l" llvm pico)
pico~$ (1528 "@src/flow.l" llvm pico)
pico~% (1245 "@src/big.l" llvm pico)
pico~%@ (1447 "@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)
llvm~reopenTty (299 "@src/lib.c" llvm pico)
llvm~getUsec (310 "@src/lib.c" llvm pico)
llvm~getMsec (321 "@src/lib.c" llvm pico)
llvm~getDate (329 "@src/lib.c" llvm pico)
llvm~getGmDate (336 "@src/lib.c" llvm pico)
llvm~getTime (343 "@src/lib.c" llvm pico)
llvm~getGmTime (352 "@src/lib.c" llvm pico)
llvm~ulimStk (356 "@src/lib.c" llvm pico)
llvm~fileInfo (366 "@src/lib.c" llvm pico)
llvm~pollIn (385 "@src/lib.c" llvm pico)
llvm~pollOut (390 "@src/lib.c" llvm pico)
llvm~pollIgn (395 "@src/lib.c" llvm pico)
llvm~gPoll (399 "@src/lib.c" llvm pico)
llvm~readyIn (435 "@src/lib.c" llvm pico)
llvm~readyOut (442 "@src/lib.c" llvm pico)
llvm~rdLock (450 "@src/lib.c" llvm pico)
llvm~wrLock (460 "@src/lib.c" llvm pico)
llvm~unLock (470 "@src/lib.c" llvm pico)
llvm~getLock (480 "@src/lib.c" llvm pico)
llvm~JmpBufSize (493 "@src/lib.c" llvm pico)
llvm~QuitRst (494 "@src/lib.c" llvm pico)
llvm~Fdigit (525 "@src/lib.c" llvm pico)
llvm~boxFloat (532 "@src/lib.c" llvm pico)
llvm~boxFlt (550 "@src/lib.c" llvm pico)
llvm~boxDouble (558 "@src/lib.c" llvm pico)
llvm~boxDbl (576 "@src/lib.c" llvm pico)
llvm~bufFloat (584 "@src/lib.c" llvm pico)
llvm~bufDouble (600 "@src/lib.c" llvm pico)
llvm~dlOpen (628 "@src/lib.c" llvm pico)
llvm~ffiPrep (632 "@src/lib.c" llvm pico)
llvm~ffiCall (677 "@src/lib.c" llvm pico)
llvm~arg (738 "@src/lib.c" llvm pico)
llvm~chance (743 "@src/lib.c" llvm pico)
llvm~isLowc (1277 "@src/lib.c" llvm pico)
llvm~isUppc (1283 "@src/lib.c" llvm pico)
llvm~isLetterOrDigit (1289 "@src/lib.c" llvm pico)
llvm~toUpperCase (1295 "@src/lib.c" llvm pico)
llvm~toLowerCase (1301 "@src/lib.c" llvm pico)
pico~! (1497 "@src/flow.l" llvm pico)
pico~$ (1547 "@src/flow.l" llvm pico)
pico~% (1266 "@src/big.l" llvm pico)
pico~%@ (1464 "@src/main.l" llvm pico)
pico~& (1401 "@src/big.l" llvm pico)
pico~* (1195 "@src/big.l" llvm pico)
pico~*/ (1216 "@src/big.l" llvm pico)
pico~+ (1124 "@src/big.l" llvm pico)
pico~>> (1267 "@src/big.l" llvm pico)
pico~abs (1349 "@src/big.l" llvm pico)
pico~adr (1646 "@src/main.l" llvm pico)
pico~alarm (501 "@src/main.l" llvm pico)
pico~>> (1288 "@src/big.l" llvm pico)
pico~abs (1370 "@src/big.l" llvm pico)
pico~adr (1663 "@src/main.l" llvm pico)
pico~alarm (514 "@src/main.l" llvm pico)
pico~case (646 "@src/flow.l" llvm pico)
pico~casq (658 "@src/flow.l" llvm pico)
pico~catch (1048 "@src/flow.l" llvm pico)
pico~cd (1032 "@src/main.l" llvm pico)
pico~case (654 "@src/flow.l" llvm pico)
pico~casq (666 "@src/flow.l" llvm pico)
pico~catch (1056 "@src/flow.l" llvm pico)
pico~cd (1051 "@src/main.l" llvm pico)
pico~env (1671 "@src/main.l" llvm pico)
pico~eof (1792 "@src/io.l" llvm pico)
pico~eol (1785 "@src/io.l" llvm pico)
pico~err (1983 "@src/io.l" llvm pico)
pico~errno (1217 "@src/main.l" llvm pico)
pico~env (1688 "@src/main.l" llvm pico)
pico~eof (1790 "@src/io.l" llvm pico)
pico~eol (1783 "@src/io.l" llvm pico)
pico~err (1979 "@src/io.l" llvm pico)
pico~errno (1234 "@src/main.l" llvm pico)
pico~prin (2530 "@src/io.l" llvm pico)
pico~prinl (2538 "@src/io.l" llvm pico)
pico~print (2553 "@src/io.l" llvm pico)
pico~println (2566 "@src/io.l" llvm pico)
pico~printsp (2562 "@src/io.l" llvm pico)
pico~prin (2531 "@src/io.l" llvm pico)
pico~prinl (2539 "@src/io.l" llvm pico)
pico~print (2554 "@src/io.l" llvm pico)
pico~println (2567 "@src/io.l" llvm pico)
pico~printsp (2563 "@src/io.l" llvm pico)
(for (X (readJson) (not (= "}" X)) (readJson))
(checkJson ":" (readJson))
(link (cons (intern X) (readJson)))
(T (= "}" (setq X (readJson))))
(for (X (readJson Arr) (not (= "}" X)) (readJson Arr))
(checkJson ":" (readJson Arr))
(link (cons (intern X) (readJson Arr)))
(T (= "}" (setq X (readJson Arr))))
cvs.csMv = true;
if (!cvs.csMv)
cvs.csMv = [x, y];
else {
if (Array.isArray(cvs.csMv)) {
if (drawCanvas(cvs.id, cvs.dly, 0, cvs.csDnX, cvs.csDnY, cvs.csMv[0] - r.left, cvs.csMv[1] - r.top))
return true;
cvs.csMv = true;
}
if (drawCanvas(cvs.id, cvs.dly, -1, cvs.csDnX, cvs.csDnY, x - r.left, y - r.top))
return true;
}
(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) ) ) )
(de gps (Flg)
(if Flg
(when *LocMan
(java *LocMan 'removeUpdates *GpsLsn)
(java *LocMan 'removeUpdates *NetLsn)
(off *LocMan) )
(unless *LocMan
(setq
*LocMan (java CONTEXT 'getSystemService "location")
*GpsLsn (java T "android.location.LocationListener")
*NetLsn (java T "android.location.LocationListener") )
(java *LocMan 'requestLocationUpdates "gps" (20000 . L) (100 . -1000) *GpsLsn)
(java *LocMan 'requestLocationUpdates "network" (20000 . L) (100 . -1000) *NetLsn) )
(and
(or
(and
(java *LocMan 'isProviderEnabled "gps")
(java *LocMan 'getLastKnownLocation "gps") )
(and
(java *LocMan 'isProviderEnabled "network")
(java *LocMan 'getLastKnownLocation "network") ) )
(cons
(+ (java @ 'getLatitude) 90000000)
(+ (java @ 'getLongitude) 180000000) ) ) ) )
the current namespace search order. When <code>flg</code> non-<code>NIL</code>,
these and the overshadowed symbols are printed as a side effect. See also
<code><a href="refS.html#symbols">symbols</a></code> and <code><a
the current <a href="ref.html#namespaces">namespace</a> search order.
When <code>flg</code> non-<code>NIL</code>, these and the overshadowed
symbols are printed as a side effect. See also <code><a
href="refS.html#symbols">symbols</a></code> and <code><a
<dd>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 <code>lst</code>, and the previous namespace list is
returned. In the third form, the current namespace list is set to
<code>lst</code> during the execution of <code>prg</code>, and the result is
returned. In the fourth form, <code>sym1</code> is initialized to a new
namespace if its value is <code>NIL</code> and not modified otherwise,
<code>sym1</code>, <code>sym2</code> and all following arguments are set as the
current namespace list, and if the value of the global variable <a
href="refD.html#*Dbg">*Dbg</a> is non-<code>NIL</code>, the current line number
and file name (if any) are stored in the <code>*Dbg</code> property of
<code>sym1</code>. See also <code><a href="refP.html#pico">pico</a></code>,
<code><a href="refN.html#nsp">nsp</a></code>, <code><a
<dd>Creates and manages <a href="ref.html#namespaces">namespaces</a> 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
<code>lst</code>, and the previous namespace list is returned. In the
third form, the current namespace list is set to <code>lst</code> during
the execution of <code>prg</code>, and the result is returned. In the
fourth form, <code>sym1</code> is initialized to a new namespace if its
value is <code>NIL</code> and not modified otherwise, <code>sym1</code>,
<code>sym2</code> and all following arguments are set as the current
namespace list, and if the value of the global variable <a
href="refD.html#*Dbg">*Dbg</a> is non-<code>NIL</code>, the current line
number and file name (if any) are stored in the <code>*Dbg</code>
property of <code>sym1</code>. See also <code><a
href="refP.html#pico">pico</a></code>, <code><a
href="refN.html#nsp">nsp</a></code>, <code><a
<dd>A global constant holding the initial (default) namespace of internal
symbols. Its value is a cons pair of two '<code><a
href="refI.html#idx">idx</a></code>' trees, one for symbols with short names and
one for symbols with long names (more than 7 bytes in the name). See also
<code><a href="refS.html#symbols">symbols</a></code>, <code><a
<dd>A global constant holding the initial (default) <a
href="ref.html#namespaces">namespace</a> of internal symbols. Its value
is two cons pairs of the symbol <code>~</code> (as a marker) and two
'<code><a href="refI.html#idx">idx</a></code>' trees, one for symbols
with short names and one for symbols with long names (more than 7 bytes
in the name). See also <code><a
href="refS.html#symbols">symbols</a></code>, <code><a
<dd>Intern symbols locally into an internal special namespace named
'<code>priv</code>'. This namespace is always searched first, but never gets new
symbols automatically interned. <code>(private)</code> expects a single symbol
or a list of symbols immediately following in the current input stream. See also
<code><a href="refP.html#pico">pico</a></code>, <code><a
<dd>Intern symbols locally into an internal special <a
href="ref.html#namespaces">namespace</a> named '<code>priv</code>'. This
namespace is always searched first, but never gets new symbols
automatically interned. <code>(private)</code> expects a single symbol
or a list of symbols immediately following in the current input stream.
See also <code><a href="refP.html#pico">pico</a></code>, <code><a
</pre></dd>
<dt><a id="prompt"><code>(prompt 'any . prg) -> any</code></a></dt>
<dd>Sets the prompt for non-REPL <code>readline(3)</code> calls to
<code>any</code> during the execution of prg. See also <code><a
href="refT.html#tty">tty</a></code>.
<pre>
: (prompt "== " (line))
== abc
-> ("a" "b" "c")
<dd>(Debug mode only) Returns a list of all namespaces nested in the current
search order. When <code>flg</code> non-<code>NIL</code>, their nested tree is
printed as a side effect. See also <code><a
<dd>(Debug mode only) Returns a list of all <a
href="ref.html#namespaces">namespaces</a> nested in the current search
order. When <code>flg</code> is non-<code>NIL</code>, their nested tree
is printed as a side effect. See also <code><a
<p>which accepts a symbol name as the first argument, and up to 5 numbers.
<code>lisp()</code> 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
<code><a href="ref_.html#%25@">%@</a></code>, <code><a
<p>See also <code><a href="ref_.html#%25@">%@</a></code>, <code><a
<dd>Returns the (first) namespace where <code>sym</code> is found in, according
to the current <code><a href="refS.html#symbols">symbols</a></code> search
order. See also <code><a href="refP.html#pico">pico</a></code>.
<dd>Returns the (first) <a href="ref.html#namespaces">namespaces</a>
where <code>sym</code> is found in, according to the current <code><a
href="refS.html#symbols">symbols</a></code> search order. See also
<code><a href="refP.html#pico">pico</a></code>.
<dd>Intern symbols locally in the current namespace. <code>(local)</code>
expects a single symbol or a list of symbols immediately following in the
current input stream. See also <code><a href="refP.html#pico">pico</a></code>,
<dd>Intern symbols locally in the current <a
href="ref.html#namespaces">namespace</a>. <code>(local)</code> expects a
single symbol or a list of symbols immediately following in the current
input stream. See also <code><a href="refP.html#pico">pico</a></code>,
<dt><a id="if@@"><code>(if@@ 'any1 any2 . prg) -> any</code></a></dt>
<dd>Conditional execution: If the value of the global variable <a
href="ref_.html#@@">@@</a></code> is non-<code>NIL</code> after the evaluation
of <code>any1</code>, <code>any2</code> is evaluated and returned. Otherwise,
<code>prg</code> is executed and the result returned. In both cases, <a
href="ref_.html#@">@</a></code> will hold the value of <code>any1</code>. See
also <code><a href="refI.html#if">if</a></code> and <code><a
href="refI.html#if2">if2</a></code>.
<pre>
: (de foo (N)
(if (lt0 N)
(throw 'lt0 N)
(sqrt N) ) )
-> foo
: (if@@ (catch 'lt0 (foo 64))
(msg @ " negative")
@ )
-> 8
Typically used to import symbols from other namespaces, as created by <code><a
href="refS.html#symbols">symbols</a></code>. <code>lst</code> should be a list
of symbols. See also <code><a href="refP.html#pico">pico</a></code>,
<code><a href="refP.html#private">private</a></code> and
<code><a href="refL.html#local">local</a></code> and
<code><a href="refE.html#export">export</a></code>.
Typically used to import symbols from other <a
href="ref.html#namespaces">namespaces</a>, as created by <code><a
href="refS.html#symbols">symbols</a></code>. <code>lst</code> should be
a list of symbols. See also <code><a
href="refP.html#pico">pico</a></code>, <code><a
href="refP.html#private">private</a></code> and <code><a
href="refL.html#local">local</a></code> and <code><a
href="refE.html#export">export</a></code>.
is interned in the current namespace and returned. If <code>nsp</code> is
non-<code>NIL</code>, <code>any</code> is <i>always</i> interned in the current
namespace (if <code>nsp</code> is <code>T</code>) or in the given namespace,
even if it is found in other namespaces. See also <code><a
is interned in the current <a href="ref.html#namespaces">namespaces</a>
and returned. If <code>nsp</code> is non-<code>NIL</code>,
<code>any</code> is <i>always</i> interned in the current namespace (if
<code>nsp</code> is <code>T</code>) or in the given namespace, even if
it is found in other namespaces. See also <code><a
<dd>Intern symbols explicitly in the second namespace in the current search
order, or in the given namespace if <code>sym</code> is given.
<code>(export)</code> expects a single symbol or a list of symbols immediately
following in the current input stream. See also <code><a
<dd>Intern symbols explicitly in the second <a
href="ref.html#namespaces">namespace</a> in the current search order, or
in the given namespace if <code>sym</code> is given.
<code>(export)</code> expects a single symbol or a list of symbols
immediately following in the current input stream. See also <code><a
any error whose message contains one of these strings, and this will immediately
return the matching string. If neither <code>throw</code> nor an error occurs,
the result of <code>prg</code> is returned. See also <code><a
href="refF.html#finally">finally</a></code>, <code><a
href="refQ.html#quit">quit</a></code> and
<code><a href="ref.html#errors">Error Handling</a></code>.
any error whose message contains one of these strings, and
<code>catch</code> will immediately return the matching string. If
neither <code>throw</code> nor an error occurred, the result of
<code>prg</code> is returned. The global variable <code><a
href="ref_.html#@@">@@</a></code> is set to <code>T</code> if a
<code>throw</code> or error occurred, otherwise <code>NIL</code>. See
also <code><a href="refF.html#finally">finally</a></code>, <code><a
href="refQ.html#quit">quit</a></code>, <a
href="refI.html#if@@">if@@</a></code> and <code><a
href="ref.html#errors">Error Handling</a></code>.
</pre></dd>
<dt><a id="complete"><code>(complete 'any) -> T | lst</code></a></dt>
<dd>Global variable holding a (possibly empty) function, which will be
called when TAB is pressed in <code>readline(3)</code> to complete the
text before the current input point. If it is <code>NIL</code>,
readline's default filename generator function is used. Otherwise, it
should be a function which returns the next match (if <code>any</code>
is <code>NIL</code>), some default value (if <code>any</code> is
<code>T</code>, meaning there is no partial word to be completed), or
initializes the generator with the given text and returns the first
result.
<pre>
: (pp 'complete)
(de complete (S)
(when S
(setq "*Cmpl"
(if (=T S) (list " ") (flip (all* S))) ) )
(pop '"*Cmpl") )
-> complete
coroutine. A coroutine cannot resume itself directly or indirectly. See also
<code><a href="refS.html#stack">stack</a></code>, <code><a
coroutine. A coroutine cannot call or stop itself directly or indirectly. See
also <code><a href="refS.html#stack">stack</a></code>, <code><a
<h3><a id="namespaces">Namespaces</a></h3>
<p>When the reader encounters an atom that is not a number, it looks for
it in the current namespace search order. If a symbol with that name is
found, it is used; otherwise, a new symbol is created and interned in
the current namespace.
<p>In general, namespaces in PicoLisp have nothing to do with the values
or definitions of symbols, but only with their scope (visibility).
Several symbols with the same name may exist in different namespaces,
and a single symbol may exist in one or many (or none at all)
namespaces.
<p>At interpreter startup, only the internal <code><a
href="refP.html#pico">pico</a></code> namespace exists, along with the
three special built-in namespaces for <a
href="#transient-io">transient</a>, <a href="#external-io">external</a>,
and <code><a href="refP.html#private">private</a></code> symbols.
<p>For internal symbols, it may not always be clear which namespace(s)
they belong to. Depending on the search order, the same name in a given
code segment might refer to different physical symbols. To avoid
ambiguity, it is recommended to follow these namespace policies:
<p><dl>
<dt>Invariant namespace order</dt>
<dd>Across different parts of a program and all loaded libraries the
search order may be changed as needed, but the position of each
namespace relative to other namespaces should stay the same. That is,
namespace A should not overshadow namespace B in one context and be
overshadowed by B in another context.
</dd>
<dt>Scope declaration before first usage</dt>
<dd>Calls to <code><a href="refS.html#symbols">symbols</a></code>,
<code><a href="refP.html#private">private</a></code>, <code><a
href="refL.html#local">local</a></code> or <code><a
href="refI.html#import">import</a></code> should precede any appearance
(not just definition!) of all involved symbols, because merely reading a
symbol may already intern it in the wrong namespace. </dd>
</dl>
<p><hr>
<p>Sometimes it is necessary to do the reverse: Call Lisp code from C code. This
can be done in two ways - with certain limitations.
<h4><a id="byName">Call by Name</a></h4>
<p>The first way is actually not a <a
href="http://en.wikipedia.org/wiki/Callback_(computer_programming)">callback</a>
in the strict sense. It just allows to call a Lisp function with a given name.
<p>The limitation is that this function can accept only maximally five numeric
arguments, and must return a number.
<p>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:
<pre>
long lisp(char*,long,long,long,long,long);
</pre>
<p>Then you can call <code>lisp</code> from C:
<pre>
long n = lisp("myLispFun", a, b, 0, 0, 0);
</pre>
<p>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.
<p>Be sure to pass dummy arguments (e.g. zero) if your function expects less
than five arguments, to keep the C compiler happy.
<p>This mechanism can generally be used for any type of argument and return
value (not only <code>long</code>). 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 <code><a
href="refS.html#struct">struct</a></code> and memory management operations.
<p>This is a true <a
href="http://en.wikipedia.org/wiki/Callback_(computer_programming)">callback</a>
mechanism. It uses the Lisp-level function <code><a
href="refL.html#lisp">lisp</a></code> (not to confuse with the C-level function
with the same name in the previous section). No C source code access is
<p>This mechanism uses the Lisp-level function <code><a
href="refL.html#lisp">lisp</a></code>. No C source code access is
<p><code>lisp</code> returns a function pointer, which can be passed to C
functions via <code>native</code>. 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 <code><a
href="refS.html#struct">struct</a></code> and memory management operations.
<p><code>lisp</code> returns a function pointer, which can be passed to
C functions via <code>native</code>. When this function pointer is
dereferenced and called from the C code, the corresponding Lisp function
is invoked. Only five numeric arguments and a numeric return value can
be used, and other data types must be handled by the Lisp function with
<code><a href="refS.html#struct">struct</a></code> and memory management
operations.
25.2.5
'if@@' function
src/glob.l
src/flow.l
test/src/flow.l
doc/ref.html
doc/refC.html
doc/refI.html
25.2.1
Missing 'F' argument to 'packJson'
lib/json.l
25.1.22
Change 'permute' to use a callback function
lib/simul.l
25.1.21
Postpone first move event for better double-click detection
lib/canvas.js
25.1.9
Re-introduce "array" feature
lib/json.l
25.1.5
Handle "^?"
lib/vip.l
Read and print decimal unicode in symbol names
src/io.l
lib.l
25.1.4
Wrong examples for 'eval' and 'run' offset
doc/refE.html
doc/refR.html
Fix 'remark'
lib.l
####### 24.12 #######
24.12.30
Remove '*SesAdr' check
lib/http.l
lib/adm.l
24.12.23
Automatic lib configuration (Mike Pechkin)
src/Makefile
Reset form on 'pagehide' event to disable back/forward cache
lib/xhtml.l
24.12.22
Reduce Cache-Control to 'no-store'
lib/http.l
24.12.17
'remark' continued
lib.l
lib/vip.l
Typo
doc/refT.html
24.12.16
'remark' function to generalize REPL-comments
src/glob.l
src/io.l
lib.l
lib/vip.l
doc/refR.html
'complete' reference
doc/refC.html
24.12.14
Print namespace of symbols in REPL-comments
src/io.l
lib/vip.l
24.12.13
Cyan attribute for REPL-comments
src/io.l
'markup' also in 'scratch'
Print numbers as fixnum-comments also in Vip REPL
lib/vip.l
24.12.10
New file
lib/vip/load.l
24.12.5
Add ":wq" as alias for ":x"
lib/vip.l
24.12.2
Add section about namespaces
doc/ref.html
doc/refE.html
doc/refI.html
doc/refL.html
doc/refN.html
doc/refP.html
doc/refS.html
24.11.23
Example for catching errors
doc/refC.html
24.11.21
Intern mark names into 'vip'
lib/vip.l
24.11.20
Generalize 'llvm~fmtNum'
Print numbers as fixnum-comments in REPL
src/big.l
src/io.l
src/subr.l
doc/rc.sample
doc/refR.html
doc/refS.html
doc/ref_.html
24.11.7
Remove obsolete C-level 'lisp' descriptions
doc/refN.html
doc/native.html
24.10.16
Support also HOME and END keys
lib/vip.l
####### 24.9 #######
24.9.7
'0' for empty name in minimal symbol diagram
doc/ref.html
24.8.19
Stop 'gps' via 'Flg' argument
lib/android.l
24.8.16
'pil' is obsolete
doc/refT.html
24.8.7
Add 'L' and 'S' to private symbols
lib/vip.l
24.8.6
Pass TERM environment variable to 'psh'
lib/http.l
bin/psh
24.8.4
'wake' returns 'isHeld'
lib/android.l
24.8.3
Fix 'gps' with two Location Listeners
lib/android.l
24.7.30
Typo
doc/refN.html
24.7.23
Call 'restart' as a UI thread (avoid 'java' reentrancy)
lib/android.l
24.7.15
Cosmetics
src/io.l
src/ht.l
24.7.10
'volatile' access to '$Signal'
src/lib/llvm.l
src/dec.l
24.7.9
'Exe' argument to 'xName' not used
src/main.l
src/sym.l
src/io.l
src/db.l
src/flow.l
src/ext.l
'prompt' function
src/glob.l
src/main.l
doc/ref.html
doc/refP.html
Typo
doc/structures
24.7.7
Check for stale I/O frames in 'unwind'
src/main.l
24.7.5
Change pbPut/pbGet to Zip transfers
bin/pty
Bug in 'erVar'
lib/form.l
Typo
doc/refD.html
24.7.4
Mention '~' in the 'pico' reference
doc/refP.html
24.7.3
Check for SDK_INT >= 31 in 'alarm?'
lib/android.l
24.7.2
Adjust 'alarm' for changed numeric arguments
lib/android.l
####### 24.6 #######
24.6.27
Minimal delay time 1 ms in 'des'
lib/simul.l
Force frame buffer register through runCo()
src/flow.l
Re-arrange structures for alignment
src/glob.l
src/dec.l
24.6.26
'otg' in coroutine structure missing
doc/structures
24.6.23
Show terminated originator in 'yield' error
src/flow.l
24.6.22
'prv' in coroutine structure is obsolete
doc/structures
Fix 'This' upon coroutine termination
Bug in coroutines with non-symbolic tags
src/flow.l
24.6.21
Change 'opt' from "-O3" to "-O2"
src/Makefile
Generalize 'all*'
lib.l
dirString() function
src/main.l
Bug in coroutine free-list management
src/flow.l
24.6.20
Generalize output in 'tty'
src/main.l
src/gc.l
Check for terminated originator in 'yield'
src/flow.l
24.6.18
Clear 'at' in coroutine 'unwind'
src/main.l
'putCrtEnv' clean up
src/dec.l
src/flow.l
24.6.17
Reentrant 'co' checks
src/flow.l
24.6.16
Thread exceptions revisited
lib/android.l
24.6.14
'alarm?' function
lib/android.l
24.6.13
Call fcntlSetFl() in 'accept' if OpenBSD or FreeBSD
lib/net.l
24.6.12
Disallow reentrant 'co' calls
src/flow.l
doc/ref.html
doc/refC.html
24.6.9
Default format 72 columns
lib/vip.l
COPYING
README
INSTALL
doc/microTemplates
24.6.5
Handle thread exceptions in 'java1'
lib/android.l
24.6.2
Make 'dirname' and 'basename' non-destructive
lib/misc.l
24.5.30
'catch' stores throw/error-flag in '@@'
src/flow.l
test/src/flow.l
doc/refC.html
lib/vip.l
lib/form.l
24.5.24
'iter' returns 'NIL'
doc/refI.html
24.5.23
Typo
doc/search.html
24.5.8
Minor mismatch
doc/faq.html
24.4.4
TAB-completion also for search commands
lib/vip.l
24.4.3
No 'flushAll' in child process 'bye'
src/main.l
src/lib.c
24.4.1
'for' instead of 'while' in 'des'
lib/simul.l
24.3.31
Change 'sendCmd' protocol to UDP -> background task
bin/pty
####### 24.3 #######
24.3.29
Include lib/sysdefs in "clean2"
src/Makefile
24.3.28
Ignore ESC in command mode
lib/vip.l
24.3.11
Call (raw T) at start and (raw NIL) when done
lib/vip.l
24.3.10
'scale' function
lib/svg.l
24.3.5
Bug in "words"
doc/viprc.sample
(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.
(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 internal data structure should be as simple as possible. Only one
single data structure is used to build all higher level constructs.
The internal data structure should be as simple as possible. Only
one single data structure is used to build all higher level
constructs.
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.
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.
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.
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.
PicoLisp is not just a toy of theoretical value. PicoLisp is used since
1988 in actual application development, research and production.
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
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
* 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.
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.
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.
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 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.
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.
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").
PicoLisp is free software, and you are welcome to use and redistribute
it under the conditions of the MIT/X11 License (see "COPYING").
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.
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.
Note that you are still free to have local installations along with a
global installation, and invoke them explicitly as desired.
If that is not available, you can (as root) create symbolic links from /usr/lib
and /usr/bin to a local installation directory:
If that is not available, you can (as root) create symbolic links from
/usr/lib and /usr/bin to a local installation directory:
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.
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.
For further information, please look at "doc/index.html". There you find the
PicoLisp Reference Manual ("doc/ref.html"), the PicoLisp tutorial
For further information, please look at "doc/index.html". There you find
the PicoLisp Reference Manual ("doc/ref.html"), the PicoLisp tutorial
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:
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 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.
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.