make  all-recursive
make[1]: Entering directory `/home/wingo/src/guile'
Making all in lib
make[2]: Entering directory `/home/wingo/src/guile/lib'
make  all-recursive
make[3]: Entering directory `/home/wingo/src/guile/lib'
make[4]: Entering directory `/home/wingo/src/guile/lib'
make[4]: Nothing to be done for `all-am'.
make[4]: Leaving directory `/home/wingo/src/guile/lib'
make[3]: Leaving directory `/home/wingo/src/guile/lib'
make[2]: Leaving directory `/home/wingo/src/guile/lib'
Making all in meta
make[2]: Entering directory `/home/wingo/src/guile/meta'
make[2]: Nothing to be done for `all'.
make[2]: Leaving directory `/home/wingo/src/guile/meta'
Making all in libguile
make[2]: Entering directory `/home/wingo/src/guile/libguile'
make  all-am
make[3]: Entering directory `/home/wingo/src/guile/libguile'
make[3]: Nothing to be done for `all-am'.
make[3]: Leaving directory `/home/wingo/src/guile/libguile'
make[2]: Leaving directory `/home/wingo/src/guile/libguile'
Making all in module
make[2]: Entering directory `/home/wingo/src/guile/module'
  GUILEC ice-9/eval.go
;;; note: source file /home/wingo/src/guile/module/ice-9/eval.scm
;;;       newer than compiled /home/wingo/src/guile/module/ice-9/eval.go

;;; (inferring #<tree-il (lexical t t-74002)> #t)

;;; (inferring #<tree-il (lexical rest?* rest?*-73998)> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical args args-73565))> #t)
wrote `ice-9/eval.go'
  GUILEC ice-9/psyntax-pp.go

;;; (inferring #<tree-il (apply (primitive eq?) (lexical x x-19192) (lexical y y-19193))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical ids ids-19828))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical ids ids-20080))> #t)

;;; (inferring #<tree-il (lexical t t-20843)> #t)

;;; (inferring #<tree-il (lexical t t-20892)> #t)

;;; (inferring #<tree-il (lexical t t-21021)> #t)

;;; (inferring #<tree-il (lexical t t-21070)> #t)

;;; (inferring #<tree-il (apply (primitive vector?) (lexical e e-22940))> #t)

;;; (elide effect (lexical new-w new-w-25848))

;;; (elide effect (lexical w w-25747))

;;; (elide effect (if (lexical rec? rec?-25744) (void) (void)))

;;; (inferring #<tree-il (apply (primitive vector?) (lexical x x-9038))> #t)

;;; (inferring #<tree-il (lexical aok aok-28358)> #t)

;;; (propagate-value value (apply (primitive car) (lexical x x-9504)))

;;; (inferring #<tree-il (apply (primitive vector?) (lexical dots dots-16428))> #t)

;;; (inferring #<tree-il (apply (primitive vector?) (lexical dots dots-16537))> #t)

;;; (inferring #<tree-il (apply (primitive vector?) (lexical x x-15767))> #t)

;;; (inferring #<tree-il (apply (primitive vector?) (lexical x x-14659))> #t)

;;; (elide effect (apply (primitive string?) (lexical who who-17641)))

;;; (inferring #<tree-il (apply (primitive string?) (lexical who who-17641))> #t)

;;; (inferring #<tree-il (lexical who who-17641)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical who who-17641))> #t)
wrote `ice-9/psyntax-pp.go'
  GUILEC ice-9/boot-9.go

;;; (inferring #<tree-il (apply (primitive car) (lexical args args-10807))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical thrown-k thrown-k-10853) (lexical catch-k catch-k-10850))> #t)

;;; (inferring #<tree-il (apply (primitive symbol?) (lexical k k-10791))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical thrown-k thrown-k-10815) (lexical k k-10791))> #t)

;;; (inferring #<tree-il (apply (primitive symbol?) (lexical k k-10835))> #t)

;;; (elide effect (lexical result result-11428))

;;; (elide effect (const #f))

;;; (elide effect (if (apply (primitive null?) (lexical l l-11429)) (void) (void)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical datum datum-13250))> #t)

;;; (inferring #<tree-il (lexical t t-13264)> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical rest rest-14011))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical h2 h2-14110))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical rest rest-14239))> #t)

;;; (inferring #<tree-il (lexical tail tail-15886)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical tail tail-15886))> #t)

;;; (inferring #<tree-il (lexical t t-16386)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical module module-16418) (lexical interface interface-16419))> #t)

;;; (inferring #<tree-il (lexical t t-16530)> #t)

;;; (inferring #<tree-il (lexical interface interface-17361)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical interface interface-17361))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical v-refs v-refs-17407))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical version-ref version-ref-17371))> #t)

;;; (inferring #<tree-il (lexical autoload autoload-17456)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical autoload autoload-17456))> #t)

;;; (inferring #<tree-il (lexical module module-17489)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical module module-17489))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical l l-18455))> #t)

;;; (inferring #<tree-il (apply (primitive symbol?) (lexical x x-18278))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical old old-20630) (lexical new new-20631))> #t)

;;; (inferring #<tree-il (lexical t t-20841)> #t)

;;; (inferring #<tree-il (lexical t t-20800)> #t)

;;; (elide effect (lexical dir dir-20847))

;;; (elide effect (const (#(syntax-object getcwd ((top) #(ribcage () () ()) #(ribcage #(t) #((address@hidden top)) #("address@hidden")) #(ribcage #(arg) #((top)) #("address@hidden")) #(ribcage () () ()) #(ribcage () () ()) #(ribcage #(dir) #((top)) #("address@hidden")) #(ribcage () () ()) #(ribcage #(file) #((top)) #("address@hidden")) #(ribcage () () ()) #(ribcage #(src) #((top)) #("address@hidden")) #(ribcage () () ()) #(ribcage () () ()) #(ribcage #(x) #((top)) #("address@hidden"))) (hygiene guile)))))

;;; (elide effect (if (lexical dir dir-20847) (void) (void)))

;;; (elide effect (lexical dir dir-20847))

;;; (elide effect (const (#(syntax-object getcwd ((top) #(ribcage () () ()) #(ribcage #(t) #((address@hidden top)) #("address@hidden")) #(ribcage #(id) #((top)) #("address@hidden")) #(ribcage () () ()) #(ribcage () () ()) #(ribcage #(dir) #((top)) #("address@hidden")) #(ribcage () () ()) #(ribcage #(file) #((top)) #("address@hidden")) #(ribcage () () ()) #(ribcage #(src) #((top)) #("address@hidden")) #(ribcage () () ()) #(ribcage () () ()) #(ribcage #(x) #((top)) #("address@hidden"))) (hygiene guile)))))

;;; (elide effect (if (lexical dir dir-20847) (void) (void)))
wrote `ice-9/boot-9.go'
  GUILEC language/tree-il.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical tree tree-6406))> #t)
wrote `language/tree-il.go'
  GUILEC language/glil.go
wrote `language/glil.go'
  GUILEC language/assembly.go

;;; (inferring #<tree-il (apply (primitive pair?) (lexical assembly assembly-827))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical assembly assembly-827))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical assembly assembly-827))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical assembly assembly-827))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical assembly assembly-827))> #f)
wrote `language/assembly.go'
  GUILEC language/tree-il/primitives.go

;;; (inferring #<tree-il (apply (primitive pair?) (lexical exp exp-2807))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical exp exp-2807)))

;;; (propagate-value value (apply (primitive cdr) (lexical exp exp-2807)))
wrote `language/tree-il/primitives.go'
  GUILEC language/tree-il/peval.go

;;; (inferring #<tree-il (if (apply (primitive struct?) (lexical exp exp-23895)) (apply (primitive eq?) (apply (primitive struct-vtable) (lexical exp exp-23895)) (toplevel <lexical-ref>)) (const #f))> #f)

;;; (inferring #<tree-il (apply (primitive struct?) (lexical exp exp-23895))> #t)

;;; (inferring #<tree-il (apply (primitive struct?) (lexical exp exp-23895))> #t)

;;; (inferring #<tree-il (apply (primitive struct?) (lexical exp exp-23895))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical var var-24290)) (toplevel <var>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical counter counter-25018)) (toplevel <counter>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-25831)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-25831)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (lexical counter counter-25832)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-25831)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-25831)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-25831)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-25831)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-25831)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (lexical len len-38173)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical len len-38173))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical ctx ctx-38225) (const operator))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical ctx ctx-38225) (const operator))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-38290)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (lexical t t-33731)> #t)

;;; (inferring #<tree-il (lexical t t-33769)> #t)

;;; (elide effect (const eq?))

;;; (elide effect (const eqv?))

;;; (elide effect (if (apply (primitive eq?) (lexical w w-32971) (const memq)) (void) (void)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-32977))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-32977))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-32977))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-32977))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-32977))> #t)

;;; (elide effect (apply (primitive car) (lexical v v-32977)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-32977))> #f)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (elide effect (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (elide effect (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (elide effect (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (elide effect (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (elide effect (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (elide effect (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (elide effect (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (elide effect (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (elide effect (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (elide effect (apply (primitive cdr) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (propagate-value value (apply (primitive car) (lexical v v-31541)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-31541))> #f)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-32787))> #t)

;;; (elide effect (apply (primitive car) (lexical v v-32787)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-32787))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-32787)))

;;; (elide effect (apply (primitive car) (lexical v v-32787)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-32787))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical v v-32787)))

;;; (elide effect (apply (primitive car) (lexical v v-32787)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-32787))> #f)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-26724)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-26332)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical op op-26332)) (toplevel <operand>))> #t)

;;; (inferring #<tree-il (lexical t t-26427)> #t)

;;; (inferring #<tree-il (lexical t t-26431)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical ctx ctx-26051) (const value))> #t)
wrote `language/tree-il/peval.go'
  GUILEC language/tree-il/effects.go
wrote `language/tree-il/effects.go'
  GUILEC language/tree-il/fix-letrec.go
wrote `language/tree-il/fix-letrec.go'
  GUILEC language/tree-il/optimize.go
wrote `language/tree-il/optimize.go'
  GUILEC language/tree-il/canonicalize.go

;;; (inferring #<tree-il (lexical t t-2006)> #t)
wrote `language/tree-il/canonicalize.go'
  GUILEC language/tree-il/analyze.go

;;; (inferring #<tree-il (lexical t t-9110)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical graph graph-9398)) (toplevel <reference-graph>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical graph graph-9398)) (toplevel <reference-graph>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical graph graph-9267)) (toplevel <reference-graph>))> #t)

;;; (inferring #<tree-il (lexical t t-9781)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical info info-9824)) (toplevel <toplevel-info>))> #t)

;;; (inferring #<tree-il (lexical t t-9841)> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical req req-10096))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical opt opt-10097))> #t)

;;; (inferring #<tree-il (lexical t t-10352)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical info info-10796)) (toplevel <arity-info>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical info info-10796)) (toplevel <arity-info>))> #t)

;;; (inferring #<tree-il (lexical t t-11006)> #t)

;;; (propagate-value value (apply (primitive car) (lexical chars chars-11043)))

;;; (propagate-value value (apply (primitive car) (lexical chars chars-11043)))

;;; (inferring #<tree-il (apply (primitive eq?) (lexical min min-11816) (const any))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical max max-11817) (const any))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical chars chars-12130))> #t)

;;; (elide effect (apply (primitive car) (lexical chars chars-12130)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical chars chars-12130))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical chars chars-12130)))

;;; (elide effect (apply (primitive car) (lexical chars chars-12130)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical chars chars-12130))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical chars chars-12130)))

;;; (elide effect (apply (primitive car) (lexical chars chars-12130)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical chars chars-12130))> #f)

;;; (inferring #<tree-il (lexical t t-11549)> #t)
wrote `language/tree-il/analyze.go'
  GUILEC language/tree-il/inline.go
wrote `language/tree-il/inline.go'
  GUILEC language/tree-il/compile-glil.go

;;; (elide effect (if (lexical RA RA-2949) (void) (void)))

;;; (elide effect (lexical opt opt-4361))

;;; (elide effect (const ()))

;;; (elide effect (if (lexical opt opt-4361) (void) (void)))

;;; (inferring #<tree-il (lexical rest rest-4362)> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical inits inits-4635))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical context context-2948) (const tail))> #t)

;;; (elide effect (if (lexical RA RA-2949) (void) (void)))

;;; (inferring #<tree-il (lexical opt opt-5221)> #t)

;;; (inferring #<tree-il (lexical kw kw-5222)> #t)

;;; (elide effect (lexical RA RA-2949))

;;; (elide effect (lexical POST POST-5631))

;;; (elide effect (if (lexical RA RA-2949) (void) (void)))

;;; (elide effect (lexical RA RA-2949))

;;; (elide effect (lexical POST POST-5631))

;;; (elide effect (if (lexical RA RA-2949) (void) (void)))

;;; (inferring #<tree-il (lexical opt opt-5749)> #t)

;;; (inferring #<tree-il (lexical kw kw-5750)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical context context-2948) (const push))> #t)
wrote `language/tree-il/compile-glil.go'
  GUILEC language/tree-il/cse.go

;;; (inferring #<tree-il (apply (primitive eq?) (lexical primitive primitive-9640) (const not))> #t)

;;; (elide effect (lexical v1 v1-16643))

;;; (elide effect (lexical v2 v2-16644))

;;; (elide effect (if (apply (primitive vector?) (lexical v1 v1-16643)) (void) (void)))

;;; (inferring #<tree-il (lexical ctx ctx-16223)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical ctx ctx-16223))> #t)

;;; (inferring #<tree-il (lexical ctx ctx-16223)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical ctx ctx-16223))> #t)

;;; (inferring #<tree-il (lexical t t-16777)> #t)

;;; (elide effect (lexical v1 v1-16906))

;;; (elide effect (lexical v2 v2-16907))

;;; (elide effect (if (apply (primitive vector?) (lexical v1 v1-16906)) (void) (void)))

;;; (inferring #<tree-il (lexical t t-15287)> #t)

;;; (inferring #<tree-il (lexical t t-15301)> #t)
wrote `language/tree-il/cse.go'
  GUILEC language/tree-il/debug.go

;;; (inferring #<tree-il (apply (primitive list?) (lexical w w-4785))> #t)
wrote `language/tree-il/debug.go'
  GUILEC language/tree-il/spec.go
wrote `language/tree-il/spec.go'
  GUILEC language/glil/spec.go
wrote `language/glil/spec.go'
  GUILEC language/glil/compile-assembly.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical out out-2795))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical x x-2819) (const ()))> #t)

;;; (elide effect (apply (primitive number?) (lexical x x-2890)))

;;; (inferring #<tree-il (apply (primitive number?) (lexical x x-2890))> #t)

;;; (elide effect (apply (primitive string?) (lexical x x-2890)))

;;; (inferring #<tree-il (apply (primitive string?) (lexical x x-2890))> #t)

;;; (inferring #<tree-il (apply (primitive symbol?) (lexical x x-2890))> #t)

;;; (elide effect (apply (primitive number?) (lexical x x-4031)))

;;; (inferring #<tree-il (apply (primitive number?) (lexical x x-4031))> #t)

;;; (elide effect (apply (primitive string?) (lexical x x-4031)))

;;; (inferring #<tree-il (apply (primitive string?) (lexical x x-4031))> #t)

;;; (inferring #<tree-il (apply (primitive symbol?) (lexical x x-4031))> #t)
wrote `language/glil/compile-assembly.go'
  GUILEC language/glil/decompile-assembly.go
language/glil/decompile-assembly.scm:174:21: warning: possibly unbound variable `make-glil-local'
language/glil/decompile-assembly.scm:170:21: warning: possibly unbound variable `make-glil-local'

;;; (inferring #<tree-il (apply (primitive null?) (lexical in in-1385))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical in in-1373))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical out out-1018))> #t)
wrote `language/glil/decompile-assembly.go'
  GUILEC language/assembly/spec.go
wrote `language/assembly/spec.go'
  GUILEC language/assembly/compile-bytecode.go
wrote `language/assembly/compile-bytecode.go'
  GUILEC language/assembly/decompile-bytecode.go
wrote `language/assembly/decompile-bytecode.go'
  GUILEC language/assembly/disassemble.go

;;; (propagate-value value (apply (primitive car) (lexical bindings bindings-751)))
wrote `language/assembly/disassemble.go'
  GUILEC language/bytecode/spec.go
wrote `language/bytecode/spec.go'
  GUILEC language/objcode/spec.go
wrote `language/objcode/spec.go'
  GUILEC language/value/spec.go
wrote `language/value/spec.go'
  GUILEC language/scheme/spec.go
wrote `language/scheme/spec.go'
  GUILEC language/scheme/compile-tree-il.go
wrote `language/scheme/compile-tree-il.go'
  GUILEC language/scheme/decompile-tree-il.go

;;; (inferring #<tree-il (apply (primitive pair?) (lexical x x-29111))> #t)

;;; (inferring #<tree-il (lexical len len-30851)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical len len-30851))> #t)

;;; (inferring #<tree-il (lexical len len-30043)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical len len-30043))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical w w-30629))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical w w-30587))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical w w-28619))> #t)

;;; (inferring #<tree-il (lexical len len-28645)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical len len-28645))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical w w-28496))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical w w-28373))> #t)

;;; (elide effect (const @))

;;; (elide effect (const @@))

;;; (elide effect (if (lexical public? public?-31217) (void) (void)))

;;; (elide effect (if (lexical public? public?-31239) (void) (void)))

;;; (inferring #<tree-il (lexical opt opt-31470)> #t)

;;; (inferring #<tree-il (lexical kw kw-31472)> #t)

;;; (elide effect (if (lexical in-order? in-order?-31681) (void) (void)))
wrote `language/scheme/decompile-tree-il.go'
  GUILEC system/base/pmatch.go
wrote `system/base/pmatch.go'
  GUILEC system/base/syntax.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical slots slots-1131))> #t)
wrote `system/base/syntax.go'
  GUILEC system/base/compile.go

;;; (inferring #<tree-il (lexical t t-603)> #t)

;;; (inferring #<tree-il (lexical t t-613)> #t)
wrote `system/base/compile.go'
  GUILEC system/base/language.go
wrote `system/base/language.go'
  GUILEC system/base/lalr.go

;;; (inferring #<tree-il (lexical t t-15710)> #t)

;;; (inferring #<tree-il (lexical t t-17347)> #t)

;;; (inferring #<tree-il (lexical t t-18051)> #t)

;;; (inferring #<tree-il (lexical t t-18134)> #t)

;;; (inferring #<tree-il (lexical t t-18136)> #t)

;;; (inferring #<tree-il (lexical t t-17553)> #t)

;;; (inferring #<tree-il (lexical p p-13675)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical p p-13675))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-1 src-location-1-19905)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-2 src-location-2-19906)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (lexical t t-19915)> #t)

;;; (inferring #<tree-il (lexical t t-19917)> #t)

;;; (inferring #<tree-il (lexical t t-19919)> #t)

;;; (inferring #<tree-il (apply (primitive number?) (lexical length-2 length-2-19910))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (apply (primitive number?) (lexical length-1 length-1-19909))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (apply (primitive number?) (lexical offset-2 offset-2-19908))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (apply (primitive number?) (lexical offset-1 offset-1-19907))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-1 src-location-1-19905)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-1 src-location-1-19905)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-1 src-location-1-19905)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-1 src-location-1-19905)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-1 src-location-1-19905)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-1 src-location-1-19905)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-1 src-location-1-19905)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-1 src-location-1-19905)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical src-location-1 src-location-1-19905)) (toplevel source-location))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical tok tok-20241)) (toplevel lexical-token))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical tok tok-20017)) (toplevel lexical-token))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical tok tok-20076)) (toplevel lexical-token))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical tok tok-20369)) (toplevel lexical-token))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical tok tok-20380)) (toplevel lexical-token))> #t)
wrote `system/base/lalr.go'
  GUILEC system/base/message.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical wt wt-2386)) (toplevel <warning-type>))> #t)
wrote `system/base/message.go'
  GUILEC system/base/target.go

;;; (inferring #<tree-il (lexical t t-227)> #t)

;;; (inferring #<tree-il (apply (primitive string?) (lexical target target-221))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)
wrote `system/base/target.go'
  GUILEC ice-9/r4rs.go
wrote `ice-9/r4rs.go'
  GUILEC ice-9/r5rs.go
wrote `ice-9/r5rs.go'
  GUILEC ice-9/deprecated.go

;;; (inferring #<tree-il (lexical t t-1673)> #t)

;;; (inferring #<tree-il (lexical t t-2165)> #t)

;;; (inferring #<tree-il (lexical kw-opt? kw-opt?-2169)> #t)

;;; (elide effect (const #f))

;;; (elide effect (lexical x x-2302))

;;; (elide effect (if (apply (primitive list?) (lexical x x-2302)) (void) (void)))

;;; (inferring #<tree-il (lexical t t-2271)> #t)

;;; (propagate-value value (apply (primitive car) (lexical kws kws-2485)))
wrote `ice-9/deprecated.go'
  GUILEC ice-9/and-let-star.go
wrote `ice-9/and-let-star.go'
  GUILEC ice-9/binary-ports.go
wrote `ice-9/binary-ports.go'
  GUILEC ice-9/calling.go
wrote `ice-9/calling.go'
  GUILEC ice-9/command-line.go

;;; (inferring #<tree-il (lexical t t-731)> #t)

;;; (inferring #<tree-il (lexical t t-733)> #t)

;;; (inferring #<tree-il (lexical t t-745)> #t)
wrote `ice-9/command-line.go'
  GUILEC ice-9/common-list.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical l l-1062))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical l l-1197))> #t)
wrote `ice-9/common-list.go'
  GUILEC ice-9/control.go
wrote `ice-9/control.go'
  GUILEC ice-9/curried-definitions.go
wrote `ice-9/curried-definitions.go'
  GUILEC ice-9/debug.go
wrote `ice-9/debug.go'
  GUILEC ice-9/documentation.go

;;; (inferring #<tree-il (lexical t t-340)> #t)
wrote `ice-9/documentation.go'
  GUILEC ice-9/eval-string.go

;;; (inferring #<tree-il (lexical compile? compile?-290)> #t)
wrote `ice-9/eval-string.go'
  GUILEC ice-9/expect.go
wrote `ice-9/expect.go'
  GUILEC ice-9/format.go

;;; (inferring #<tree-il (apply (primitive >=) (lexical format:pos format:pos-2757) (lexical format-string-len format-string-len-2834))> #f)

;;; (inferring #<tree-il (lexical t t-2888)> #t)

;;; (inferring #<tree-il (apply (primitive >=) (lexical format:pos format:pos-2757) (lexical format-string-len format-string-len-2834))> #f)

;;; (inferring #<tree-il (lexical t t-2894)> #t)

;;; (inferring #<tree-il (lexical t t-3947)> #t)

;;; (inferring #<tree-il (apply (primitive >=) (lexical format:pos format:pos-2757) (lexical format-string-len format-string-len-2834))> #f)

;;; (inferring #<tree-il (lexical t t-4275)> #t)

;;; (inferring #<tree-il (lexical t t-4470)> #t)

;;; (inferring #<tree-il (lexical t t-4487)> #t)

;;; (inferring #<tree-il (lexical t t-4582)> #t)

;;; (inferring #<tree-il (lexical t t-4808)> #t)

;;; (elide effect (apply (primitive number?) (lexical number number-6604)))

;;; (inferring #<tree-il (apply (primitive number?) (lexical number number-6604))> #t)

;;; (inferring #<tree-il (lexical t t-6619)> #t)

;;; (inferring #<tree-il (lexical t t-6679)> #t)

;;; (inferring #<tree-il (lexical t t-6749)> #t)

;;; (elide effect (apply (primitive number?) (lexical number number-6823)))

;;; (inferring #<tree-il (apply (primitive number?) (lexical number number-6823))> #t)

;;; (inferring #<tree-il (lexical t t-6840)> #t)

;;; (inferring #<tree-il (lexical t t-6945)> #t)

;;; (inferring #<tree-il (lexical t t-7145)> #t)

;;; (elide effect (apply (primitive number?) (lexical number number-7404)))

;;; (inferring #<tree-il (apply (primitive number?) (lexical number number-7404))> #t)

;;; (inferring #<tree-il (lexical t t-7419)> #t)

;;; (elide effect (apply (primitive number?) (lexical number number-7568)))

;;; (inferring #<tree-il (apply (primitive number?) (lexical number number-7568))> #t)

;;; (inferring #<tree-il (lexical t t-7582)> #t)

;;; (inferring #<tree-il (lexical t t-7624)> #t)

;;; (inferring #<tree-il (lexical t t-7902)> #t)

;;; (inferring #<tree-il (lexical t t-7930)> #t)

;;; (inferring #<tree-il (lexical t t-8246)> #t)

;;; (inferring #<tree-il (lexical t t-8413)> #t)

;;; (inferring #<tree-il (lexical t t-8462)> #t)
wrote `ice-9/format.go'
  GUILEC ice-9/futures.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical future future-714)) (toplevel <future>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical future future-837)) (toplevel <future>))> #t)
wrote `ice-9/futures.go'
  GUILEC ice-9/getopt-long.go

;;; (inferring #<tree-il (lexical val val-1879)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical val val-1879))> #t)

;;; (elide effect (apply (primitive char?) (lexical w w-1821)))

;;; (inferring #<tree-il (apply (primitive null?) (lexical ls ls-2098))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical spec spec-2097)) (toplevel option-spec))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical ls ls-2098))> #t)
wrote `ice-9/getopt-long.go'
  GUILEC ice-9/hcons.go
wrote `ice-9/hcons.go'
  GUILEC ice-9/i18n.go

;;; (inferring #<tree-il (apply (primitive >) (lexical amount amount-870) (const 0))> #t)

;;; (inferring #<tree-il (lexical t t-938)> #t)

;;; (inferring #<tree-il (lexical t t-961)> #t)
wrote `ice-9/i18n.go'
  GUILEC ice-9/lineio.go
wrote `ice-9/lineio.go'
  GUILEC ice-9/ls.go
wrote `ice-9/ls.go'
  GUILEC ice-9/mapping.go
ice-9/mapping.scm:97:48: warning: possibly wrong number of arguments to `hashx-get-handle'
ice-9/mapping.scm:94:48: warning: possibly unbound variable `hashx-create-handle'
wrote `ice-9/mapping.go'
  GUILEC ice-9/match.go
wrote `ice-9/match.go'
  GUILEC ice-9/networking.go
wrote `ice-9/networking.go'
  GUILEC ice-9/null.go
wrote `ice-9/null.go'
  GUILEC ice-9/occam-channel.go

;;; (inferring #<tree-il (lexical t t-860)> #t)

;;; (inferring #<tree-il (lexical t t-862)> #t)

;;; (inferring #<tree-il (lexical t t-864)> #t)

;;; (inferring #<tree-il (lexical t t-866)> #t)

;;; (inferring #<tree-il (lexical t t-876)> #t)

;;; (inferring #<tree-il (lexical t t-886)> #t)

;;; (inferring #<tree-il (lexical t t-891)> #t)

;;; (inferring #<tree-il (lexical t t-897)> #t)

;;; (inferring #<tree-il (lexical t t-905)> #t)

;;; (inferring #<tree-il (lexical t t-915)> #t)

;;; (inferring #<tree-il (lexical t t-925)> #t)

;;; (inferring #<tree-il (lexical t t-933)> #t)

;;; (inferring #<tree-il (lexical t t-940)> #t)

;;; (inferring #<tree-il (lexical t t-946)> #t)

;;; (inferring #<tree-il (lexical t t-951)> #t)

;;; (inferring #<tree-il (lexical t t-957)> #t)

;;; (inferring #<tree-il (lexical t t-963)> #t)

;;; (inferring #<tree-il (lexical t t-971)> #t)

;;; (inferring #<tree-il (lexical t t-978)> #t)
wrote `ice-9/occam-channel.go'
  GUILEC ice-9/optargs.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical args-tail args-tail-1174))> #t)

;;; (inferring #<tree-il (lexical rest-idx rest-idx-1176)> #f)

;;; (inferring #<tree-il (lexical rest-idx rest-idx-1176)> #f)
wrote `ice-9/optargs.go'
  GUILEC ice-9/poe.go
wrote `ice-9/poe.go'
  GUILEC ice-9/poll.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical set set-988)) (toplevel <poll-set>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical set set-1020)) (toplevel <poll-set>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical set set-1048)) (toplevel <poll-set>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical set set-1076)) (toplevel <poll-set>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical set set-1105)) (toplevel <poll-set>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical set set-1133)) (toplevel <poll-set>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical set set-1247)) (toplevel <poll-set>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical set set-1247)) (toplevel <poll-set>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical set set-1247)) (toplevel <poll-set>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical set set-1247)) (toplevel <poll-set>))> #t)
wrote `ice-9/poll.go'
  GUILEC ice-9/popen.go
wrote `ice-9/popen.go'
  GUILEC ice-9/posix.go
wrote `ice-9/posix.go'
  GUILEC ice-9/q.go
wrote `ice-9/q.go'
  GUILEC ice-9/rdelim.go

;;; (inferring #<tree-il (lexical terminator terminator-325)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical terminator terminator-325))> #t)
wrote `ice-9/rdelim.go'
  GUILEC ice-9/receive.go
wrote `ice-9/receive.go'
  GUILEC ice-9/regex.go
wrote `ice-9/regex.go'
  GUILEC ice-9/runq.go
wrote `ice-9/runq.go'
  GUILEC ice-9/rw.go
wrote `ice-9/rw.go'
  GUILEC ice-9/safe-r5rs.go
wrote `ice-9/safe-r5rs.go'
  GUILEC ice-9/safe.go
wrote `ice-9/safe.go'
  GUILEC ice-9/save-stack.go
wrote `ice-9/save-stack.go'
  GUILEC ice-9/scm-style-repl.go

;;; (inferring #<tree-il (lexical t t-957)> #t)

;;; (inferring #<tree-il (lexical t t-967)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical key key-969) (const wrong-type-arg))> #t)
wrote `ice-9/scm-style-repl.go'
  GUILEC ice-9/session.go

;;; (inferring #<tree-il (lexical t t-1079)> #t)

;;; (inferring #<tree-il (lexical t t-1100)> #t)
wrote `ice-9/session.go'
ice-9/session.scm:239:11: warning: non-literal format string
  GUILEC ice-9/slib.go
wrote `ice-9/slib.go'
  GUILEC ice-9/stack-catch.go
wrote `ice-9/stack-catch.go'
  GUILEC ice-9/streams.go
wrote `ice-9/streams.go'
  GUILEC ice-9/string-fun.go

;;; (propagate-value value (apply (primitive string-length) (lexical s s-1353)))
wrote `ice-9/string-fun.go'
  GUILEC ice-9/syncase.go
wrote `ice-9/syncase.go'
  GUILEC ice-9/threads.go
wrote `ice-9/threads.go'
  GUILEC ice-9/top-repl.go
wrote `ice-9/top-repl.go'
  GUILEC ice-9/buffered-input.go
wrote `ice-9/buffered-input.go'
  GUILEC ice-9/time.go
wrote `ice-9/time.go'
  GUILEC ice-9/history.go
wrote `ice-9/history.go'
  GUILEC ice-9/channel.go
wrote `ice-9/channel.go'
  GUILEC ice-9/pretty-print.go

;;; (inferring #<tree-il (lexical col col-3963)> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical obj obj-2140))> #t)

;;; (inferring #<tree-il (lexical col col-2764)> #t)

;;; (inferring #<tree-il (lexical t t-5274)> #t)

;;; (inferring #<tree-il (apply (primitive =) (lexical i i-5271) (const 0))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical x x-5231))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)
wrote `ice-9/pretty-print.go'
  GUILEC ice-9/ftw.go

;;; (inferring #<tree-il (lexical t t-1528)> #t)

;;; (inferring #<tree-il (lexical s-follow s-follow-1639)> #t)

;;; (inferring #<tree-il (lexical s-follow s-follow-1639)> #t)

;;; (inferring #<tree-il (lexical physical? physical?-1632)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical physical? physical?-1632))> #t)

;;; (inferring #<tree-il (lexical t t-1865)> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical v v-1889))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (apply (primitive cdr) (lexical v v-1889)))> #t)

;;; (propagate-value value (apply (primitive car) (lexical v v-1889)))

;;; (inferring #<tree-il (if (apply (primitive pair?) (lexical v v-1889)) (apply (primitive null?) (apply (primitive cdr) (lexical v v-1889))) (const #f))> #f)
wrote `ice-9/ftw.go'
  GUILEC ice-9/gap-buffer.go
wrote `ice-9/gap-buffer.go'
  GUILEC ice-9/weak-vector.go
wrote `ice-9/weak-vector.go'
  GUILEC ice-9/list.go
wrote `ice-9/list.go'
  GUILEC ice-9/serialize.go
wrote `ice-9/serialize.go'
  GUILEC ice-9/vlist.go

;;; (propagate-value value (apply (primitive vector-ref) (lexical base base-2300) (const 4)))

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical obj obj-3037)) (toplevel <vlist>))> #t)

;;; (propagate-value value (apply (primitive vector-ref) (lexical base base-3543) (const 4)))
wrote `ice-9/vlist.go'
  GUILEC ice-9/local-eval.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical e e-1337)) (toplevel lexical-environment-type))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical e e-1358)) (toplevel lexical-environment-type))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical e e-1380)) (toplevel lexical-environment-type))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical e e-1380)) (toplevel lexical-environment-type))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical e e-1380)) (toplevel lexical-environment-type))> #t)
wrote `ice-9/local-eval.go'
  GUILEC srfi/srfi-1.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical rest rest-2404))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical clist clist-5340))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical r r-6055))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical r r-6070))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical = =-6082) (primitive eq?))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical = =-6165) (primitive eq?))> #t)
wrote `srfi/srfi-1.go'
  GUILEC srfi/srfi-2.go
wrote `srfi/srfi-2.go'
  GUILEC srfi/srfi-4.go
wrote `srfi/srfi-4.go'
  GUILEC srfi/srfi-4/gnu.go
wrote `srfi/srfi-4/gnu.go'
  GUILEC srfi/srfi-6.go
wrote `srfi/srfi-6.go'
  GUILEC srfi/srfi-8.go
wrote `srfi/srfi-8.go'
  GUILEC srfi/srfi-9.go
wrote `srfi/srfi-9.go'
  GUILEC srfi/srfi-9/gnu.go
wrote `srfi/srfi-9/gnu.go'
  GUILEC srfi/srfi-10.go
wrote `srfi/srfi-10.go'
  GUILEC srfi/srfi-11.go
wrote `srfi/srfi-11.go'
  GUILEC srfi/srfi-13.go
wrote `srfi/srfi-13.go'
  GUILEC srfi/srfi-14.go
wrote `srfi/srfi-14.go'
  GUILEC srfi/srfi-16.go
wrote `srfi/srfi-16.go'
  GUILEC srfi/srfi-17.go
wrote `srfi/srfi-17.go'
  GUILEC srfi/srfi-18.go

;;; (inferring #<tree-il (lexical t t-650)> #t)
wrote `srfi/srfi-18.go'
  GUILEC srfi/srfi-19.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t t-4237)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t t-4237)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t t-4237)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t t-4237)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t t-4237)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t1 t1-4504)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t2 t2-4505)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t1 t1-4504)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t2 t2-4505)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t1 t1-4584)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t2 t2-4585)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t1 t1-4584)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t2 t2-4585)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t1 t1-4684)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t2 t2-4685)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t1 t1-4684)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t2 t2-4685)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t1 t1-4784)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t2 t2-4785)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t1 t1-4784)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t2 t2-4785)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t1 t1-4884)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t2 t2-4885)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t1 t1-4884)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t2 t2-4885)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical time1 time1-4984)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical duration duration-5074)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical duration duration-5074)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t t-5073)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical duration duration-5161)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical duration duration-5161)) (toplevel time))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical t t-5160)) (toplevel time))> #t)

;;; (inferring #<tree-il (lexical t t-7068)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical date date-7248)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical date date-7248)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical date date-7360)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical date date-7360)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical date date-7506)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical date date-7506)) (toplevel date))> #t)

;;; (inferring #<tree-il (lexical t t-7732)> #t)

;;; (inferring #<tree-il (lexical t t-7734)> #t)

;;; (inferring #<tree-il (lexical t t-7756)> #t)

;;; (inferring #<tree-il (lexical t t-8476)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical newdate newdate-8485)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical newdate newdate-8485)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical newdate newdate-8485)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical newdate newdate-8485)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical newdate newdate-8485)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical newdate newdate-8485)) (toplevel date))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical newdate newdate-8485)) (toplevel date))> #t)
wrote `srfi/srfi-19.go'
  GUILEC srfi/srfi-26.go
wrote `srfi/srfi-26.go'
  GUILEC srfi/srfi-27.go
wrote `srfi/srfi-27.go'
  GUILEC srfi/srfi-31.go
wrote `srfi/srfi-31.go'
  GUILEC srfi/srfi-34.go
wrote `srfi/srfi-34.go'
  GUILEC srfi/srfi-35.go

;;; (inferring #<tree-il (apply (primitive eq?) (lexical ct ct-867) (lexical type type-775))> #t)
wrote `srfi/srfi-35.go'
  GUILEC srfi/srfi-37.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical opt opt-726)) (toplevel srfi-37:option))> #t)

;;; (inferring #<tree-il (lexical t t-789)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical option-here option-here-776)) (toplevel srfi-37:option))> #t)

;;; (inferring #<tree-il (lexical t t-690)> #t)
wrote `srfi/srfi-37.go'
  GUILEC srfi/srfi-38.go

;;; (inferring #<tree-il (apply (primitive pair?) (lexical obj obj-637))> #t)

;;; (inferring #<tree-il (apply (primitive struct?) (lexical obj obj-637))> #t)

;;; (inferring #<tree-il (apply (primitive struct?) (lexical obj obj-637))> #f)

;;; (inferring #<tree-il (lexical t t-955)> #t)
wrote `srfi/srfi-38.go'
  GUILEC srfi/srfi-42.go

;;; (inferring #<tree-il (apply (primitive integer?) (lexical a1 a1-3984))> #t)

;;; (inferring #<tree-il (apply (primitive exact?) (lexical a1 a1-3984))> #t)

;;; (inferring #<tree-il (apply (primitive real?) (lexical a1 a1-3984))> #t)

;;; (inferring #<tree-il (lexical t t-4054)> #t)

;;; (inferring #<tree-il (apply (primitive string?) (lexical a1 a1-4091))> #t)

;;; (inferring #<tree-il (apply (primitive integer?) (lexical a1 a1-4091))> #t)

;;; (inferring #<tree-il (apply (primitive exact?) (lexical a1 a1-4091))> #t)

;;; (inferring #<tree-il (apply (primitive integer?) (lexical a2 a2-4092))> #t)

;;; (inferring #<tree-il (apply (primitive exact?) (lexical a2 a2-4092))> #t)

;;; (inferring #<tree-il (apply (primitive real?) (lexical a2 a2-4092))> #t)

;;; (inferring #<tree-il (lexical t t-4166)> #t)

;;; (inferring #<tree-il (apply (primitive string?) (lexical a1 a1-4213))> #t)

;;; (inferring #<tree-il (apply (primitive integer?) (lexical a1 a1-4213))> #t)

;;; (inferring #<tree-il (apply (primitive exact?) (lexical a1 a1-4213))> #t)

;;; (inferring #<tree-il (apply (primitive integer?) (lexical a2 a2-4214))> #t)

;;; (inferring #<tree-il (apply (primitive exact?) (lexical a2 a2-4214))> #t)

;;; (inferring #<tree-il (apply (primitive integer?) (lexical a3 a3-4215))> #t)

;;; (inferring #<tree-il (apply (primitive exact?) (lexical a3 a3-4215))> #t)

;;; (inferring #<tree-il (apply (primitive real?) (lexical a2 a2-4214))> #t)

;;; (inferring #<tree-il (apply (primitive real?) (lexical a3 a3-4215))> #t)

;;; (inferring #<tree-il (lexical t t-4323)> #t)
wrote `srfi/srfi-42.go'
  GUILEC srfi/srfi-39.go
wrote `srfi/srfi-39.go'
  GUILEC srfi/srfi-45.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical content content-668)) (toplevel value))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical content content-668)) (toplevel value))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical content content-709)) (toplevel value))> #t)
wrote `srfi/srfi-45.go'
  GUILEC srfi/srfi-60.go
wrote `srfi/srfi-60.go'
  GUILEC srfi/srfi-67.go

;;; (elide effect (apply (primitive char?) (lexical x x-7181)))

;;; (elide effect (apply (primitive char?) (lexical y y-7182)))

;;; (elide effect (apply (primitive string?) (lexical x x-7181)))

;;; (elide effect (apply (primitive string?) (lexical y y-7182)))

;;; (elide effect (apply (primitive number?) (lexical x x-7181)))

;;; (elide effect (apply (primitive number?) (lexical y y-7182)))

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7397) (const -1))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7397) (const 0))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7424) (const -1))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7424) (const 0))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7451) (const -1))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7451) (const 0))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7478) (const -1))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7478) (const 0))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7509) (const -1))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7509) (const 0))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7532) (const -1))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7532) (const 0))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7555) (const -1))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7555) (const 0))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7578) (const -1))> #t)

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical c-xy c-xy-7578) (const 0))> #t)
wrote `srfi/srfi-67.go'
  GUILEC srfi/srfi-69.go

;;; (inferring #<tree-il (apply (primitive eq?) (primitive equal?) (lexical equal-proc equal-proc-1183))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical result result-1211)) (toplevel srfi-69:hash-table))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical result result-1211)) (toplevel srfi-69:hash-table))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical result result-1211)) (toplevel srfi-69:hash-table))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical ht ht-1354)) (toplevel srfi-69:hash-table))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical ht ht-1410)) (toplevel srfi-69:hash-table))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical ht ht-1510)) (toplevel srfi-69:hash-table))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical ht ht-1582)) (toplevel srfi-69:hash-table))> #t)
wrote `srfi/srfi-69.go'
  GUILEC srfi/srfi-88.go
wrote `srfi/srfi-88.go'
  GUILEC srfi/srfi-98.go
wrote `srfi/srfi-98.go'
  GUILEC rnrs/base.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical rest rest-791))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical lst lst-1061))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical bools bools-878))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical lst lst-1255))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical syms syms-1072))> #t)
wrote `rnrs/base.go'
  GUILEC rnrs/conditions.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical conditions conditions-799))> #t)
wrote `rnrs/conditions.go'
  GUILEC rnrs/control.go
wrote `rnrs/control.go'
  GUILEC rnrs/enums.go
wrote `rnrs/enums.go'
  GUILEC rnrs/eval.go
wrote `rnrs/eval.go'
  GUILEC rnrs/exceptions.go
wrote `rnrs/exceptions.go'
  GUILEC rnrs/files.go
wrote `rnrs/files.go'
  GUILEC rnrs/hashtables.go
wrote `rnrs/hashtables.go'
  GUILEC rnrs/lists.go
wrote `rnrs/lists.go'
  GUILEC rnrs/mutable-pairs.go
wrote `rnrs/mutable-pairs.go'
  GUILEC rnrs/mutable-strings.go
wrote `rnrs/mutable-strings.go'
  GUILEC rnrs/programs.go
wrote `rnrs/programs.go'
  GUILEC rnrs/r5rs.go
wrote `rnrs/r5rs.go'
  GUILEC rnrs/sorting.go
wrote `rnrs/sorting.go'
  GUILEC rnrs/syntax-case.go
wrote `rnrs/syntax-case.go'
  GUILEC rnrs/unicode.go

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical char char-131) (const #\460))> #t)
wrote `rnrs/unicode.go'
  GUILEC rnrs/arithmetic/bitwise.go
wrote `rnrs/arithmetic/bitwise.go'
  GUILEC rnrs/arithmetic/fixnums.go
wrote `rnrs/arithmetic/fixnums.go'
  GUILEC rnrs/arithmetic/flonums.go
wrote `rnrs/arithmetic/flonums.go'
  GUILEC rnrs/bytevectors.go
wrote `rnrs/bytevectors.go'
  GUILEC rnrs/io/simple.go
wrote `rnrs/io/simple.go'
  GUILEC rnrs/io/ports.go
wrote `rnrs/io/ports.go'
  GUILEC rnrs/records/inspection.go
wrote `rnrs/records/inspection.go'
  GUILEC rnrs/records/procedural.go

;;; (elide effect (lexical protocol protocol-599))

;;; (elide effect (lambda ((name . default-inherited-protocol)) (lambda-case (((n) #f #f #f () (n-633)) (lambda () (lambda-case ((() #f args #f () (args-634)) (let-values (apply (toplevel split-at) (lexical args args-634) (apply (primitive -) (apply (toplevel length) (lexical args args-634)) (lexical rtd-arity rtd-arity-600))) (lambda-case (((n-args p-args) #f #f #f () (n-args-635 p-args-636)) (let (p) (p-637) ((apply (primitive @apply) (lexical n n-633) (lexical n-args n-args-635))) (apply (primitive @apply) (lexical p p-637) (lexical p-args p-args-636)))))))))))))

;;; (elide effect (lambda ((name . default-protocol)) (lambda-case (((p) #f #f #f () (p-639)) (lexical p p-639)))))

;;; (elide effect (if (lexical pcd pcd-604) (void) (void)))

;;; (elide effect (if (lexical protocol protocol-599) (void) (void)))
wrote `rnrs/records/procedural.go'
  GUILEC rnrs/records/syntactic.go

;;; (elide effect (const ()))

;;; (elide effect (lexical _fields _fields-1053))

;;; (elide effect (if (apply (primitive eq?) (lexical *unspecified* *unspecified*-1038) (lexical _fields _fields-1053)) (void) (void)))

;;; (elide effect (const #f))

;;; (elide effect (lexical _protocol _protocol-1055))

;;; (elide effect (if (apply (primitive eq?) (lexical *unspecified* *unspecified*-1038) (lexical _protocol _protocol-1055)) (void) (void)))

;;; (elide effect (const #f))

;;; (elide effect (lexical _nongenerative _nongenerative-1058))

;;; (elide effect (if (apply (primitive eq?) (lexical *unspecified* *unspecified*-1038) (lexical _nongenerative _nongenerative-1058)) (void) (void)))

;;; (elide effect (const #f))

;;; (elide effect (lexical _sealed _sealed-1056))

;;; (elide effect (if (apply (primitive eq?) (lexical *unspecified* *unspecified*-1038) (lexical _sealed _sealed-1056)) (void) (void)))

;;; (elide effect (const #f))

;;; (elide effect (lexical _opaque _opaque-1057))

;;; (elide effect (if (apply (primitive eq?) (lexical *unspecified* *unspecified*-1038) (lexical _opaque _opaque-1057)) (void) (void)))
wrote `rnrs/records/syntactic.go'
  GUILEC rnrs.go
wrote `rnrs.go'
  GUILEC oop/goops.go

;;; (inferring #<tree-il (lexical t t-4674)> #t)

;;; (inferring #<tree-il (lexical t t-5333)> #t)

;;; (inferring #<tree-il (lexical t t-5345)> #t)

;;; (inferring #<tree-il (lexical t t-5353)> #t)

;;; (inferring #<tree-il (lexical t t-5368)> #t)

;;; (inferring #<tree-il (lexical t t-5382)> #t)

;;; (inferring #<tree-il (lexical t t-5406)> #t)

;;; (inferring #<tree-il (lexical t t-5420)> #t)

;;; (inferring #<tree-il (lexical t t-5440)> #t)

;;; (inferring #<tree-il (lexical t t-5462)> #t)

;;; (inferring #<tree-il (lexical t t-5485)> #t)

;;; (inferring #<tree-il (lexical t t-5500)> #t)

;;; (inferring #<tree-il (lexical t t-5514)> #t)

;;; (inferring #<tree-il (lexical t t-5534)> #t)

;;; (inferring #<tree-il (lexical t t-5554)> #t)

;;; (inferring #<tree-il (lexical t t-5574)> #t)

;;; (inferring #<tree-il (lexical t t-5594)> #t)

;;; (inferring #<tree-il (lexical t t-5623)> #t)

;;; (inferring #<tree-il (lexical t t-5632)> #t)

;;; (inferring #<tree-il (lexical t t-5639)> #t)

;;; (inferring #<tree-il (lexical t t-5647)> #t)

;;; (inferring #<tree-il (lexical t t-5656)> #t)

;;; (inferring #<tree-il (lexical t t-5666)> #t)

;;; (inferring #<tree-il (lexical t t-5676)> #t)

;;; (inferring #<tree-il (lexical t t-5684)> #t)

;;; (inferring #<tree-il (lexical t t-5692)> #t)

;;; (inferring #<tree-il (lexical t t-5704)> #t)

;;; (inferring #<tree-il (lexical t t-5722)> #t)

;;; (inferring #<tree-il (lexical t t-5742)> #t)

;;; (inferring #<tree-il (lexical t t-5758)> #t)

;;; (inferring #<tree-il (lexical t t-5813)> #t)

;;; (inferring #<tree-il (lexical t t-5867)> #t)

;;; (inferring #<tree-il (lexical t t-5890)> #t)

;;; (inferring #<tree-il (lexical t t-5904)> #t)

;;; (inferring #<tree-il (lexical t t-6186)> #t)

;;; (inferring #<tree-il (lexical t t-6192)> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical this-one this-one-6658))> #t)

;;; (inferring #<tree-il (lexical t t-6760)> #t)

;;; (inferring #<tree-il (lexical t t-6850)> #t)

;;; (inferring #<tree-il (lexical t t-6857)> #t)

;;; (inferring #<tree-il (lexical t t-6864)> #t)

;;; (inferring #<tree-il (lexical t t-6883)> #t)

;;; (inferring #<tree-il (lexical proc proc-6900)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical proc proc-6900))> #t)

;;; (inferring #<tree-il (lexical t t-6916)> #t)

;;; (inferring #<tree-il (lexical t t-6937)> #t)

;;; (inferring #<tree-il (lexical t t-6958)> #t)

;;; (inferring #<tree-il (lexical t t-6974)> #t)

;;; (inferring #<tree-il (lexical t t-6991)> #t)

;;; (inferring #<tree-il (lexical t t-7011)> #t)

;;; (inferring #<tree-il (lexical t t-7019)> #t)

;;; (inferring #<tree-il (lexical t t-7027)> #t)

;;; (inferring #<tree-il (lexical t t-7037)> #t)

;;; (inferring #<tree-il (lexical t t-7049)> #t)

;;; (inferring #<tree-il (lexical t t-7059)> #t)

;;; (inferring #<tree-il (lexical t t-7072)> #t)

;;; (inferring #<tree-il (lexical t t-7086)> #t)

;;; (inferring #<tree-il (lexical t t-7097)> #t)

;;; (inferring #<tree-il (lexical t t-7119)> #t)

;;; (elide effect (if (apply (primitive null?) (lexical new-args new-args-7128)) (void) (void)))
wrote `oop/goops.go'
  GUILEC oop/goops/active-slot.go

;;; (inferring #<tree-il (lexical t t-272)> #t)
wrote `oop/goops/active-slot.go'
  GUILEC oop/goops/compile.go
wrote `oop/goops/compile.go'
  GUILEC oop/goops/composite-slot.go

;;; (inferring #<tree-il (lexical t t-291)> #t)
wrote `oop/goops/composite-slot.go'
  GUILEC oop/goops/describe.go

;;; (inferring #<tree-il (lexical t t-533)> #t)

;;; (inferring #<tree-il (lexical t t-541)> #t)

;;; (inferring #<tree-il (lexical t t-553)> #t)

;;; (inferring #<tree-il (lexical t t-572)> #t)

;;; (inferring #<tree-il (lexical t t-593)> #t)

;;; (inferring #<tree-il (lexical t t-643)> #t)
wrote `oop/goops/describe.go'
  GUILEC oop/goops/dispatch.go

;;; (inferring #<tree-il (lexical t t-1089)> #t)

;;; (inferring #<tree-il (lexical t t-1275)> #t)

;;; (inferring #<tree-il (lexical t t-1426)> #t)
wrote `oop/goops/dispatch.go'
  GUILEC oop/goops/internal.go
wrote `oop/goops/internal.go'
  GUILEC oop/goops/save.go

;;; (inferring #<tree-il (lexical t t-2216)> #t)

;;; (inferring #<tree-il (lexical t t-2222)> #t)

;;; (inferring #<tree-il (lexical t t-2228)> #t)

;;; (inferring #<tree-il (lexical t t-2234)> #t)

;;; (inferring #<tree-il (lexical t t-2240)> #t)

;;; (inferring #<tree-il (lexical t t-2246)> #t)

;;; (inferring #<tree-il (lexical t t-2252)> #t)

;;; (inferring #<tree-il (lexical t t-2259)> #t)

;;; (inferring #<tree-il (lexical t t-2268)> #t)

;;; (inferring #<tree-il (lexical t t-2297)> #t)

;;; (inferring #<tree-il (lexical t t-2314)> #t)

;;; (inferring #<tree-il (apply (primitive vector?) (lexical o o-2316))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (lexical t t-2333)> #t)

;;; (inferring #<tree-il (lexical t t-2350)> #t)

;;; (inferring #<tree-il (lexical t t-2533)> #t)

;;; (inferring #<tree-il (lexical t t-2547)> #t)

;;; (inferring #<tree-il (lexical t t-2750)> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical ls ls-2843))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical ls ls-2788))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (lexical t t-2886)> #t)

;;; (inferring #<tree-il (lexical t t-2916)> #t)

;;; (inferring #<tree-il (lexical t t-2942)> #t)

;;; (inferring #<tree-il (lexical t t-2951)> #t)

;;; (inferring #<tree-il (lexical t t-2960)> #t)

;;; (inferring #<tree-il (lexical t t-2969)> #t)

;;; (inferring #<tree-il (lexical t t-2978)> #t)

;;; (inferring #<tree-il (lexical t t-2987)> #t)

;;; (inferring #<tree-il (lexical t t-3014)> #t)

;;; (inferring #<tree-il (lexical t t-3016)> #t)

;;; (inferring #<tree-il (lexical t t-3018)> #t)

;;; (inferring #<tree-il (lexical t t-3020)> #t)

;;; (inferring #<tree-il (lexical t t-3022)> #t)

;;; (inferring #<tree-il (lexical t t-3024)> #t)

;;; (inferring #<tree-il (lexical t t-3026)> #t)

;;; (inferring #<tree-il (lexical t t-3028)> #t)

;;; (inferring #<tree-il (lexical t t-3030)> #t)

;;; (inferring #<tree-il (lexical t t-3032)> #t)

;;; (inferring #<tree-il (lexical t t-3034)> #t)

;;; (inferring #<tree-il (lexical t t-3049)> #t)

;;; (inferring #<tree-il (lexical t t-3064)> #t)

;;; (inferring #<tree-il (lexical t t-3073)> #t)

;;; (inferring #<tree-il (lexical t t-3092)> #t)

;;; (inferring #<tree-il (lexical t t-3094)> #t)

;;; (inferring #<tree-il (lexical t t-3096)> #t)

;;; (inferring #<tree-il (lexical t t-3101)> #t)

;;; (inferring #<tree-il (lexical t t-3108)> #t)

;;; (inferring #<tree-il (lexical t t-3115)> #t)

;;; (inferring #<tree-il (lexical t t-3129)> #t)

;;; (inferring #<tree-il (lexical t t-3138)> #t)

;;; (inferring #<tree-il (lexical t t-3187)> #t)

;;; (inferring #<tree-il (lexical t t-3189)> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical ls ls-3196))> #t)

;;; (inferring #<tree-il (lexical t t-3290)> #t)

;;; (inferring #<tree-il (lexical t t-3307)> #t)

;;; (inferring #<tree-il (lexical t t-3324)> #t)

;;; (inferring #<tree-il (lexical t t-3331)> #t)
wrote `oop/goops/save.go'
  GUILEC oop/goops/stklos.go
wrote `oop/goops/stklos.go'
  GUILEC oop/goops/util.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical env env-210))> #t)
wrote `oop/goops/util.go'
  GUILEC oop/goops/accessors.go
wrote `oop/goops/accessors.go'
  GUILEC oop/goops/simple.go
wrote `oop/goops/simple.go'
  GUILEC system/vm/inspect.go
wrote `system/vm/inspect.go'
  GUILEC system/vm/coverage.go
wrote `system/vm/coverage.go'
  GUILEC system/vm/frame.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical bs bs-604))> #t)
wrote `system/vm/frame.go'
  GUILEC system/vm/instruction.go
wrote `system/vm/instruction.go'
  GUILEC system/vm/objcode.go
wrote `system/vm/objcode.go'
  GUILEC system/vm/program.go

;;; (inferring #<tree-il (lexical arities arities-1566)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical arities arities-1566))> #t)
wrote `system/vm/program.go'
  GUILEC system/vm/trace.go
wrote `system/vm/trace.go'
  GUILEC system/vm/traps.go

;;; (inferring #<tree-il (apply (primitive eq?) (lexical frame-proc frame-proc-1354) (lexical proc proc-1351))> #t)

;;; (inferring #<tree-il (lexical in-proc? in-proc?-1384)> #t)

;;; (inferring #<tree-il (lexical in-proc? in-proc?-1384)> #t)

;;; (inferring #<tree-il (lexical in-proc? in-proc?-1384)> #t)

;;; (inferring #<tree-il (lexical in-proc? in-proc?-1384)> #t)

;;; (inferring #<tree-il (lexical in-proc? in-proc?-1384)> #t)

;;; (inferring #<tree-il (lexical in-proc? in-proc?-1384)> #t)
wrote `system/vm/traps.go'
  GUILEC system/vm/trap-state.go
wrote `system/vm/trap-state.go'
  GUILEC system/vm/vm.go
wrote `system/vm/vm.go'
  GUILEC system/foreign.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical vals vals-377))> #t)
wrote `system/foreign.go'
  GUILEC system/xref.go
wrote `system/xref.go'
  GUILEC system/repl/debug.go

;;; (inferring #<tree-il (lexical w w-580)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical w w-580))> #t)

;;; (inferring #<tree-il (lexical count count-674)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical count count-674))> #t)

;;; (elide effect (const 1))

;;; (elide effect (const -1))

;;; (elide effect (if (lexical forward? forward?-673) (void) (void)))
wrote `system/repl/debug.go'
  GUILEC system/repl/error-handling.go
wrote `system/repl/error-handling.go'
  GUILEC system/repl/common.go

;;; (inferring #<tree-il (lexical t t-539)> #t)
wrote `system/repl/common.go'
  GUILEC system/repl/command.go

;;; (inferring #<tree-il (apply (primitive eq?) (lexical command command-8382) (void))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical args args-8717))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical args args-8717))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical args args-8717)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical args args-8717))> #f)

;;; (inferring #<tree-il (lexical t t-11479)> #t)

;;; (inferring #<tree-il (lexical t t-12317)> #t)

;;; (inferring #<tree-il (lexical t t-12453)> #t)

;;; (inferring #<tree-il (lexical t t-12589)> #t)
wrote `system/repl/command.go'
  GUILEC system/repl/repl.go

;;; (inferring #<tree-il (apply (primitive eqv?) (lexical ch ch-579) (const #\newline))> #t)
wrote `system/repl/repl.go'
  GUILEC system/repl/server.go
wrote `system/repl/server.go'
  GUILEC scripts/autofrisk.go
scripts/autofrisk.scm:185:2: warning: non-literal format string

;;; (inferring #<tree-il (apply (primitive eq?) (const quote) (lexical key key-422))> #t)
wrote `scripts/autofrisk.go'
  GUILEC scripts/compile.go

;;; (inferring #<tree-il (lexical help? help?-619)> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical input-files input-files-624))> #t)
wrote `scripts/compile.go'
  GUILEC scripts/disassemble.go
wrote `scripts/disassemble.go'
  GUILEC scripts/display-commentary.go
wrote `scripts/display-commentary.go'
  GUILEC scripts/doc-snarf.go
wrote `scripts/doc-snarf.go'
  GUILEC scripts/frisk.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical ls ls-495))> #t)
wrote `scripts/frisk.go'
  GUILEC scripts/generate-autoload.go

;;; (inferring #<tree-il (lexical t t-354)> #t)
wrote `scripts/generate-autoload.go'
  GUILEC scripts/help.go

;;; (inferring #<tree-il (lexical t t-478)> #t)

;;; (inferring #<tree-il (lexical all? all?-493)> #t)

;;; (inferring #<tree-il (apply (primitive equal?) (lexical args args-531) (const ("--all")))> #t)
wrote `scripts/help.go'
  GUILEC scripts/lint.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical free-vars free-vars-484))> #t)

;;; (propagate-value value (apply (primitive car) (lexical x x-598)))

;;; (propagate-value value (apply (primitive car) (lexical x x-860)))
wrote `scripts/lint.go'
  GUILEC scripts/list.go

;;; (inferring #<tree-il (lexical t t-279)> #t)
wrote `scripts/list.go'
  GUILEC scripts/punify.go
wrote `scripts/punify.go'
  GUILEC scripts/read-scheme-source.go

;;; (inferring #<tree-il (lexical t t-585)> #t)

;;; (inferring #<tree-il (lexical n n-571)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical n n-571))> #t)
wrote `scripts/read-scheme-source.go'
  GUILEC scripts/read-text-outline.go
wrote `scripts/read-text-outline.go'
  GUILEC scripts/use2dot.go
wrote `scripts/use2dot.go'
  GUILEC scripts/snarf-check-and-output-texi.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical strings strings-4555))> #t)

;;; (inferring #<tree-il (lexical scm-deffnx scm-deffnx-4556)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical scm-deffnx scm-deffnx-4556))> #t)
wrote `scripts/snarf-check-and-output-texi.go'
  GUILEC scripts/summarize-guile-TODO.go
wrote `scripts/summarize-guile-TODO.go'
  GUILEC scripts/scan-api.go
wrote `scripts/scan-api.go'
  GUILEC scripts/api-diff.go
wrote `scripts/api-diff.go'
  GUILEC scripts/read-rfc822.go
wrote `scripts/read-rfc822.go'
  GUILEC scripts/snarf-guile-m4-docs.go

;;; (propagate-value value (apply (primitive car) (lexical line line-327)))
wrote `scripts/snarf-guile-m4-docs.go'
  GUILEC language/ecmascript/tokenize.go

;;; (inferring #<tree-il (lexical t t-1175)> #t)

;;; (inferring #<tree-il (lexical t t-1324)> #t)

;;; (inferring #<tree-il (lexical t t-1354)> #t)

;;; (inferring #<tree-il (lexical t t-1451)> #t)

;;; (inferring #<tree-il (lexical t t-1458)> #t)

;;; (inferring #<tree-il (lexical t t-1584)> #t)

;;; (inferring #<tree-il (lexical t t-1586)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical tok tok-1596)) (@@ (system base lalr) lexical-token))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical cat cat-1604) (const Identifier))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical cat cat-1604) (const NumericLiteral))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical tok tok-1632)) (@@ (system base lalr) lexical-token))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical tok tok-1632)) (@@ (system base lalr) lexical-token))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical cat cat-1722) (const Identifier))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical cat cat-1722) (const NumericLiteral))> #t)
wrote `language/ecmascript/tokenize.go'
  GUILEC language/ecmascript/parse.go
%% Shift/Reduce conflict (shift 36, reduce 82) on 'lbrace' in state 437
%% Shift/Reduce conflict (shift 35, reduce 82) on 'lparen' in state 437
%% Shift/Reduce conflict (shift 34, reduce 82) on 'lbracket' in state 437
%% Shift/Reduce conflict (shift 33, reduce 82) on 'dot' in state 437
%% Shift/Reduce conflict (shift 32, reduce 82) on 'semicolon' in state 437
%% Shift/Reduce conflict (shift 31, reduce 82) on '+' in state 437
%% Shift/Reduce conflict (shift 30, reduce 82) on '-' in state 437
%% Shift/Reduce conflict (shift 29, reduce 82) on '++' in state 437
%% Shift/Reduce conflict (shift 28, reduce 82) on '--' in state 437
%% Shift/Reduce conflict (shift 27, reduce 82) on '!' in state 437
%% Shift/Reduce conflict (shift 26, reduce 82) on '~' in state 437
%% Shift/Reduce conflict (shift 25, reduce 82) on 'break' in state 437
%% Shift/Reduce conflict (shift 24, reduce 82) on 'new' in state 437
%% Shift/Reduce conflict (shift 23, reduce 82) on 'var' in state 437
%% Shift/Reduce conflict (shift 22, reduce 82) on 'return' in state 437
%% Shift/Reduce conflict (shift 21, reduce 82) on 'void' in state 437
%% Shift/Reduce conflict (shift 20, reduce 82) on 'for' in state 437
%% Shift/Reduce conflict (shift 19, reduce 82) on 'switch' in state 437
%% Shift/Reduce conflict (shift 18, reduce 82) on 'while' in state 437
%% Shift/Reduce conflict (shift 17, reduce 82) on 'continue' in state 437
%% Shift/Reduce conflict (shift 82, reduce 82) on 'function' in state 437
%% Shift/Reduce conflict (shift 15, reduce 82) on 'this' in state 437
%% Shift/Reduce conflict (shift 14, reduce 82) on 'with' in state 437
%% Shift/Reduce conflict (shift 13, reduce 82) on 'if' in state 437
%% Shift/Reduce conflict (shift 12, reduce 82) on 'throw' in state 437
%% Shift/Reduce conflict (shift 11, reduce 82) on 'delete' in state 437
%% Shift/Reduce conflict (shift 10, reduce 82) on 'try' in state 437
%% Shift/Reduce conflict (shift 9, reduce 82) on 'do' in state 437
%% Shift/Reduce conflict (shift 8, reduce 82) on 'typeof' in state 437
%% Shift/Reduce conflict (shift 7, reduce 82) on 'null' in state 437
%% Shift/Reduce conflict (shift 6, reduce 82) on 'true' in state 437
%% Shift/Reduce conflict (shift 5, reduce 82) on 'false' in state 437
%% Shift/Reduce conflict (shift 4, reduce 82) on 'Identifier' in state 437
%% Shift/Reduce conflict (shift 3, reduce 82) on 'StringLiteral' in state 437
%% Shift/Reduce conflict (shift 2, reduce 82) on 'NumericLiteral' in state 437
%% Shift/Reduce conflict (shift 1, reduce 82) on 'RegexpLiteral' in state 437
%% Shift/Reduce conflict (shift 36, reduce 81) on 'lbrace' in state 424
%% Shift/Reduce conflict (shift 35, reduce 81) on 'lparen' in state 424
%% Shift/Reduce conflict (shift 34, reduce 81) on 'lbracket' in state 424
%% Shift/Reduce conflict (shift 33, reduce 81) on 'dot' in state 424
%% Shift/Reduce conflict (shift 32, reduce 81) on 'semicolon' in state 424
%% Shift/Reduce conflict (shift 31, reduce 81) on '+' in state 424
%% Shift/Reduce conflict (shift 30, reduce 81) on '-' in state 424
%% Shift/Reduce conflict (shift 29, reduce 81) on '++' in state 424
%% Shift/Reduce conflict (shift 28, reduce 81) on '--' in state 424
%% Shift/Reduce conflict (shift 27, reduce 81) on '!' in state 424
%% Shift/Reduce conflict (shift 26, reduce 81) on '~' in state 424
%% Shift/Reduce conflict (shift 25, reduce 81) on 'break' in state 424
%% Shift/Reduce conflict (shift 24, reduce 81) on 'new' in state 424
%% Shift/Reduce conflict (shift 23, reduce 81) on 'var' in state 424
%% Shift/Reduce conflict (shift 22, reduce 81) on 'return' in state 424
%% Shift/Reduce conflict (shift 21, reduce 81) on 'void' in state 424
%% Shift/Reduce conflict (shift 20, reduce 81) on 'for' in state 424
%% Shift/Reduce conflict (shift 19, reduce 81) on 'switch' in state 424
%% Shift/Reduce conflict (shift 18, reduce 81) on 'while' in state 424
%% Shift/Reduce conflict (shift 17, reduce 81) on 'continue' in state 424
%% Shift/Reduce conflict (shift 82, reduce 81) on 'function' in state 424
%% Shift/Reduce conflict (shift 15, reduce 81) on 'this' in state 424
%% Shift/Reduce conflict (shift 14, reduce 81) on 'with' in state 424
%% Shift/Reduce conflict (shift 13, reduce 81) on 'if' in state 424
%% Shift/Reduce conflict (shift 12, reduce 81) on 'throw' in state 424
%% Shift/Reduce conflict (shift 11, reduce 81) on 'delete' in state 424
%% Shift/Reduce conflict (shift 10, reduce 81) on 'try' in state 424
%% Shift/Reduce conflict (shift 9, reduce 81) on 'do' in state 424
%% Shift/Reduce conflict (shift 8, reduce 81) on 'typeof' in state 424
%% Shift/Reduce conflict (shift 7, reduce 81) on 'null' in state 424
%% Shift/Reduce conflict (shift 6, reduce 81) on 'true' in state 424
%% Shift/Reduce conflict (shift 5, reduce 81) on 'false' in state 424
%% Shift/Reduce conflict (shift 4, reduce 81) on 'Identifier' in state 424
%% Shift/Reduce conflict (shift 3, reduce 81) on 'StringLiteral' in state 424
%% Shift/Reduce conflict (shift 2, reduce 81) on 'NumericLiteral' in state 424
%% Shift/Reduce conflict (shift 1, reduce 81) on 'RegexpLiteral' in state 424
%% Shift/Reduce conflict (shift 36, reduce 84) on 'lbrace' in state 423
%% Shift/Reduce conflict (shift 35, reduce 84) on 'lparen' in state 423
%% Shift/Reduce conflict (shift 34, reduce 84) on 'lbracket' in state 423
%% Shift/Reduce conflict (shift 33, reduce 84) on 'dot' in state 423
%% Shift/Reduce conflict (shift 32, reduce 84) on 'semicolon' in state 423
%% Shift/Reduce conflict (shift 31, reduce 84) on '+' in state 423
%% Shift/Reduce conflict (shift 30, reduce 84) on '-' in state 423
%% Shift/Reduce conflict (shift 29, reduce 84) on '++' in state 423
%% Shift/Reduce conflict (shift 28, reduce 84) on '--' in state 423
%% Shift/Reduce conflict (shift 27, reduce 84) on '!' in state 423
%% Shift/Reduce conflict (shift 26, reduce 84) on '~' in state 423
%% Shift/Reduce conflict (shift 25, reduce 84) on 'break' in state 423
%% Shift/Reduce conflict (shift 24, reduce 84) on 'new' in state 423
%% Shift/Reduce conflict (shift 23, reduce 84) on 'var' in state 423
%% Shift/Reduce conflict (shift 22, reduce 84) on 'return' in state 423
%% Shift/Reduce conflict (shift 21, reduce 84) on 'void' in state 423
%% Shift/Reduce conflict (shift 20, reduce 84) on 'for' in state 423
%% Shift/Reduce conflict (shift 19, reduce 84) on 'switch' in state 423
%% Shift/Reduce conflict (shift 18, reduce 84) on 'while' in state 423
%% Shift/Reduce conflict (shift 17, reduce 84) on 'continue' in state 423
%% Shift/Reduce conflict (shift 82, reduce 84) on 'function' in state 423
%% Shift/Reduce conflict (shift 15, reduce 84) on 'this' in state 423
%% Shift/Reduce conflict (shift 14, reduce 84) on 'with' in state 423
%% Shift/Reduce conflict (shift 13, reduce 84) on 'if' in state 423
%% Shift/Reduce conflict (shift 12, reduce 84) on 'throw' in state 423
%% Shift/Reduce conflict (shift 11, reduce 84) on 'delete' in state 423
%% Shift/Reduce conflict (shift 10, reduce 84) on 'try' in state 423
%% Shift/Reduce conflict (shift 9, reduce 84) on 'do' in state 423
%% Shift/Reduce conflict (shift 8, reduce 84) on 'typeof' in state 423
%% Shift/Reduce conflict (shift 7, reduce 84) on 'null' in state 423
%% Shift/Reduce conflict (shift 6, reduce 84) on 'true' in state 423
%% Shift/Reduce conflict (shift 5, reduce 84) on 'false' in state 423
%% Shift/Reduce conflict (shift 4, reduce 84) on 'Identifier' in state 423
%% Shift/Reduce conflict (shift 3, reduce 84) on 'StringLiteral' in state 423
%% Shift/Reduce conflict (shift 2, reduce 84) on 'NumericLiteral' in state 423
%% Shift/Reduce conflict (shift 1, reduce 84) on 'RegexpLiteral' in state 423
%% Reduce/Reduce conflict (reduce 11, reduce 7) on '--' in state 422
%% Reduce/Reduce conflict (reduce 11, reduce 7) on '++' in state 422
%% Reduce/Reduce conflict (reduce 11, reduce 7) on '-' in state 422
%% Reduce/Reduce conflict (reduce 11, reduce 7) on '+' in state 422
%% Reduce/Reduce conflict (reduce 11, reduce 7) on 'semicolon' in state 422
%% Reduce/Reduce conflict (reduce 11, reduce 7) on 'dot' in state 422
%% Reduce/Reduce conflict (reduce 11, reduce 7) on 'lbracket' in state 422
%% Reduce/Reduce conflict (reduce 11, reduce 7) on 'lparen' in state 422
%% Shift/Reduce conflict (shift 36, reduce 83) on 'lbrace' in state 400
%% Shift/Reduce conflict (shift 35, reduce 83) on 'lparen' in state 400
%% Shift/Reduce conflict (shift 34, reduce 83) on 'lbracket' in state 400
%% Shift/Reduce conflict (shift 33, reduce 83) on 'dot' in state 400
%% Shift/Reduce conflict (shift 32, reduce 83) on 'semicolon' in state 400
%% Shift/Reduce conflict (shift 31, reduce 83) on '+' in state 400
%% Shift/Reduce conflict (shift 30, reduce 83) on '-' in state 400
%% Shift/Reduce conflict (shift 29, reduce 83) on '++' in state 400
%% Shift/Reduce conflict (shift 28, reduce 83) on '--' in state 400
%% Shift/Reduce conflict (shift 27, reduce 83) on '!' in state 400
%% Shift/Reduce conflict (shift 26, reduce 83) on '~' in state 400
%% Shift/Reduce conflict (shift 25, reduce 83) on 'break' in state 400
%% Shift/Reduce conflict (shift 24, reduce 83) on 'new' in state 400
%% Shift/Reduce conflict (shift 23, reduce 83) on 'var' in state 400
%% Shift/Reduce conflict (shift 22, reduce 83) on 'return' in state 400
%% Shift/Reduce conflict (shift 21, reduce 83) on 'void' in state 400
%% Shift/Reduce conflict (shift 20, reduce 83) on 'for' in state 400
%% Shift/Reduce conflict (shift 19, reduce 83) on 'switch' in state 400
%% Shift/Reduce conflict (shift 18, reduce 83) on 'while' in state 400
%% Shift/Reduce conflict (shift 17, reduce 83) on 'continue' in state 400
%% Shift/Reduce conflict (shift 82, reduce 83) on 'function' in state 400
%% Shift/Reduce conflict (shift 15, reduce 83) on 'this' in state 400
%% Shift/Reduce conflict (shift 14, reduce 83) on 'with' in state 400
%% Shift/Reduce conflict (shift 13, reduce 83) on 'if' in state 400
%% Shift/Reduce conflict (shift 12, reduce 83) on 'throw' in state 400
%% Shift/Reduce conflict (shift 11, reduce 83) on 'delete' in state 400
%% Shift/Reduce conflict (shift 10, reduce 83) on 'try' in state 400
%% Shift/Reduce conflict (shift 9, reduce 83) on 'do' in state 400
%% Shift/Reduce conflict (shift 8, reduce 83) on 'typeof' in state 400
%% Shift/Reduce conflict (shift 7, reduce 83) on 'null' in state 400
%% Shift/Reduce conflict (shift 6, reduce 83) on 'true' in state 400
%% Shift/Reduce conflict (shift 5, reduce 83) on 'false' in state 400
%% Shift/Reduce conflict (shift 4, reduce 83) on 'Identifier' in state 400
%% Shift/Reduce conflict (shift 3, reduce 83) on 'StringLiteral' in state 400
%% Shift/Reduce conflict (shift 2, reduce 83) on 'NumericLiteral' in state 400
%% Shift/Reduce conflict (shift 1, reduce 83) on 'RegexpLiteral' in state 400
%% Reduce/Reduce conflict (reduce 9, reduce 6) on '--' in state 397
%% Reduce/Reduce conflict (reduce 9, reduce 6) on '++' in state 397
%% Reduce/Reduce conflict (reduce 9, reduce 6) on '-' in state 397
%% Reduce/Reduce conflict (reduce 9, reduce 6) on '+' in state 397
%% Reduce/Reduce conflict (reduce 9, reduce 6) on 'semicolon' in state 397
%% Reduce/Reduce conflict (reduce 9, reduce 6) on 'dot' in state 397
%% Reduce/Reduce conflict (reduce 9, reduce 6) on 'lbracket' in state 397
%% Reduce/Reduce conflict (reduce 9, reduce 6) on 'lparen' in state 397
%% Shift/Reduce conflict (shift 36, reduce 17) on 'lbrace' in state 393
%% Shift/Reduce conflict (shift 35, reduce 17) on 'lparen' in state 393
%% Shift/Reduce conflict (shift 34, reduce 17) on 'lbracket' in state 393
%% Shift/Reduce conflict (shift 33, reduce 17) on 'dot' in state 393
%% Shift/Reduce conflict (shift 32, reduce 17) on 'semicolon' in state 393
%% Shift/Reduce conflict (shift 31, reduce 17) on '+' in state 393
%% Shift/Reduce conflict (shift 30, reduce 17) on '-' in state 393
%% Shift/Reduce conflict (shift 29, reduce 17) on '++' in state 393
%% Shift/Reduce conflict (shift 28, reduce 17) on '--' in state 393
%% Shift/Reduce conflict (shift 27, reduce 17) on '!' in state 393
%% Shift/Reduce conflict (shift 26, reduce 17) on '~' in state 393
%% Shift/Reduce conflict (shift 25, reduce 17) on 'break' in state 393
%% Shift/Reduce conflict (shift 24, reduce 17) on 'new' in state 393
%% Shift/Reduce conflict (shift 23, reduce 17) on 'var' in state 393
%% Shift/Reduce conflict (shift 22, reduce 17) on 'return' in state 393
%% Shift/Reduce conflict (shift 21, reduce 17) on 'void' in state 393
%% Shift/Reduce conflict (shift 20, reduce 17) on 'for' in state 393
%% Shift/Reduce conflict (shift 19, reduce 17) on 'switch' in state 393
%% Shift/Reduce conflict (shift 18, reduce 17) on 'while' in state 393
%% Shift/Reduce conflict (shift 17, reduce 17) on 'continue' in state 393
%% Shift/Reduce conflict (shift 16, reduce 17) on 'function' in state 393
%% Shift/Reduce conflict (shift 15, reduce 17) on 'this' in state 393
%% Shift/Reduce conflict (shift 14, reduce 17) on 'with' in state 393
%% Shift/Reduce conflict (shift 13, reduce 17) on 'if' in state 393
%% Shift/Reduce conflict (shift 12, reduce 17) on 'throw' in state 393
%% Shift/Reduce conflict (shift 11, reduce 17) on 'delete' in state 393
%% Shift/Reduce conflict (shift 10, reduce 17) on 'try' in state 393
%% Shift/Reduce conflict (shift 9, reduce 17) on 'do' in state 393
%% Shift/Reduce conflict (shift 8, reduce 17) on 'typeof' in state 393
%% Shift/Reduce conflict (shift 7, reduce 17) on 'null' in state 393
%% Shift/Reduce conflict (shift 6, reduce 17) on 'true' in state 393
%% Shift/Reduce conflict (shift 5, reduce 17) on 'false' in state 393
%% Shift/Reduce conflict (shift 4, reduce 17) on 'Identifier' in state 393
%% Shift/Reduce conflict (shift 3, reduce 17) on 'StringLiteral' in state 393
%% Shift/Reduce conflict (shift 2, reduce 17) on 'NumericLiteral' in state 393
%% Shift/Reduce conflict (shift 1, reduce 17) on 'RegexpLiteral' in state 393
%% Shift/Reduce conflict (shift 36, reduce 17) on 'lbrace' in state 369
%% Shift/Reduce conflict (shift 35, reduce 17) on 'lparen' in state 369
%% Shift/Reduce conflict (shift 34, reduce 17) on 'lbracket' in state 369
%% Shift/Reduce conflict (shift 33, reduce 17) on 'dot' in state 369
%% Shift/Reduce conflict (shift 32, reduce 17) on 'semicolon' in state 369
%% Shift/Reduce conflict (shift 31, reduce 17) on '+' in state 369
%% Shift/Reduce conflict (shift 30, reduce 17) on '-' in state 369
%% Shift/Reduce conflict (shift 29, reduce 17) on '++' in state 369
%% Shift/Reduce conflict (shift 28, reduce 17) on '--' in state 369
%% Shift/Reduce conflict (shift 27, reduce 17) on '!' in state 369
%% Shift/Reduce conflict (shift 26, reduce 17) on '~' in state 369
%% Shift/Reduce conflict (shift 25, reduce 17) on 'break' in state 369
%% Shift/Reduce conflict (shift 24, reduce 17) on 'new' in state 369
%% Shift/Reduce conflict (shift 23, reduce 17) on 'var' in state 369
%% Shift/Reduce conflict (shift 22, reduce 17) on 'return' in state 369
%% Shift/Reduce conflict (shift 21, reduce 17) on 'void' in state 369
%% Shift/Reduce conflict (shift 20, reduce 17) on 'for' in state 369
%% Shift/Reduce conflict (shift 19, reduce 17) on 'switch' in state 369
%% Shift/Reduce conflict (shift 18, reduce 17) on 'while' in state 369
%% Shift/Reduce conflict (shift 17, reduce 17) on 'continue' in state 369
%% Shift/Reduce conflict (shift 16, reduce 17) on 'function' in state 369
%% Shift/Reduce conflict (shift 15, reduce 17) on 'this' in state 369
%% Shift/Reduce conflict (shift 14, reduce 17) on 'with' in state 369
%% Shift/Reduce conflict (shift 13, reduce 17) on 'if' in state 369
%% Shift/Reduce conflict (shift 12, reduce 17) on 'throw' in state 369
%% Shift/Reduce conflict (shift 11, reduce 17) on 'delete' in state 369
%% Shift/Reduce conflict (shift 10, reduce 17) on 'try' in state 369
%% Shift/Reduce conflict (shift 9, reduce 17) on 'do' in state 369
%% Shift/Reduce conflict (shift 8, reduce 17) on 'typeof' in state 369
%% Shift/Reduce conflict (shift 7, reduce 17) on 'null' in state 369
%% Shift/Reduce conflict (shift 6, reduce 17) on 'true' in state 369
%% Shift/Reduce conflict (shift 5, reduce 17) on 'false' in state 369
%% Shift/Reduce conflict (shift 4, reduce 17) on 'Identifier' in state 369
%% Shift/Reduce conflict (shift 3, reduce 17) on 'StringLiteral' in state 369
%% Shift/Reduce conflict (shift 2, reduce 17) on 'NumericLiteral' in state 369
%% Shift/Reduce conflict (shift 1, reduce 17) on 'RegexpLiteral' in state 369
%% Shift/Reduce conflict (shift 36, reduce 17) on 'lbrace' in state 363
%% Shift/Reduce conflict (shift 35, reduce 17) on 'lparen' in state 363
%% Shift/Reduce conflict (shift 34, reduce 17) on 'lbracket' in state 363
%% Shift/Reduce conflict (shift 33, reduce 17) on 'dot' in state 363
%% Shift/Reduce conflict (shift 32, reduce 17) on 'semicolon' in state 363
%% Shift/Reduce conflict (shift 31, reduce 17) on '+' in state 363
%% Shift/Reduce conflict (shift 30, reduce 17) on '-' in state 363
%% Shift/Reduce conflict (shift 29, reduce 17) on '++' in state 363
%% Shift/Reduce conflict (shift 28, reduce 17) on '--' in state 363
%% Shift/Reduce conflict (shift 27, reduce 17) on '!' in state 363
%% Shift/Reduce conflict (shift 26, reduce 17) on '~' in state 363
%% Shift/Reduce conflict (shift 25, reduce 17) on 'break' in state 363
%% Shift/Reduce conflict (shift 24, reduce 17) on 'new' in state 363
%% Shift/Reduce conflict (shift 23, reduce 17) on 'var' in state 363
%% Shift/Reduce conflict (shift 22, reduce 17) on 'return' in state 363
%% Shift/Reduce conflict (shift 21, reduce 17) on 'void' in state 363
%% Shift/Reduce conflict (shift 20, reduce 17) on 'for' in state 363
%% Shift/Reduce conflict (shift 19, reduce 17) on 'switch' in state 363
%% Shift/Reduce conflict (shift 18, reduce 17) on 'while' in state 363
%% Shift/Reduce conflict (shift 17, reduce 17) on 'continue' in state 363
%% Shift/Reduce conflict (shift 16, reduce 17) on 'function' in state 363
%% Shift/Reduce conflict (shift 15, reduce 17) on 'this' in state 363
%% Shift/Reduce conflict (shift 14, reduce 17) on 'with' in state 363
%% Shift/Reduce conflict (shift 13, reduce 17) on 'if' in state 363
%% Shift/Reduce conflict (shift 12, reduce 17) on 'throw' in state 363
%% Shift/Reduce conflict (shift 11, reduce 17) on 'delete' in state 363
%% Shift/Reduce conflict (shift 10, reduce 17) on 'try' in state 363
%% Shift/Reduce conflict (shift 9, reduce 17) on 'do' in state 363
%% Shift/Reduce conflict (shift 8, reduce 17) on 'typeof' in state 363
%% Shift/Reduce conflict (shift 7, reduce 17) on 'null' in state 363
%% Shift/Reduce conflict (shift 6, reduce 17) on 'true' in state 363
%% Shift/Reduce conflict (shift 5, reduce 17) on 'false' in state 363
%% Shift/Reduce conflict (shift 4, reduce 17) on 'Identifier' in state 363
%% Shift/Reduce conflict (shift 3, reduce 17) on 'StringLiteral' in state 363
%% Shift/Reduce conflict (shift 2, reduce 17) on 'NumericLiteral' in state 363
%% Shift/Reduce conflict (shift 1, reduce 17) on 'RegexpLiteral' in state 363
%% Shift/Reduce conflict (shift 170, reduce 139) on '++' in state 338
%% Shift/Reduce conflict (shift 169, reduce 139) on '--' in state 338
%% Shift/Reduce conflict (shift 168, reduce 139) on '=' in state 338
%% Shift/Reduce conflict (shift 167, reduce 139) on '+=' in state 338
%% Shift/Reduce conflict (shift 166, reduce 139) on '-=' in state 338
%% Shift/Reduce conflict (shift 165, reduce 139) on '*=' in state 338
%% Shift/Reduce conflict (shift 164, reduce 139) on '%=' in state 338
%% Shift/Reduce conflict (shift 163, reduce 139) on '<<=' in state 338
%% Shift/Reduce conflict (shift 162, reduce 139) on '>>=' in state 338
%% Shift/Reduce conflict (shift 161, reduce 139) on '>>>=' in state 338
%% Shift/Reduce conflict (shift 160, reduce 139) on '&=' in state 338
%% Shift/Reduce conflict (shift 159, reduce 139) on 'bor=' in state 338
%% Shift/Reduce conflict (shift 158, reduce 139) on '^=' in state 338
%% Shift/Reduce conflict (shift 157, reduce 139) on '/=' in state 338
%% Shift/Reduce conflict (shift 36, reduce 17) on 'lbrace' in state 326
%% Shift/Reduce conflict (shift 35, reduce 17) on 'lparen' in state 326
%% Shift/Reduce conflict (shift 34, reduce 17) on 'lbracket' in state 326
%% Shift/Reduce conflict (shift 33, reduce 17) on 'dot' in state 326
%% Shift/Reduce conflict (shift 32, reduce 17) on 'semicolon' in state 326
%% Shift/Reduce conflict (shift 31, reduce 17) on '+' in state 326
%% Shift/Reduce conflict (shift 30, reduce 17) on '-' in state 326
%% Shift/Reduce conflict (shift 29, reduce 17) on '++' in state 326
%% Shift/Reduce conflict (shift 28, reduce 17) on '--' in state 326
%% Shift/Reduce conflict (shift 27, reduce 17) on '!' in state 326
%% Shift/Reduce conflict (shift 26, reduce 17) on '~' in state 326
%% Shift/Reduce conflict (shift 25, reduce 17) on 'break' in state 326
%% Shift/Reduce conflict (shift 24, reduce 17) on 'new' in state 326
%% Shift/Reduce conflict (shift 23, reduce 17) on 'var' in state 326
%% Shift/Reduce conflict (shift 22, reduce 17) on 'return' in state 326
%% Shift/Reduce conflict (shift 21, reduce 17) on 'void' in state 326
%% Shift/Reduce conflict (shift 20, reduce 17) on 'for' in state 326
%% Shift/Reduce conflict (shift 19, reduce 17) on 'switch' in state 326
%% Shift/Reduce conflict (shift 18, reduce 17) on 'while' in state 326
%% Shift/Reduce conflict (shift 17, reduce 17) on 'continue' in state 326
%% Shift/Reduce conflict (shift 16, reduce 17) on 'function' in state 326
%% Shift/Reduce conflict (shift 15, reduce 17) on 'this' in state 326
%% Shift/Reduce conflict (shift 14, reduce 17) on 'with' in state 326
%% Shift/Reduce conflict (shift 13, reduce 17) on 'if' in state 326
%% Shift/Reduce conflict (shift 12, reduce 17) on 'throw' in state 326
%% Shift/Reduce conflict (shift 11, reduce 17) on 'delete' in state 326
%% Shift/Reduce conflict (shift 10, reduce 17) on 'try' in state 326
%% Shift/Reduce conflict (shift 9, reduce 17) on 'do' in state 326
%% Shift/Reduce conflict (shift 8, reduce 17) on 'typeof' in state 326
%% Shift/Reduce conflict (shift 7, reduce 17) on 'null' in state 326
%% Shift/Reduce conflict (shift 6, reduce 17) on 'true' in state 326
%% Shift/Reduce conflict (shift 5, reduce 17) on 'false' in state 326
%% Shift/Reduce conflict (shift 4, reduce 17) on 'Identifier' in state 326
%% Shift/Reduce conflict (shift 3, reduce 17) on 'StringLiteral' in state 326
%% Shift/Reduce conflict (shift 2, reduce 17) on 'NumericLiteral' in state 326
%% Shift/Reduce conflict (shift 1, reduce 17) on 'RegexpLiteral' in state 326
%% Shift/Reduce conflict (shift 36, reduce 16) on 'lbrace' in state 324
%% Shift/Reduce conflict (shift 35, reduce 16) on 'lparen' in state 324
%% Shift/Reduce conflict (shift 34, reduce 16) on 'lbracket' in state 324
%% Shift/Reduce conflict (shift 33, reduce 16) on 'dot' in state 324
%% Shift/Reduce conflict (shift 32, reduce 16) on 'semicolon' in state 324
%% Shift/Reduce conflict (shift 31, reduce 16) on '+' in state 324
%% Shift/Reduce conflict (shift 30, reduce 16) on '-' in state 324
%% Shift/Reduce conflict (shift 29, reduce 16) on '++' in state 324
%% Shift/Reduce conflict (shift 28, reduce 16) on '--' in state 324
%% Shift/Reduce conflict (shift 27, reduce 16) on '!' in state 324
%% Shift/Reduce conflict (shift 26, reduce 16) on '~' in state 324
%% Shift/Reduce conflict (shift 25, reduce 16) on 'break' in state 324
%% Shift/Reduce conflict (shift 24, reduce 16) on 'new' in state 324
%% Shift/Reduce conflict (shift 23, reduce 16) on 'var' in state 324
%% Shift/Reduce conflict (shift 22, reduce 16) on 'return' in state 324
%% Shift/Reduce conflict (shift 21, reduce 16) on 'void' in state 324
%% Shift/Reduce conflict (shift 20, reduce 16) on 'for' in state 324
%% Shift/Reduce conflict (shift 19, reduce 16) on 'switch' in state 324
%% Shift/Reduce conflict (shift 18, reduce 16) on 'while' in state 324
%% Shift/Reduce conflict (shift 17, reduce 16) on 'continue' in state 324
%% Shift/Reduce conflict (shift 16, reduce 16) on 'function' in state 324
%% Shift/Reduce conflict (shift 15, reduce 16) on 'this' in state 324
%% Shift/Reduce conflict (shift 14, reduce 16) on 'with' in state 324
%% Shift/Reduce conflict (shift 13, reduce 16) on 'if' in state 324
%% Shift/Reduce conflict (shift 12, reduce 16) on 'throw' in state 324
%% Shift/Reduce conflict (shift 11, reduce 16) on 'delete' in state 324
%% Shift/Reduce conflict (shift 10, reduce 16) on 'try' in state 324
%% Shift/Reduce conflict (shift 9, reduce 16) on 'do' in state 324
%% Shift/Reduce conflict (shift 8, reduce 16) on 'typeof' in state 324
%% Shift/Reduce conflict (shift 7, reduce 16) on 'null' in state 324
%% Shift/Reduce conflict (shift 6, reduce 16) on 'true' in state 324
%% Shift/Reduce conflict (shift 5, reduce 16) on 'false' in state 324
%% Shift/Reduce conflict (shift 4, reduce 16) on 'Identifier' in state 324
%% Shift/Reduce conflict (shift 3, reduce 16) on 'StringLiteral' in state 324
%% Shift/Reduce conflict (shift 2, reduce 16) on 'NumericLiteral' in state 324
%% Shift/Reduce conflict (shift 1, reduce 16) on 'RegexpLiteral' in state 324
%% Shift/Reduce conflict (shift 36, reduce 17) on 'lbrace' in state 321
%% Shift/Reduce conflict (shift 35, reduce 17) on 'lparen' in state 321
%% Shift/Reduce conflict (shift 34, reduce 17) on 'lbracket' in state 321
%% Shift/Reduce conflict (shift 33, reduce 17) on 'dot' in state 321
%% Shift/Reduce conflict (shift 32, reduce 17) on 'semicolon' in state 321
%% Shift/Reduce conflict (shift 31, reduce 17) on '+' in state 321
%% Shift/Reduce conflict (shift 30, reduce 17) on '-' in state 321
%% Shift/Reduce conflict (shift 29, reduce 17) on '++' in state 321
%% Shift/Reduce conflict (shift 28, reduce 17) on '--' in state 321
%% Shift/Reduce conflict (shift 27, reduce 17) on '!' in state 321
%% Shift/Reduce conflict (shift 26, reduce 17) on '~' in state 321
%% Shift/Reduce conflict (shift 25, reduce 17) on 'break' in state 321
%% Shift/Reduce conflict (shift 24, reduce 17) on 'new' in state 321
%% Shift/Reduce conflict (shift 23, reduce 17) on 'var' in state 321
%% Shift/Reduce conflict (shift 22, reduce 17) on 'return' in state 321
%% Shift/Reduce conflict (shift 21, reduce 17) on 'void' in state 321
%% Shift/Reduce conflict (shift 20, reduce 17) on 'for' in state 321
%% Shift/Reduce conflict (shift 19, reduce 17) on 'switch' in state 321
%% Shift/Reduce conflict (shift 18, reduce 17) on 'while' in state 321
%% Shift/Reduce conflict (shift 17, reduce 17) on 'continue' in state 321
%% Shift/Reduce conflict (shift 16, reduce 17) on 'function' in state 321
%% Shift/Reduce conflict (shift 15, reduce 17) on 'this' in state 321
%% Shift/Reduce conflict (shift 14, reduce 17) on 'with' in state 321
%% Shift/Reduce conflict (shift 13, reduce 17) on 'if' in state 321
%% Shift/Reduce conflict (shift 12, reduce 17) on 'throw' in state 321
%% Shift/Reduce conflict (shift 11, reduce 17) on 'delete' in state 321
%% Shift/Reduce conflict (shift 10, reduce 17) on 'try' in state 321
%% Shift/Reduce conflict (shift 9, reduce 17) on 'do' in state 321
%% Shift/Reduce conflict (shift 8, reduce 17) on 'typeof' in state 321
%% Shift/Reduce conflict (shift 7, reduce 17) on 'null' in state 321
%% Shift/Reduce conflict (shift 6, reduce 17) on 'true' in state 321
%% Shift/Reduce conflict (shift 5, reduce 17) on 'false' in state 321
%% Shift/Reduce conflict (shift 4, reduce 17) on 'Identifier' in state 321
%% Shift/Reduce conflict (shift 3, reduce 17) on 'StringLiteral' in state 321
%% Shift/Reduce conflict (shift 2, reduce 17) on 'NumericLiteral' in state 321
%% Shift/Reduce conflict (shift 1, reduce 17) on 'RegexpLiteral' in state 321
%% Shift/Reduce conflict (shift 367, reduce 49) on 'else' in state 319
%% Shift/Reduce conflict (shift 216, reduce 42) on '=' in state 279
%% Shift/Reduce conflict (shift 36, reduce 17) on 'lbrace' in state 274
%% Shift/Reduce conflict (shift 35, reduce 17) on 'lparen' in state 274
%% Shift/Reduce conflict (shift 34, reduce 17) on 'lbracket' in state 274
%% Shift/Reduce conflict (shift 33, reduce 17) on 'dot' in state 274
%% Shift/Reduce conflict (shift 32, reduce 17) on 'semicolon' in state 274
%% Shift/Reduce conflict (shift 31, reduce 17) on '+' in state 274
%% Shift/Reduce conflict (shift 30, reduce 17) on '-' in state 274
%% Shift/Reduce conflict (shift 29, reduce 17) on '++' in state 274
%% Shift/Reduce conflict (shift 28, reduce 17) on '--' in state 274
%% Shift/Reduce conflict (shift 27, reduce 17) on '!' in state 274
%% Shift/Reduce conflict (shift 26, reduce 17) on '~' in state 274
%% Shift/Reduce conflict (shift 25, reduce 17) on 'break' in state 274
%% Shift/Reduce conflict (shift 24, reduce 17) on 'new' in state 274
%% Shift/Reduce conflict (shift 23, reduce 17) on 'var' in state 274
%% Shift/Reduce conflict (shift 22, reduce 17) on 'return' in state 274
%% Shift/Reduce conflict (shift 21, reduce 17) on 'void' in state 274
%% Shift/Reduce conflict (shift 20, reduce 17) on 'for' in state 274
%% Shift/Reduce conflict (shift 19, reduce 17) on 'switch' in state 274
%% Shift/Reduce conflict (shift 18, reduce 17) on 'while' in state 274
%% Shift/Reduce conflict (shift 17, reduce 17) on 'continue' in state 274
%% Shift/Reduce conflict (shift 16, reduce 17) on 'function' in state 274
%% Shift/Reduce conflict (shift 15, reduce 17) on 'this' in state 274
%% Shift/Reduce conflict (shift 14, reduce 17) on 'with' in state 274
%% Shift/Reduce conflict (shift 13, reduce 17) on 'if' in state 274
%% Shift/Reduce conflict (shift 12, reduce 17) on 'throw' in state 274
%% Shift/Reduce conflict (shift 11, reduce 17) on 'delete' in state 274
%% Shift/Reduce conflict (shift 10, reduce 17) on 'try' in state 274
%% Shift/Reduce conflict (shift 9, reduce 17) on 'do' in state 274
%% Shift/Reduce conflict (shift 8, reduce 17) on 'typeof' in state 274
%% Shift/Reduce conflict (shift 7, reduce 17) on 'null' in state 274
%% Shift/Reduce conflict (shift 6, reduce 17) on 'true' in state 274
%% Shift/Reduce conflict (shift 5, reduce 17) on 'false' in state 274
%% Shift/Reduce conflict (shift 4, reduce 17) on 'Identifier' in state 274
%% Shift/Reduce conflict (shift 3, reduce 17) on 'StringLiteral' in state 274
%% Shift/Reduce conflict (shift 2, reduce 17) on 'NumericLiteral' in state 274
%% Shift/Reduce conflict (shift 1, reduce 17) on 'RegexpLiteral' in state 274
%% Shift/Reduce conflict (shift 144, reduce 177) on 'in' in state 242
%% Shift/Reduce conflict (shift 144, reduce 178) on 'in' in state 241
%% Shift/Reduce conflict (shift 144, reduce 179) on 'in' in state 240
%% Shift/Reduce conflict (shift 144, reduce 180) on 'in' in state 239
%% Shift/Reduce conflict (shift 170, reduce 139) on '++' in state 214
%% Shift/Reduce conflict (shift 169, reduce 139) on '--' in state 214
%% Shift/Reduce conflict (shift 168, reduce 139) on '=' in state 214
%% Shift/Reduce conflict (shift 167, reduce 139) on '+=' in state 214
%% Shift/Reduce conflict (shift 166, reduce 139) on '-=' in state 214
%% Shift/Reduce conflict (shift 165, reduce 139) on '*=' in state 214
%% Shift/Reduce conflict (shift 164, reduce 139) on '%=' in state 214
%% Shift/Reduce conflict (shift 163, reduce 139) on '<<=' in state 214
%% Shift/Reduce conflict (shift 162, reduce 139) on '>>=' in state 214
%% Shift/Reduce conflict (shift 161, reduce 139) on '>>>=' in state 214
%% Shift/Reduce conflict (shift 160, reduce 139) on '&=' in state 214
%% Shift/Reduce conflict (shift 159, reduce 139) on 'bor=' in state 214
%% Shift/Reduce conflict (shift 158, reduce 139) on '^=' in state 214
%% Shift/Reduce conflict (shift 157, reduce 139) on '/=' in state 214
%% Shift/Reduce conflict (shift 301, reduce 139) on 'in' in state 214
%% Shift/Reduce conflict (shift 188, reduce 87) on 'finally' in state 190
%% Shift/Reduce conflict (shift 80, reduce 119) on 'colon' in state 125
%% Shift/Reduce conflict (shift 174, reduce 127) on 'lparen' in state 107
%% Shift/Reduce conflict (shift 177, reduce 127) on 'lbracket' in state 107
%% Shift/Reduce conflict (shift 176, reduce 127) on 'dot' in state 107
%% Shift/Reduce conflict (shift 216, reduce 40) on '=' in state 103
%% Shift/Reduce conflict (shift 170, reduce 139) on '++' in state 85
%% Shift/Reduce conflict (shift 169, reduce 139) on '--' in state 85
%% Shift/Reduce conflict (shift 36, reduce 2) on 'lbrace' in state 75
%% Shift/Reduce conflict (shift 35, reduce 2) on 'lparen' in state 75
%% Shift/Reduce conflict (shift 34, reduce 2) on 'lbracket' in state 75
%% Shift/Reduce conflict (shift 33, reduce 2) on 'dot' in state 75
%% Shift/Reduce conflict (shift 32, reduce 2) on 'semicolon' in state 75
%% Shift/Reduce conflict (shift 31, reduce 2) on '+' in state 75
%% Shift/Reduce conflict (shift 30, reduce 2) on '-' in state 75
%% Shift/Reduce conflict (shift 29, reduce 2) on '++' in state 75
%% Shift/Reduce conflict (shift 28, reduce 2) on '--' in state 75
%% Shift/Reduce conflict (shift 27, reduce 2) on '!' in state 75
%% Shift/Reduce conflict (shift 26, reduce 2) on '~' in state 75
%% Shift/Reduce conflict (shift 25, reduce 2) on 'break' in state 75
%% Shift/Reduce conflict (shift 24, reduce 2) on 'new' in state 75
%% Shift/Reduce conflict (shift 23, reduce 2) on 'var' in state 75
%% Shift/Reduce conflict (shift 22, reduce 2) on 'return' in state 75
%% Shift/Reduce conflict (shift 21, reduce 2) on 'void' in state 75
%% Shift/Reduce conflict (shift 20, reduce 2) on 'for' in state 75
%% Shift/Reduce conflict (shift 19, reduce 2) on 'switch' in state 75
%% Shift/Reduce conflict (shift 18, reduce 2) on 'while' in state 75
%% Shift/Reduce conflict (shift 17, reduce 2) on 'continue' in state 75
%% Shift/Reduce conflict (shift 16, reduce 2) on 'function' in state 75
%% Shift/Reduce conflict (shift 15, reduce 2) on 'this' in state 75
%% Shift/Reduce conflict (shift 14, reduce 2) on 'with' in state 75
%% Shift/Reduce conflict (shift 13, reduce 2) on 'if' in state 75
%% Shift/Reduce conflict (shift 12, reduce 2) on 'throw' in state 75
%% Shift/Reduce conflict (shift 11, reduce 2) on 'delete' in state 75
%% Shift/Reduce conflict (shift 10, reduce 2) on 'try' in state 75
%% Shift/Reduce conflict (shift 9, reduce 2) on 'do' in state 75
%% Shift/Reduce conflict (shift 8, reduce 2) on 'typeof' in state 75
%% Shift/Reduce conflict (shift 7, reduce 2) on 'null' in state 75
%% Shift/Reduce conflict (shift 6, reduce 2) on 'true' in state 75
%% Shift/Reduce conflict (shift 5, reduce 2) on 'false' in state 75
%% Shift/Reduce conflict (shift 4, reduce 2) on 'Identifier' in state 75
%% Shift/Reduce conflict (shift 3, reduce 2) on 'StringLiteral' in state 75
%% Shift/Reduce conflict (shift 2, reduce 2) on 'NumericLiteral' in state 75
%% Shift/Reduce conflict (shift 1, reduce 2) on 'RegexpLiteral' in state 75
%% Shift/Reduce conflict (shift 174, reduce 127) on 'lparen' in state 56
%% Shift/Reduce conflict (shift 177, reduce 127) on 'lbracket' in state 56
%% Shift/Reduce conflict (shift 176, reduce 127) on 'dot' in state 56
%% Shift/Reduce conflict (shift 174, reduce 138) on 'lparen' in state 54
%% Shift/Reduce conflict (shift 173, reduce 138) on 'lbracket' in state 54
%% Shift/Reduce conflict (shift 172, reduce 138) on 'dot' in state 54
%% Shift/Reduce conflict (shift 170, reduce 139) on '++' in state 53
%% Shift/Reduce conflict (shift 169, reduce 139) on '--' in state 53
%% Shift/Reduce conflict (shift 168, reduce 139) on '=' in state 53
%% Shift/Reduce conflict (shift 167, reduce 139) on '+=' in state 53
%% Shift/Reduce conflict (shift 166, reduce 139) on '-=' in state 53
%% Shift/Reduce conflict (shift 165, reduce 139) on '*=' in state 53
%% Shift/Reduce conflict (shift 164, reduce 139) on '%=' in state 53
%% Shift/Reduce conflict (shift 163, reduce 139) on '<<=' in state 53
%% Shift/Reduce conflict (shift 162, reduce 139) on '>>=' in state 53
%% Shift/Reduce conflict (shift 161, reduce 139) on '>>>=' in state 53
%% Shift/Reduce conflict (shift 160, reduce 139) on '&=' in state 53
%% Shift/Reduce conflict (shift 159, reduce 139) on 'bor=' in state 53
%% Shift/Reduce conflict (shift 158, reduce 139) on '^=' in state 53
%% Shift/Reduce conflict (shift 157, reduce 139) on '/=' in state 53
%% Shift/Reduce conflict (shift 153, reduce 159) on '+' in state 49
%% Shift/Reduce conflict (shift 152, reduce 159) on '-' in state 49
%% Shift/Reduce conflict (shift 144, reduce 176) on 'in' in state 47

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical token token-6466)) (@@ (system base lalr) lexical-token))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical token token-6466)) (@@ (system base lalr) lexical-token))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical token token-6466)) (@@ (system base lalr) lexical-token))> #t)
wrote `language/ecmascript/parse.go'
  GUILEC language/ecmascript/impl.go

;;; (inferring #<tree-il (lexical t t-888)> #t)

;;; (inferring #<tree-il (lexical t t-894)> #t)

;;; (inferring #<tree-il (lexical t t-908)> #t)

;;; (inferring #<tree-il (lexical t t-923)> #t)

;;; (inferring #<tree-il (lexical t t-933)> #t)

;;; (inferring #<tree-il (lexical t t-946)> #t)

;;; (inferring #<tree-il (lexical t t-958)> #t)

;;; (inferring #<tree-il (lexical t t-971)> #t)

;;; (inferring #<tree-il (lexical t t-984)> #t)

;;; (inferring #<tree-il (lexical t t-996)> #t)

;;; (inferring #<tree-il (lexical t t-1004)> #t)

;;; (inferring #<tree-il (lexical t t-1012)> #t)

;;; (inferring #<tree-il (lexical t t-1020)> #t)

;;; (inferring #<tree-il (lexical t t-1028)> #t)

;;; (inferring #<tree-il (lexical t t-1036)> #t)

;;; (inferring #<tree-il (lexical t t-1044)> #t)

;;; (inferring #<tree-il (lexical t t-1052)> #t)

;;; (inferring #<tree-il (lexical t t-1060)> #t)

;;; (inferring #<tree-il (lexical t t-1068)> #t)

;;; (inferring #<tree-il (lexical t t-1076)> #t)

;;; (inferring #<tree-il (lexical t t-1084)> #t)

;;; (inferring #<tree-il (lexical t t-1092)> #t)

;;; (inferring #<tree-il (lexical t t-1100)> #t)

;;; (inferring #<tree-il (lexical t t-1108)> #t)
wrote `language/ecmascript/impl.go'
  GUILEC language/ecmascript/base.go
language/ecmascript/base.scm:179:31: warning: wrong number of arguments to `object->number'
language/ecmascript/base.scm:95:6: warning: possibly unbound variable `v'
language/ecmascript/base.scm:181:14: warning: possibly unbound variable `o'
language/ecmascript/base.scm:226:22: warning: possibly unbound variable `Boolean'
language/ecmascript/base.scm:227:21: warning: possibly unbound variable `String'
language/ecmascript/base.scm:228:21: warning: possibly unbound variable `Number'

;;; (inferring #<tree-il (lexical t t-934)> #t)

;;; (inferring #<tree-il (lexical t t-936)> #t)

;;; (inferring #<tree-il (lexical t t-938)> #t)

;;; (inferring #<tree-il (lexical t t-940)> #t)

;;; (inferring #<tree-il (lexical t t-942)> #t)

;;; (inferring #<tree-il (lexical t t-944)> #t)

;;; (inferring #<tree-il (lexical t t-951)> #t)

;;; (inferring #<tree-il (lexical t t-960)> #t)

;;; (inferring #<tree-il (lexical t t-972)> #t)

;;; (inferring #<tree-il (lexical t t-991)> #t)

;;; (inferring #<tree-il (lexical t t-1007)> #t)

;;; (inferring #<tree-il (lexical t t-1017)> #t)

;;; (inferring #<tree-il (lexical t t-1027)> #t)

;;; (inferring #<tree-il (lexical t t-1036)> #t)

;;; (inferring #<tree-il (lexical t t-1045)> #t)

;;; (inferring #<tree-il (lexical t t-1056)> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical x x-1148))> #t)

;;; (inferring #<tree-il (lexical x x-1148)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical x x-1148))> #t)

;;; (inferring #<tree-il (lexical t t-1175)> #t)

;;; (inferring #<tree-il (lexical t t-1177)> #t)

;;; (inferring #<tree-il (lexical t t-1186)> #t)

;;; (inferring #<tree-il (lexical t t-1188)> #t)

;;; (inferring #<tree-il (lexical t t-1194)> #t)

;;; (inferring #<tree-il (lexical t t-1196)> #t)

;;; (inferring #<tree-il (lexical t t-1206)> #t)
wrote `language/ecmascript/base.go'
  GUILEC language/ecmascript/function.go
language/ecmascript/function.scm:40:9: warning: possibly unbound variable `<js-array-object>'
language/ecmascript/function.scm:44:43: warning: possibly unbound variable `js-array-vector'

;;; (inferring #<tree-il (apply (primitive null?) (lexical array array-419))> #t)

;;; (inferring #<tree-il (lexical t t-439)> #t)

;;; (inferring #<tree-il (lexical t t-454)> #t)

;;; (inferring #<tree-il (lexical t t-468)> #t)

;;; (inferring #<tree-il (lexical t t-473)> #t)
wrote `language/ecmascript/function.go'
  GUILEC language/ecmascript/array.go

;;; (inferring #<tree-il (lexical t t-634)> #t)

;;; (inferring #<tree-il (lexical t t-743)> #t)

;;; (inferring #<tree-il (lexical t t-753)> #t)

;;; (inferring #<tree-il (lexical t t-783)> #t)

;;; (inferring #<tree-il (lexical t t-794)> #t)
wrote `language/ecmascript/array.go'
  GUILEC language/ecmascript/compile-tree-il.go

;;; (inferring #<tree-il (apply (primitive pair?) (lexical form form-6747))> #t)

;;; (inferring #<tree-il (apply (primitive pair?) (lexical form form-6747))> #t)

;;; (propagate-value value (apply (primitive cdr) (lexical form form-6747)))

;;; (inferring #<tree-il (apply (primitive pair?) (lexical form form-6747))> #f)

;;; (inferring #<tree-il (lexical t t-8708)> #t)

;;; (inferring #<tree-il (lexical t t-8649)> #t)
wrote `language/ecmascript/compile-tree-il.go'
  GUILEC language/ecmascript/spec.go
wrote `language/ecmascript/spec.go'
  GUILEC language/elisp/lexer.go

;;; (inferring #<tree-il (lexical digits digits-642)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical digits digits-642))> #t)

;;; (inferring #<tree-il (lexical t t-721)> #t)

;;; (inferring #<tree-il (lexical t t-724)> #t)

;;; (inferring #<tree-il (lexical t t-955)> #t)
wrote `language/elisp/lexer.go'
  GUILEC language/elisp/parser.go
wrote `language/elisp/parser.go'
  GUILEC language/elisp/bindings.go

;;; (inferring #<tree-il (apply (primitive list?) (lexical syms syms-380))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (apply (primitive list?) (lexical targets targets-396))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)
wrote `language/elisp/bindings.go'
  GUILEC language/elisp/compile-tree-il.go

;;; (inferring #<tree-il (apply (primitive list?) (lexical b b-2016))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical module module-2025) (const lexical))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical always always-2035) (const all))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical always always-2113) (const all))> #t)

;;; (inferring #<tree-il (lexical t t-2140)> #t)

;;; (inferring #<tree-il (lexical t t-2241)> #t)

;;; (inferring #<tree-il (lexical t t-2249)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical syms syms-2261) (const all))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical args args-2420))> #f)

;;; (inferring #<tree-il (apply (primitive null?) (lexical args args-2420))> #f)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical value value-2886) (const all))> #t)
wrote `language/elisp/compile-tree-il.go'
  GUILEC language/elisp/runtime.go
wrote `language/elisp/runtime.go'
  GUILEC language/elisp/runtime/function-slot.go
WARNING: (language elisp runtime function-slot): imported module (language elisp compile-tree-il) overrides core binding `if'
WARNING: (language elisp runtime function-slot): imported module (language elisp compile-tree-il) overrides core binding `let'
WARNING: (language elisp runtime function-slot): imported module (language elisp compile-tree-il) overrides core binding `let*'
WARNING: (language elisp runtime function-slot): imported module (language elisp compile-tree-il) overrides core binding `while'
WARNING: (language elisp runtime function-slot): imported module (language elisp compile-tree-il) overrides core binding `defmacro'
WARNING: (language elisp runtime function-slot): imported module (language elisp compile-tree-il) overrides core binding `quote'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime macros) overrides core binding `lambda'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime macros) overrides core binding `when'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime macros) overrides core binding `unless'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime macros) overrides core binding `cond'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime macros) overrides core binding `and'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime macros) overrides core binding `or'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime macros) overrides core binding `catch'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `='
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `<'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `<='
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `>'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `>='
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `max'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `min'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `abs'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `#{1+}#'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `#{1-}#'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `+'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `-'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `*'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `car'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `cdr'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `length'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `cons'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `list'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `make-list'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `append'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `reverse'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `copy-tree'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `apply'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `throw'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `not'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `eval'
WARNING: (language elisp runtime function-slot): imported module (language elisp runtime subrs) overrides core binding `load'
wrote `language/elisp/runtime/function-slot.go'
  GUILEC language/elisp/runtime/value-slot.go
wrote `language/elisp/runtime/value-slot.go'
  GUILEC language/elisp/runtime/macros.go

;;; (inferring #<tree-il (apply (primitive list?) (lexical cur cur-449))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (lexical t t-800)> #t)

;;; (inferring #<tree-il (apply (primitive list?) (lexical args args-798))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (lexical t t-825)> #t)

;;; (inferring #<tree-il (apply (primitive list?) (lexical args args-823))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)
wrote `language/elisp/runtime/macros.go'
  GUILEC language/elisp/runtime/subrs.go

;;; (inferring #<tree-il (apply (primitive pair?) (lexical el el-834))> #t)

;;; (inferring #<tree-il (lexical t t-1287)> #t)

;;; (inferring #<tree-il (lexical t t-1284)> #t)
wrote `language/elisp/runtime/subrs.go'
  GUILEC language/elisp/spec.go
wrote `language/elisp/spec.go'
  GUILEC language/brainfuck/parse.go
wrote `language/brainfuck/parse.go'
  GUILEC language/brainfuck/compile-scheme.go

;;; (propagate-value value (apply (primitive car) (lexical ins ins-251)))
wrote `language/brainfuck/compile-scheme.go'
  GUILEC language/brainfuck/compile-tree-il.go
wrote `language/brainfuck/compile-tree-il.go'
  GUILEC language/brainfuck/spec.go
wrote `language/brainfuck/spec.go'
  GUILEC statprof.go

;;; (inferring #<tree-il (lexical t t-1066)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical a a-1160) (lexical b b-1161))> #t)
wrote `statprof.go'
  GUILEC sxml/apply-templates.go
wrote `sxml/apply-templates.go'
  GUILEC sxml/fold.go
wrote `sxml/fold.go'
  GUILEC sxml/match.go

;;; (inferring #<tree-il (lexical t t-4235)> #t)

;;; (elide effect (apply (primitive string?) (lexical x x-4967)))

;;; (inferring #<tree-il (apply (primitive string?) (lexical x x-4967))> #t)

;;; (elide effect (apply (primitive char?) (lexical x x-4967)))

;;; (inferring #<tree-il (apply (primitive char?) (lexical x x-4967))> #t)

;;; (elide effect (apply (primitive number?) (lexical x x-4967)))

;;; (inferring #<tree-il (apply (primitive number?) (lexical x x-4967))> #t)

;;; (elide effect (apply (primitive string?) (lexical x x-5966)))

;;; (inferring #<tree-il (apply (primitive string?) (lexical x x-5966))> #t)

;;; (elide effect (apply (primitive char?) (lexical x x-5966)))

;;; (inferring #<tree-il (apply (primitive char?) (lexical x x-5966))> #t)

;;; (elide effect (apply (primitive number?) (lexical x x-5966)))

;;; (inferring #<tree-il (apply (primitive number?) (lexical x x-5966))> #t)

;;; (elide effect (apply (primitive string?) (lexical x x-3406)))

;;; (inferring #<tree-il (apply (primitive string?) (lexical x x-3406))> #t)

;;; (elide effect (apply (primitive char?) (lexical x x-3406)))

;;; (inferring #<tree-il (apply (primitive char?) (lexical x x-3406))> #t)

;;; (elide effect (apply (primitive number?) (lexical x x-3406)))

;;; (inferring #<tree-il (apply (primitive number?) (lexical x x-3406))> #t)

;;; (elide effect (apply (primitive string?) (lexical x x-3445)))

;;; (inferring #<tree-il (apply (primitive string?) (lexical x x-3445))> #t)

;;; (elide effect (apply (primitive char?) (lexical x x-3445)))

;;; (inferring #<tree-il (apply (primitive char?) (lexical x x-3445))> #t)

;;; (elide effect (apply (primitive number?) (lexical x x-3445)))

;;; (inferring #<tree-il (apply (primitive number?) (lexical x x-3445))> #t)
wrote `sxml/match.go'
  GUILEC sxml/simple.go

;;; (inferring #<tree-il (lexical t t-568)> #t)

;;; (inferring #<tree-il (lexical t t-570)> #t)
wrote `sxml/simple.go'
  GUILEC sxml/ssax/input-parse.go

;;; (inferring #<tree-il (lexical t t-1425)> #t)
wrote `sxml/ssax/input-parse.go'
  GUILEC sxml/ssax.go

;;; (inferring #<tree-il (lexical t t-3835)> #t)

;;; (inferring #<tree-il (lexical t t-3923)> #t)

;;; (propagate-value value (apply (primitive car) (lexical token token-3993)))

;;; (elide effect (lexical terminators-usual-eof terminators-usual-eof-4011))

;;; (elide effect (lexical terminators-usual terminators-usual-4010))

;;; (elide effect (if (lexical expect-eof? expect-eof?-4014) (void) (void)))
wrote `sxml/ssax.go'
  GUILEC sxml/transform.go

;;; (inferring #<tree-il (lexical keep? keep?-596)> #t)
wrote `sxml/transform.go'
  GUILEC sxml/xpath.go
wrote `sxml/xpath.go'
  GUILEC texinfo.go

;;; (inferring #<tree-il (apply (primitive eq?) (lexical content content-1620) (const INLINE-TEXT))> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical names names-1776))> #t)

;;; (inferring #<tree-il (lexical t t-1801)> #t)

;;; (elide effect (lexical line line-1790))

;;; (elide effect (const #f))

;;; (elide effect (if (apply (primitive eq?) (lexical length length-1791) (const 1)) (void) (void)))

;;; (elide effect (const ""))

;;; (elide effect (const " "))

;;; (elide effect (if (lexical end? end?-2022) (void) (void)))

;;; (elide effect (const "\n"))

;;; (elide effect (const " "))

;;; (elide effect (if (lexical preserve-ws? preserve-ws?-1929) (void) (void)))

;;; (inferring #<tree-il (lexical sig-ws? sig-ws?-2255)> #t)

;;; (propagate-value value (apply (primitive car) (apply (primitive car) (lexical in in-2541))))
wrote `texinfo.go'
  GUILEC texinfo/docbook.go
wrote `texinfo/docbook.go'
  GUILEC texinfo/html.go
wrote `texinfo/html.go'
  GUILEC texinfo/indexing.go
wrote `texinfo/indexing.go'
  GUILEC texinfo/string-utils.go

;;; (elide effect (lexical rchr rchr-593))

;;; (elide effect (lexical chr chr-592))

;;; (elide effect (if (lexical rchr rchr-593) (void) (void)))
wrote `texinfo/string-utils.go'
  GUILEC texinfo/plain-text.go
wrote `texinfo/plain-text.go'
  GUILEC texinfo/reflection.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical args args-1205))> #t)

;;; (inferring #<tree-il (lexical str str-1292)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical str str-1292))> #t)

;;; (inferring #<tree-il (lexical t t-1305)> #t)
wrote `texinfo/reflection.go'
  GUILEC texinfo/serialize.go

;;; (inferring #<tree-il (apply (primitive null?) (lexical body body-1003))> #t)

;;; (inferring #<tree-il (lexical in in-1077)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical in in-1077))> #t)
wrote `texinfo/serialize.go'
  GUILEC web/client.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-280)) (@@ (web uri) <uri>))> #t)
wrote `web/client.go'
  GUILEC web/http.go

;;; (inferring #<tree-il (lexical t t-4713)> #t)

;;; (inferring #<tree-il (lexical t t-4717)> #t)

;;; (inferring #<tree-il (lexical t t-5128)> #t)

;;; (inferring #<tree-il (lexical t t-5130)> #t)

;;; (inferring #<tree-il (lexical t t-5132)> #t)

;;; (inferring #<tree-il (lexical t t-5134)> #t)

;;; (inferring #<tree-il (lexical t t-5136)> #t)

;;; (inferring #<tree-il (apply (primitive null?) (lexical val val-5250))> #t)

;;; (inferring #<tree-il (lexical val val-5428)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical val val-5428))> #t)

;;; (inferring #<tree-il (lexical t t-5439)> #t)

;;; (inferring #<tree-il (lexical t t-5441)> #t)

;;; (inferring #<tree-il (lexical comma comma-5454)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical comma comma-5454))> #t)

;;; (inferring #<tree-il (lexical t t-5496)> #t)

;;; (inferring #<tree-il (lexical comma comma-6658)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical comma comma-6658))> #t)

;;; (inferring #<tree-il (lexical t t-6700)> #t)

;;; (inferring #<tree-il (lexical f f-6906)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical f f-6906))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-6949)) (@@ (web uri) <uri>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-6949)) (@@ (web uri) <uri>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-6949)) (@@ (web uri) <uri>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical val val-7173) (const *))> #t)

;;; (inferring #<tree-il (lexical v v-7220)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical v v-7220))> #t)

;;; (inferring #<tree-il (lexical v v-7220)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical v v-7220))> #t)

;;; (inferring #<tree-il (lexical v v-7220)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical v v-7220))> #t)

;;; (inferring #<tree-il (lexical date date-7343)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical date date-7343))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical x x-7372) (const *))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical x x-7380) (const *))> #t)

;;; (inferring #<tree-il (lexical v v-7406)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical v v-7406))> #t)

;;; (inferring #<tree-il (lexical t t-7426)> #t)

;;; (inferring #<tree-il (lexical x x-7458)> #t)

;;; (inferring #<tree-il (lexical x x-7458)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical x x-7458))> #t)

;;; (inferring #<tree-il (lexical y y-7459)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical y y-7459))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (lexical val val-7512) (const *))> #t)
wrote `web/http.go'
  GUILEC web/request.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-1449)) (@@ (web uri) <uri>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical r r-1533)) (toplevel <request>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical r r-1533)) (toplevel <request>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical r r-1533)) (toplevel <request>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical r r-1533)) (toplevel <request>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical r r-1533)) (toplevel <request>))> #t)
wrote `web/request.go'
  GUILEC web/response.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical response response-1194)) (toplevel <response>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical r r-1287)) (toplevel <response>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical r r-1287)) (toplevel <response>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical r r-1287)) (toplevel <response>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical r r-1378)) (toplevel <response>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical r r-1378)) (toplevel <response>))> #t)
wrote `web/response.go'
  GUILEC web/server.go

;;; (elide effect (lexical declared-charset declared-charset-1190))

;;; (elide effect (const "utf-8"))

;;; (elide effect (if (lexical declared-charset declared-charset-1190) (void) (void)))

;;; (inferring #<tree-il (lexical declared-charset declared-charset-1190)> #f)

;;; (elide effect (lexical declared-charset declared-charset-1217))

;;; (elide effect (const "utf-8"))

;;; (elide effect (if (lexical declared-charset declared-charset-1217) (void) (void)))

;;; (inferring #<tree-il (lexical declared-charset declared-charset-1217)> #f)

;;; (inferring #<tree-il (lexical body body-1149)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical request request-1147)) (@@ (web request) <request>))> #t)
wrote `web/server.go'
  GUILEC web/server/http.go

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical server server-738)) (toplevel <http-server>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical response response-837)) (@@ (web response) <response>))> #t)

;;; (inferring #<tree-il (lexical t t-839)> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical response response-837)) (@@ (web response) <response>))> #t)
wrote `web/server/http.go'
  GUILEC web/uri.go

;;; (inferring #<tree-il (lexical userinfo userinfo-1126)> #t)

;;; (inferring #<tree-il (apply (primitive string?) (lexical host host-1127))> #f)

;;; (inferring #<tree-il (apply (primitive not) (const #f))> #t)

;;; (inferring #<tree-il (lexical port port-1272)> #f)

;;; (inferring #<tree-il (apply (primitive not) (lexical port port-1272))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-1280)) (toplevel <uri>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-1280)) (toplevel <uri>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-1280)) (toplevel <uri>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-1280)) (toplevel <uri>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-1280)) (toplevel <uri>))> #t)

;;; (inferring #<tree-il (apply (primitive eq?) (apply (primitive struct-vtable) (lexical uri uri-1280)) (toplevel <uri>))> #t)
wrote `web/uri.go'
make[2]: Leaving directory `/home/wingo/src/guile/module'
Making all in guile-readline
make[2]: Entering directory `/home/wingo/src/guile/guile-readline'
make  all-am
make[3]: Entering directory `/home/wingo/src/guile/guile-readline'
make[3]: Nothing to be done for `all-am'.
make[3]: Leaving directory `/home/wingo/src/guile/guile-readline'
make[2]: Leaving directory `/home/wingo/src/guile/guile-readline'
Making all in examples
make[2]: Entering directory `/home/wingo/src/guile/examples'
make[2]: Nothing to be done for `all'.
make[2]: Leaving directory `/home/wingo/src/guile/examples'
Making all in emacs
make[2]: Entering directory `/home/wingo/src/guile/emacs'
make[2]: Nothing to be done for `all'.
make[2]: Leaving directory `/home/wingo/src/guile/emacs'
Making all in test-suite
make[2]: Entering directory `/home/wingo/src/guile/test-suite'
Making all in standalone
make[3]: Entering directory `/home/wingo/src/guile/test-suite/standalone'
make  all-am
make[4]: Entering directory `/home/wingo/src/guile/test-suite/standalone'
make[4]: Nothing to be done for `all-am'.
make[4]: Leaving directory `/home/wingo/src/guile/test-suite/standalone'
make[3]: Leaving directory `/home/wingo/src/guile/test-suite/standalone'
Making all in vm
make[3]: Entering directory `/home/wingo/src/guile/test-suite/vm'
make[3]: Nothing to be done for `all'.
make[3]: Leaving directory `/home/wingo/src/guile/test-suite/vm'
make[3]: Entering directory `/home/wingo/src/guile/test-suite'
make[3]: Nothing to be done for `all-am'.
make[3]: Leaving directory `/home/wingo/src/guile/test-suite'
make[2]: Leaving directory `/home/wingo/src/guile/test-suite'
Making all in benchmark-suite
make[2]: Entering directory `/home/wingo/src/guile/benchmark-suite'
make[2]: Nothing to be done for `all'.
make[2]: Leaving directory `/home/wingo/src/guile/benchmark-suite'
Making all in gc-benchmarks
make[2]: Entering directory `/home/wingo/src/guile/gc-benchmarks'
make[2]: Nothing to be done for `all'.
make[2]: Leaving directory `/home/wingo/src/guile/gc-benchmarks'
Making all in am
make[2]: Entering directory `/home/wingo/src/guile/am'
make[2]: Nothing to be done for `all'.
make[2]: Leaving directory `/home/wingo/src/guile/am'
Making all in doc
make[2]: Entering directory `/home/wingo/src/guile/doc'
Making all in ref
make[3]: Entering directory `/home/wingo/src/guile/doc/ref'
make  all-am
make[4]: Entering directory `/home/wingo/src/guile/doc/ref'
make[4]: Nothing to be done for `all-am'.
make[4]: Leaving directory `/home/wingo/src/guile/doc/ref'
make[3]: Leaving directory `/home/wingo/src/guile/doc/ref'
Making all in r5rs
make[3]: Entering directory `/home/wingo/src/guile/doc/r5rs'
make[3]: Nothing to be done for `all'.
make[3]: Leaving directory `/home/wingo/src/guile/doc/r5rs'
make[3]: Entering directory `/home/wingo/src/guile/doc'
make[3]: Nothing to be done for `all-am'.
make[3]: Leaving directory `/home/wingo/src/guile/doc'
make[2]: Leaving directory `/home/wingo/src/guile/doc'
make[2]: Entering directory `/home/wingo/src/guile'
make[2]: Leaving directory `/home/wingo/src/guile'
make[1]: Leaving directory `/home/wingo/src/guile'