diff --git a/core/alien/compiler/compiler-tests.factor b/core/alien/compiler/compiler-tests.factor
index dd2d9587cb..d1a14dd758 100755
--- a/core/alien/compiler/compiler-tests.factor
+++ b/core/alien/compiler/compiler-tests.factor
@@ -3,7 +3,7 @@ USING: alien alien.c-types alien.syntax compiler kernel
 namespaces namespaces tools.test sequences inference words
 arrays parser quotations continuations inference.backend effects
 namespaces.private io io.streams.string memory system threads
-tools.test ;
+tools.test math ;
 
 FUNCTION: void ffi_test_0 ;
 [ ] [ ffi_test_0 ] unit-test
@@ -280,6 +280,10 @@ FUNCTION: double ffi_test_36 ( test-struct-12 x ) ;
 
 [ 1.23456 ] [ 1.23456 make-struct-12 ffi_test_36 ] unit-test
 
+FUNCTION: ulonglong ffi_test_38 ( ulonglong x, ulonglong y ) ;
+
+[ t ] [ 31 2^ 32 2^ ffi_test_38 63 2^ = ] unit-test
+
 ! Test callbacks
 
 : callback-1 "void" { } "cdecl" [ ] alien-callback ;
@@ -354,3 +358,14 @@ FUNCTION: double ffi_test_36 ( test-struct-12 x ) ;
     ] alien-callback ;
 
 [ ] [ callback-8 callback_test_1 ] unit-test
+
+: callback-9
+    "int" { "int" "int" "int" } "cdecl" [
+        + + 1+
+    ] alien-callback ;
+
+FUNCTION: int ffi_test_37 ( void* func ) ;
+
+[ 1 ] [ callback-9 ffi_test_37 ] unit-test
+
+[ 7 ] [ callback-9 ffi_test_37 ] unit-test
diff --git a/core/alien/compiler/compiler.factor b/core/alien/compiler/compiler.factor
index b6fcbe6176..9bd65aa0bc 100755
--- a/core/alien/compiler/compiler.factor
+++ b/core/alien/compiler/compiler.factor
@@ -403,7 +403,6 @@ TUPLE: callback-context ;
 : generate-callback ( node -- )
     dup xt>> dup [
         init-templates
-        %save-word-xt
         %prologue-later
         dup alien-stack-frame [
             dup registers>objects
diff --git a/core/bootstrap/primitives.factor b/core/bootstrap/primitives.factor
index f1e41ac2b6..061866fe3e 100755
--- a/core/bootstrap/primitives.factor
+++ b/core/bootstrap/primitives.factor
@@ -58,16 +58,13 @@ num-types get f <array> builtins set
     "alien.accessors"
     "arrays"
     "bit-arrays"
-    "bit-vectors"
     "byte-arrays"
-    "byte-vectors"
     "classes.private"
     "classes.tuple"
     "classes.tuple.private"
     "compiler.units"
     "continuations.private"
     "float-arrays"
-    "float-vectors"
     "generator"
     "growable"
     "hashtables"
@@ -455,54 +452,6 @@ tuple
     }
 } define-tuple-class
 
-"byte-vector" "byte-vectors" create
-tuple
-{
-    {
-        { "byte-array" "byte-arrays" }
-        "underlying"
-        { "underlying" "growable" }
-        { "set-underlying" "growable" }
-    } {
-        { "array-capacity" "sequences.private" }
-        "fill"
-        { "length" "sequences" }
-        { "set-fill" "growable" }
-    }
-} define-tuple-class
-
-"bit-vector" "bit-vectors" create
-tuple
-{
-    {
-        { "bit-array" "bit-arrays" }
-        "underlying"
-        { "underlying" "growable" }
-        { "set-underlying" "growable" }
-    } {
-        { "array-capacity" "sequences.private" }
-        "fill"
-        { "length" "sequences" }
-        { "set-fill" "growable" }
-    }
-} define-tuple-class
-
-"float-vector" "float-vectors" create
-tuple
-{
-    {
-        { "float-array" "float-arrays" }
-        "underlying"
-        { "underlying" "growable" }
-        { "set-underlying" "growable" }
-    } {
-        { "array-capacity" "sequences.private" }
-        "fill"
-        { "length" "sequences" }
-        { "set-fill" "growable" }
-    }
-} define-tuple-class
-
 "curry" "kernel" create
 tuple
 {
diff --git a/core/bootstrap/stage2.factor b/core/bootstrap/stage2.factor
index ca90587ea9..dfd2e4be6f 100755
--- a/core/bootstrap/stage2.factor
+++ b/core/bootstrap/stage2.factor
@@ -27,10 +27,6 @@ SYMBOL: bootstrap-time
     diff
     [ "bootstrap." prepend require ] each ;
 
-! : compile-remaining ( -- )
-!     "Compiling remaining words..." print flush
-!     vocabs [ words [ compiled? not ] subset compile ] each ;
-
 : count-words ( pred -- )
     all-words swap subset length number>string write ;
 
diff --git a/core/bootstrap/syntax.factor b/core/bootstrap/syntax.factor
index 4d5f31dc82..4b74804749 100755
--- a/core/bootstrap/syntax.factor
+++ b/core/bootstrap/syntax.factor
@@ -14,16 +14,13 @@ IN: bootstrap.syntax
     ";"
     "<PRIVATE"
     "?{"
-    "?V{"
     "BIN:"
     "B{"
-    "BV{"
     "C:"
     "CHAR:"
     "DEFER:"
     "ERROR:"
     "F{"
-    "FV{"
     "FORGET:"
     "GENERIC#"
     "GENERIC:"
diff --git a/core/classes/algebra/algebra-tests.factor b/core/classes/algebra/algebra-tests.factor
index d61b62af3b..dba97c16f5 100755
--- a/core/classes/algebra/algebra-tests.factor
+++ b/core/classes/algebra/algebra-tests.factor
@@ -4,7 +4,7 @@ kernel math namespaces parser prettyprint sequences strings
 tools.test vectors words quotations classes classes.algebra
 classes.private classes.union classes.mixin classes.predicate
 vectors definitions source-files compiler.units growable
-random inference effects kernel.private ;
+random inference effects kernel.private sbufs ;
 
 : class= [ class< ] 2keep swap class< and ;
 
@@ -144,6 +144,48 @@ UNION: z1 b1 c1 ;
 
 [ f ] [ null class-not null class= ] unit-test
 
+[ t ] [
+    fixnum class-not
+    fixnum fixnum class-not class-or
+    class<
+] unit-test
+
+! Test method inlining
+[ f ] [ fixnum { } min-class ] unit-test
+
+[ string ] [
+    \ string
+    [ integer string array reversed sbuf
+    slice vector quotation ]
+    sort-classes min-class
+] unit-test
+
+[ fixnum ] [
+    \ fixnum
+    [ fixnum integer object ]
+    sort-classes min-class
+] unit-test
+
+[ integer ] [
+    \ fixnum
+    [ integer float object ]
+    sort-classes min-class
+] unit-test
+
+[ object ] [
+    \ word
+    [ integer float object ]
+    sort-classes min-class
+] unit-test
+
+[ reversed ] [
+    \ reversed
+    [ integer reversed slice ]
+    sort-classes min-class
+] unit-test
+
+[ f ] [ null { number fixnum null } min-class ] unit-test
+
 ! Test for hangs?
 : random-class classes random ;
 
diff --git a/core/classes/algebra/algebra.factor b/core/classes/algebra/algebra.factor
index b7a3e074e5..f2941e3cef 100755
--- a/core/classes/algebra/algebra.factor
+++ b/core/classes/algebra/algebra.factor
@@ -77,10 +77,10 @@ C: <anonymous-complement> anonymous-complement
         { [ 2dup [ anonymous-complement? ] both? ] [ anonymous-complement< ] }
         { [ over anonymous-union? ] [ left-anonymous-union< ] }
         { [ over anonymous-intersection? ] [ left-anonymous-intersection< ] }
-        { [ over anonymous-complement? ] [ 2drop f ] }
         { [ over members ] [ left-union-class< ] }
         { [ dup anonymous-union? ] [ right-anonymous-union< ] }
         { [ dup anonymous-intersection? ] [ right-anonymous-intersection< ] }
+        { [ over anonymous-complement? ] [ 2drop f ] }
         { [ dup anonymous-complement? ] [ class>> classes-intersect? not ] }
         { [ dup members ] [ right-union-class< ] }
         { [ over superclass ] [ superclass< ] }
@@ -193,9 +193,8 @@ C: <anonymous-complement> anonymous-complement
     [ ] unfold nip ;
 
 : min-class ( class seq -- class/f )
-    [ dupd classes-intersect? ] subset dup empty? [
-        2drop f
-    ] [
+    over [ classes-intersect? ] curry subset
+    dup empty? [ 2drop f ] [
         tuck [ class< ] with all? [ peek ] [ drop f ] if
     ] if ;
 
diff --git a/core/compiler/tests/simple.factor b/core/compiler/tests/simple.factor
index dce2ec562a..bc9c56864c 100755
--- a/core/compiler/tests/simple.factor
+++ b/core/compiler/tests/simple.factor
@@ -1,6 +1,6 @@
 USING: compiler.units tools.test kernel kernel.private
 sequences.private math.private math combinators strings
-alien arrays memory ;
+alien arrays memory vocabs parser ;
 IN: compiler.tests
 
 ! Test empty word
@@ -230,3 +230,11 @@ M: f single-combination-test-2 single-combination-test-4 ;
 
 ! Regression
 [ 100 ] [ [ 100 [ [ ] times ] keep ] compile-call ] unit-test
+
+! Regression
+10 [
+    [ "compiler.tests.foo" forget-vocab ] with-compilation-unit
+    [ t ] [
+        "USING: prettyprint words ; IN: compiler.tests.foo : (recursive) (  -- ) (recursive) (recursive) ; inline : recursive ( -- ) (recursive) ; \\ (recursive) compiled?" eval
+    ] unit-test
+] times
diff --git a/core/compiler/tests/templates.factor b/core/compiler/tests/templates.factor
index 845189ce2c..14d75cdc03 100755
--- a/core/compiler/tests/templates.factor
+++ b/core/compiler/tests/templates.factor
@@ -3,7 +3,7 @@ USING: arrays compiler kernel kernel.private math
 hashtables.private math.private namespaces sequences
 sequences.private tools.test namespaces.private slots.private
 sequences.private byte-arrays alien alien.accessors layouts
-words definitions compiler.units io combinators ;
+words definitions compiler.units io combinators vectors ;
 IN: compiler.tests
 
 ! Oops!
@@ -246,3 +246,12 @@ TUPLE: my-tuple ;
     } cleave ;
 
 [ t ] [ \ float-spill-bug compiled? ] unit-test
+
+! Regression
+: dispatch-alignment-regression ( -- c )
+    { tuple vector } 3 slot { word } declare
+    dup 1 slot 0 fixnum-bitand { [ ] } dispatch ;
+
+[ t ] [ \ dispatch-alignment-regression compiled? ] unit-test
+
+[ vector ] [ dispatch-alignment-regression ] unit-test
diff --git a/core/cpu/architecture/architecture.factor b/core/cpu/architecture/architecture.factor
index 65d1763ea8..4e939bddb8 100755
--- a/core/cpu/architecture/architecture.factor
+++ b/core/cpu/architecture/architecture.factor
@@ -56,7 +56,7 @@ HOOK: %call cpu ( word -- )
 HOOK: %jump-label cpu ( label -- )
 
 ! Test if vreg is 'f' or not
-HOOK: %jump-t cpu ( label -- )
+HOOK: %jump-f cpu ( label -- )
 
 HOOK: %dispatch cpu ( -- )
 
@@ -187,6 +187,9 @@ HOOK: %unbox-any-c-ptr cpu ( dst src -- )
 
 HOOK: %box-alien cpu ( dst src -- )
 
+! GC check
+HOOK: %gc cpu
+
 : operand ( var -- op ) get v>operand ; inline
 
 : unique-operands ( operands quot -- )
diff --git a/core/cpu/ppc/allot/allot.factor b/core/cpu/ppc/allot/allot.factor
index 34ea82dc4e..49c77c65ed 100755
--- a/core/cpu/ppc/allot/allot.factor
+++ b/core/cpu/ppc/allot/allot.factor
@@ -1,4 +1,4 @@
-! Copyright (C) 2006, 2007 Slava Pestov.
+! Copyright (C) 2006, 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: kernel cpu.ppc.architecture cpu.ppc.assembler
 kernel.private namespaces math sequences generic arrays
@@ -7,7 +7,7 @@ cpu.architecture alien ;
 IN: cpu.ppc.allot
 
 : load-zone-ptr ( reg -- )
-    "nursery" f pick %load-dlsym dup 0 LWZ ;
+    >r "nursery" f r> %load-dlsym ;
 
 : %allot ( header size -- )
     #! Store a pointer to 'size' bytes allocated from the
@@ -25,6 +25,19 @@ IN: cpu.ppc.allot
 : %store-tagged ( reg tag -- )
     >r dup fresh-object v>operand 11 r> tag-number ORI ;
 
+M: ppc %gc
+    "end" define-label
+    12 load-zone-ptr
+    11 12 cell LWZ ! nursery.here -> r11
+    12 12 3 cells LWZ ! nursery.end -> r12
+    11 11 1024 ADDI ! add ALLOT_BUFFER_ZONE to here
+    11 0 12 CMP ! is here >= end?
+    "end" get BLE
+    0 frame-required
+    %prepare-alien-invoke
+    "minor_gc" f %alien-invoke
+    "end" resolve-label ;
+
 : %allot-float ( reg -- )
     #! exits with tagged ptr to object in r12, untagged in r11
     float 16 %allot
diff --git a/core/cpu/ppc/architecture/architecture.factor b/core/cpu/ppc/architecture/architecture.factor
index 09ffead029..1799411021 100755
--- a/core/cpu/ppc/architecture/architecture.factor
+++ b/core/cpu/ppc/architecture/architecture.factor
@@ -106,8 +106,8 @@ M: ppc %call ( label -- ) BL ;
 
 M: ppc %jump-label ( label -- ) B ;
 
-M: ppc %jump-t ( label -- )
-    0 "flag" operand f v>operand CMPI BNE ;
+M: ppc %jump-f ( label -- )
+    0 "flag" operand f v>operand CMPI BEQ ;
 
 M: ppc %dispatch ( -- )
     [
diff --git a/core/cpu/ppc/intrinsics/intrinsics.factor b/core/cpu/ppc/intrinsics/intrinsics.factor
index d092473960..34e9900893 100755
--- a/core/cpu/ppc/intrinsics/intrinsics.factor
+++ b/core/cpu/ppc/intrinsics/intrinsics.factor
@@ -217,11 +217,11 @@ IN: cpu.ppc.intrinsics
     2array define-if-intrinsics ;
 
 {
-    { fixnum< BLT }
-    { fixnum<= BLE }
-    { fixnum> BGT }
-    { fixnum>= BGE }
-    { eq? BEQ }
+    { fixnum< BGE }
+    { fixnum<= BGT }
+    { fixnum> BLE }
+    { fixnum>= BLT }
+    { eq? BNE }
 } [
     first2 define-fixnum-jump
 ] each
@@ -356,11 +356,11 @@ IN: cpu.ppc.intrinsics
     { { float "x" } { float "y" } } define-if-intrinsic ;
 
 {
-    { float< BLT }
-    { float<= BLE }
-    { float> BGT }
-    { float>= BGE }
-    { float= BEQ }
+    { float< BGE }
+    { float<= BGT }
+    { float> BLE }
+    { float>= BLT }
+    { float= BNE }
 } [
     first2 define-float-jump
 ] each
diff --git a/core/cpu/x86/32/32.factor b/core/cpu/x86/32/32.factor
index cc3fceff23..50e38f2082 100755
--- a/core/cpu/x86/32/32.factor
+++ b/core/cpu/x86/32/32.factor
@@ -16,8 +16,9 @@ IN: cpu.x86.32
 M: x86.32 ds-reg ESI ;
 M: x86.32 rs-reg EDI ;
 M: x86.32 stack-reg ESP ;
-M: x86.32 xt-reg ECX ;
 M: x86.32 stack-save-reg EDX ;
+M: x86.32 temp-reg-1 EAX ;
+M: x86.32 temp-reg-2 ECX ;
 
 M: temp-reg v>operand drop EBX ;
 
@@ -267,7 +268,7 @@ os windows? [
     EDX 26 SHR
     EDX 1 AND
     { EAX EBX ECX EDX } [ POP ] each
-    JNE
+    JE
 ] { } define-if-intrinsic
 
 "-no-sse2" cli-args member? [
diff --git a/core/cpu/x86/64/64.factor b/core/cpu/x86/64/64.factor
index 811387675a..d79ce58d88 100755
--- a/core/cpu/x86/64/64.factor
+++ b/core/cpu/x86/64/64.factor
@@ -11,8 +11,9 @@ IN: cpu.x86.64
 M: x86.64 ds-reg R14 ;
 M: x86.64 rs-reg R15 ;
 M: x86.64 stack-reg RSP ;
-M: x86.64 xt-reg RCX ;
 M: x86.64 stack-save-reg RSI ;
+M: x86.64 temp-reg-1 RAX ;
+M: x86.64 temp-reg-2 RCX ;
 
 M: temp-reg v>operand drop RBX ;
 
diff --git a/core/cpu/x86/allot/allot.factor b/core/cpu/x86/allot/allot.factor
index f236cdcfa6..63870f94cd 100755
--- a/core/cpu/x86/allot/allot.factor
+++ b/core/cpu/x86/allot/allot.factor
@@ -16,12 +16,12 @@ IN: cpu.x86.allot
 
 : object@ ( n -- operand ) cells (object@) ;
 
-: load-zone-ptr ( -- )
+: load-zone-ptr ( reg -- )
     #! Load pointer to start of zone array
-    "nursery" f allot-reg %alien-global ;
+    0 MOV "nursery" f rc-absolute-cell rel-dlsym ;
 
 : load-allot-ptr ( -- )
-    load-zone-ptr
+    allot-reg load-zone-ptr
     allot-reg PUSH
     allot-reg dup cell [+] MOV ;
 
@@ -29,6 +29,19 @@ IN: cpu.x86.allot
     allot-reg POP
     allot-reg cell [+] swap 8 align ADD ;
 
+M: x86 %gc ( -- )
+    "end" define-label
+    temp-reg-1 load-zone-ptr
+    temp-reg-2 temp-reg-1 cell [+] MOV
+    temp-reg-2 1024 ADD
+    temp-reg-1 temp-reg-1 3 cells [+] MOV
+    temp-reg-2 temp-reg-1 CMP
+    "end" get JLE
+    0 frame-required
+    %prepare-alien-invoke
+    "minor_gc" f %alien-invoke
+    "end" resolve-label ;
+
 : store-header ( header -- )
     0 object@ swap type-number tag-fixnum MOV ;
 
diff --git a/core/cpu/x86/architecture/architecture.factor b/core/cpu/x86/architecture/architecture.factor
index 25bb3c6e07..7e7ff8a334 100755
--- a/core/cpu/x86/architecture/architecture.factor
+++ b/core/cpu/x86/architecture/architecture.factor
@@ -9,7 +9,6 @@ IN: cpu.x86.architecture
 HOOK: ds-reg cpu
 HOOK: rs-reg cpu
 HOOK: stack-reg cpu
-HOOK: xt-reg cpu
 HOOK: stack-save-reg cpu
 
 : stack@ stack-reg swap [+] ;
@@ -35,6 +34,10 @@ GENERIC: push-return-reg ( reg-class -- )
 GENERIC: load-return-reg ( stack@ reg-class -- )
 GENERIC: store-return-reg ( stack@ reg-class -- )
 
+! Only used by inline allocation
+HOOK: temp-reg-1 cpu
+HOOK: temp-reg-2 cpu
+
 HOOK: address-operand cpu ( address -- operand )
 
 HOOK: fixnum>slot@ cpu
@@ -47,13 +50,13 @@ M: x86 stack-frame ( n -- i )
     3 cells + 16 align cell - ;
 
 M: x86 %save-word-xt ( -- )
-    xt-reg 0 MOV rc-absolute-cell rel-this ;
+    temp-reg v>operand 0 MOV rc-absolute-cell rel-this ;
 
 : factor-area-size 4 cells ;
 
 M: x86 %prologue ( n -- )
     dup cell + PUSH
-    xt-reg PUSH
+    temp-reg v>operand PUSH
     stack-reg swap 2 cells - SUB ;
 
 M: x86 %epilogue ( n -- )
@@ -76,8 +79,8 @@ M: x86 %call ( label -- ) CALL ;
 
 M: x86 %jump-label ( label -- ) JMP ;
 
-M: x86 %jump-t ( label -- )
-    "flag" operand f v>operand CMP JNE ;
+M: x86 %jump-f ( label -- )
+    "flag" operand f v>operand CMP JE ;
 
 : code-alignment ( -- n )
     building get length dup cell align swap - ;
diff --git a/core/cpu/x86/intrinsics/intrinsics.factor b/core/cpu/x86/intrinsics/intrinsics.factor
index 80a786c9fa..c48f33b765 100755
--- a/core/cpu/x86/intrinsics/intrinsics.factor
+++ b/core/cpu/x86/intrinsics/intrinsics.factor
@@ -212,11 +212,11 @@ IN: cpu.x86.intrinsics
     2array define-if-intrinsics ;
 
 {
-    { fixnum< JL }
-    { fixnum<= JLE }
-    { fixnum> JG }
-    { fixnum>= JGE }
-    { eq? JE }
+    { fixnum< JGE }
+    { fixnum<= JG }
+    { fixnum> JLE }
+    { fixnum>= JL }
+    { eq? JNE }
 } [
     first2 define-fixnum-jump
 ] each
diff --git a/core/cpu/x86/sse2/sse2.factor b/core/cpu/x86/sse2/sse2.factor
index 9c477b4132..fb96649753 100755
--- a/core/cpu/x86/sse2/sse2.factor
+++ b/core/cpu/x86/sse2/sse2.factor
@@ -27,11 +27,11 @@ IN: cpu.x86.sse2
     { { float "x" } { float "y" } } define-if-intrinsic ;
 
 {
-    { float< JB }
-    { float<= JBE }
-    { float> JA }
-    { float>= JAE }
-    { float= JE }
+    { float< JAE }
+    { float<= JA }
+    { float> JBE }
+    { float>= JB }
+    { float= JNE }
 } [
     first2 define-float-jump
 ] each
diff --git a/core/generator/generator.factor b/core/generator/generator.factor
index 919e89d3c8..390dc28d8e 100755
--- a/core/generator/generator.factor
+++ b/core/generator/generator.factor
@@ -40,16 +40,16 @@ SYMBOL: current-label-start
     compiled-stack-traces?
     compiling-word get f ?
     1vector literal-table set
-    f compiling-word get compiled get set-at ;
+    f compiling-label get compiled get set-at ;
 
-: finish-compiling ( literals relocation labels code -- )
+: save-machine-code ( literals relocation labels code -- )
     4array compiling-label get compiled get set-at ;
 
 : with-generator ( node word label quot -- )
     [
         >r begin-compiling r>
         { } make fixup
-        finish-compiling
+        save-machine-code
     ] with-scope ; inline
 
 GENERIC: generate-node ( node -- next )
@@ -131,14 +131,14 @@ M: #loop generate-node
 
 : generate-if ( node label -- next )
     <label> [
-        >r >r node-children first2 generate-branch
+        >r >r node-children first2 swap generate-branch
         r> r> end-false-branch resolve-label
         generate-branch
         init-templates
     ] keep resolve-label iterate-next ;
 
 M: #if generate-node
-    [ <label> dup %jump-t ]
+    [ <label> dup %jump-f ]
     H{ { +input+ { { f "flag" } } } }
     with-template
     generate-if ;
@@ -189,13 +189,13 @@ M: #dispatch generate-node
     "if-intrinsics" set-word-prop ;
 
 : if>boolean-intrinsic ( quot -- )
-    "true" define-label
+    "false" define-label
     "end" define-label
-    "true" get swap call
-    f "if-scratch" get load-literal
-    "end" get %jump-label
-    "true" resolve-label
+    "false" get swap call
     t "if-scratch" get load-literal
+    "end" get %jump-label
+    "false" resolve-label
+    f "if-scratch" get load-literal
     "end" resolve-label
     "if-scratch" get phantom-push ; inline
 
diff --git a/core/generator/registers/registers.factor b/core/generator/registers/registers.factor
index 627f51acc2..a3198784ee 100755
--- a/core/generator/registers/registers.factor
+++ b/core/generator/registers/registers.factor
@@ -65,9 +65,7 @@ M: float-regs move-spec drop float ;
 M: float-regs operand-class* drop float ;
 
 ! Temporary register for stack shuffling
-TUPLE: temp-reg reg-class>> ;
-
-: temp-reg T{ temp-reg f int-regs } ;
+SINGLETON: temp-reg
 
 M: temp-reg move-spec drop f ;
 
@@ -470,11 +468,6 @@ M: loc lazy-store
 : finalize-contents ( -- )
     finalize-locs finalize-vregs reset-phantoms ;
 
-: %gc ( -- )
-    0 frame-required
-    %prepare-alien-invoke
-    "simple_gc" f %alien-invoke ;
-
 ! Loading stacks to vregs
 : free-vregs? ( int# float# -- ? )
     double-float-regs free-vregs length <=
diff --git a/core/generic/generic.factor b/core/generic/generic.factor
index caae16e8ed..6c59d76d07 100755
--- a/core/generic/generic.factor
+++ b/core/generic/generic.factor
@@ -29,6 +29,9 @@ PREDICATE: method-spec < pair
 : order ( generic -- seq )
     "methods" word-prop keys sort-classes ;
 
+: specific-method ( class word -- class )
+    order min-class ;
+
 GENERIC: effective-method ( ... generic -- method )
 
 : next-method-class ( class generic -- class/f )
diff --git a/core/generic/standard/engines/tuple/tuple.factor b/core/generic/standard/engines/tuple/tuple.factor
index 0ffd953d77..7639d1d499 100644
--- a/core/generic/standard/engines/tuple/tuple.factor
+++ b/core/generic/standard/engines/tuple/tuple.factor
@@ -1,8 +1,11 @@
-IN: generic.standard.engines.tuple
+! Copyright (c) 2008 Slava Pestov
+! See http://factorcode.org/license.txt for BSD license.
 USING: kernel classes.tuple.private hashtables assocs sorting
 accessors combinators sequences slots.private math.parser words
 effects namespaces generic generic.standard.engines
-classes.algebra math math.private quotations arrays ;
+classes.algebra math math.private kernel.private
+quotations arrays ;
+IN: generic.standard.engines.tuple
 
 TUPLE: echelon-dispatch-engine n methods ;
 
@@ -27,14 +30,7 @@ TUPLE: tuple-dispatch-engine echelons ;
 
 : <tuple-dispatch-engine> ( methods -- engine )
     echelon-sort
-    [
-        over zero? [
-            dup assoc-empty?
-            [ drop f ] [ values first ] if
-        ] [
-            dupd <echelon-dispatch-engine>
-        ] if
-    ] assoc-map [ nip ] assoc-subset
+    [ dupd <echelon-dispatch-engine> ] assoc-map
     \ tuple-dispatch-engine boa ;
 
 : convert-tuple-methods ( assoc -- assoc' )
@@ -48,52 +44,51 @@ M: trivial-tuple-dispatch-engine engine>quot
     >alist V{ } clone [ hashcode 1array ] distribute-buckets
     [ <trivial-tuple-dispatch-engine> ] map ;
 
+: word-hashcode% [ 1 slot ] % ;
+
 : class-hash-dispatch-quot ( methods -- quot )
-    #! 1 slot == word hashcode
     [
-        [ dup 1 slot ] %
+        \ dup ,
+        word-hashcode%
         hash-methods [ engine>quot ] map hash-dispatch-quot %
     ] [ ] make ;
 
-: tuple-dispatch-engine-word-name ( engine -- string )
-    [
-        generic get word-name %
-        "/tuple-dispatch-engine/" %
-        n>> #
-    ] "" make ;
+: engine-word-name ( -- string )
+    generic get word-name "/tuple-dispatch-engine" append ;
 
-PREDICATE: tuple-dispatch-engine-word < word
+PREDICATE: engine-word < word
     "tuple-dispatch-generic" word-prop generic? ;
 
-M: tuple-dispatch-engine-word stack-effect
+M: engine-word stack-effect
     "tuple-dispatch-generic" word-prop
     [ extra-values ] [ stack-effect ] bi
     dup [ clone [ length + ] change-in ] [ 2drop f ] if ;
 
-M: tuple-dispatch-engine-word compiled-crossref?
+M: engine-word compiled-crossref?
     drop t ;
 
 : remember-engine ( word -- )
     generic get "engines" word-prop push ;
 
-: <tuple-dispatch-engine-word> ( engine -- word )
-    tuple-dispatch-engine-word-name f <word>
-    [ generic get "tuple-dispatch-generic" set-word-prop ]
-    [ remember-engine ]
-    [ ]
-    tri ;
+: <engine-word> ( -- word )
+    engine-word-name f <word>
+    dup generic get "tuple-dispatch-generic" set-word-prop ;
 
-: define-tuple-dispatch-engine-word ( engine quot -- word )
-    >r <tuple-dispatch-engine-word> dup r> define ;
+: define-engine-word ( quot -- word )
+    >r <engine-word> dup r> define ;
+
+: array-nth% 2 + , [ slot { word } declare ] % ;
+
+: tuple-layout-superclasses ( obj -- array )
+    { tuple } declare
+    1 slot { tuple-layout } declare
+    4 slot { array } declare ; inline
 
 : tuple-dispatch-engine-body ( engine -- quot )
-    #! 1 slot == tuple-layout
-    #! 2 slot == 0 array-nth
-    #! 4 slot == layout-superclasses
     [
         picker %
-        [ 1 slot 4 slot ] %
-        [ n>> 2 + , [ slot ] % ]
+        [ tuple-layout-superclasses ] %
+        [ n>> array-nth% ]
         [
             methods>> [
                 <trivial-tuple-dispatch-engine> engine>quot
@@ -104,25 +99,54 @@ M: tuple-dispatch-engine-word compiled-crossref?
     ] [ ] make ;
 
 M: echelon-dispatch-engine engine>quot
-    dup tuple-dispatch-engine-body
-    define-tuple-dispatch-engine-word
-    1quotation ;
+    dup n>> zero? [
+        methods>> dup assoc-empty?
+        [ drop default get ] [ values first engine>quot ] if
+    ] [
+        [
+            picker %
+            [ tuple-layout-superclasses ] %
+            [ n>> array-nth% ]
+            [
+                methods>> [
+                    <trivial-tuple-dispatch-engine> engine>quot
+                ] [
+                    class-hash-dispatch-quot
+                ] if-small? %
+            ] bi
+        ] [ ] make
+    ] if ;
 
 : >=-case-quot ( alist -- quot )
     default get [ drop ] prepend swap
     [ >r [ dupd fixnum>= ] curry r> \ drop prefix ] assoc-map
     alist>quot ;
 
+: tuple-layout-echelon ( obj -- array )
+    { tuple } declare
+    1 slot { tuple-layout } declare
+    5 slot ; inline
+
+: unclip-last [ 1 head* ] [ peek ] bi ;
+
 M: tuple-dispatch-engine engine>quot
-    #! 1 slot == tuple-layout
-    #! 5 slot == layout-echelon
     [
         picker %
-        [ 1 slot 5 slot ] %
-        echelons>>
+        [ tuple-layout-echelon ] %
         [
             tuple assumed set
-            [ engine>quot dup default set ] assoc-map
+            echelons>> dup empty? [
+                unclip-last
+                [
+                    [
+                        engine>quot define-engine-word
+                        [ remember-engine ] [ 1quotation ] bi
+                        dup default set
+                    ] assoc-map
+                ]
+                [ first2 engine>quot 2array ] bi*
+                suffix
+            ] unless
         ] with-scope
         >=-case-quot %
     ] [ ] make ;
diff --git a/core/generic/standard/standard-tests.factor b/core/generic/standard/standard-tests.factor
index 8799169445..c31c46f3f7 100644
--- a/core/generic/standard/standard-tests.factor
+++ b/core/generic/standard/standard-tests.factor
@@ -251,6 +251,14 @@ HOOK: my-tuple-hook my-var ( -- x )
 
 M: sequence my-tuple-hook my-hook ;
 
+TUPLE: m-t-h-a ;
+
+M: m-t-h-a my-tuple-hook "foo" ;
+
+TUPLE: m-t-h-b < m-t-h-a ;
+
+M: m-t-h-b my-tuple-hook "bar" ;
+
 [ f ] [
     \ my-tuple-hook [ "engines" word-prop ] keep prefix
     [ 1quotation infer ] map all-equal?
diff --git a/core/inference/backend/backend-docs.factor b/core/inference/backend/backend-docs.factor
index 0125f04efa..91314d1312 100755
--- a/core/inference/backend/backend-docs.factor
+++ b/core/inference/backend/backend-docs.factor
@@ -48,10 +48,6 @@ HELP: no-effect
 { $description "Throws a " { $link no-effect } " error." }
 { $error-description "Thrown when inference encounters a call to a word which is already known not to have a static stack effect, due to a prior inference attempt failing." } ;
 
-HELP: collect-recursion
-{ $values { "#label" "a " { $link #label } " node" } { "seq" "a new sequence" } }
-{ $description "Collect the input stacks of all child " { $link #call-label } " nodes that call the given label." } ;
-
 HELP: inline-word
 { $values { "word" word } }
 { $description "Called during inference to infer stack effects of inline words."
diff --git a/core/inference/backend/backend.factor b/core/inference/backend/backend.factor
index cf40944d1d..f60748a5ac 100755
--- a/core/inference/backend/backend.factor
+++ b/core/inference/backend/backend.factor
@@ -15,7 +15,7 @@ GENERIC: inline? ( word -- ? )
 M: method-body inline?
     "method-generic" word-prop inline? ;
 
-M: tuple-dispatch-engine-word inline?
+M: engine-word inline?
     "tuple-dispatch-generic" word-prop inline? ;
 
 M: word inline?
@@ -130,25 +130,27 @@ TUPLE: too-many->r ;
 
 TUPLE: too-many-r> ;
 
-: check-r> ( -- )
-    meta-r get empty?
+: check-r> ( n -- )
+    meta-r get length >
     [ \ too-many-r> inference-error ] when ;
 
-: infer->r ( -- )
-    1 ensure-values
+: infer->r ( n -- )
+    dup ensure-values
     #>r
-    1 0 pick node-inputs
-    pop-d push-r
-    0 1 pick node-outputs
-    node, ;
+    over 0 pick node-inputs
+    over [ drop pop-d ] map reverse [ push-r ] each
+    0 pick pick node-outputs
+    node,
+    drop ;
 
-: infer-r> ( -- )
-    check-r>
+: infer-r> ( n -- )
+    dup check-r>
     #r>
-    0 1 pick node-inputs
-    pop-r push-d
-    1 0 pick node-outputs
-    node, ;
+    0 pick pick node-inputs
+    over [ drop pop-r ] map reverse [ push-d ] each
+    over 0 pick node-outputs
+    node,
+    drop ;
 
 : undo-infer ( -- )
     recorded get [ f "inferred-effect" set-word-prop ] each ;
@@ -199,18 +201,18 @@ M: object constructor drop f ;
     dup infer-uncurry
     constructor [
         peek-d reify-curry
-        infer->r
+        1 infer->r
         peek-d reify-curry
-        infer-r>
+        1 infer-r>
         2 1 <effect> swap #call consume/produce
     ] when* ;
 
 : reify-curries ( n -- )
     meta-d get reverse [
         dup special? [
-            over [ infer->r ] times
+            over infer->r
             dup reify-curry
-            over [ infer-r> ] times
+            over infer-r>
         ] when 2drop
     ] 2each ;
 
@@ -407,6 +409,25 @@ TUPLE: recursive-declare-error word ;
         \ recursive-declare-error inference-error
     ] if* ;
 
+GENERIC: collect-label-info* ( label node -- )
+
+M: node collect-label-info* 2drop ;
+
+: (collect-label-info) ( label node vector -- )
+    >r tuck [ param>> ] bi@ eq? r> [ push ] curry [ drop ] if ;
+    inline
+
+M: #call-label collect-label-info*
+    over calls>> (collect-label-info) ;
+
+M: #return collect-label-info*
+    over returns>> (collect-label-info) ;
+
+: collect-label-info ( #label -- )
+    V{ } clone >>calls
+    V{ } clone >>returns
+    dup [ collect-label-info* ] with each-node ;
+
 : nest-node ( -- ) #entry node, ;
 
 : unnest-node ( new-node -- new-node )
@@ -417,27 +438,17 @@ TUPLE: recursive-declare-error word ;
 
 : <inlined-block> gensym dup t "inlined-block" set-word-prop ;
 
-: inline-block ( word -- node-block data )
+: inline-block ( word -- #label data )
     [
         copy-inference nest-node
         dup word-def swap <inlined-block>
         [ infer-quot-recursive ] 2keep
         #label unnest-node
+        dup collect-label-info
     ] H{ } make-assoc ;
 
-GENERIC: collect-recursion* ( label node -- )
-
-M: node collect-recursion* 2drop ;
-
-M: #call-label collect-recursion*
-    tuck node-param eq? [ , ] [ drop ] if ;
-
-: collect-recursion ( #label -- seq )
-    dup node-param
-    [ [ swap collect-recursion* ] curry each-node ] { } make ;
-
-: join-values ( node -- )
-    collect-recursion [ node-in-d ] map meta-d get suffix
+: join-values ( #label -- )
+    calls>> [ node-in-d ] map meta-d get suffix
     unify-lengths unify-stacks
     meta-d [ length tail* ] change ;
 
@@ -458,7 +469,7 @@ M: #call-label collect-recursion*
         drop join-values inline-block apply-infer
         r> over set-node-in-d
         dup node,
-        collect-recursion [
+        calls>> [
             [ flatten-curries ] modify-values
         ] each
     ] [
diff --git a/core/inference/class/class-tests.factor b/core/inference/class/class-tests.factor
index 038ab1d230..0c4ff82798 100755
--- a/core/inference/class/class-tests.factor
+++ b/core/inference/class/class-tests.factor
@@ -4,7 +4,12 @@ inference.dataflow optimizer tools.test kernel.private generic
 sequences words inference.class quotations alien
 alien.c-types strings sbufs sequences.private
 slots.private combinators definitions compiler.units
-system layouts vectors ;
+system layouts vectors optimizer.math.partial accessors
+optimizer.inlining ;
+
+[ t ] [ T{ literal-constraint f 1 2 } T{ literal-constraint f 1 2 } equal? ] unit-test
+
+[ f ] [ T{ literal-constraint f 1 3 } T{ literal-constraint f 1 2 } equal? ] unit-test
 
 ! Make sure these compile even though this is invalid code
 [ ] [ [ 10 mod 3.0 /i ] dataflow optimize drop ] unit-test
@@ -13,9 +18,15 @@ system layouts vectors ;
 ! Ensure type inference works as it is supposed to by checking
 ! if various methods get inlined
 
-: inlined? ( quot word -- ? )
+: inlined? ( quot seq/word -- ? )
+    dup word? [ 1array ] when
     swap dataflow optimize
-    [ node-param eq? ] with node-exists? not ;
+    [ node-param swap member? ] with node-exists? not ;
+
+[ f ] [
+    [ { integer } declare >fixnum ]
+    \ >fixnum inlined?
+] unit-test
 
 GENERIC: mynot ( x -- y )
 
@@ -109,12 +120,17 @@ M: object xyz ;
     [ { fixnum } declare [ ] times ] \ fixnum+ inlined?
 ] unit-test
 
-[ f ] [
+[ t ] [
     [ { integer fixnum } declare dupd < [ 1 + ] when ]
     \ + inlined?
 ] unit-test
 
-[ f ] [ [ dup 0 < [ neg ] when ] \ neg inlined? ] unit-test
+[ f ] [
+    [ { integer fixnum } declare dupd < [ 1 + ] when ]
+    \ +-integer-fixnum inlined?
+] unit-test
+
+[ f ] [ [ dup 0 < [ neg ] when ] \ - inlined? ] unit-test
 
 [ f ] [
     [
@@ -137,13 +153,13 @@ M: object xyz ;
 
 DEFER: blah
 
-[ t ] [
+[ ] [
     [
         \ blah
         [ dup V{ } eq? [ foo ] when ] dup second dup push define
     ] with-compilation-unit
 
-    \ blah compiled?
+    \ blah word-def dataflow optimize drop
 ] unit-test
 
 GENERIC: detect-fx ( n -- n )
@@ -158,14 +174,20 @@ M: fixnum detect-fx ;
     ] \ detect-fx inlined?
 ] unit-test
 
+[ t ] [
+    [
+        1000000000000000000000000000000000 [ ] times
+    ] \ + inlined?
+] unit-test
 [ f ] [
     [
         1000000000000000000000000000000000 [ ] times
-    ] \ 1+ inlined?
+    ] \ +-integer-fixnum inlined?
 ] unit-test
 
 [ f ] [
-    [ { bignum } declare [ ] times ] \ 1+ inlined?
+    [ { bignum } declare [ ] times ]
+    \ +-integer-fixnum inlined?
 ] unit-test
 
 
@@ -251,19 +273,24 @@ M: float detect-float ;
     [ 3 + = ] \ equal? inlined?
 ] unit-test
 
-[ t ] [
+[ f ] [
     [ { fixnum fixnum } declare 7 bitand neg shift ]
-    \ shift inlined?
+    \ fixnum-shift-fast inlined?
 ] unit-test
 
 [ t ] [
     [ { fixnum fixnum } declare 7 bitand neg shift ]
-    \ fixnum-shift inlined?
+    { shift fixnum-shift } inlined?
 ] unit-test
 
 [ t ] [
     [ { fixnum fixnum } declare 1 swap 7 bitand shift ]
-    \ fixnum-shift inlined?
+    { shift fixnum-shift } inlined?
+] unit-test
+
+[ f ] [
+    [ { fixnum fixnum } declare 1 swap 7 bitand shift ]
+    { fixnum-shift-fast } inlined?
 ] unit-test
 
 cell-bits 32 = [
@@ -278,6 +305,11 @@ cell-bits 32 = [
     ] unit-test
 ] when
 
+[ f ] [
+    [ { integer } declare -63 shift 4095 bitand ]
+    \ shift inlined?
+] unit-test
+
 [ t ] [
     [ B{ 1 0 } *short 0 number= ]
     \ number= inlined?
@@ -323,3 +355,228 @@ cell-bits 32 = [
         ] when
     ] \ + inlined?
 ] unit-test
+
+[ f ] [
+    [
+        256 mod
+    ] { mod fixnum-mod } inlined?
+] unit-test
+
+[ f ] [
+    [
+        dup 0 >= [ 256 mod ] when
+    ] { mod fixnum-mod } inlined?
+] unit-test
+
+[ t ] [
+    [
+        { integer } declare dup 0 >= [ 256 mod ] when
+    ] { mod fixnum-mod } inlined?
+] unit-test
+
+[ t ] [
+    [
+        { integer } declare 256 rem
+    ] { mod fixnum-mod } inlined?
+] unit-test
+
+[ t ] [
+    [
+        { integer } declare [ 256 rem ] map
+    ] { mod fixnum-mod rem } inlined?
+] unit-test
+
+[ t ] [
+    [ 1000 [ 1+ ] map ] { 1+ fixnum+ } inlined?
+] unit-test
+
+: rec ( a -- b )
+    dup 0 > [ 1 - rec ] when ; inline
+
+[ t ] [
+    [ { fixnum } declare rec 1 + ]
+    { > - + } inlined?
+] unit-test
+
+: fib ( m -- n )
+    dup 2 < [ drop 1 ] [ dup 1 - fib swap 2 - fib + ] if ; inline
+
+[ t ] [
+    [ 27.0 fib ] { < - + } inlined?
+] unit-test
+
+[ f ] [
+    [ 27.0 fib ] { +-integer-integer } inlined?
+] unit-test
+
+[ t ] [
+    [ 27 fib ] { < - + } inlined?
+] unit-test
+
+[ t ] [
+    [ 27 >bignum fib ] { < - + } inlined?
+] unit-test
+
+[ f ] [
+    [ 27/2 fib ] { < - } inlined?
+] unit-test
+
+: hang-regression ( m n -- x )
+    over 0 number= [
+        nip
+    ] [
+        dup [
+            drop 1 hang-regression
+        ] [
+            dupd hang-regression hang-regression
+        ] if
+    ] if ; inline
+
+[ t ] [
+    [ dup fixnum? [ 3 over hang-regression ] [ 3 over hang-regression ] if
+] { } inlined? ] unit-test
+
+: detect-null ( a -- b ) dup drop ;
+
+\ detect-null {
+    { [ dup dup in-d>> first node-class null eq? ] [ [ ] f splice-quot ] }
+} define-optimizers
+
+[ t ] [
+    [ { null } declare detect-null ] \ detect-null inlined?
+] unit-test
+
+[ t ] [
+    [ { null null } declare + detect-null ] \ detect-null inlined?
+] unit-test
+
+[ f ] [
+    [ { null fixnum } declare + detect-null ] \ detect-null inlined?
+] unit-test
+
+GENERIC: detect-integer ( a -- b )
+
+M: integer detect-integer ;
+
+[ t ] [
+    [ { null fixnum } declare + detect-integer ] \ detect-integer inlined?
+] unit-test
+
+[ t ] [
+    [ { fixnum } declare 10 [ -1 shift ] times ] \ shift inlined?
+] unit-test
+
+[ f ] [
+    [ { integer } declare 10 [ -1 shift ] times ] \ shift inlined?
+] unit-test
+
+[ f ] [
+    [ { fixnum } declare 1048575 fixnum-bitand 524288 fixnum- ]
+    \ fixnum-bitand inlined?
+] unit-test
+
+[ t ] [
+    [ { integer } declare 127 bitand 3 + ]
+    { + +-integer-fixnum +-integer-fixnum-fast bitand } inlined?
+] unit-test
+
+[ f ] [
+    [ { integer } declare 127 bitand 3 + ]
+    { >fixnum } inlined?
+] unit-test
+
+[ t ] [
+    [ { fixnum } declare [ drop ] each-integer ]
+    { < <-integer-fixnum +-integer-fixnum + } inlined?
+] unit-test
+
+[ t ] [
+    [ { fixnum } declare length [ drop ] each-integer ]
+    { < <-integer-fixnum +-integer-fixnum + } inlined?
+] unit-test
+
+[ t ] [
+    [ { fixnum } declare [ drop ] each ]
+    { < <-integer-fixnum +-integer-fixnum + } inlined?
+] unit-test
+
+[ t ] [
+    [ { fixnum } declare 0 [ + ] reduce ]
+    { < <-integer-fixnum } inlined?
+] unit-test
+
+[ f ] [
+    [ { fixnum } declare 0 [ + ] reduce ]
+    \ +-integer-fixnum inlined?
+] unit-test
+
+[ t ] [
+    [
+        { integer } declare
+        dup 0 >= [
+            615949 * 797807 + 20 2^ mod dup 19 2^ -
+        ] [ dup ] if
+    ] { * + shift mod fixnum-mod fixnum* fixnum+ fixnum- } inlined?
+] unit-test
+
+[ t ] [
+    [
+        { fixnum } declare
+        615949 * 797807 + 20 2^ mod dup 19 2^ -
+    ] { >fixnum } inlined?
+] unit-test
+
+[ f ] [
+    [
+        { integer } declare [ ] map
+    ] \ >fixnum inlined?
+] unit-test
+
+[ f ] [
+    [
+        { integer } declare { } set-nth-unsafe
+    ] \ >fixnum inlined?
+] unit-test
+
+[ f ] [
+    [
+        { integer } declare 1 + { } set-nth-unsafe
+    ] \ >fixnum inlined?
+] unit-test
+
+[ t ] [
+    [
+        { integer } declare 0 swap
+        [
+            drop 615949 * 797807 + 20 2^ rem dup 19 2^ -
+        ] map
+    ] { * + shift rem mod fixnum-mod fixnum* fixnum+ fixnum- } inlined?
+] unit-test
+
+[ t ] [
+    [
+        { fixnum } declare 0 swap
+        [
+            drop 615949 * 797807 + 20 2^ rem dup 19 2^ -
+        ] map
+    ] { * + shift rem mod fixnum-mod fixnum* fixnum+ fixnum- >fixnum } inlined?
+] unit-test
+
+[ t ] [
+    [ { integer } declare bitnot detect-integer ]
+    \ detect-integer inlined?
+] unit-test
+
+! Later
+
+! [ t ] [
+!     [
+!         { integer } declare [ 256 mod ] map
+!     ] { mod fixnum-mod } inlined?
+! ] unit-test
+! 
+! [ t ] [
+!     [
+!         { integer } declare [ 0 >= ] map
+!     ] { >= fixnum>= } inlined?
+! ] unit-test
diff --git a/core/inference/class/class.factor b/core/inference/class/class.factor
index 033d2cce7a..6d5b708f34 100755
--- a/core/inference/class/class.factor
+++ b/core/inference/class/class.factor
@@ -1,9 +1,9 @@
-! Copyright (C) 2004, 2007 Slava Pestov.
+! Copyright (C) 2004, 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: arrays generic assocs hashtables inference kernel
 math namespaces sequences words parser math.intervals
 effects classes classes.algebra inference.dataflow
-inference.backend combinators ;
+inference.backend combinators accessors ;
 IN: inference.class
 
 ! Class inference
@@ -25,12 +25,10 @@ C: <literal-constraint> literal-constraint
 
 M: literal-constraint equal?
     over literal-constraint? [
-        2dup
-        [ literal-constraint-literal ] bi@ eql? >r
-        [ literal-constraint-value ] bi@ = r> and
-    ] [
-        2drop f
-    ] if ;
+        [ [ literal>> ] bi@ eql? ]
+        [ [ value>>   ] bi@ =    ]
+        2bi and
+    ] [ 2drop f ] if ;
 
 TUPLE: class-constraint class value ;
 
@@ -43,8 +41,8 @@ C: <interval-constraint> interval-constraint
 GENERIC: apply-constraint ( constraint -- )
 GENERIC: constraint-satisfied? ( constraint -- ? )
 
-: `input node get node-in-d nth ;
-: `output node get node-out-d nth ;
+: `input node get in-d>> nth ;
+: `output node get out-d>> nth ;
 : class, <class-constraint> , ;
 : literal, <literal-constraint> , ;
 : interval, <interval-constraint> , ;
@@ -84,14 +82,12 @@ SYMBOL: value-classes
     set-value-interval* ;
 
 M: interval-constraint apply-constraint
-    dup interval-constraint-interval
-    swap interval-constraint-value intersect-value-interval ;
+    [ interval>> ] [ value>> ] bi intersect-value-interval ;
 
 : set-class-interval ( class value -- )
     over class? [
-        over "interval" word-prop [
-            >r "interval" word-prop r> set-value-interval*
-        ] [ 2drop ] if
+        >r "interval" word-prop r> over
+        [ set-value-interval* ] [ 2drop ] if
     ] [ 2drop ] if ;
 
 : value-class* ( value -- class )
@@ -110,18 +106,21 @@ M: interval-constraint apply-constraint
     [ value-class* class-and ] keep set-value-class* ;
 
 M: class-constraint apply-constraint
-    dup class-constraint-class
-    swap class-constraint-value intersect-value-class ;
+    [ class>> ] [ value>> ] bi intersect-value-class ;
+
+: literal-interval ( value -- interval/f )
+    dup real? [ [a,a] ] [ drop f ] if ;
 
 : set-value-literal* ( literal value -- )
-    over class over set-value-class*
-    over real? [ over [a,a] over set-value-interval* ] when
-    2dup <literal-constraint> assume
-    value-literals get set-at ;
+    {
+        [ >r class r> set-value-class* ]
+        [ >r literal-interval r> set-value-interval* ]
+        [ <literal-constraint> assume ]
+        [ value-literals get set-at ]
+    } 2cleave ;
 
 M: literal-constraint apply-constraint
-    dup literal-constraint-literal
-    swap literal-constraint-value set-value-literal* ;
+    [ literal>> ] [ value>> ] bi set-value-literal* ;
 
 ! For conditionals, an assoc of child node # --> constraint
 GENERIC: child-constraints ( node -- seq )
@@ -133,19 +132,18 @@ GENERIC: infer-classes-around ( node -- )
 M: node infer-classes-before drop ;
 
 M: node child-constraints
-    node-children length
+    children>> length
     dup zero? [ drop f ] [ f <repetition> ] if ;
 
 : value-literal* ( value -- obj ? )
     value-literals get at* ;
 
 M: literal-constraint constraint-satisfied?
-    dup literal-constraint-value value-literal*
-    [ swap literal-constraint-literal eql? ] [ 2drop f ] if ;
+    dup value>> value-literal*
+    [ swap literal>> eql? ] [ 2drop f ] if ;
 
 M: class-constraint constraint-satisfied?
-    dup class-constraint-value value-class*
-    swap class-constraint-class class< ;
+    [ value>> value-class* ] [ class>> ] bi class< ;
 
 M: pair apply-constraint
     first2 2dup constraints get set-at
@@ -154,19 +152,18 @@ M: pair apply-constraint
 M: pair constraint-satisfied?
     first constraint-satisfied? ;
 
-: extract-keys ( assoc seq -- newassoc )
-    dup length <hashtable> swap [
-        dup >r pick at* [ r> pick set-at ] [ r> 2drop ] if
-    ] each nip f assoc-like ;
+: extract-keys ( seq assoc -- newassoc )
+    [ dupd at ] curry H{ } map>assoc [ nip ] assoc-subset f assoc-like ;
 
 : annotate-node ( node -- )
     #! Annotate the node with the currently-inferred set of
     #! value classes.
-    dup node-values
-    value-intervals get over extract-keys pick set-node-intervals
-    value-classes get over extract-keys pick set-node-classes
-    value-literals get over extract-keys pick set-node-literals
-    2drop ;
+    dup node-values {
+        [ value-intervals get extract-keys >>intervals ]
+        [ value-classes   get extract-keys >>classes   ]
+        [ value-literals  get extract-keys >>literals  ]
+        [ 2drop ]
+    } cleave ;
 
 : intersect-classes ( classes values -- )
     [ intersect-value-class ] 2each ;
@@ -190,31 +187,29 @@ M: pair constraint-satisfied?
     ] 2bi ;
 
 : compute-constraints ( #call -- )
-    dup node-param "constraints" word-prop [
+    dup param>> "constraints" word-prop [
         call
     ] [
-        dup node-param "predicating" word-prop dup
+        dup param>> "predicating" word-prop dup
         [ swap predicate-constraints ] [ 2drop ] if
     ] if* ;
 
 : compute-output-classes ( node word -- classes intervals )
-    dup node-param "output-classes" word-prop
+    dup param>> "output-classes" word-prop
     dup [ call ] [ 2drop f f ] if ;
 
 : output-classes ( node -- classes intervals )
     dup compute-output-classes >r
-    [ ] [ node-param "default-output-classes" word-prop ] ?if
+    [ ] [ param>> "default-output-classes" word-prop ] ?if
     r> ;
 
 M: #call infer-classes-before
-    dup compute-constraints
-    dup node-out-d swap output-classes
-    >r over intersect-classes
-    r> swap intersect-intervals ;
+    [ compute-constraints ] keep
+    [ output-classes ] [ out-d>> ] bi
+    tuck [ intersect-classes ] [ intersect-intervals ] 2bi* ;
 
 M: #push infer-classes-before
-    node-out-d
-    [ [ value-literal ] keep set-value-literal* ] each ;
+    out-d>> [ [ value-literal ] keep set-value-literal* ] each ;
 
 M: #if child-constraints
     [
@@ -224,19 +219,17 @@ M: #if child-constraints
 
 M: #dispatch child-constraints
     dup [
-        node-children length [
-            0 `input literal,
-        ] each
+        children>> length [ 0 `input literal, ] each
     ] make-constraints ;
 
 M: #declare infer-classes-before
-    dup node-param swap node-in-d
+    [ param>> ] [ in-d>> ] bi
     [ intersect-value-class ] 2each ;
 
 DEFER: (infer-classes)
 
 : infer-children ( node -- )
-    dup node-children swap child-constraints [
+    [ children>> ] [ child-constraints ] bi [
         [
             value-classes [ clone ] change
             value-literals [ clone ] change
@@ -251,27 +244,27 @@ DEFER: (infer-classes)
     >r dup [ length ] map supremum r> [ pad-left ] 2curry map ;
 
 : (merge-classes) ( nodes -- seq )
-    [ node-input-classes ] map
-    null pad-all flip [ null [ class-or ] reduce ] map ;
+    dup length 1 = [
+        first node-input-classes
+    ] [
+        [ node-input-classes ] map null pad-all flip
+        [ null [ class-or ] reduce ] map
+    ] if ;
 
 : set-classes ( seq node -- )
-    node-out-d [ set-value-class* ] 2reverse-each ;
+    out-d>> [ set-value-class* ] 2reverse-each ;
 
 : merge-classes ( nodes node -- )
     >r (merge-classes) r> set-classes ;
 
-: (merge-intervals) ( nodes quot -- seq )
-    >r
-    [ node-input-intervals ] map
-    f pad-all flip
-    r> map ; inline
-
 : set-intervals ( seq node -- )
-    node-out-d [ set-value-interval* ] 2reverse-each ;
+    out-d>> [ set-value-interval* ] 2reverse-each ;
 
 : merge-intervals ( nodes node -- )
-    >r [ dup first [ interval-union ] reduce ]
-    (merge-intervals) r> set-intervals ;
+    >r
+    [ node-input-intervals ] map f pad-all flip
+    [ dup first [ interval-union ] reduce ] map
+    r> set-intervals ;
 
 : annotate-merge ( nodes #merge/#entry -- )
     [ merge-classes ] [ merge-intervals ] 2bi ;
@@ -280,28 +273,68 @@ DEFER: (infer-classes)
     dup node-successor dup #merge? [
         swap active-children dup empty?
         [ 2drop ] [ swap annotate-merge ] if
-    ] [
-        2drop
-    ] if ;
+    ] [ 2drop ] if ;
+
+: classes= ( inferred current -- ? )
+    2dup min-length [ tail* ] curry bi@ sequence= ;
+
+SYMBOL: fixed-point?
+
+SYMBOL: nested-labels
 
 : annotate-entry ( nodes #label -- )
-    node-child merge-classes ;
+    >r (merge-classes) r> node-child
+    2dup node-output-classes classes=
+    [ 2drop ] [ set-classes fixed-point? off ] if ;
+
+: init-recursive-calls ( #label -- )
+    #! We set recursive calls to output the empty type, then
+    #! repeat inference until a fixed point is reached.
+    #! Hopefully, our type functions are monotonic so this
+    #! will always converge.
+    returns>> [ dup in-d>> [ null ] { } map>assoc >>classes drop ] each ;
 
 M: #label infer-classes-before ( #label -- )
-    #! First, infer types under the hypothesis which hold on
-    #! entry to the recursive label.
-    [ 1array ] keep annotate-entry ;
+    [ init-recursive-calls ]
+    [ [ 1array ] keep annotate-entry ] bi ;
+
+: infer-label-loop ( #label -- )
+    fixed-point? on
+    dup node-child (infer-classes)
+    dup [ calls>> ] [ suffix ] [ annotate-entry ] tri
+    fixed-point? get [ drop ] [ infer-label-loop ] if ;
 
 M: #label infer-classes-around ( #label -- )
     #! Now merge the types at every recursion point with the
     #! entry types.
-    {
-        [ annotate-node ]
-        [ infer-classes-before ]
-        [ infer-children ]
-        [ [ collect-recursion ] [ suffix ] [ annotate-entry ] tri ]
-        [ node-child (infer-classes) ]
-    } cleave ;
+    [
+        {
+            [ nested-labels get push ]
+            [ annotate-node ]
+            [ infer-classes-before ]
+            [ infer-label-loop ]
+            [ drop nested-labels get pop* ]
+        } cleave
+    ] with-scope ;
+
+: find-label ( param -- #label )
+    param>> nested-labels get [ param>> eq? ] with find nip ;
+
+M: #call-label infer-classes-before ( #call-label -- )
+    [ find-label returns>> (merge-classes) ] [ out-d>> ] bi
+    [ set-value-class* ] 2each ;
+
+M: #return infer-classes-around
+    nested-labels get length 0 > [
+        dup param>> nested-labels get peek param>> eq? [
+            [ ] [ node-input-classes ] [ in-d>> [ value-class* ] map ] tri
+            classes= not [
+                fixed-point? off
+                [ in-d>> value-classes get extract-keys ] keep
+                set-node-classes
+            ] [ drop ] if
+        ] [ call-next-method ] if
+    ] [ call-next-method ] if ;
 
 M: object infer-classes-around
     {
@@ -314,11 +347,13 @@ M: object infer-classes-around
 : (infer-classes) ( node -- )
     [
         [ infer-classes-around ]
-        [ node-successor (infer-classes) ] bi
+        [ node-successor ] bi
+        (infer-classes)
     ] when* ;
 
 : infer-classes-with ( node classes literals intervals -- )
     [
+        V{ } clone nested-labels set
         H{ } assoc-like value-intervals set
         H{ } assoc-like value-literals set
         H{ } assoc-like value-classes set
@@ -326,13 +361,11 @@ M: object infer-classes-around
         (infer-classes)
     ] with-scope ;
 
-: infer-classes ( node -- )
-    f f f infer-classes-with ;
+: infer-classes ( node -- node )
+    dup f f f infer-classes-with ;
 
 : infer-classes/node ( node existing -- )
     #! Infer classes, using the existing node's class info as a
     #! starting point.
-    dup node-classes
-    over node-literals
-    rot node-intervals
+    [ classes>> ] [ literals>> ] [ intervals>> ] tri
     infer-classes-with ;
diff --git a/core/inference/dataflow/dataflow.factor b/core/inference/dataflow/dataflow.factor
index 3fb047b781..bb66a5386c 100755
--- a/core/inference/dataflow/dataflow.factor
+++ b/core/inference/dataflow/dataflow.factor
@@ -90,7 +90,7 @@ M: object flatten-curry , ;
 
 : node-child node-children first ;
 
-TUPLE: #label < node word loop? ;
+TUPLE: #label < node word loop? returns calls ;
 
 : #label ( word label -- node )
     \ #label param-node swap >>word ;
@@ -290,6 +290,9 @@ SYMBOL: node-stack
 : node-input-classes ( node -- seq )
     dup in-d>> [ node-class ] with map ;
 
+: node-output-classes ( node -- seq )
+    dup out-d>> [ node-class ] with map ;
+
 : node-input-intervals ( node -- seq )
     dup in-d>> [ node-interval ] with map ;
 
diff --git a/core/inference/known-words/known-words.factor b/core/inference/known-words/known-words.factor
index 453e2460b0..2e471420da 100755
--- a/core/inference/known-words/known-words.factor
+++ b/core/inference/known-words/known-words.factor
@@ -54,9 +54,9 @@ IN: inference.known-words
     { swap  T{ effect f 2 { 1 0         } } }
 } [ define-shuffle ] assoc-each
 
-\ >r [ infer->r ] "infer" set-word-prop
+\ >r [ 1 infer->r ] "infer" set-word-prop
 
-\ r> [ infer-r> ] "infer" set-word-prop
+\ r> [ 1 infer-r> ] "infer" set-word-prop
 
 \ declare [
     1 ensure-values
@@ -81,8 +81,8 @@ M: curried infer-call
 
 M: composed infer-call
     infer-uncurry
-    infer->r peek-d infer-call
-    terminated? get [ infer-r> peek-d infer-call ] unless ;
+    1 infer->r peek-d infer-call
+    terminated? get [ 1 infer-r> peek-d infer-call ] unless ;
 
 M: object infer-call
     \ literal-expected inference-warning ;
diff --git a/core/math/integers/integers-tests.factor b/core/math/integers/integers-tests.factor
index eebc45511a..fe8e5bddc8 100755
--- a/core/math/integers/integers-tests.factor
+++ b/core/math/integers/integers-tests.factor
@@ -184,3 +184,10 @@ unit-test
 [ HEX: 988a259c3433f237 ] [
     B{ HEX: 37 HEX: f2 HEX: 33 HEX: 34 HEX: 9c HEX: 25 HEX: 8a HEX: 98 } byte-array>bignum
 ] unit-test
+
+[ t ] [ 256 power-of-2? ] unit-test
+[ f ] [ 123 power-of-2? ] unit-test
+
+[ f ] [ -128 power-of-2? ] unit-test
+[ f ] [ 0 power-of-2? ] unit-test
+[ t ] [ 1 power-of-2? ] unit-test
diff --git a/core/math/intervals/intervals.factor b/core/math/intervals/intervals.factor
index 4ca1a8637c..77d60e67f8 100755
--- a/core/math/intervals/intervals.factor
+++ b/core/math/intervals/intervals.factor
@@ -96,6 +96,8 @@ C: <interval> interval
 
 : interval-bitnot ( i1 -- i2 ) interval-neg interval-1- ;
 
+: interval-sq ( i1 -- i2 ) dup interval* ;
+
 : make-interval ( from to -- int )
     over first over first {
         { [ 2dup > ] [ 2drop 2drop f ] }
diff --git a/core/math/math-docs.factor b/core/math/math-docs.factor
index 5533c00090..c8a763b5f7 100755
--- a/core/math/math-docs.factor
+++ b/core/math/math-docs.factor
@@ -1,5 +1,5 @@
 USING: help.markup help.syntax kernel sequences quotations
-math.private math.functions ;
+math.private ;
 IN: math
 
 ARTICLE: "division-by-zero" "Division by zero"
@@ -26,17 +26,13 @@ $nl
 { $subsection < }
 { $subsection <= }
 { $subsection > }
-{ $subsection >= }
-"Inexact comparison:"
-{ $subsection ~ } ;
+{ $subsection >= } ;
 
 ARTICLE: "modular-arithmetic" "Modular arithmetic"
 { $subsection mod }
 { $subsection rem }
 { $subsection /mod }
 { $subsection /i }
-{ $subsection mod-inv }
-{ $subsection ^mod }
 { $see-also "integer-functions" } ;
 
 ARTICLE: "bitwise-arithmetic" "Bitwise arithmetic"
@@ -363,6 +359,10 @@ HELP: next-power-of-2
 { $values { "m" "a non-negative integer" } { "n" "an integer" } }
 { $description "Outputs the smallest power of 2 greater than " { $snippet "m" } ". The output value is always at least 1." } ;
 
+HELP: power-of-2?
+{ $values { "n" integer } { "?" "a boolean" } }
+{ $description "Tests if " { $snippet "n" } " is a power of 2." } ;
+
 HELP: each-integer
 { $values { "n" integer } { "quot" "a quotation with stack effect " { $snippet "( i -- )" } } }
 { $description "Applies the quotation to each integer from 0 up to " { $snippet "n" } ", excluding " { $snippet "n" } "." }
diff --git a/core/math/math.factor b/core/math/math.factor
index 064b488ac3..14cbe68351 100755
--- a/core/math/math.factor
+++ b/core/math/math.factor
@@ -55,26 +55,26 @@ GENERIC: zero? ( x -- ? ) foldable
 
 M: object zero? drop f ;
 
-: 1+ ( x -- y ) 1 + ; foldable
-: 1- ( x -- y ) 1 - ; foldable
-: 2/ ( x -- y ) -1 shift ; foldable
-: sq ( x -- y ) dup * ; foldable
-: neg ( x -- -x ) 0 swap - ; foldable
-: recip ( x -- y ) 1 swap / ; foldable
+: 1+ ( x -- y ) 1 + ; inline
+: 1- ( x -- y ) 1 - ; inline
+: 2/ ( x -- y ) -1 shift ; inline
+: sq ( x -- y ) dup * ; inline
+: neg ( x -- -x ) 0 swap - ; inline
+: recip ( x -- y ) 1 swap / ; inline
 
 : ?1+ [ 1+ ] [ 0 ] if* ; inline
 
 : /f  ( x y -- z ) >r >float r> >float float/f ; inline
 
-: max ( x y -- z ) [ > ] most ; foldable
-: min ( x y -- z ) [ < ] most ; foldable
+: max ( x y -- z ) [ > ] most ; inline
+: min ( x y -- z ) [ < ] most ; inline
 
 : between? ( x y z -- ? )
     pick >= [ >= ] [ 2drop f ] if ; inline
 
 : rem ( x y -- z ) tuck mod over + swap mod ; foldable
 
-: sgn ( x -- n ) dup 0 < -1 0 ? swap 0 > 1 0 ? bitor ; foldable
+: sgn ( x -- n ) dup 0 < [ drop -1 ] [ 0 > 1 0 ? ] if ; inline
 
 : [-] ( x y -- z ) - 0 max ; inline
 
@@ -121,7 +121,11 @@ M: float fp-nan?
 
 : next-power-of-2 ( m -- n ) 2 swap (next-power-of-2) ; foldable
 
-: align ( m w -- n ) 1- [ + ] keep bitnot bitand ; inline
+: power-of-2? ( n -- ? )
+    dup 0 <= [ drop f ] [ dup 1- bitand zero? ] if ; foldable
+
+: align ( m w -- n )
+    1- [ + ] keep bitnot bitand ; inline
 
 <PRIVATE
 
diff --git a/core/optimizer/backend/backend.factor b/core/optimizer/backend/backend.factor
index 3237f095bf..9630f9dc70 100755
--- a/core/optimizer/backend/backend.factor
+++ b/core/optimizer/backend/backend.factor
@@ -3,7 +3,7 @@
 USING: arrays generic assocs inference inference.class
 inference.dataflow inference.backend inference.state io kernel
 math namespaces sequences vectors words quotations hashtables
-combinators classes optimizer.def-use ;
+combinators classes optimizer.def-use accessors ;
 IN: optimizer.backend
 
 SYMBOL: class-substitutions
@@ -16,37 +16,32 @@ SYMBOL: optimizer-changed
 
 GENERIC: optimize-node* ( node -- node/t changed? )
 
-: ?union ( assoc/f assoc -- hash )
-    over [ assoc-union ] [ nip ] if ;
+: ?union ( assoc assoc/f -- assoc' )
+    dup assoc-empty? [ drop ] [ swap assoc-union ] if ;
 
-: add-node-literals ( assoc node -- )
-    over assoc-empty? [
+: add-node-literals ( node assoc -- )
+    [ ?union ] curry change-literals drop ;
+
+: add-node-classes ( node assoc -- )
+    [ ?union ] curry change-classes drop ;
+
+: substitute-values ( node assoc -- )
+    dup assoc-empty? [
         2drop
     ] [
-        [ node-literals ?union ] keep set-node-literals
-    ] if ;
-
-: add-node-classes ( assoc node -- )
-    over assoc-empty? [
-        2drop
-    ] [
-        [ node-classes ?union ] keep set-node-classes
-    ] if ;
-
-: substitute-values ( assoc node -- )
-    over assoc-empty? [
-        2drop
-    ] [
-        2dup node-in-d swap substitute-here
-        2dup node-in-r swap substitute-here
-        2dup node-out-d swap substitute-here
-        node-out-r swap substitute-here
+        {
+            [ >r  in-d>> r> substitute-here ]
+            [ >r  in-r>> r> substitute-here ]
+            [ >r out-d>> r> substitute-here ]
+            [ >r out-r>> r> substitute-here ]
+        } 2cleave
     ] if ;
 
 : perform-substitutions ( node -- )
-    class-substitutions get over add-node-classes
-    literal-substitutions get over add-node-literals
-    value-substitutions get swap substitute-values ;
+    [   class-substitutions get add-node-classes  ]
+    [ literal-substitutions get add-node-literals ]
+    [   value-substitutions get substitute-values ]
+    tri ;
 
 DEFER: optimize-nodes
 
@@ -90,18 +85,21 @@ M: node optimize-node* drop t f ;
     #! Not very efficient.
     dupd union* update ;
 
-: compute-value-substitutions ( #return/#values #call/#merge -- assoc )
-    node-out-d swap node-in-d 2array unify-lengths flip
+: compute-value-substitutions ( #call/#merge #return/#values -- assoc )
+    [ out-d>> ] [ in-d>> ] bi* 2array unify-lengths flip
     [ = not ] assoc-subset >hashtable ;
 
 : cleanup-inlining ( #return/#values -- newnode changed? )
-    dup node-successor dup [
-        class-substitutions get pick node-classes update
-        literal-substitutions get pick node-literals update
-        tuck compute-value-substitutions value-substitutions get swap update*
-        node-successor t
+    dup node-successor [
+        [ node-successor ] keep
+        {
+            [ nip classes>> class-substitutions get swap update ]
+            [ nip literals>> literal-substitutions get swap update ]
+            [ compute-value-substitutions value-substitutions get swap update* ]
+            [ drop node-successor ]
+        } 2cleave t
     ] [
-        2drop t f
+        drop t f
     ] if ;
 
 ! #return
diff --git a/core/optimizer/collect/collect.factor b/core/optimizer/collect/collect.factor
new file mode 100644
index 0000000000..6b9aee4e1a
--- /dev/null
+++ b/core/optimizer/collect/collect.factor
@@ -0,0 +1,10 @@
+! Copyright (C) 2006, 2008 Slava Pestov.
+! See http://factorcode.org/license.txt for BSD license.
+USING: inference.dataflow inference.backend kernel ;
+IN: optimizer
+
+: collect-label-infos ( node -- node )
+    dup [
+        dup #label? [ collect-label-info ] [ drop ] if
+    ] each-node ;
+
diff --git a/core/optimizer/control/control-tests.factor b/core/optimizer/control/control-tests.factor
index ce77cdd43a..9c6d041bca 100755
--- a/core/optimizer/control/control-tests.factor
+++ b/core/optimizer/control/control-tests.factor
@@ -27,22 +27,22 @@ optimizer ;
     dup [ 1+ loop-test-1 ] [ drop ] if ; inline
                           
 [ t ] [
-    [ loop-test-1 ] dataflow dup detect-loops
+    [ loop-test-1 ] dataflow detect-loops
     \ loop-test-1 label-is-loop?
 ] unit-test
 
 [ t ] [
-    [ loop-test-1 1 2 3 ] dataflow dup detect-loops
+    [ loop-test-1 1 2 3 ] dataflow detect-loops
     \ loop-test-1 label-is-loop?
 ] unit-test
 
 [ t ] [
-    [ [ loop-test-1 ] each ] dataflow dup detect-loops
+    [ [ loop-test-1 ] each ] dataflow detect-loops
     \ loop-test-1 label-is-loop?
 ] unit-test
 
 [ t ] [
-    [ [ loop-test-1 ] each ] dataflow dup detect-loops
+    [ [ loop-test-1 ] each ] dataflow detect-loops
     \ (each-integer) label-is-loop?
 ] unit-test
 
@@ -50,7 +50,7 @@ optimizer ;
     dup [ 1+ loop-test-2 1- ] [ drop ] if ; inline
 
 [ t ] [
-    [ loop-test-2 ] dataflow dup detect-loops
+    [ loop-test-2 ] dataflow detect-loops
     \ loop-test-2 label-is-not-loop?
 ] unit-test
 
@@ -58,7 +58,7 @@ optimizer ;
     dup [ [ loop-test-3 ] each ] [ drop ] if ; inline
 
 [ t ] [
-    [ loop-test-3 ] dataflow dup detect-loops
+    [ loop-test-3 ] dataflow detect-loops
     \ loop-test-3 label-is-not-loop?
 ] unit-test
 
@@ -73,7 +73,7 @@ optimizer ;
     dup #label? [ node-successor find-label ] unless ;
 
 : test-loop-exits
-    dataflow dup detect-loops find-label
+    dataflow detect-loops find-label
     dup node-param swap
     [ node-child find-tail find-loop-exits [ class ] map ] keep
     #label-loop? ;
@@ -113,7 +113,7 @@ optimizer ;
 ] unit-test
 
 [ f ] [
-    [ [ [ ] map ] map ] dataflow dup detect-loops
+    [ [ [ ] map ] map ] dataflow detect-loops
     [ dup #label? swap #loop? not and ] node-exists?
 ] unit-test
 
@@ -128,22 +128,22 @@ DEFER: a
     blah [ b ] [ a ] if ; inline
 
 [ t ] [
-    [ a ] dataflow dup detect-loops
+    [ a ] dataflow detect-loops
     \ a label-is-loop?
 ] unit-test
 
 [ t ] [
-    [ a ] dataflow dup detect-loops
+    [ a ] dataflow detect-loops
     \ b label-is-loop?
 ] unit-test
 
 [ t ] [
-    [ b ] dataflow dup detect-loops
+    [ b ] dataflow detect-loops
     \ a label-is-loop?
 ] unit-test
 
 [ t ] [
-    [ a ] dataflow dup detect-loops
+    [ a ] dataflow detect-loops
     \ b label-is-loop?
 ] unit-test
 
@@ -156,12 +156,12 @@ DEFER: a'
     blah [ b' ] [ a' ] if ; inline
 
 [ f ] [
-    [ a' ] dataflow dup detect-loops
+    [ a' ] dataflow detect-loops
     \ a' label-is-loop?
 ] unit-test
 
 [ f ] [
-    [ b' ] dataflow dup detect-loops
+    [ b' ] dataflow detect-loops
     \ b' label-is-loop?
 ] unit-test
 
@@ -171,11 +171,11 @@ DEFER: a'
 ! a standard iterative dataflow problem after all -- so I'm
 ! tempted to believe the computer here
 [ t ] [
-    [ b' ] dataflow dup detect-loops
+    [ b' ] dataflow detect-loops
     \ a' label-is-loop?
 ] unit-test
 
 [ f ] [
-    [ a' ] dataflow dup detect-loops
+    [ a' ] dataflow detect-loops
     \ b' label-is-loop?
 ] unit-test
diff --git a/core/optimizer/control/control.factor b/core/optimizer/control/control.factor
index f9f8901c41..976156db77 100755
--- a/core/optimizer/control/control.factor
+++ b/core/optimizer/control/control.factor
@@ -109,8 +109,9 @@ SYMBOL: potential-loops
         ] [ 2drop ] if
     ] assoc-each [ remove-non-loop-calls ] when ;
 
-: detect-loops ( nodes -- )
+: detect-loops ( node -- node )
     [
+        dup
         collect-label-info
         remove-non-tail-calls
         remove-non-loop-calls
diff --git a/core/optimizer/def-use/def-use-tests.factor b/core/optimizer/def-use/def-use-tests.factor
index f22cce9fa8..914018437a 100755
--- a/core/optimizer/def-use/def-use-tests.factor
+++ b/core/optimizer/def-use/def-use-tests.factor
@@ -3,12 +3,12 @@ USING: inference inference.dataflow optimizer optimizer.def-use
 namespaces assocs kernel sequences math tools.test words ;
 
 [ 3 { 1 1 1 } ] [
-    [ 1 2 3 ] dataflow compute-def-use
+    [ 1 2 3 ] dataflow compute-def-use drop
     def-use get values dup length swap [ length ] map
 ] unit-test
 
 : kill-set ( quot -- seq )
-    dataflow compute-def-use compute-dead-literals keys
+    dataflow compute-def-use drop compute-dead-literals keys
     [ value-literal ] map ;
 
 : subset? [ member? ] curry all? ;
diff --git a/core/optimizer/def-use/def-use.factor b/core/optimizer/def-use/def-use.factor
index 54fca38ee2..66bffd9767 100755
--- a/core/optimizer/def-use/def-use.factor
+++ b/core/optimizer/def-use/def-use.factor
@@ -1,8 +1,9 @@
-! Copyright (C) 2004, 2007 Slava Pestov.
+! Copyright (C) 2004, 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
-IN: optimizer.def-use
 USING: namespaces assocs sequences inference.dataflow
-inference.backend kernel generic assocs classes vectors ;
+inference.backend kernel generic assocs classes vectors
+accessors combinators ;
+IN: optimizer.def-use
 
 SYMBOL: def-use
 
@@ -21,17 +22,20 @@ SYMBOL: def-use
 
 GENERIC: node-def-use ( node -- )
 
-: compute-def-use ( node -- )
-    H{ } clone def-use set [ node-def-use ] each-node ;
+: compute-def-use ( node -- node )
+    H{ } clone def-use set
+    dup [ node-def-use ] each-node ;
 
 : nest-def-use ( node -- def-use )
-    [ compute-def-use def-use get ] with-scope ;
+    [ compute-def-use drop def-use get ] with-scope ;
 
 : (node-def-use) ( node -- )
-    dup dup node-in-d uses-values
-    dup dup node-in-r uses-values
-    dup node-out-d defs-values
-    node-out-r defs-values ;
+    {
+        [ dup in-d>> uses-values ] 
+        [ dup in-r>> uses-values ] 
+        [ out-d>>    defs-values ] 
+        [ out-r>>    defs-values ]
+    } cleave ;
 
 M: object node-def-use (node-def-use) ;
 
@@ -43,7 +47,7 @@ M: #passthru node-def-use drop ;
 
 M: #return node-def-use
     #! Values returned by local labels can be killed.
-    dup node-param [ drop ] [ (node-def-use) ] if ;
+    dup param>> [ drop ] [ (node-def-use) ] if ;
 
 ! nodes that don't use their values directly
 UNION: #killable
@@ -56,13 +60,13 @@ UNION: #killable
 
 M: #label node-def-use
     [
-        dup node-in-d ,
-        dup node-child node-out-d ,
-        dup collect-recursion [ node-in-d , ] each
+        dup in-d>> ,
+        dup node-child out-d>> ,
+        dup calls>> [ in-d>> , ] each
     ] { } make purge-invariants uses-values ;
 
 : branch-def-use ( #branch -- )
-    active-children [ node-in-d ] map
+    active-children [ in-d>> ] map
     purge-invariants t swap uses-values ;
 
 M: #branch node-def-use
@@ -85,16 +89,16 @@ M: node kill-node* drop t ;
     inline
 
 M: #shuffle kill-node* 
-    [
-        dup node-in-d empty? swap node-out-d empty? and
-    ] prune-if ;
+    [ [ in-d>> empty? ] [ out-d>> empty? ] bi and ] prune-if ;
 
 M: #push kill-node* 
-    [ node-out-d empty? ] prune-if ;
+    [ out-d>> empty? ] prune-if ;
 
-M: #>r kill-node* [ node-in-d empty? ] prune-if ;
+M: #>r kill-node*
+    [ in-d>> empty? ] prune-if ;
 
-M: #r> kill-node* [ node-in-r empty? ] prune-if ;
+M: #r> kill-node*
+    [ in-r>> empty? ] prune-if ;
 
 : kill-node ( node -- node )
     dup [
@@ -116,7 +120,7 @@ M: #r> kill-node* [ node-in-r empty? ] prune-if ;
     ] if ;
 
 : sole-consumer ( #call -- node/f )
-    node-out-d first used-by
+    out-d>> first used-by
     dup length 1 = [ first ] [ drop f ] if ;
 
 : splice-def-use ( node -- )
@@ -128,5 +132,5 @@ M: #r> kill-node* [ node-in-r empty? ] prune-if ;
     #! degree of accuracy; the new values should be marked as
     #! having _some_ usage, so that flushing doesn't erronously
     #! flush them away.
-    [ compute-def-use def-use get keys ] with-scope
+    nest-def-use keys
     def-use get [ [ t swap ?push ] change-at ] curry each ;
diff --git a/core/optimizer/inlining/inlining-tests.factor b/core/optimizer/inlining/inlining-tests.factor
new file mode 100644
index 0000000000..608054becb
--- /dev/null
+++ b/core/optimizer/inlining/inlining-tests.factor
@@ -0,0 +1,10 @@
+IN: optimizer.inlining.tests
+USING: tools.test optimizer.inlining ;
+
+\ word-flat-length must-infer
+
+\ inlining-math-method must-infer
+
+\ optimistic-inline? must-infer
+
+\ find-identity must-infer
diff --git a/core/optimizer/inlining/inlining.factor b/core/optimizer/inlining/inlining.factor
index 8447d1be5f..33c8244b4c 100755
--- a/core/optimizer/inlining/inlining.factor
+++ b/core/optimizer/inlining/inlining.factor
@@ -3,10 +3,11 @@
 USING: arrays generic assocs inference inference.class
 inference.dataflow inference.backend inference.state io kernel
 math namespaces sequences vectors words quotations hashtables
-combinators classes classes.algebra generic.math continuations
-optimizer.def-use optimizer.backend generic.standard
-optimizer.specializers optimizer.def-use optimizer.pattern-match
-generic.standard optimizer.control kernel.private ;
+combinators classes classes.algebra generic.math
+optimizer.math.partial continuations optimizer.def-use
+optimizer.backend generic.standard optimizer.specializers
+optimizer.def-use optimizer.pattern-match generic.standard
+optimizer.control kernel.private ;
 IN: optimizer.inlining
 
 : remember-inlining ( node history -- )
@@ -53,8 +54,6 @@ DEFER: (flat-length)
     [ word-def (flat-length) ] with-scope ;
 
 ! Single dispatch method inlining optimization
-: specific-method ( class word -- class ) order min-class ;
-
 : node-class# ( node n -- class )
     over node-in-d <reversed> ?nth node-class ;
 
@@ -72,6 +71,7 @@ DEFER: (flat-length)
 ! Partial dispatch of math-generic words
 : normalize-math-class ( class -- class' )
     {
+        null
         fixnum bignum integer
         ratio rational
         float real
@@ -79,21 +79,31 @@ DEFER: (flat-length)
         object
     } [ class< ] with find nip ;
 
-: math-both-known? ( word left right -- ? )
-    math-class-max swap specific-method ;
-
-: inline-math-method ( #call word -- node )
-    over node-input-classes
+: inlining-math-method ( #call word -- quot/f )
+    swap node-input-classes
     [ first normalize-math-class ]
     [ second normalize-math-class ] bi
-    3dup math-both-known?
-    [ math-method f splice-quot ]
-    [ 2drop 2drop t ] if ;
+    3dup math-both-known? [ math-method* ] [ 3drop f ] if ;
+
+: inline-math-method ( #call word -- node/t )
+    [ drop ] [ inlining-math-method ] 2bi
+    dup [ f splice-quot ] [ 2drop t ] if ;
+
+: inline-math-partial ( #call word -- node/t )
+    [ drop ]
+    [
+        "derived-from" word-prop first
+        inlining-math-method dup
+    ]
+    [ nip 1quotation ] 2tri
+    [ = not ] [ drop ] 2bi and
+    [ f splice-quot ] [ 2drop t ] if ;
 
 : inline-method ( #call -- node )
     dup node-param {
         { [ dup standard-generic? ] [ inline-standard-method ] }
         { [ dup math-generic? ] [ inline-math-method ] }
+        { [ dup math-partial? ] [ inline-math-partial ] }
         [ 2drop t ]
     } cond ;
 
@@ -183,7 +193,7 @@ DEFER: (flat-length)
     nip dup [ second ] when ;
 
 : apply-identities ( node -- node/f )
-    dup find-identity dup [ f splice-quot ] [ 2drop f ] if ;
+    dup find-identity f splice-quot ;
 
 : optimistic-inline? ( #call -- ? )
     dup node-param "specializer" word-prop dup [
diff --git a/core/optimizer/known-words/known-words.factor b/core/optimizer/known-words/known-words.factor
index cf71af216e..91d0c1c0de 100755
--- a/core/optimizer/known-words/known-words.factor
+++ b/core/optimizer/known-words/known-words.factor
@@ -83,21 +83,11 @@ sequences.private combinators ;
 ] "constraints" set-word-prop
 
 ! eq? on the same object is always t
-{ eq? bignum= float= number= = } {
+{ eq? = } {
     { { @ @ } [ 2drop t ] }
 } define-identities
 
 ! Specializers
-{ 1+ 1- sq neg recip sgn } [
-    { number } "specializer" set-word-prop
-] each
-
-\ 2/ { fixnum } "specializer" set-word-prop
-
-{ min max } [
-    { number number } "specializer" set-word-prop
-] each
-
 { first first2 first3 first4 }
 [ { array } "specializer" set-word-prop ] each
 
diff --git a/core/optimizer/math/math.factor b/core/optimizer/math/math.factor
index 4ec4bfeb36..ab8a1f3eda 100755
--- a/core/optimizer/math/math.factor
+++ b/core/optimizer/math/math.factor
@@ -8,103 +8,104 @@ namespaces assocs quotations math.intervals sequences.private
 combinators splitting layouts math.parser classes
 classes.algebra generic.math optimizer.pattern-match
 optimizer.backend optimizer.def-use optimizer.inlining
-generic.standard system ;
+optimizer.math.partial generic.standard system accessors ;
 
-{ + bignum+ float+ fixnum+fast } {
+: define-math-identities ( word identities -- )
+    >r all-derived-ops r> define-identities ;
+
+\ number= {
+    { { @ @ } [ 2drop t ] }
+} define-math-identities
+
+\ + {
     { { number 0 } [ drop ] }
     { { 0 number } [ nip ] }
-} define-identities
+} define-math-identities
 
-{ fixnum+ } {
-    { { number 0 } [ drop ] }
-    { { 0 number } [ nip ] }
-} define-identities
-
-{ - fixnum- bignum- float- fixnum-fast } {
+\ - {
     { { number 0 } [ drop ] }
     { { @ @ } [ 2drop 0 ] }
-} define-identities
+} define-math-identities
 
-{ < fixnum< bignum< float< } {
+\ < {
     { { @ @ } [ 2drop f ] }
-} define-identities
+} define-math-identities
 
-{ <= fixnum<= bignum<= float<= } {
+\ <= {
     { { @ @ } [ 2drop t ] }
-} define-identities
+} define-math-identities
 
-{ > fixnum> bignum> float>= } {
+\ > {
     { { @ @ } [ 2drop f ] }
-} define-identities
+} define-math-identities
 
-{ >= fixnum>= bignum>= float>= } {
+\ >= {
     { { @ @ } [ 2drop t ] }
-} define-identities
+} define-math-identities
 
-{ * fixnum* bignum* float* } {
+\ * {
     { { number 1 } [ drop ] }
     { { 1 number } [ nip ] }
     { { number 0 } [ nip ] }
     { { 0 number } [ drop ] }
     { { number -1 } [ drop 0 swap - ] }
     { { -1 number } [ nip 0 swap - ] }
-} define-identities
+} define-math-identities
 
-{ / fixnum/i bignum/i float/f } {
+\ / {
     { { number 1 } [ drop ] }
     { { number -1 } [ drop 0 swap - ] }
-} define-identities
+} define-math-identities
 
-{ fixnum-mod bignum-mod } {
-    { { number 1 } [ 2drop 0 ] }
-} define-identities
+\ mod {
+    { { integer 1 } [ 2drop 0 ] }
+} define-math-identities
 
-{ bitand fixnum-bitand bignum-bitand } {
+\ rem {
+    { { integer 1 } [ 2drop 0 ] }
+} define-math-identities
+
+\ bitand {
     { { number -1 } [ drop ] }
     { { -1 number } [ nip ] }
     { { @ @ } [ drop ] }
     { { number 0 } [ nip ] }
     { { 0 number } [ drop ] }
-} define-identities
+} define-math-identities
 
-{ bitor fixnum-bitor bignum-bitor } {
+\ bitor {
     { { number 0 } [ drop ] }
     { { 0 number } [ nip ] }
     { { @ @ } [ drop ] }
     { { number -1 } [ nip ] }
     { { -1 number } [ drop ] }
-} define-identities
+} define-math-identities
 
-{ bitxor fixnum-bitxor bignum-bitxor } {
+\ bitxor {
     { { number 0 } [ drop ] }
     { { 0 number } [ nip ] }
     { { number -1 } [ drop bitnot ] }
     { { -1 number } [ nip bitnot ] }
     { { @ @ } [ 2drop 0 ] }
-} define-identities
+} define-math-identities
 
-{ shift fixnum-shift fixnum-shift-fast bignum-shift } {
+\ shift {
     { { 0 number } [ drop ] }
     { { number 0 } [ drop ] }
-} define-identities
+} define-math-identities
 
 : math-closure ( class -- newclass )
-    { fixnum integer rational real }
+    { null fixnum bignum integer rational float real number }
     [ class< ] with find nip number or ;
 
 : fits? ( interval class -- ? )
     "interval" word-prop dup
     [ interval-subset? ] [ 2drop t ] if ;
 
-: math-output-class ( node min -- newclass )
-    #! if min is f, it means we just want to use the declared
-    #! output class from the "infer-effect".
-    dup [
-        swap node-in-d
-        [ value-class* math-closure math-class-max ] each
-    ] [
-        2drop f
-    ] if ;
+: math-output-class ( node upgrades -- newclass )
+    >r
+    in-d>> null [ value-class* math-closure math-class-max ] reduce
+    dup r> at swap or ;
 
 : won't-overflow? ( interval node -- ? )
     node-in-d [ value-class* fixnum class< ] all?
@@ -123,28 +124,18 @@ generic.standard system ;
         2drop f
     ] if ; inline
 
-: math-output-class/interval-1 ( node min word -- classes intervals )
-    pick >r
-    >r over r>
-    math-output-interval-1
-    >r math-output-class r>
-    r> post-process ; inline
+: math-output-class/interval-1 ( node word -- classes intervals )
+    [ drop { } math-output-class 1array ]
+    [ math-output-interval-1 1array ] 2bi ;
 
 {
-    { 1+ integer interval-1+ }
-    { 1- integer interval-1- }
-    { neg integer interval-neg }
-    { shift integer interval-recip }
-    { bitnot fixnum interval-bitnot }
-    { fixnum-bitnot f interval-bitnot }
-    { bignum-bitnot f interval-bitnot }
-    { 2/ fixnum interval-2/ }
-    { sq integer f }
+    { bitnot interval-bitnot }
+    { fixnum-bitnot interval-bitnot }
+    { bignum-bitnot interval-bitnot }
 } [
-    first3 [
-        math-output-class/interval-1
-    ] 2curry "output-classes" set-word-prop
-] each
+    [ math-output-class/interval-1 ] curry
+    "output-classes" set-word-prop
+] assoc-each
 
 : intervals ( node -- i1 i2 )
     node-in-d first2 [ value-interval* ] bi@ ;
@@ -156,7 +147,7 @@ generic.standard system ;
         2drop f
     ] if ; inline
 
-: math-output-class/interval-2 ( node min word -- classes intervals )
+: math-output-class/interval-2 ( node upgrades word -- classes intervals )
     pick >r
     >r over r>
     math-output-interval-2
@@ -164,47 +155,18 @@ generic.standard system ;
     r> post-process ; inline
 
 {
-    { + integer interval+ }
-    { - integer interval- }
-    { * integer interval* }
-    { / rational interval/ }
-    { /i integer interval/i }
-
-    { fixnum+ f interval+ }
-    { fixnum+fast f interval+ }
-    { fixnum- f interval- }
-    { fixnum-fast f interval- }
-    { fixnum* f interval* }
-    { fixnum*fast f interval* }
-    { fixnum/i f interval/i }
-
-    { bignum+ f interval+ }
-    { bignum- f interval- }
-    { bignum* f interval* }
-    { bignum/i f interval/i }
-    { bignum-shift f interval-shift-safe }
-
-    { float+ f interval+ }
-    { float- f interval- }
-    { float* f interval* }
-    { float/f f interval/ }
-
-    { min fixnum interval-min }
-    { max fixnum interval-max }
+    { + { { fixnum integer } } interval+ }
+    { - { { fixnum integer } } interval- }
+    { * { { fixnum integer } } interval* }
+    { / { { fixnum rational } { integer rational } } interval/ }
+    { /i { { fixnum integer } } interval/i }
+    { shift { { fixnum integer } } interval-shift-safe }
 } [
     first3 [
-        math-output-class/interval-2
-    ] 2curry "output-classes" set-word-prop
-] each
-
-{ fixnum-shift fixnum-shift-fast shift } [
-    [
-        dup
-        node-in-d second value-interval*
-        -1./0. 0 [a,b] interval-subset? fixnum integer ?
-        \ interval-shift-safe
-        math-output-class/interval-2
-    ] "output-classes" set-word-prop
+        [
+            math-output-class/interval-2
+        ] 2curry "output-classes" set-word-prop
+    ] 2curry each-derived-op
 ] each
 
 : real-value? ( value -- n ? )
@@ -235,22 +197,18 @@ generic.standard system ;
     r> post-process ; inline
 
 {
-    { mod fixnum mod-range }
-    { fixnum-mod f mod-range }
-    { bignum-mod f mod-range }
-    { float-mod f mod-range }
+    { mod { } mod-range }
+    { rem { { fixnum integer } } rem-range }
 
-    { rem integer rem-range }
-
-    { bitand fixnum bitand-range }
-    { fixnum-bitand f bitand-range }
-
-    { bitor fixnum f }
-    { bitxor fixnum f }
+    { bitand { } bitand-range }
+    { bitor { } f }
+    { bitxor { } f }
 } [
     first3 [
-        math-output-class/interval-special
-    ] 2curry "output-classes" set-word-prop
+        [
+            math-output-class/interval-special
+        ] 2curry "output-classes" set-word-prop
+    ] 2curry each-derived-op
 ] each
 
 : twiddle-interval ( i1 -- i2 )
@@ -280,26 +238,12 @@ generic.standard system ;
     { <= assume<= assume> }
     { > assume> assume<= }
     { >= assume>= assume< }
-
-    { fixnum< assume< assume>= }
-    { fixnum<= assume<= assume> }
-    { fixnum> assume> assume<= }
-    { fixnum>= assume>= assume< }
-
-    { bignum< assume< assume>= }
-    { bignum<= assume<= assume> }
-    { bignum> assume> assume<= }
-    { bignum>= assume>= assume< }
-
-    { float< assume< assume>= }
-    { float<= assume<= assume> }
-    { float> assume> assume<= }
-    { float>= assume>= assume< }
 } [
-    first3
-    [
-        [ comparison-constraints ] with-scope
-    ] 2curry "constraints" set-word-prop
+    first3 [
+        [
+            [ comparison-constraints ] with-scope
+        ] 2curry "constraints" set-word-prop
+    ] 2curry each-derived-op
 ] each
 
 {
@@ -348,22 +292,20 @@ most-negative-fixnum most-positive-fixnum [a,b]
 
 ! Removing overflow checks
 : remove-overflow-check? ( #call -- ? )
-    dup node-out-d first node-class fixnum class< ;
+    dup out-d>> first node-class
+    [ fixnum class< ] [ null eq? not ] bi and ;
 
 {
     { + [ fixnum+fast ] }
+    { +-integer-fixnum [ fixnum+fast ] }
     { - [ fixnum-fast ] }
     { * [ fixnum*fast ] }
+    { *-integer-fixnum [ fixnum*fast ] }
+    { shift [ fixnum-shift-fast ] }
     { fixnum+ [ fixnum+fast ] }
     { fixnum- [ fixnum-fast ] }
     { fixnum* [ fixnum*fast ] }
-    ! these are here as an optimization. if they weren't given
-    ! explicitly, the same would be inferred after an extra
-    ! optimization step (see optimistic-inline?)
-    { 1+ [ 1 fixnum+fast ] }
-    { 1- [ 1 fixnum-fast ] }
-    { 2/ [ -1 fixnum-shift ] }
-    { neg [ 0 swap fixnum-fast ] }
+    { fixnum-shift [ fixnum-shift-fast ] }
 } [
     [
         [ dup remove-overflow-check? ] ,
@@ -397,26 +339,13 @@ most-negative-fixnum most-positive-fixnum [a,b]
     { <= interval<= }
     { > interval> }
     { >= interval>= }
-
-    { fixnum< interval< }
-    { fixnum<= interval<= }
-    { fixnum> interval> }
-    { fixnum>= interval>= }
-
-    { bignum< interval< }
-    { bignum<= interval<= }
-    { bignum> interval> }
-    { bignum>= interval>= }
-
-    { float< interval< }
-    { float<= interval<= }
-    { float> interval> }
-    { float>= interval>= }
 } [
     [
-        dup [ dupd foldable-comparison? ] curry ,
-        [ fold-comparison ] curry ,
-    ] { } make 1array define-optimizers
+        [
+            dup [ dupd foldable-comparison? ] curry ,
+            [ fold-comparison ] curry ,
+        ] { } make 1array define-optimizers
+    ] curry each-derived-op
 ] assoc-each
 
 ! The following words are handled in a similar way except if
@@ -426,44 +355,68 @@ most-negative-fixnum most-positive-fixnum [a,b]
     swap sole-consumer
     dup #call? [ node-param eq? ] [ 2drop f ] if ;
 
-: coereced-to-fixnum? ( #call -- ? )
-    \ >fixnum consumed-by? ;
+: coerced-to-fixnum? ( #call -- ? )
+    dup dup node-in-d [ node-class integer class< ] with all?
+    [ \ >fixnum consumed-by? ] [ drop f ] if ;
 
 {
-    { fixnum+ [ fixnum+fast ] }
-    { fixnum- [ fixnum-fast ] }
-    { fixnum* [ fixnum*fast ] }
+    { + [ [ >fixnum ] bi@ fixnum+fast ] }
+    { - [ [ >fixnum ] bi@ fixnum-fast ] }
+    { * [ [ >fixnum ] bi@ fixnum*fast ] }
 } [
-    [
+    >r derived-ops r> [
         [
-            dup remove-overflow-check?
-            over coereced-to-fixnum? or
-        ] ,
-        [ f splice-quot ] curry ,
-    ] { } make 1array define-optimizers
+            [
+                dup remove-overflow-check?
+                over coerced-to-fixnum? or
+            ] ,
+            [ f splice-quot ] curry ,
+        ] { } make 1array define-optimizers
+    ] curry each
 ] assoc-each
 
-: fixnum-shift-fast-pos? ( node -- ? )
-    #! Shifting 1 to the left won't overflow if the shift
-    #! count is small enough
-    dup dup node-in-d first node-literal 1 = [
-        dup node-in-d second node-interval
-        0 cell-bits tag-bits get - 2 - [a,b] interval-subset?
-    ] [ drop f ] if ;
+: convert-rem-to-and? ( #call -- ? )
+    dup node-in-d {
+        { [ 2dup first node-class integer class< not ] [ f ] }
+        { [ 2dup second node-literal integer? not ] [ f ] }
+        { [ 2dup second node-literal power-of-2? not ] [ f ] }
+        [ t ]
+    } cond 2nip ;
 
-: fixnum-shift-fast-neg? ( node -- ? )
-    #! Shifting any number to the right won't overflow if the
-    #! shift count is small enough
-    dup node-in-d second node-interval
-    cell-bits 1- neg 0 [a,b] interval-subset? ;
+: convert-mod-to-and? ( #call -- ? )
+    dup dup node-in-d first node-interval 0 [a,inf] interval-subset?
+    [ convert-rem-to-and? ] [ drop f ] if ;
 
-: fixnum-shift-fast? ( node -- ? )
-    dup fixnum-shift-fast-pos?
-    [ drop t ] [ fixnum-shift-fast-neg? ] if ;
+: convert-mod-to-and ( #call -- node )
+    dup
+    dup node-in-d second node-literal 1-
+    [ nip bitand ] curry f splice-quot ;
 
-\ fixnum-shift {
+\ mod [
     {
-        [ dup fixnum-shift-fast? ]
-        [ [ fixnum-shift-fast ] f splice-quot ]
+        {
+            [ dup convert-mod-to-and? ]
+            [ convert-mod-to-and ]
+        }
+    } define-optimizers
+] each-derived-op
+
+\ rem {
+    {
+        [ dup convert-rem-to-and? ]
+        [ convert-mod-to-and ]
+    }
+} define-optimizers
+
+: fixnumify-bitand? ( #call -- ? )
+    dup node-in-d second node-interval fixnum fits? ;
+
+: fixnumify-bitand ( #call -- node )
+    [ [ >fixnum ] bi@ fixnum-bitand ] f splice-quot ;
+
+\ bitand {
+    {
+        [ dup fixnumify-bitand? ]
+        [ fixnumify-bitand ]
     }
 } define-optimizers
diff --git a/core/optimizer/math/partial/partial-tests.factor b/core/optimizer/math/partial/partial-tests.factor
new file mode 100644
index 0000000000..671933b682
--- /dev/null
+++ b/core/optimizer/math/partial/partial-tests.factor
@@ -0,0 +1,13 @@
+IN: optimizer.math.partial.tests
+USING: optimizer.math.partial tools.test math kernel
+sequences ;
+
+[ t ] [ \ + integer fixnum math-both-known? ] unit-test
+[ t ] [ \ + bignum fixnum math-both-known? ] unit-test
+[ t ] [ \ + integer bignum math-both-known? ] unit-test
+[ t ] [ \ + float fixnum math-both-known? ] unit-test
+[ f ] [ \ + real fixnum math-both-known? ] unit-test
+[ f ] [ \ + object number math-both-known? ] unit-test
+[ f ] [ \ number= fixnum object math-both-known? ] unit-test
+[ t ] [ \ number= integer fixnum math-both-known? ] unit-test
+[ f ] [ \ >fixnum \ shift derived-ops memq? ] unit-test
diff --git a/core/optimizer/math/partial/partial.factor b/core/optimizer/math/partial/partial.factor
new file mode 100644
index 0000000000..bbe1d0a83f
--- /dev/null
+++ b/core/optimizer/math/partial/partial.factor
@@ -0,0 +1,172 @@
+! Copyright (C) 2008 Slava Pestov.
+! See http://factorcode.org/license.txt for BSD license.
+USING: kernel kernel.private math math.private words
+sequences parser namespaces assocs quotations arrays
+generic generic.math hashtables effects ;
+IN: optimizer.math.partial
+
+! Partial dispatch.
+
+! This code will be overhauled and generalized when
+! multi-methods go into the core.
+PREDICATE: math-partial < word
+    "derived-from" word-prop >boolean ;
+
+: fixnum-integer-op ( a b fix-word big-word -- c )
+    pick tag 0 eq? [
+        drop execute
+    ] [
+        >r drop >r fixnum>bignum r> r> execute
+    ] if ; inline
+
+: integer-fixnum-op ( a b fix-word big-word -- c )
+    >r pick tag 0 eq? [
+        r> drop execute
+    ] [
+        drop fixnum>bignum r> execute
+    ] if ; inline
+
+: integer-integer-op ( a b fix-word big-word -- c )
+    pick tag 0 eq? [
+        integer-fixnum-op
+    ] [
+        >r drop over tag 0 eq? [
+            >r fixnum>bignum r> r> execute
+        ] [
+            r> execute
+        ] if
+    ] if ; inline
+
+<<
+: integer-op-combinator ( triple -- word )
+    [
+        [ second word-name % "-" % ]
+        [ third word-name % "-op" % ]
+        bi
+    ] "" make in get lookup ;
+
+: integer-op-word ( triple fix-word big-word -- word )
+    [
+        drop
+        word-name "fast" tail? >r
+        [ "-" % ] [ word-name % ] interleave
+        r> [ "-fast" % ] when
+    ] "" make in get create ;
+
+: integer-op-quot ( word fix-word big-word -- quot )
+    rot integer-op-combinator 1quotation 2curry ;
+
+: define-integer-op-word ( word fix-word big-word -- )
+    [
+        [ integer-op-word ] [ integer-op-quot ] 3bi
+        2 1 <effect> define-declared
+    ]
+    [
+        [ integer-op-word ] [ 2drop ] 3bi
+        "derived-from" set-word-prop
+    ] 3bi ;
+
+: define-integer-op-words ( words fix-word big-word -- )
+    [ define-integer-op-word ] 2curry each ;
+
+: integer-op-triples ( word -- triples )
+    {
+        { fixnum integer }
+        { integer fixnum }
+        { integer integer }
+    } swap [ prefix ] curry map ;
+
+: define-integer-ops ( word fix-word big-word -- )
+    >r >r integer-op-triples r> r>
+    [ define-integer-op-words ]
+    [ [ 2drop ] [ [ integer-op-word ] 2curry map ] 3bi zip % ]
+    3bi ;
+
+: define-math-ops ( op -- )
+    { fixnum bignum float }
+    [ [ dup 3array ] [ swap method ] 2bi ] with { } map>assoc
+    [ nip ] assoc-subset
+    [ word-def peek ] assoc-map % ;
+
+SYMBOL: math-ops
+
+[
+    \ +       define-math-ops
+    \ -       define-math-ops
+    \ *       define-math-ops
+    \ shift   define-math-ops
+    \ mod     define-math-ops
+    \ /i      define-math-ops
+
+    \ bitand  define-math-ops
+    \ bitor   define-math-ops
+    \ bitxor  define-math-ops
+
+    \ <       define-math-ops
+    \ <=      define-math-ops
+    \ >       define-math-ops
+    \ >=      define-math-ops
+    \ number= define-math-ops
+
+    \ + \ fixnum+ \ bignum+ define-integer-ops
+    \ - \ fixnum- \ bignum- define-integer-ops
+    \ * \ fixnum* \ bignum* define-integer-ops
+    \ shift \ fixnum-shift \ bignum-shift define-integer-ops
+    \ mod \ fixnum-mod \ bignum-mod define-integer-ops
+    \ /i \ fixnum/i \ bignum/i define-integer-ops
+    
+    \ bitand \ fixnum-bitand \ bignum-bitand define-integer-ops
+    \ bitor \ fixnum-bitor \ bignum-bitor define-integer-ops
+    \ bitxor \ fixnum-bitxor \ bignum-bitxor define-integer-ops
+    
+    \ < \ fixnum< \ bignum< define-integer-ops
+    \ <= \ fixnum<= \ bignum<= define-integer-ops
+    \ > \ fixnum> \ bignum> define-integer-ops
+    \ >= \ fixnum>= \ bignum>= define-integer-ops
+    \ number= \ eq? \ bignum= define-integer-ops
+] { } make >hashtable math-ops set-global
+
+SYMBOL: fast-math-ops
+
+[
+    { { + fixnum fixnum } fixnum+fast } ,
+    { { - fixnum fixnum } fixnum-fast } ,
+    { { * fixnum fixnum } fixnum*fast } ,
+    { { shift fixnum fixnum } fixnum-shift-fast } ,
+
+    \ + \ fixnum+fast \ bignum+ define-integer-ops
+    \ - \ fixnum-fast \ bignum- define-integer-ops
+    \ * \ fixnum*fast \ bignum* define-integer-ops
+    \ shift \ fixnum-shift-fast \ bignum-shift define-integer-ops
+] { } make >hashtable fast-math-ops set-global
+
+>>
+
+: math-op ( word left right -- word' ? )
+    3array math-ops get at* ;
+
+: math-method* ( word left right -- quot )
+    3dup math-op
+    [ >r 3drop r> 1quotation ] [ drop math-method ] if ;
+
+: math-both-known? ( word left right -- ? )
+    3dup math-op
+    [ 2drop 2drop t ]
+    [ drop math-class-max swap specific-method >boolean ] if ;
+
+: (derived-ops) ( word assoc -- words )
+    swap [ rot first eq? nip ] curry assoc-subset values ;
+
+: derived-ops ( word -- words )
+    [ 1array ]
+    [ math-ops get (derived-ops) ]
+    bi append ;
+
+: fast-derived-ops ( word -- words )
+    fast-math-ops get (derived-ops) ;
+
+: all-derived-ops ( word -- words )
+    [ derived-ops ] [ fast-derived-ops ] bi append ;
+
+: each-derived-op ( word quot -- )
+    >r derived-ops r> each ; inline
diff --git a/core/optimizer/optimizer-tests.factor b/core/optimizer/optimizer-tests.factor
index 1a48e353a2..14dcd62c61 100755
--- a/core/optimizer/optimizer-tests.factor
+++ b/core/optimizer/optimizer-tests.factor
@@ -14,40 +14,6 @@ IN: optimizer.tests
     H{ { 1 2 } { 3 4 } } H{ { 2 3 } } union*
 ] unit-test
 
-! Test method inlining
-[ f ] [ fixnum { } min-class ] unit-test
-
-[ string ] [
-    \ string
-    [ integer string array reversed sbuf
-    slice vector quotation ]
-    sort-classes min-class
-] unit-test
-
-[ fixnum ] [
-    \ fixnum
-    [ fixnum integer object ]
-    sort-classes min-class
-] unit-test
-
-[ integer ] [
-    \ fixnum
-    [ integer float object ]
-    sort-classes min-class
-] unit-test
-
-[ object ] [
-    \ word
-    [ integer float object ]
-    sort-classes min-class
-] unit-test
-
-[ reversed ] [
-    \ reversed
-    [ integer reversed slice ]
-    sort-classes min-class
-] unit-test
-
 GENERIC: xyz ( obj -- obj )
 M: array xyz xyz ;
 
@@ -325,7 +291,6 @@ TUPLE: silly-tuple a b ;
 
 [ 1 2 3 ] [ lift-loop-tail-test-2 ] unit-test
 
-! Make sure we don't lose
 GENERIC: generic-inline-test ( x -- y )
 M: integer generic-inline-test ;
 
@@ -342,6 +307,7 @@ M: integer generic-inline-test ;
     generic-inline-test
     generic-inline-test ;
 
+! Inlining all of the above should only take two passes
 [ { t f } ] [
     \ generic-inline-test-1 word-def dataflow
     [ optimize-1 , optimize-1 , drop ] { } make
@@ -374,3 +340,12 @@ HINTS: recursive-inline-hang-3 array ;
 USE: sequences.private
 
 [ ] [ { (3append) } compile ] unit-test
+
+! Wow
+: counter-example ( a b c d -- a' b' c' d' )
+    dup 0 > [ 1 - >r rot 2 * r> counter-example ] when ; inline
+
+: counter-example' ( -- a' b' c' d' )
+    1 2 3.0 3 counter-example ;
+
+[ 2 4 6.0 0 ] [ counter-example' ] unit-test
diff --git a/core/optimizer/optimizer.factor b/core/optimizer/optimizer.factor
index 9e898450cc..23cba3ea4c 100755
--- a/core/optimizer/optimizer.factor
+++ b/core/optimizer/optimizer.factor
@@ -2,7 +2,7 @@
 ! See http://factorcode.org/license.txt for BSD license.
 USING: kernel namespaces optimizer.backend optimizer.def-use
 optimizer.known-words optimizer.math optimizer.control
-optimizer.inlining inference.class ;
+optimizer.collect optimizer.inlining inference.class ;
 IN: optimizer
 
 : optimize-1 ( node -- newnode ? )
@@ -10,10 +10,13 @@ IN: optimizer
         H{ } clone class-substitutions set
         H{ } clone literal-substitutions set
         H{ } clone value-substitutions set
-        dup compute-def-use
+
+        collect-label-infos
+        compute-def-use
         kill-values
-        dup detect-loops
-        dup infer-classes
+        detect-loops
+        infer-classes
+
         optimizer-changed off
         optimize-nodes
         optimizer-changed get
diff --git a/core/prettyprint/backend/backend.factor b/core/prettyprint/backend/backend.factor
index c9019b029d..c9933d5be2 100755
--- a/core/prettyprint/backend/backend.factor
+++ b/core/prettyprint/backend/backend.factor
@@ -1,11 +1,10 @@
 ! Copyright (C) 2003, 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: arrays byte-arrays byte-vectors bit-arrays bit-vectors
-generic hashtables io assocs kernel math namespaces sequences
-strings sbufs io.styles vectors words prettyprint.config
-prettyprint.sections quotations io io.files math.parser effects
-classes.tuple classes.tuple.private classes float-arrays
-float-vectors ;
+USING: arrays byte-arrays bit-arrays generic hashtables io
+assocs kernel math namespaces sequences strings sbufs io.styles
+vectors words prettyprint.config prettyprint.sections quotations
+io io.files math.parser effects classes.tuple
+classes.tuple.private classes float-arrays ;
 IN: prettyprint.backend
 
 GENERIC: pprint* ( obj -- )
@@ -140,11 +139,8 @@ M: curry pprint-delims drop \ [ \ ] ;
 M: compose pprint-delims drop \ [ \ ] ;
 M: array pprint-delims drop \ { \ } ;
 M: byte-array pprint-delims drop \ B{ \ } ;
-M: byte-vector pprint-delims drop \ BV{ \ } ;
 M: bit-array pprint-delims drop \ ?{ \ } ;
-M: bit-vector pprint-delims drop \ ?V{ \ } ;
 M: float-array pprint-delims drop \ F{ \ } ;
-M: float-vector pprint-delims drop \ FV{ \ } ;
 M: vector pprint-delims drop \ V{ \ } ;
 M: hashtable pprint-delims drop \ H{ \ } ;
 M: tuple pprint-delims drop \ T{ \ } ;
@@ -156,9 +152,6 @@ GENERIC: >pprint-sequence ( obj -- seq )
 M: object >pprint-sequence ;
 
 M: vector >pprint-sequence ;
-M: bit-vector >pprint-sequence ;
-M: byte-vector >pprint-sequence ;
-M: float-vector >pprint-sequence ;
 M: curry >pprint-sequence ;
 M: compose >pprint-sequence ;
 M: hashtable >pprint-sequence >alist ;
diff --git a/core/sequences/sequences-docs.factor b/core/sequences/sequences-docs.factor
index bb3dc9337e..0dea0f43d9 100755
--- a/core/sequences/sequences-docs.factor
+++ b/core/sequences/sequences-docs.factor
@@ -76,10 +76,7 @@ ARTICLE: "sequences-reshape" "Reshaping sequences"
 { $subsection reversed }
 { $subsection <reversed> }
 "Transposing a matrix:"
-{ $subsection flip }
-"A " { $emphasis "column" } " presents a column of a matrix represented as a sequence of rows:"
-{ $subsection column }
-{ $subsection <column> } ;
+{ $subsection flip } ;
 
 ARTICLE: "sequences-appending" "Appending sequences"
 { $subsection append }
@@ -785,23 +782,6 @@ HELP: <slice>
 
 { <slice> subseq } related-words
 
-HELP: column
-{ $class-description "A virtual sequence which presents a fixed column of a matrix represented as a sequence of rows. New instances can be created by calling " { $link <column> } "." } ;
-
-HELP: <column> ( seq n -- column )
-{ $values { "seq" sequence } { "n" "a non-negative integer" } { "column" column } }
-{ $description "Outputs a new virtual sequence which presents a fixed column of a matrix represented as a sequence of rows." "The " { $snippet "i" } "th element of a column is the " { $snippet "n" } "th element of the " { $snippet "i" } "th element of" { $snippet "seq" } ". Every element of " { $snippet "seq" } " must be a sequence, and all sequences must have equal length." }
-{ $examples
-    { $example
-        "USING: arrays prettyprint sequences ;"
-        "{ { 1 2 3 } { 4 5 6 } { 7 8 9 } } 0 <column> >array ."
-        "{ 1 4 7 }"
-    }
-}
-{ $notes
-    "In the same sense that " { $link <reversed> } " is a virtual variant of " { $link reverse } ", " { $link <column> } " is a virtual variant of " { $snippet "swap [ nth ] curry map" } "."
-} ;
-
 HELP: repetition
 { $class-description "A virtual sequence consisting of " { $link repetition-elt } " repeated " { $link repetition-len } " times. Repetitions are created by calling " { $link <repetition> } "." } ;
 
diff --git a/core/sequences/sequences-tests.factor b/core/sequences/sequences-tests.factor
index e8db18b3d0..100184798c 100755
--- a/core/sequences/sequences-tests.factor
+++ b/core/sequences/sequences-tests.factor
@@ -224,13 +224,6 @@ unit-test
 [ V{ 1 2 3 } ]
 [ 3 V{ 1 3 2 } clone [ push-new ] keep ] unit-test
 
-! Columns
-{ { 1 2 3 } { 4 5 6 } { 7 8 9 } } [ clone ] map "seq" set
-
-[ { 1 4 7 } ] [ "seq" get 0 <column> >array ] unit-test
-[ ] [ "seq" get 1 <column> [ sq ] change-each ] unit-test
-[ { 4 25 64 } ] [ "seq" get 1 <column> >array ] unit-test
-
 ! erg's random tester found this one
 [ SBUF" 12341234" ] [
     9 <sbuf> dup "1234" swap push-all dup dup swap push-all
diff --git a/core/sequences/sequences.factor b/core/sequences/sequences.factor
index 252df54391..924d9a05cb 100755
--- a/core/sequences/sequences.factor
+++ b/core/sequences/sequences.factor
@@ -215,18 +215,6 @@ M: slice length dup slice-to swap slice-from - ;
 
 INSTANCE: slice virtual-sequence
 
-! A column of a matrix
-TUPLE: column seq col ;
-
-C: <column> column
-
-M: column virtual-seq column-seq ;
-M: column virtual@
-    dup column-col -rot column-seq nth bounds-check ;
-M: column length column-seq length ;
-
-INSTANCE: column virtual-sequence
-
 ! One element repeated many times
 TUPLE: repetition len elt ;
 
@@ -703,5 +691,5 @@ PRIVATE>
 : flip ( matrix -- newmatrix )
     dup empty? [
         dup [ length ] map infimum
-        [ <column> dup like ] with map
+        swap [ [ nth-unsafe ] with { } map-as ] curry { } map-as
     ] unless ;
diff --git a/core/syntax/syntax-docs.factor b/core/syntax/syntax-docs.factor
index c2eb411f0a..a2d15d2981 100755
--- a/core/syntax/syntax-docs.factor
+++ b/core/syntax/syntax-docs.factor
@@ -150,18 +150,6 @@ ARTICLE: "syntax-byte-arrays" "Byte array syntax"
 { $subsection POSTPONE: B{ }
 "Byte arrays are documented in " { $link "byte-arrays" } "." ;
 
-ARTICLE: "syntax-bit-vectors" "Bit vector syntax"
-{ $subsection POSTPONE: ?V{ }
-"Bit vectors are documented in " { $link "bit-vectors" } "." ;
-
-ARTICLE: "syntax-float-vectors" "Float vector syntax"
-{ $subsection POSTPONE: FV{ }
-"Float vectors are documented in " { $link "float-vectors" } "." ;
-
-ARTICLE: "syntax-byte-vectors" "Byte vector syntax"
-{ $subsection POSTPONE: BV{ }
-"Byte vectors are documented in " { $link "byte-vectors" } "." ;
-
 ARTICLE: "syntax-pathnames" "Pathname syntax"
 { $subsection POSTPONE: P" }
 "Pathnames are documented in " { $link "pathnames" } "." ;
@@ -182,9 +170,6 @@ $nl
 { $subsection "syntax-float-arrays" }
 { $subsection "syntax-vectors" }
 { $subsection "syntax-sbufs" }
-{ $subsection "syntax-bit-vectors" }
-{ $subsection "syntax-byte-vectors" }
-{ $subsection "syntax-float-vectors" }
 { $subsection "syntax-hashtables" }
 { $subsection "syntax-tuples" }
 { $subsection "syntax-pathnames" } ;
@@ -291,30 +276,12 @@ HELP: B{
 { $description "Marks the beginning of a literal byte array. Literal byte arrays are terminated by " { $link POSTPONE: } } "." } 
 { $examples { $code "B{ 1 2 3 }" } } ;
 
-HELP: BV{
-{ $syntax "BV{ elements... }" }
-{ $values { "elements" "a list of bytes" } }
-{ $description "Marks the beginning of a literal byte vector. Literal byte vectors are terminated by " { $link POSTPONE: } } "." } 
-{ $examples { $code "BV{ 1 2 3 12 }" } } ;
-
 HELP: ?{
 { $syntax "?{ elements... }" }
 { $values { "elements" "a list of booleans" } }
 { $description "Marks the beginning of a literal bit array. Literal bit arrays are terminated by " { $link POSTPONE: } } "." } 
 { $examples { $code "?{ t f t }" } } ;
 
-HELP: ?V{
-{ $syntax "?V{ elements... }" }
-{ $values { "elements" "a list of booleans" } }
-{ $description "Marks the beginning of a literal bit vector. Literal bit vectors are terminated by " { $link POSTPONE: } } "." } 
-{ $examples { $code "?V{ t f t }" } } ;
-
-HELP: FV{
-{ $syntax "FV{ elements... }" }
-{ $values { "elements" "a list of real numbers" } }
-{ $description "Marks the beginning of a literal float vector. Literal float vectors are terminated by " { $link POSTPONE: } } "." } 
-{ $examples { $code "FV{ 1.0 2.0 3.0 }" } } ;
-
 HELP: F{
 { $syntax "F{ elements... }" }
 { $values { "elements" "a list of real numbers" } }
diff --git a/core/syntax/syntax.factor b/core/syntax/syntax.factor
index eaf5ffea05..566f5471f4 100755
--- a/core/syntax/syntax.factor
+++ b/core/syntax/syntax.factor
@@ -1,10 +1,10 @@
 ! Copyright (C) 2004, 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: alien arrays bit-arrays bit-vectors byte-arrays
-byte-vectors definitions generic hashtables kernel math
+USING: alien arrays bit-arrays byte-arrays
+definitions generic hashtables kernel math
 namespaces parser sequences strings sbufs vectors words
 quotations io assocs splitting classes.tuple generic.standard
-generic.math classes io.files vocabs float-arrays float-vectors
+generic.math classes io.files vocabs float-arrays
 classes.union classes.mixin classes.predicate classes.singleton
 compiler.units combinators debugger ;
 IN: bootstrap.syntax
@@ -79,11 +79,8 @@ IN: bootstrap.syntax
     "{" [ \ } [ >array ] parse-literal ] define-syntax
     "V{" [ \ } [ >vector ] parse-literal ] define-syntax
     "B{" [ \ } [ >byte-array ] parse-literal ] define-syntax
-    "BV{" [ \ } [ >byte-vector ] parse-literal ] define-syntax
     "?{" [ \ } [ >bit-array ] parse-literal ] define-syntax
-    "?V{" [ \ } [ >bit-vector ] parse-literal ] define-syntax
     "F{" [ \ } [ >float-array ] parse-literal ] define-syntax
-    "FV{" [ \ } [ >float-vector ] parse-literal ] define-syntax
     "H{" [ \ } [ >hashtable ] parse-literal ] define-syntax
     "T{" [ \ } [ >tuple ] parse-literal ] define-syntax
     "W{" [ \ } [ first <wrapper> ] parse-literal ] define-syntax
diff --git a/core/threads/threads-docs.factor b/core/threads/threads-docs.factor
index a2c50346df..3f9ff54ac8 100755
--- a/core/threads/threads-docs.factor
+++ b/core/threads/threads-docs.factor
@@ -26,7 +26,7 @@ ARTICLE: "threads-yield" "Yielding and suspending threads"
 { $subsection resume }
 { $subsection resume-with } ;
 
-ARTICLE: "thread-state" "Thread-local state"
+ARTICLE: "thread-state" "Thread-local state and variables"
 "Threads form a class of objects:"
 { $subsection thread }
 "The current thread:"
@@ -36,6 +36,8 @@ ARTICLE: "thread-state" "Thread-local state"
 { $subsection tget }
 { $subsection tset }
 { $subsection tchange }
+"Each thread has its own independent set of thread-local variables and newly-spawned threads begin with an empty set."
+$nl
 "Global hashtable of all threads, keyed by " { $link thread-id } ":"
 { $subsection threads }
 "Threads have an identity independent of continuations. If a continuation is refied in one thread and then resumed in another thread, the code running in that continuation will observe a change in the value output by " { $link self } "." ;
diff --git a/core/threads/threads-tests.factor b/core/threads/threads-tests.factor
index d746404cba..0ac607f0ed 100755
--- a/core/threads/threads-tests.factor
+++ b/core/threads/threads-tests.factor
@@ -1,4 +1,5 @@
-USING: namespaces io tools.test threads kernel ;
+USING: namespaces io tools.test threads kernel
+concurrency.combinators math ;
 IN: threads.tests
 
 3 "x" set
@@ -16,3 +17,13 @@ yield
 ] unit-test
 
 [ f ] [ f get-global ] unit-test
+
+{ { 0 3 6 9 12 15 18 21 24 27 } } [
+    10 [
+        0 "i" tset
+        [
+            "i" [ yield 3 + ] tchange
+        ] times yield
+        "i" tget
+    ] parallel-map
+] unit-test
diff --git a/core/threads/threads.factor b/core/threads/threads.factor
index f99191b91f..2f9c3a73de 100755
--- a/core/threads/threads.factor
+++ b/core/threads/threads.factor
@@ -27,7 +27,7 @@ mailbox variables sleep-entry ;
     tnamespace set-at ;
 
 : tchange ( key quot -- )
-    tnamespace change-at ; inline
+    tnamespace swap change-at ; inline
 
 : threads 41 getenv ;
 
diff --git a/extra/benchmark/dispatch2/dispatch2.factor b/extra/benchmark/dispatch2/dispatch2.factor
index d51a723cbd..53e9c9a14c 100644
--- a/extra/benchmark/dispatch2/dispatch2.factor
+++ b/extra/benchmark/dispatch2/dispatch2.factor
@@ -1,4 +1,4 @@
-USING: namespaces math sequences splitting kernel ;
+USING: namespaces math sequences splitting kernel columns ;
 IN: benchmark.dispatch2
 
 : sequences
diff --git a/extra/benchmark/dispatch3/dispatch3.factor b/extra/benchmark/dispatch3/dispatch3.factor
index bb4c5ba904..409d6d4a0f 100644
--- a/extra/benchmark/dispatch3/dispatch3.factor
+++ b/extra/benchmark/dispatch3/dispatch3.factor
@@ -1,5 +1,5 @@
 USING: sequences math mirrors splitting kernel namespaces
-assocs alien.syntax ;
+assocs alien.syntax columns ;
 IN: benchmark.dispatch3
 
 GENERIC: g ( obj -- str )
diff --git a/extra/benchmark/recursive/recursive.factor b/extra/benchmark/recursive/recursive.factor
index ee66e303ec..f69547df60 100755
--- a/extra/benchmark/recursive/recursive.factor
+++ b/extra/benchmark/recursive/recursive.factor
@@ -1,38 +1,37 @@
+USING: math kernel hints prettyprint io combinators ;
 IN: benchmark.recursive
-USING: math kernel hints prettyprint io ;
 
 : fib ( m -- n )
-    dup 2 < [ drop 1 ] [ dup 1 - fib swap 2 - fib + ] if ;
+    dup 2 < [ drop 1 ] [ [ 1 - fib ] [ 2 - fib ] bi + ] if ;
+    inline
 
 : ack ( m n -- x )
-    over zero? [
-        nip 1+
-    ] [
-        dup zero? [
-            drop 1- 1 ack
-        ] [
-            dupd 1- ack >r 1- r> ack
-        ] if
-    ] if ;
+    {
+        { [ over zero? ] [ nip 1+ ] }
+        { [ dup zero? ] [ drop 1- 1 ack ] }
+        [ [ drop 1- ] [ 1- ack ] 2bi ack ]
+    } cond ; inline
 
 : tak ( x y z -- t )
-    2over swap < [
-        [ rot 1- -rot tak ] 3keep
-        [ -rot 1- -rot tak ] 3keep
-        1- -rot tak
-        tak
-    ] [
+    2over <= [
         2nip
-    ] if ;
+    ] [
+        [  rot 1- -rot tak ]
+        [ -rot 1- -rot tak ]
+        [      1- -rot tak ]
+        3tri
+        tak
+    ] if ; inline
 
 : recursive ( n -- )
-    3 over ack . flush
-    dup 27.0 + fib . flush
-    1-
-    dup 3 * over 2 * rot tak . flush
+    [ 3 swap ack . flush ]
+    [ 27.0 + fib . flush ]
+    [ 1- [ 3 * ] [ 2 * ] [ ] tri tak . flush ] tri
     3 fib . flush
     3.0 2.0 1.0 tak . flush ;
 
+HINTS: recursive fixnum ;
+
 : recursive-main 11 recursive ;
 
 MAIN: recursive-main
diff --git a/extra/benchmark/spectral-norm/spectral-norm.factor b/extra/benchmark/spectral-norm/spectral-norm.factor
index 7eddeefc1b..2c7dc1e80d 100644
--- a/extra/benchmark/spectral-norm/spectral-norm.factor
+++ b/extra/benchmark/spectral-norm/spectral-norm.factor
@@ -19,7 +19,7 @@ IN: benchmark.spectral-norm
         pick 0.0 [
             swap >r >r 2dup r> (eval-A-times-u) r> +
         ] reduce nip
-    ] F{ } map-as 2nip ; inline
+    ] F{ } map-as { float-array } declare 2nip ; inline
 
 : (eval-At-times-u) ( u i j -- x )
     tuck swap eval-A >r swap nth-unsafe r> * ; inline
@@ -29,7 +29,7 @@ IN: benchmark.spectral-norm
         pick 0.0 [
             swap >r >r 2dup r> (eval-At-times-u) r> +
         ] reduce nip
-    ] F{ } map-as 2nip ; inline
+    ] F{ } map-as { float-array } declare 2nip ; inline
 
 : eval-AtA-times-u ( n u -- seq )
     dupd eval-A-times-u eval-At-times-u ; inline
diff --git a/core/bit-vectors/bit-vectors-docs.factor b/extra/bit-vectors/bit-vectors-docs.factor
similarity index 82%
rename from core/bit-vectors/bit-vectors-docs.factor
rename to extra/bit-vectors/bit-vectors-docs.factor
index f2f5c4da2c..9ceb2df342 100755
--- a/core/bit-vectors/bit-vectors-docs.factor
+++ b/extra/bit-vectors/bit-vectors-docs.factor
@@ -11,6 +11,8 @@ $nl
 "Creating bit vectors:"
 { $subsection >bit-vector }
 { $subsection <bit-vector> }
+"Literal syntax:"
+{ $subsection POSTPONE: ?V{ }
 "If you don't care about initial capacity, a more elegant way to create a new bit vector is to write:"
 { $code "?V{ } clone" } ;
 
@@ -31,3 +33,10 @@ HELP: bit-array>vector
 { $values { "bit-array" "an array" } { "length" "a non-negative integer" } { "bit-vector" bit-vector } }
 { $description "Creates a new bit vector using the array for underlying storage with the specified initial length." }
 { $warning "This word is in the " { $vocab-link "bit-vectors.private" } " vocabulary because it does not perform type or bounds checks. User code should call " { $link >bit-vector } " instead." } ;
+
+HELP: ?V{
+{ $syntax "?V{ elements... }" }
+{ $values { "elements" "a list of booleans" } }
+{ $description "Marks the beginning of a literal bit vector. Literal bit vectors are terminated by " { $link POSTPONE: } } "." } 
+{ $examples { $code "?V{ t f t }" } } ;
+
diff --git a/core/bit-vectors/bit-vectors-tests.factor b/extra/bit-vectors/bit-vectors-tests.factor
similarity index 100%
rename from core/bit-vectors/bit-vectors-tests.factor
rename to extra/bit-vectors/bit-vectors-tests.factor
diff --git a/core/bit-vectors/bit-vectors.factor b/extra/bit-vectors/bit-vectors.factor
similarity index 56%
rename from core/bit-vectors/bit-vectors.factor
rename to extra/bit-vectors/bit-vectors.factor
index db941ac6f7..b011f146c5 100755
--- a/core/bit-vectors/bit-vectors.factor
+++ b/extra/bit-vectors/bit-vectors.factor
@@ -1,9 +1,20 @@
 ! Copyright (C) 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: arrays kernel kernel.private math sequences
-sequences.private growable bit-arrays ;
+sequences.private growable bit-arrays prettyprint.backend
+parser ;
 IN: bit-vectors
 
+TUPLE: bit-vector underlying fill ;
+
+M: bit-vector underlying underlying>> { bit-array } declare ;
+
+M: bit-vector set-underlying (>>underlying) ;
+
+M: bit-vector length fill>> { array-capacity } declare ;
+
+M: bit-vector set-fill (>>fill) ;
+
 <PRIVATE
 
 : bit-array>vector ( bit-array length -- bit-vector )
@@ -14,7 +25,8 @@ PRIVATE>
 : <bit-vector> ( n -- bit-vector )
     <bit-array> 0 bit-array>vector ; inline
 
-: >bit-vector ( seq -- bit-vector ) ?V{ } clone-like ;
+: >bit-vector ( seq -- bit-vector )
+    T{ bit-vector f ?{ } 0 } clone-like ;
 
 M: bit-vector like
     drop dup bit-vector? [
@@ -31,3 +43,9 @@ M: bit-vector equal?
 M: bit-array new-resizable drop <bit-vector> ;
 
 INSTANCE: bit-vector growable
+
+: ?V \ } [ >bit-vector ] parse-literal ; parsing
+
+M: bit-vector >pprint-sequence ;
+
+M: bit-vector pprint-delims drop \ ?V{ \ } ;
diff --git a/core/bit-vectors/summary.txt b/extra/bit-vectors/summary.txt
similarity index 100%
rename from core/bit-vectors/summary.txt
rename to extra/bit-vectors/summary.txt
diff --git a/core/bit-vectors/tags.txt b/extra/bit-vectors/tags.txt
similarity index 100%
rename from core/bit-vectors/tags.txt
rename to extra/bit-vectors/tags.txt
diff --git a/core/byte-vectors/byte-vectors-docs.factor b/extra/byte-vectors/byte-vectors-docs.factor
similarity index 79%
rename from core/byte-vectors/byte-vectors-docs.factor
rename to extra/byte-vectors/byte-vectors-docs.factor
index 0f1054ee5e..f34bc20219 100755
--- a/core/byte-vectors/byte-vectors-docs.factor
+++ b/extra/byte-vectors/byte-vectors-docs.factor
@@ -3,7 +3,7 @@ byte-vectors.private combinators ;
 IN: byte-vectors
 
 ARTICLE: "byte-vectors" "Byte vectors"
-"A byte vector is a resizable mutable sequence of unsigned bytes. The literal syntax is covered in " { $link "syntax-byte-vectors" } ". Byte vector words are found in the " { $vocab-link "byte-vectors" } " vocabulary."
+"A byte vector is a resizable mutable sequence of unsigned bytes. Byte vector words are found in the " { $vocab-link "byte-vectors" } " vocabulary."
 $nl
 "Byte vectors form a class:"
 { $subsection byte-vector }
@@ -11,6 +11,8 @@ $nl
 "Creating byte vectors:"
 { $subsection >byte-vector }
 { $subsection <byte-vector> }
+"Literal syntax:"
+{ $subsection POSTPONE: BV{ }
 "If you don't care about initial capacity, a more elegant way to create a new byte vector is to write:"
 { $code "BV{ } clone" } ;
 
@@ -32,3 +34,9 @@ HELP: byte-array>vector
 { $values { "byte-array" "an array" } { "length" "a non-negative integer" } { "byte-vector" byte-vector } }
 { $description "Creates a new byte vector using the array for underlying storage with the specified initial length." }
 { $warning "This word is in the " { $vocab-link "byte-vectors.private" } " vocabulary because it does not perform type or bounds checks. User code should call " { $link >byte-vector } " instead." } ;
+
+HELP: BV{
+{ $syntax "BV{ elements... }" }
+{ $values { "elements" "a list of bytes" } }
+{ $description "Marks the beginning of a literal byte vector. Literal byte vectors are terminated by " { $link POSTPONE: } } "." } 
+{ $examples { $code "BV{ 1 2 3 12 }" } } ;
diff --git a/core/byte-vectors/byte-vectors-tests.factor b/extra/byte-vectors/byte-vectors-tests.factor
similarity index 100%
rename from core/byte-vectors/byte-vectors-tests.factor
rename to extra/byte-vectors/byte-vectors-tests.factor
diff --git a/core/byte-vectors/byte-vectors.factor b/extra/byte-vectors/byte-vectors.factor
similarity index 55%
rename from core/byte-vectors/byte-vectors.factor
rename to extra/byte-vectors/byte-vectors.factor
index 206a23f43b..a8351dc781 100755
--- a/core/byte-vectors/byte-vectors.factor
+++ b/extra/byte-vectors/byte-vectors.factor
@@ -1,9 +1,20 @@
 ! Copyright (C) 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: arrays kernel kernel.private math sequences
-sequences.private growable byte-arrays ;
+sequences.private growable byte-arrays prettyprint.backend
+parser accessors ;
 IN: byte-vectors
 
+TUPLE: byte-vector underlying fill ;
+
+M: byte-vector underlying underlying>> { byte-array } declare ;
+
+M: byte-vector set-underlying (>>underlying) ;
+
+M: byte-vector length fill>> { array-capacity } declare ;
+
+M: byte-vector set-fill (>>fill) ;
+
 <PRIVATE
 
 : byte-array>vector ( byte-array length -- byte-vector )
@@ -14,7 +25,8 @@ PRIVATE>
 : <byte-vector> ( n -- byte-vector )
     <byte-array> 0 byte-array>vector ; inline
 
-: >byte-vector ( seq -- byte-vector ) BV{ } clone-like ;
+: >byte-vector ( seq -- byte-vector )
+    T{ byte-vector f B{ } 0 } clone-like ;
 
 M: byte-vector like
     drop dup byte-vector? [
@@ -31,3 +43,9 @@ M: byte-vector equal?
 M: byte-array new-resizable drop <byte-vector> ;
 
 INSTANCE: byte-vector growable
+
+: BV{ \ } [ >byte-vector ] parse-literal ; parsing
+
+M: byte-vector >pprint-sequence ;
+
+M: byte-vector pprint-delims drop \ BV{ \ } ;
diff --git a/core/byte-vectors/summary.txt b/extra/byte-vectors/summary.txt
similarity index 100%
rename from core/byte-vectors/summary.txt
rename to extra/byte-vectors/summary.txt
diff --git a/core/byte-vectors/tags.txt b/extra/byte-vectors/tags.txt
similarity index 100%
rename from core/byte-vectors/tags.txt
rename to extra/byte-vectors/tags.txt
diff --git a/extra/columns/authors.txt b/extra/columns/authors.txt
new file mode 100644
index 0000000000..a44f8d7f8d
--- /dev/null
+++ b/extra/columns/authors.txt
@@ -0,0 +1,2 @@
+Slava Pestov
+Daniel Ehrenberg
diff --git a/extra/columns/columns-docs.factor b/extra/columns/columns-docs.factor
new file mode 100644
index 0000000000..6b2adce9d9
--- /dev/null
+++ b/extra/columns/columns-docs.factor
@@ -0,0 +1,26 @@
+USING: help.markup help.syntax sequences ;
+IN: columns
+
+ARTICLE: "columns" "Column sequences"
+"A " { $emphasis "column" } " presents a column of a matrix represented as a sequence of rows:"
+{ $subsection column }
+{ $subsection <column> } ;
+
+HELP: column
+{ $class-description "A virtual sequence which presents a fixed column of a matrix represented as a sequence of rows. New instances can be created by calling " { $link <column> } "." } ;
+
+HELP: <column> ( seq n -- column )
+{ $values { "seq" sequence } { "n" "a non-negative integer" } { "column" column } }
+{ $description "Outputs a new virtual sequence which presents a fixed column of a matrix represented as a sequence of rows." "The " { $snippet "i" } "th element of a column is the " { $snippet "n" } "th element of the " { $snippet "i" } "th element of" { $snippet "seq" } ". Every element of " { $snippet "seq" } " must be a sequence, and all sequences must have equal length." }
+{ $examples
+    { $example
+        "USING: arrays prettyprint sequences ;"
+        "{ { 1 2 3 } { 4 5 6 } { 7 8 9 } } 0 <column> >array ."
+        "{ 1 4 7 }"
+    }
+}
+{ $notes
+    "In the same sense that " { $link <reversed> } " is a virtual variant of " { $link reverse } ", " { $link <column> } " is a virtual variant of " { $snippet "swap [ nth ] curry map" } "."
+} ;
+
+ABOUT: "columns"
diff --git a/extra/columns/columns-tests.factor b/extra/columns/columns-tests.factor
new file mode 100644
index 0000000000..657b9e0a25
--- /dev/null
+++ b/extra/columns/columns-tests.factor
@@ -0,0 +1,9 @@
+IN: columns.tests
+USING: columns sequences kernel namespaces arrays tools.test math ;
+
+! Columns
+{ { 1 2 3 } { 4 5 6 } { 7 8 9 } } [ clone ] map "seq" set
+
+[ { 1 4 7 } ] [ "seq" get 0 <column> >array ] unit-test
+[ ] [ "seq" get 1 <column> [ sq ] change-each ] unit-test
+[ { 4 25 64 } ] [ "seq" get 1 <column> >array ] unit-test
diff --git a/extra/columns/columns.factor b/extra/columns/columns.factor
new file mode 100644
index 0000000000..7e4a7fd408
--- /dev/null
+++ b/extra/columns/columns.factor
@@ -0,0 +1,15 @@
+! Copyright (C) 2005, 2008 Slava Pestov, Daniel Ehrenberg.
+! See http://factorcode.org/license.txt for BSD license.
+USING: sequences kernel accessors ;
+IN: columns
+
+! A column of a matrix
+TUPLE: column seq col ;
+
+C: <column> column
+
+M: column virtual-seq seq>> ;
+M: column virtual@ dup col>> -rot seq>> nth bounds-check ;
+M: column length seq>> length ;
+
+INSTANCE: column virtual-sequence
diff --git a/extra/columns/summary.txt b/extra/columns/summary.txt
new file mode 100644
index 0000000000..c4ade7fb51
--- /dev/null
+++ b/extra/columns/summary.txt
@@ -0,0 +1 @@
+Virtual sequence view of a matrix column
diff --git a/core/float-vectors/tags.txt b/extra/columns/tags.txt
similarity index 100%
rename from core/float-vectors/tags.txt
rename to extra/columns/tags.txt
diff --git a/extra/editors/vim/vim.factor b/extra/editors/vim/vim.factor
index 8d60942d67..9ce256868b 100755
--- a/extra/editors/vim/vim.factor
+++ b/extra/editors/vim/vim.factor
@@ -1,5 +1,5 @@
 USING: definitions io io.launcher kernel math math.parser
-namespaces parser prettyprint sequences editors ;
+namespaces parser prettyprint sequences editors accessors ;
 IN: editors.vim
 
 SYMBOL: vim-path
@@ -17,8 +17,9 @@ M: vim vim-command ( file line -- array )
 
 : vim-location ( file line -- )
     vim-command
-    vim-detach get-global
-    [ run-detached ] [ run-process ] if drop ;
+    <process> swap >>command
+    vim-detach get-global [ t >>detached ] when
+    try-process ;
 
 "vim" vim-path set-global
 [ vim-location ] edit-hook set-global
diff --git a/core/float-vectors/float-vectors-docs.factor b/extra/float-vectors/float-vectors-docs.factor
similarity index 83%
rename from core/float-vectors/float-vectors-docs.factor
rename to extra/float-vectors/float-vectors-docs.factor
index ef0645a0af..8d25da54be 100755
--- a/core/float-vectors/float-vectors-docs.factor
+++ b/extra/float-vectors/float-vectors-docs.factor
@@ -11,6 +11,8 @@ $nl
 "Creating float vectors:"
 { $subsection >float-vector }
 { $subsection <float-vector> }
+"Literal syntax:"
+{ $subsection POSTPONE: FV{ }
 "If you don't care about initial capacity, a more elegant way to create a new float vector is to write:"
 { $code "FV{ } clone" } ;
 
@@ -32,3 +34,9 @@ HELP: float-array>vector
 { $values { "float-array" "an array" } { "length" "a non-negative integer" } { "float-vector" float-vector } }
 { $description "Creates a new float vector using the array for underlying storage with the specified initial length." }
 { $warning "This word is in the " { $vocab-link "float-vectors.private" } " vocabulary because it does not perform type or bounds checks. User code should call " { $link >float-vector } " instead." } ;
+
+HELP: FV{
+{ $syntax "FV{ elements... }" }
+{ $values { "elements" "a list of real numbers" } }
+{ $description "Marks the beginning of a literal float vector. Literal float vectors are terminated by " { $link POSTPONE: } } "." } 
+{ $examples { $code "FV{ 1.0 2.0 3.0 }" } } ;
diff --git a/core/float-vectors/float-vectors-tests.factor b/extra/float-vectors/float-vectors-tests.factor
similarity index 100%
rename from core/float-vectors/float-vectors-tests.factor
rename to extra/float-vectors/float-vectors-tests.factor
diff --git a/core/float-vectors/float-vectors.factor b/extra/float-vectors/float-vectors.factor
similarity index 56%
rename from core/float-vectors/float-vectors.factor
rename to extra/float-vectors/float-vectors.factor
index 7f62f6f95c..f0db37610a 100755
--- a/core/float-vectors/float-vectors.factor
+++ b/extra/float-vectors/float-vectors.factor
@@ -1,9 +1,20 @@
 ! Copyright (C) 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: arrays kernel kernel.private math sequences
-sequences.private growable float-arrays ;
+sequences.private growable float-arrays prettyprint.backend
+parser ;
 IN: float-vectors
 
+TUPLE: float-vector underlying fill ;
+
+M: float-vector underlying underlying>> { float-array } declare ;
+
+M: float-vector set-underlying (>>underlying) ;
+
+M: float-vector length fill>> { array-capacity } declare ;
+
+M: float-vector set-fill (>>fill) ;
+
 <PRIVATE
 
 : float-array>vector ( float-array length -- float-vector )
@@ -14,7 +25,8 @@ PRIVATE>
 : <float-vector> ( n -- float-vector )
     0.0 <float-array> 0 float-array>vector ; inline
 
-: >float-vector ( seq -- float-vector ) FV{ } clone-like ;
+: >float-vector ( seq -- float-vector )
+    T{ float-vector f F{ } 0 } clone-like ;
 
 M: float-vector like
     drop dup float-vector? [
@@ -31,3 +43,9 @@ M: float-vector equal?
 M: float-array new-resizable drop <float-vector> ;
 
 INSTANCE: float-vector growable
+
+: FV{ \ } [ >float-vector ] parse-literal ; parsing
+
+M: float-vector >pprint-sequence ;
+
+M: float-vector pprint-delims drop \ FV{ \ } ;
diff --git a/core/float-vectors/summary.txt b/extra/float-vectors/summary.txt
similarity index 100%
rename from core/float-vectors/summary.txt
rename to extra/float-vectors/summary.txt
diff --git a/extra/float-vectors/tags.txt b/extra/float-vectors/tags.txt
new file mode 100644
index 0000000000..42d711b32b
--- /dev/null
+++ b/extra/float-vectors/tags.txt
@@ -0,0 +1 @@
+collections
diff --git a/extra/help/handbook/handbook.factor b/extra/help/handbook/handbook.factor
index 4e6bfe4888..d5bc1875e4 100755
--- a/extra/help/handbook/handbook.factor
+++ b/extra/help/handbook/handbook.factor
@@ -145,9 +145,9 @@ ARTICLE: "collections" "Collections"
 { $subsection "vectors" }
 "Resizable specialized sequences:"
 { $subsection "sbufs" }
-{ $subsection "bit-vectors" }
-{ $subsection "byte-vectors" }
-{ $subsection "float-vectors" }
+{ $vocab-subsection "Bit vectors" "bit-vectors" }
+{ $vocab-subsection "Byte vectors" "byte-vectors" }
+{ $vocab-subsection "Float vectors" "float-vectors" }
 { $heading "Associative mappings" }
 { $subsection "assocs" }
 { $subsection "namespaces" }
diff --git a/extra/help/help.factor b/extra/help/help.factor
index aa2704a799..e0b2709932 100755
--- a/extra/help/help.factor
+++ b/extra/help/help.factor
@@ -38,7 +38,7 @@ M: predicate word-help* drop \ $predicate ;
     \ $error-description swap word-help elements empty? not ;
 
 : sort-articles ( seq -- newseq )
-    [ dup article-title ] { } map>assoc sort-values 0 <column> ;
+    [ dup article-title ] { } map>assoc sort-values keys ;
 
 : all-errors ( -- seq )
     all-words [ error? ] subset sort-articles ;
diff --git a/extra/html/elements/elements.factor b/extra/html/elements/elements.factor
index 754afb1ea7..41e29fc712 100644
--- a/extra/html/elements/elements.factor
+++ b/extra/html/elements/elements.factor
@@ -161,6 +161,6 @@ SYMBOL: html
         "id" "onclick" "style" "valign" "accesskey"
         "src" "language" "colspan" "onchange" "rel"
         "width" "selected" "onsubmit" "xmlns" "lang" "xml:lang"
-        "media"
+        "media" "title"
     ] [ define-attribute-word ] each
 ] with-compilation-unit
diff --git a/extra/io/launcher/launcher-docs.factor b/extra/io/launcher/launcher-docs.factor
index 4446b82f20..dadb627fc0 100755
--- a/extra/io/launcher/launcher-docs.factor
+++ b/extra/io/launcher/launcher-docs.factor
@@ -113,6 +113,8 @@ HELP: try-process
 { $values { "desc" "a launch descriptor" } }
 { $description "Launches a process and waits for it to complete. If it exits with a non-zero status code, throws a " { $link process-failed } " error." } ;
 
+{ run-process try-process run-detached } related-words
+
 HELP: kill-process
 { $values { "process" process } }
 { $description "Kills a running process. Does nothing if the process has already exited." } ;
@@ -171,6 +173,7 @@ ARTICLE: "io.launcher.launch" "Launching processes"
 "Launching processes:"
 { $subsection run-process }
 { $subsection try-process }
+{ $subsection run-detached }
 "Redirecting standard input and output to a pipe:"
 { $subsection <process-stream> }
 { $subsection with-process-stream } ;
diff --git a/extra/io/launcher/launcher.factor b/extra/io/launcher/launcher.factor
index 9b480d0cc2..6ee8660528 100755
--- a/extra/io/launcher/launcher.factor
+++ b/extra/io/launcher/launcher.factor
@@ -127,10 +127,7 @@ HOOK: run-process* io-backend ( process -- handle )
     run-detached
     dup detached>> [ dup wait-for-process drop ] unless ;
 
-TUPLE: process-failed code ;
-
-: process-failed ( code -- * )
-    \ process-failed boa throw ;
+ERROR: process-failed code ;
 
 : try-process ( desc -- )
     run-process wait-for-process dup zero?
diff --git a/extra/locals/backend/backend-tests.factor b/extra/locals/backend/backend-tests.factor
new file mode 100644
index 0000000000..41caa87fae
--- /dev/null
+++ b/extra/locals/backend/backend-tests.factor
@@ -0,0 +1,38 @@
+IN: locals.backend.tests
+USING: tools.test locals.backend kernel arrays ;
+
+[ 3 ] [ 3 >r 1 get-local r> drop ] unit-test
+
+[ 4 ] [ 3 4 >r >r 2 get-local 2 drop-locals ] unit-test
+
+: get-local-test-1 3 >r 1 get-local r> drop ;
+
+{ 0 1 } [ get-local-test-1 ] must-infer-as
+
+[ 3 ] [ get-local-test-1 ] unit-test
+
+: get-local-test-2 3 4 >r >r 2 get-local 2 drop-locals ;
+
+{ 0 1 } [ get-local-test-2 ] must-infer-as
+
+[ 4 ] [ get-local-test-2 ] unit-test
+
+: get-local-test-3 3 4 >r >r 2 get-local r> r> 2array ;
+
+{ 0 2 } [ get-local-test-3 ] must-infer-as
+
+[ 4 { 3 4 } ] [ get-local-test-3 ] unit-test
+
+: get-local-test-4 3 4 >r >r r> r> dup swap >r swap >r r> r> 2array ;
+
+{ 0 2 } [ get-local-test-4 ] must-infer-as
+
+[ 4 { 3 4 } ] [ get-local-test-4 ] unit-test
+
+[ 1 2 ] [ 1 2 2 load-locals r> r> ] unit-test
+
+: load-locals-test-1 1 2 2 load-locals r> r> ;
+
+{ 0 2 } [ load-locals-test-1 ] must-infer-as
+
+[ 1 2 ] [ load-locals-test-1 ] unit-test
diff --git a/extra/locals/backend/backend.factor b/extra/locals/backend/backend.factor
new file mode 100644
index 0000000000..a51216b079
--- /dev/null
+++ b/extra/locals/backend/backend.factor
@@ -0,0 +1,37 @@
+USING: math kernel slots.private inference.known-words
+inference.backend sequences effects words ;
+IN: locals.backend
+
+: load-locals ( n -- )
+    dup zero? [ drop ] [ swap >r 1- load-locals ] if ;
+
+: get-local ( n -- value )
+    dup zero? [ drop dup ] [ r> swap 1- get-local swap >r ] if ;
+
+: local-value 2 slot ; inline
+
+: set-local-value 2 set-slot ; inline
+
+: drop-locals ( n -- )
+    dup zero? [ drop ] [ r> drop 1- drop-locals ] if ;
+
+\ load-locals [
+    pop-literal nip
+    [ dup reverse <effect> infer-shuffle ]
+    [ infer->r ]
+    bi
+] "infer" set-word-prop
+
+\ get-local [
+    pop-literal nip
+    [ infer-r> ]
+    [ dup 0 prefix <effect> infer-shuffle ]
+    [ infer->r ]
+    tri
+] "infer" set-word-prop
+
+\ drop-locals [
+    pop-literal nip
+    [ infer-r> ]
+    [ { } <effect> infer-shuffle ] bi
+] "infer" set-word-prop
diff --git a/extra/locals/locals-tests.factor b/extra/locals/locals-tests.factor
index 4ee9b48bb7..c13be40c8f 100755
--- a/extra/locals/locals-tests.factor
+++ b/extra/locals/locals-tests.factor
@@ -82,6 +82,8 @@ IN: locals.tests
 
 0 write-test-1 "q" set
 
+{ 1 1 } "q" get must-infer-as
+
 [ 1 ] [ 1 "q" get call ] unit-test
 
 [ 2 ] [ 1 "q" get call ] unit-test
diff --git a/extra/locals/locals.factor b/extra/locals/locals.factor
index 2b0c61cc89..be73f1db88 100755
--- a/extra/locals/locals.factor
+++ b/extra/locals/locals.factor
@@ -4,7 +4,8 @@ USING: kernel namespaces sequences sequences.private assocs math
 inference.transforms parser words quotations debugger macros
 arrays macros splitting combinators prettyprint.backend
 definitions prettyprint hashtables prettyprint.sections sets
-sequences.private effects generic compiler.units accessors ;
+sequences.private effects generic compiler.units accessors
+locals.backend ;
 IN: locals
 
 ! Inspired by
@@ -56,95 +57,80 @@ TUPLE: quote local ;
 
 C: <quote> quote
 
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-! read-local
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
 : local-index ( obj args -- n )
     [ dup quote? [ quote-local ] when eq? ] with find drop ;
 
-: read-local ( obj args -- quot )
-    local-index 1+
-    dup [ r> ] <repetition> concat [ dup ] append
-    swap [ swap >r ] <repetition> concat append ;
-
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-! localize
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+: read-local-quot ( obj args -- quot )
+    local-index 1+ [ get-local ] curry ;
 
 : localize-writer ( obj args -- quot )
-  >r "local-reader" word-prop r> read-local [ 0 swap set-array-nth ] append ;
+  >r "local-reader" word-prop r>
+  read-local-quot [ set-local-value ] append ;
 
 : localize ( obj args -- quot )
     {
-        { [ over local? ]        [ read-local ] }
-        { [ over quote? ]        [ >r quote-local r> read-local ] }
-        { [ over local-word? ]   [ read-local [ call ] append ] }
-        { [ over local-reader? ] [ read-local [ 0 swap array-nth ] append ] }
+        { [ over local? ]        [ read-local-quot ] }
+        { [ over quote? ]        [ >r quote-local r> read-local-quot ] }
+        { [ over local-word? ]   [ read-local-quot [ call ] append ] }
+        { [ over local-reader? ] [ read-local-quot [ local-value ] append ] }
         { [ over local-writer? ] [ localize-writer ] }
         { [ over \ lambda eq? ]  [ 2drop [ ] ] }
         { [ t ]                  [ drop 1quotation ] }
     } cond ;
 
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-! point-free
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
 UNION: special local quote local-word local-reader local-writer ;
 
-: load-local ( arg -- quot ) 
-    local-reader? [ 1array >r ] [ >r ] ? ;
+: load-locals-quot ( args -- quot )
+    dup [ local-reader? ] contains? [
+        <reversed> [
+            local-reader? [ 1array >r ] [ >r ] ?
+        ] map concat
+    ] [
+        length [ load-locals ] curry >quotation
+    ] if ;
 
-: load-locals ( quot args -- quot )
-    nip <reversed> [ load-local ] map concat ;
-
-: drop-locals ( args -- args quot )
-    dup length [ r> drop ] <repetition> concat ;
+: drop-locals-quot ( args -- quot )
+    length [ drop-locals ] curry ;
 
 : point-free-body ( quot args -- newquot )
     >r 1 head-slice* r> [ localize ] curry map concat ;
 
 : point-free-end ( quot args -- newquot )
     over peek special?
-    [ drop-locals >r >r peek r> localize r> append ]
-    [ drop-locals nip swap peek suffix ]
+    [ dup drop-locals-quot >r >r peek r> localize r> append ]
+    [ dup drop-locals-quot nip swap peek suffix ]
     if ;
 
 : (point-free) ( quot args -- newquot )
-    [ load-locals ] [ point-free-body ] [ point-free-end ]
+    [ nip load-locals-quot ]
+    [ point-free-body ]
+    [ point-free-end ]
     2tri 3append >quotation ;
 
 : point-free ( quot args -- newquot )
     over empty? [ drop ] [ (point-free) ] if ;
 
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-! free-vars
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
 UNION: lexical local local-reader local-writer local-word ;
 
-GENERIC: free-vars ( form -- vars )
+GENERIC: free-vars* ( form -- )
 
-: add-if-free ( vars object -- vars )
+: free-vars ( form -- vars )
+    [ free-vars* ] { } make prune ;
+
+: add-if-free ( object -- )
   {
-      { [ dup local-writer? ] [ "local-reader" word-prop suffix ] }
-      { [ dup lexical? ]      [ suffix ] }
-      { [ dup quote? ]        [ quote-local suffix ] }
-      { [ t ]                 [ free-vars append ] }
+      { [ dup local-writer? ] [ "local-reader" word-prop , ] }
+      { [ dup lexical? ]      [ , ] }
+      { [ dup quote? ]        [ local>> , ] }
+      { [ t ]                 [ free-vars* ] }
   } cond ;
 
-M: object free-vars drop { } ;
+M: object free-vars* drop ;
 
-M: quotation free-vars { } [ add-if-free ] reduce ;
+M: quotation free-vars* [ add-if-free ] each ;
 
-M: lambda free-vars
-    dup vars>> swap body>> free-vars diff ;
-
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-! lambda-rewrite
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+M: lambda free-vars*
+    [ vars>> ] [ body>> ] bi free-vars diff % ;
 
 GENERIC: lambda-rewrite* ( obj -- )
 
@@ -172,8 +158,8 @@ M: lambda block-vars vars>> ;
 M: lambda block-body body>> ;
 
 M: lambda local-rewrite*
-    dup vars>> swap body>>
-    [ local-rewrite* \ call , ] [ ] make <lambda> , ;
+    [ vars>> ] [ body>> ] bi
+    [ [ local-rewrite* ] each ] [ ] make <lambda> , ;
 
 M: block lambda-rewrite*
     #! Turn free variables into bound variables, curry them
@@ -188,8 +174,6 @@ M: object lambda-rewrite* , ;
 
 M: object local-rewrite* , ;
 
-! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
 : make-local ( name -- word )
     "!" ?tail [
         <local-reader>
diff --git a/extra/math/fft/fft.factor b/extra/math/fft/fft.factor
index 625be534ce..4d4068158e 100644
--- a/extra/math/fft/fft.factor
+++ b/extra/math/fft/fft.factor
@@ -1,7 +1,7 @@
 ! Fast Fourier Transform, copyright (C) 2007 Hans Schmid
 ! http://dressguardmeister.blogspot.com/2007/01/fft.html
 USING: arrays sequences math math.vectors math.constants
-math.functions kernel splitting ;
+math.functions kernel splitting columns ;
 IN: math.fft
 
 : n^v ( n v -- w ) [ ^ ] with map ;
diff --git a/extra/math/functions/functions-docs.factor b/extra/math/functions/functions-docs.factor
index f0819fb03e..35471653dc 100755
--- a/extra/math/functions/functions-docs.factor
+++ b/extra/math/functions/functions-docs.factor
@@ -7,6 +7,9 @@ ARTICLE: "integer-functions" "Integer functions"
 { $subsection gcd }
 { $subsection log2 }
 { $subsection next-power-of-2 }
+"Modular exponentiation:"
+{ $subsection ^mod }
+{ $subsection mod-inv }
 "Tests:"
 { $subsection power-of-2? }
 { $subsection even? }
@@ -33,7 +36,9 @@ ARTICLE: "arithmetic-functions" "Arithmetic functions"
 { $subsection ceiling }
 { $subsection floor }
 { $subsection truncate }
-{ $subsection round } ;
+{ $subsection round }
+"Inexact comparison:"
+{ $subsection ~ } ;
 
 ARTICLE: "power-functions" "Powers and logarithms"
 "Squares:"
@@ -107,10 +112,6 @@ HELP: >rect
 { $values { "z" number } { "x" real } { "y" real } }
 { $description "Extracts the real and imaginary components of a complex number." } ;
 
-HELP: power-of-2?
-{ $values { "n" integer } { "?" "a boolean" } }
-{ $description "Tests if " { $snippet "n" } " is a power of 2." } ;
-
 HELP: align
 { $values { "m" integer } { "w" "a power of 2" } { "n" "an integer multiple of " { $snippet "w" } } }
 { $description "Outputs the least multiple of " { $snippet "w" } " greater than " { $snippet "m" } "." }
diff --git a/extra/math/functions/functions-tests.factor b/extra/math/functions/functions-tests.factor
index 6773678dab..8c71eb545b 100755
--- a/extra/math/functions/functions-tests.factor
+++ b/extra/math/functions/functions-tests.factor
@@ -81,9 +81,6 @@ IN: math.functions.tests
 [ 1/8 ] [ 2 -3 ^ ] unit-test
 [ t ] [ 1 100 shift 2 100 ^ = ] unit-test
 
-[ t ] [ 256 power-of-2? ] unit-test
-[ f ] [ 123 power-of-2? ] unit-test
-
 [ 1 ] [ 7/8 ceiling ] unit-test
 [ 2 ] [ 3/2 ceiling ] unit-test
 [ 0 ] [ -7/8 ceiling ] unit-test
diff --git a/extra/math/functions/functions.factor b/extra/math/functions/functions.factor
index b3cfba8650..632939ff71 100755
--- a/extra/math/functions/functions.factor
+++ b/extra/math/functions/functions.factor
@@ -102,9 +102,6 @@ M: real absq sq ;
         [ ~abs ]
     } cond ;
 
-: power-of-2? ( n -- ? )
-    dup 0 < [ drop f ] [ dup 1- bitand zero? ] if ; foldable
-
 : >rect ( z -- x y ) dup real-part swap imaginary-part ; inline
 
 : conjugate ( z -- z* ) >rect neg rect> ; inline
diff --git a/extra/math/haar/haar.factor b/extra/math/haar/haar.factor
index 91d9fd8ece..9254fd0ce7 100644
--- a/extra/math/haar/haar.factor
+++ b/extra/math/haar/haar.factor
@@ -1,5 +1,5 @@
 ! Haar wavelet transform -- http://dmr.ath.cx/gfx/haar/
-USING: sequences math kernel splitting ;
+USING: sequences math kernel splitting columns ;
 IN: math.haar
 
 : averages ( seq -- seq )
diff --git a/extra/newfx/newfx.factor b/extra/newfx/newfx.factor
index 6a191f0e07..3e5f66eb6f 100644
--- a/extra/newfx/newfx.factor
+++ b/extra/newfx/newfx.factor
@@ -155,6 +155,23 @@ METHOD: as-mutate { object object assoc }       set-at ;
 
 ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
+: prefix-on ( elt seq -- seq ) swap prefix ;
+: suffix-on ( elt seq -- seq ) swap suffix ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: 1st 0 at ;
+: 2nd 1 at ;
+: 3rd 2 at ;
+: 4th 3 at ;
+: 5th 4 at ;
+: 6th 5 at ;
+: 7th 6 at ;
+: 8th 7 at ;
+: 9th 8 at ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
 ! A note about the 'mutate' qualifier. Other words also technically mutate
 ! their primary object. However, the 'mutate' qualifier is supposed to
 ! indicate that this is the main objective of the word, as a side effect.
\ No newline at end of file
diff --git a/extra/project-euler/076/076.factor b/extra/project-euler/076/076.factor
new file mode 100644
index 0000000000..b09a2742c3
--- /dev/null
+++ b/extra/project-euler/076/076.factor
@@ -0,0 +1,53 @@
+! Copyright (c) 2008 Eric Mertens
+! See http://factorcode.org/license.txt for BSD license.
+USING: arrays assocs combinators kernel math sequences math.ranges locals ;
+IN: project-euler.076
+
+! http://projecteuler.net/index.php?section=problems&id=76
+
+! DESCRIPTION
+! -----------
+
+! How many different ways can one hundred be written as a
+! sum of at least two positive integers?
+
+! SOLUTION
+! --------
+
+! This solution uses dynamic programming and the following
+! recurence relation:
+
+! ways(0,_) = 1
+! ways(_,0) = 0
+! ways(n,i) = ways(n-i,i) + ways(n,i-1)
+
+<PRIVATE
+
+: init ( n -- table )
+    [1,b] [ 0 2array 0 ] H{ } map>assoc
+    1 { 0 0 } pick set-at ;
+
+: use ( n i -- n i )
+    [ - dup ] keep min ; inline
+
+: ways ( n i table -- )
+    over zero? [
+        3drop
+    ] [
+        [ [ 1-  2array ] dip at     ]
+        [ [ use 2array ] dip at +   ]
+        [ [     2array ] dip set-at ] 3tri
+    ] if ;
+
+:: each-subproblem ( n quot -- )
+    n [1,b] [ dup [1,b] quot with each ] each ; inline
+
+PRIVATE>
+
+: (euler076) ( n -- m )
+    dup init
+    [ [ ways ] curry each-subproblem ]
+    [ [ dup 2array ] dip at 1- ] 2bi ;
+
+: euler076 ( -- m )
+    100 (euler076) ;
diff --git a/extra/project-euler/116/116.factor b/extra/project-euler/116/116.factor
new file mode 100644
index 0000000000..d48cdf175c
--- /dev/null
+++ b/extra/project-euler/116/116.factor
@@ -0,0 +1,55 @@
+! Copyright (c) 2008 Eric Mertens
+! See http://factorcode.org/license.txt for BSD license.
+USING: kernel math math.ranges sequences sequences.lib ;
+
+IN: project-euler.116
+
+! http://projecteuler.net/index.php?section=problems&id=116
+
+! DESCRIPTION
+! -----------
+
+! A row of five black square tiles is to have a number of its tiles replaced
+! with coloured oblong tiles chosen from red (length two), green (length
+! three), or blue (length four).
+
+! If red tiles are chosen there are exactly seven ways this can be done.
+! If green tiles are chosen there are three ways.
+! And if blue tiles are chosen there are two ways.
+
+! Assuming that colours cannot be mixed there are 7 + 3 + 2 = 12 ways of
+! replacing the black tiles in a row measuring five units in length.
+
+! How many different ways can the black tiles in a row measuring fifty units in
+! length be replaced if colours cannot be mixed and at least one coloured tile
+! must be used?
+
+! SOLUTION
+! --------
+
+! This solution uses a simple dynamic programming approach using the
+! following recurence relation
+
+! ways(n,_) = 0   | n < 0
+! ways(0,_) = 1
+! ways(n,i) = ways(n-i,i) + ways(n-1,i)
+! solution(n) = ways(n,1) - 1 + ways(n,2) - 1 + ways(n,3) - 1
+
+<PRIVATE
+
+: nth* ( n seq -- elt/0 )
+    [ length swap - 1- ] keep ?nth 0 or ;
+
+: next ( colortile seq -- )
+     [ nth* ] [ peek + ] [ push ] tri ;
+
+: ways ( length colortile -- permutations )
+    V{ 1 } clone [ [ next ] 2curry times ] keep peek 1- ;
+
+PRIVATE>
+
+: (euler116) ( length -- permutations )
+    3 [1,b] [ ways ] with sigma ;
+
+: euler116 ( -- permutations )
+    50 (euler116) ;
diff --git a/extra/project-euler/117/117.factor b/extra/project-euler/117/117.factor
new file mode 100644
index 0000000000..5056560a85
--- /dev/null
+++ b/extra/project-euler/117/117.factor
@@ -0,0 +1,42 @@
+! Copyright (c) 2008 Eric Mertens
+! See http://factorcode.org/license.txt for BSD license.
+USING: kernel math splitting sequences ;
+
+IN: project-euler.117
+
+! http://projecteuler.net/index.php?section=problems&id=117
+
+! DESCRIPTION
+! -----------
+
+! Using a combination of black square tiles and oblong tiles chosen
+! from: red tiles measuring two units, green tiles measuring three
+! units, and blue tiles measuring four units, it is possible to tile a
+! row measuring five units in length in exactly fifteen different ways.
+
+!  How many ways can a row measuring fifty units in length be tiled?
+
+! SOLUTION
+! --------
+
+! This solution uses a simple dynamic programming approach using the
+! following recurence relation
+
+! ways(i) = 1 | i <= 0
+! ways(i) = ways(i-4) + ways(i-3) + ways(i-2) + ways(i-1)
+
+<PRIVATE
+
+: short ( seq n -- seq n )
+    over length min ;
+
+: next ( seq -- )
+    [ 4 short tail* sum ] keep push ;
+
+PRIVATE>
+
+: (euler117) ( n -- m )
+    V{ 1 } clone tuck [ next ] curry times peek ;
+
+: euler117 ( -- m )
+    50 (euler117) ;
diff --git a/extra/project-euler/150/150.factor b/extra/project-euler/150/150.factor
new file mode 100644
index 0000000000..c96c1ebc73
--- /dev/null
+++ b/extra/project-euler/150/150.factor
@@ -0,0 +1,52 @@
+! Copyright (c) 2008 Eric Mertens
+! See http://factorcode.org/license.txt for BSD license.
+USING: kernel math sequences sequences.private locals hints ;
+IN: project-euler.150
+
+<PRIVATE
+
+! sequence helper functions
+
+: partial-sums ( seq -- sums )
+    0 [ + ] accumulate swap suffix ; inline
+
+: (partial-sum-infimum) ( inf sum elt -- inf sum )
+    + [ min ] keep ; inline
+
+: partial-sum-infimum ( seq -- seq )
+    0 0 rot [ (partial-sum-infimum) ] each drop ; inline
+
+: generate ( n quot -- seq )
+    [ drop ] swap compose map ; inline
+
+: map-infimum ( seq quot -- min )
+    [ min ] compose 0 swap reduce ; inline
+
+
+! triangle generator functions
+
+: next ( t -- new-t s )
+    615949 * 797807 + 20 2^ rem dup 19 2^ - ; inline
+
+: sums-triangle ( -- seq )
+    0 1000 [ 1+ [ next ] generate partial-sums ] map nip ; 
+
+PRIVATE>
+
+:: (euler150) ( m -- n )
+    [let | table [ sums-triangle ] |
+        m [| x |
+            x 1+ [| y |
+                m x - [| z |
+                    x z + table nth-unsafe
+                    [ y z + 1+ swap nth-unsafe ]
+                    [ y        swap nth-unsafe ] bi -
+                ] map partial-sum-infimum
+            ] map-infimum
+        ] map-infimum
+    ] ;
+
+HINTS: (euler150) fixnum ;
+
+: euler150 ( -- n )
+    1000 (euler150) ;
diff --git a/extra/project-euler/164/164.factor b/extra/project-euler/164/164.factor
index 67397593bd..bf1f5dcf9b 100644
--- a/extra/project-euler/164/164.factor
+++ b/extra/project-euler/164/164.factor
@@ -30,4 +30,4 @@ IN: project-euler.164
 PRIVATE>
 
 : euler164 ( -- n )
-    init-table 19 [ next-table ] times values sum ;
\ No newline at end of file
+    init-table 19 [ next-table ] times values sum ;
diff --git a/extra/random/blum-blum-shub/blum-blum-shub-tests.factor b/extra/random/blum-blum-shub/blum-blum-shub-tests.factor
index a92f256eeb..c882dd2b4d 100644
--- a/extra/random/blum-blum-shub/blum-blum-shub-tests.factor
+++ b/extra/random/blum-blum-shub/blum-blum-shub-tests.factor
@@ -1,27 +1,29 @@
 USING: kernel math tools.test namespaces random
-random.blum-blum-shub ;
+random.blum-blum-shub alien.c-types sequences splitting ;
 IN: blum-blum-shub.tests
 
 [ 887708070 ] [
-    T{ blum-blum-shub f 590695557939 811977232793 } random-32*
+    T{ blum-blum-shub f 590695557939 811977232793 } clone random-32*
 ] unit-test
 
 
 [ 887708070 ] [
-    T{ blum-blum-shub f 590695557939 811977232793 } [
+    T{ blum-blum-shub f 590695557939 811977232793 } clone [
         32 random-bits
+        little-endian? [ <uint> reverse *uint ] unless
     ] with-random
 ] unit-test
 
 [ 5726770047455156646 ] [
-    T{ blum-blum-shub f 590695557939 811977232793 } [
+    T{ blum-blum-shub f 590695557939 811977232793 } clone [
         64 random-bits
+        little-endian? [ <ulonglong> 4 group [ reverse ] map concat *ulonglong ] unless
     ] with-random
 ] unit-test
 
 [ 3716213681 ]
 [
-    100 T{ blum-blum-shub f 200352954495 846054538649 } tuck [
+    100 T{ blum-blum-shub f 200352954495 846054538649 } clone tuck [
         random-32* drop
     ] curry times
     random-32*
diff --git a/extra/random/blum-blum-shub/blum-blum-shub.factor b/extra/random/blum-blum-shub/blum-blum-shub.factor
index db8fe540e5..e60990075c 100755
--- a/extra/random/blum-blum-shub/blum-blum-shub.factor
+++ b/extra/random/blum-blum-shub/blum-blum-shub.factor
@@ -12,17 +12,16 @@ TUPLE: blum-blum-shub x n ;
 : generate-bbs-primes ( numbits -- p q )
     [ [ random-prime ] curry [ 4 mod 3 = ] generate ] dup bi ;
 
+: next-bbs-bit ( bbs -- bit )
+    [ [ x>> 2 ] [ n>> ] bi ^mod dup ] keep (>>x) 1 bitand ;
+
+PRIVATE>
+
 : <blum-blum-shub> ( numbits -- blum-blum-shub )
     generate-bbs-primes *
     [ find-relative-prime ] keep
     blum-blum-shub boa ;
 
-: next-bbs-bit ( bbs -- bit )
-    [ [ x>> 2 ] [ n>> ] bi ^mod ] keep
-    over >>x drop 1 bitand ;
-
-PRIVATE>
-
 M: blum-blum-shub random-32* ( bbs -- r )
     0 32 rot
     [ next-bbs-bit swap 1 shift bitor ] curry times ;
diff --git a/extra/regexp/regexp-tests.factor b/extra/regexp/regexp-tests.factor
index 5a6b0bdfac..e9433c6c64 100755
--- a/extra/regexp/regexp-tests.factor
+++ b/extra/regexp/regexp-tests.factor
@@ -226,3 +226,10 @@ IN: regexp-tests
 [ t ] [ "s@f" "[a-z.-]@[a-z]" f <regexp> matches? ] unit-test
 [ f ] [ "a" "[a-z.-]@[a-z]" f <regexp> matches? ] unit-test
 [ t ] [ ".o" "\\.[a-z]" f <regexp> matches? ] unit-test
+
+! Bug in parsing word
+[ t ] [
+    "a"
+    R' a'
+    matches?
+] unit-test
diff --git a/extra/regexp/regexp.factor b/extra/regexp/regexp.factor
index 6b344ad140..d517db09fe 100755
--- a/extra/regexp/regexp.factor
+++ b/extra/regexp/regexp.factor
@@ -290,10 +290,11 @@ TUPLE: regexp source parser ignore-case? ;
     } case ;
 
 : parse-regexp ( accum end -- accum )
-    lexer get dup skip-blank [
-        [ index* dup 1+ swap ] 2keep swapd subseq swap
-    ] change-lexer-column
-    lexer get (parse-token) parse-options <regexp> parsed ;
+    lexer get dup skip-blank
+    [ [ index* dup 1+ swap ] 2keep swapd subseq swap ] change-lexer-column
+    lexer get dup still-parsing-line?
+    [ (parse-token) parse-options ] [ drop f ] if
+    <regexp> parsed ;
 
 : R! CHAR: ! parse-regexp ; parsing
 : R" CHAR: " parse-regexp ; parsing
diff --git a/extra/rss/rss-tests.factor b/extra/rss/rss-tests.factor
index 77364d73e7..7523d0509f 100755
--- a/extra/rss/rss-tests.factor
+++ b/extra/rss/rss-tests.factor
@@ -1,4 +1,5 @@
-USING: rss io kernel io.files tools.test io.encodings.utf8 ;
+USING: rss io kernel io.files tools.test io.encodings.utf8
+calendar ;
 IN: rss.tests
 
 : load-news-file ( filename -- feed )
@@ -35,7 +36,7 @@ IN: rss.tests
             "http://example.org/2005/04/02/atom"
             "\n         <div xmlns=\"http://www.w3.org/1999/xhtml\">\n           <p><i>[Update: The Atom draft is finished.]</i></p>\n         </div>\n       "
 
-            "2003-12-13T08:29:29-04:00"
+            T{ timestamp f 2003 12 13 8 29 29 -4 }
         }
     }
 } ] [ "extra/rss/atom.xml" resource-path load-news-file ] unit-test
diff --git a/extra/rss/rss.factor b/extra/rss/rss.factor
index 99360e5509..2e735d2f06 100644
--- a/extra/rss/rss.factor
+++ b/extra/rss/rss.factor
@@ -4,10 +4,8 @@ IN: rss
 USING: xml.utilities kernel assocs xml.generator
     strings sequences xml.data xml.writer
     io.streams.string combinators xml xml.entities io.files io
-    http.client namespaces xml.generator hashtables ;
-
-: ?children>string ( tag/f -- string/f )
-    [ children>string ] [ f ] if* ;
+    http.client namespaces xml.generator hashtables
+    calendar.format accessors continuations ;
 
 : any-tag-named ( tag names -- tag-inside )
     f -rot [ tag-named nip dup ] with find 2drop ;
@@ -25,7 +23,7 @@ C: <entry> entry
     [ "link" tag-named children>string ] keep
     [ "description" tag-named children>string ] keep
     f "date" "http://purl.org/dc/elements/1.1/" <name>
-    tag-named ?children>string
+    tag-named dup [ children>string rfc3339>timestamp ] when
     <entry> ;
 
 : rss1.0 ( xml -- feed )
@@ -41,7 +39,7 @@ C: <entry> entry
     [ "link" tag-named ] keep
     [ "guid" tag-named dupd ? children>string ] keep
     [ "description" tag-named children>string ] keep
-    "pubDate" tag-named children>string <entry> ;
+    "pubDate" tag-named children>string rfc3339>timestamp <entry> ;
 
 : rss2.0 ( xml -- feed )
     "channel" tag-named 
@@ -59,7 +57,7 @@ C: <entry> entry
         [ children>string ] if
     ] keep
     { "published" "updated" "issued" "modified" } any-tag-named
-    children>string <entry> ;
+    children>string rfc3339>timestamp <entry> ;
 
 : atom1.0 ( xml -- feed )
     [ "title" tag-named children>string ] keep
@@ -78,10 +76,10 @@ C: <entry> entry
 
 : download-feed ( url -- feed )
     #! Retrieve an news syndication file, return as a feed tuple.
-    http-get-stream rot success? [
-        nip read-feed
+    http-get-stream swap code>> success? [
+        read-feed
     ] [
-        2drop "Error retrieving newsfeed file" throw
+        dispose "Error retrieving newsfeed file" throw
     ] if ;
 
 ! Atom generation
@@ -95,7 +93,7 @@ C: <entry> entry
     "entry" [
         dup entry-title "title" { { "type" "html" } } simple-tag*,
         "link" over entry-link "href" associate contained*,
-        dup entry-pub-date "published" simple-tag,
+        dup entry-pub-date timestamp>rfc3339 "published" simple-tag,
         entry-description [ "content" { { "type" "html" } } simple-tag*, ] when*
     ] tag, ;
 
diff --git a/extra/shell/parser/parser.factor b/extra/shell/parser/parser.factor
new file mode 100644
index 0000000000..46548bb34f
--- /dev/null
+++ b/extra/shell/parser/parser.factor
@@ -0,0 +1,94 @@
+
+USING: kernel arrays strings sequences sequences.deep accessors peg peg.ebnf
+       newfx ;
+
+IN: shell.parser
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+TUPLE: basic-expr         command  stdin stdout background ;
+TUPLE: pipeline-expr      commands stdin stdout background ;
+TUPLE: single-quoted-expr expr ;
+TUPLE: double-quoted-expr expr ;
+TUPLE: back-quoted-expr   expr ;
+TUPLE: glob-expr          expr ;
+TUPLE: variable-expr      expr ;
+TUPLE: factor-expr        expr ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: ast>basic-expr ( ast -- obj ) first4 basic-expr boa ;
+
+: ast>pipeline-expr ( ast -- obj )
+  pipeline-expr new
+    over [ 1st ] [ 4th [ 1st ] map ] [ 5th ] tri suffix prefix-on >>commands
+    over 2nd >>stdin
+    over 5th   >>stdout
+    swap 6th   >>background ;
+
+: ast>single-quoted-expr ( ast -- obj )
+  2nd >string single-quoted-expr boa ;
+
+: ast>double-quoted-expr ( ast -- obj )
+  2nd >string double-quoted-expr boa ;
+
+: ast>back-quoted-expr ( ast -- obj )
+  2nd >string back-quoted-expr boa ;
+
+: ast>glob-expr ( ast -- obj ) flatten concat glob-expr boa ;
+
+: ast>variable-expr ( ast -- obj ) 2nd variable-expr boa ;
+
+: ast>factor-expr ( ast -- obj ) 2nd >string factor-expr boa ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+EBNF: expr
+
+space = " "
+
+tab   = "\t"
+
+white = (space | tab)
+
+_ = (white)* => [[ drop ignore ]]
+
+sq = "'"
+dq = '"'
+bq = "`"
+
+single-quoted = sq (!(sq) .)* sq => [[ ast>single-quoted-expr ]]
+double-quoted = dq (!(dq) .)* dq => [[ ast>double-quoted-expr ]]
+back-quoted   = bq (!(bq) .)* bq => [[ ast>back-quoted-expr   ]]
+
+factor = "$(" (!(")") .)* ")" => [[ ast>factor-expr ]]
+
+variable = "$" other => [[ ast>variable-expr ]]
+
+glob-char = ("*" | "?")
+
+non-glob-char = !(glob-char | white) .
+
+glob-beginning-string = (non-glob-char)* => [[ >string ]]
+
+glob-rest-string = (non-glob-char)+ => [[ >string ]]
+
+glob = glob-beginning-string glob-char (glob-rest-string | glob-char)* => [[ ast>glob-expr ]]
+
+other = (!(white | "&" | ">" | ">>" | "<" | "|") .)+ => [[ >string ]]
+
+element = (single-quoted | double-quoted | back-quoted | factor | variable | glob | other)
+
+command = (element _)+
+
+to-file = ">"  _ other => [[ second ]]
+in-file = "<"  _ other => [[ second ]]
+ap-file = ">>" _ other => [[ second ]]
+
+basic = _ command _ (in-file)? _ (to-file | ap-file)? _ ("&")? => [[ ast>basic-expr ]]
+
+pipeline = _ command _ (in-file)? _ "|" _ (command _ "|" _)* command _ (to-file | ap-file)? _ ("&")? => [[ ast>pipeline-expr ]]
+
+submission = (pipeline | basic)
+
+;EBNF
\ No newline at end of file
diff --git a/extra/shell/shell.factor b/extra/shell/shell.factor
new file mode 100644
index 0000000000..57a7a7a327
--- /dev/null
+++ b/extra/shell/shell.factor
@@ -0,0 +1,130 @@
+
+USING: kernel parser words continuations namespaces debugger
+       sequences combinators prettyprint
+       system io io.files io.launcher sequences.deep
+       accessors multi-methods newfx shell.parser ;
+
+IN: shell
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: cd ( args -- )
+  dup empty?
+    [ drop home set-current-directory ]
+    [ first     set-current-directory ]
+  if ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: pwd ( args -- )
+  drop
+  current-directory get
+  print ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: swords ( -- seq ) { "cd" "pwd" } ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+GENERIC: expand ( expr -- expr )
+
+METHOD: expand { single-quoted-expr } expr>> ;
+
+METHOD: expand { double-quoted-expr } expr>> ;
+
+METHOD: expand { variable-expr } expr>> os-env ;
+
+METHOD: expand { glob-expr }
+  expr>>
+  dup "*" =
+    [ drop current-directory get directory [ first ] map ]
+    [ ]
+  if ;
+
+METHOD: expand { factor-expr } expr>> eval unparse ;
+
+METHOD: expand { object } ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: expansion ( command -- command ) [ expand ] map flatten ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: run-sword ( basic-expr -- )
+  command>> expansion unclip "shell" lookup execute ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: run-foreground ( process -- )
+  [ try-process ] [ print-error drop ] recover ;
+
+: run-background ( process -- ) run-detached drop ;
+
+: run-basic-expr ( basic-expr -- )
+  <process>
+    over command>> expansion >>command
+    over stdin>>             >>stdin
+    over stdout>>            >>stdout
+  swap background>>
+    [ run-background ]
+    [ run-foreground ]
+  if ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: basic-chant ( basic-expr -- )
+  dup command>> first swords member-of?
+    [ run-sword ]
+    [ run-basic-expr ]
+  if ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: pipeline-chant ( pipeline-chant -- )
+  drop "ix: pipelines not supported" print ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: chant ( obj -- )
+  dup basic-expr?
+    [ basic-chant    ]
+    [ pipeline-chant ]
+  if ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: prompt ( -- )
+  current-directory get write
+  " $ " write
+  flush ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+DEFER: shell
+
+: handle ( input -- )
+  {
+    { [ dup f = ]      [ drop ] }
+    { [ dup "exit" = ] [ drop ] }
+    { [ dup "" = ]     [ drop shell ] }
+    { [ dup expr ]     [ expr ast>> chant shell ] }
+    { [ t ]            [ drop "ix: ignoring input" print shell ] }
+  }
+    cond ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: shell ( -- )
+  prompt
+  readln
+  handle ;
+  
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: ix ( -- ) shell ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+MAIN: ix
\ No newline at end of file
diff --git a/extra/sudoku/sudoku.factor b/extra/sudoku/sudoku.factor
index b0ba85c97f..1cb82253b1 100644
--- a/extra/sudoku/sudoku.factor
+++ b/extra/sudoku/sudoku.factor
@@ -1,6 +1,6 @@
 ! Based on http://www.ffconsultancy.com/ocaml/sudoku/index.html
 USING: sequences namespaces kernel math math.parser io
-io.styles combinators ;
+io.styles combinators columns ;
 IN: sudoku
 
 SYMBOL: solutions
diff --git a/extra/tools/deploy/backend/backend.factor b/extra/tools/deploy/backend/backend.factor
index b838654248..d4fbf1de78 100755
--- a/extra/tools/deploy/backend/backend.factor
+++ b/extra/tools/deploy/backend/backend.factor
@@ -8,6 +8,15 @@ debugger io.streams.c io.streams.duplex io.files io.backend
 quotations io.launcher words.private tools.deploy.config
 bootstrap.image io.encodings.utf8 accessors ;
 IN: tools.deploy.backend
+    
+: copy-vm ( executable bundle-name extension -- vm )
+  [ prepend-path ] dip append vm over copy-file ;
+  
+: copy-fonts ( name dir -- )  
+  append-path "fonts/" resource-path swap copy-tree-into ;
+  
+: image-name ( vocab bundle-name -- str )  
+  prepend-path ".image" append ;
 
 : (copy-lines) ( stream -- )
     dup stream-readln dup
diff --git a/extra/tools/deploy/deploy-docs.factor b/extra/tools/deploy/deploy-docs.factor
index b225236249..eccb3982c7 100755
--- a/extra/tools/deploy/deploy-docs.factor
+++ b/extra/tools/deploy/deploy-docs.factor
@@ -7,7 +7,12 @@ ARTICLE: "tools.deploy" "Application deployment"
 $nl
 "For example, we can deploy the " { $vocab-link "hello-world" } " demo which comes with Factor:"
 { $code "\"hello-ui\" deploy" }
-"On Mac OS X, this yields a program named " { $snippet "Hello world.app" } ". On Windows, it yields a directory named " { $snippet "Hello world" } " containing a program named " { $snippet "hello-ui.exe" } ". In both cases, running the program displays a window with a message."
+{ $list
+   { "On Mac OS X, this yields a program named " { $snippet "Hello world.app" } "." }
+   { "On Windows, it yields a directory named " { $snippet "Hello world" } " containing a program named " { $snippet "hello-ui.exe" } "." }
+   { "On Unix-like systems (Linux, BSD, Solaris, etc), it yields a directory named " { $snippet "Hello world" } " containing a program named " { $snippet "hello-ui" } "." }
+}
+"In all cases, running the program displays a window with a message."
 $nl
 "The deployment tool works by bootstrapping a fresh image, loading the vocabulary into this image, then applying various heuristics to strip the image down to minimal size."
 $nl
diff --git a/extra/tools/deploy/deploy.factor b/extra/tools/deploy/deploy.factor
index 893b43844a..e57cc1f04b 100755
--- a/extra/tools/deploy/deploy.factor
+++ b/extra/tools/deploy/deploy.factor
@@ -1,9 +1,13 @@
 ! Copyright (C) 2007, 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: tools.deploy.backend system vocabs.loader kernel ;
+USING: tools.deploy.backend system vocabs.loader kernel
+combinators ;
 IN: tools.deploy
 
 : deploy ( vocab -- ) deploy* ;
 
-os macosx? [ "tools.deploy.macosx" require ] when
-os winnt? [ "tools.deploy.windows" require ] when
+{
+    { [ os macosx? ] [ "tools.deploy.macosx" ] }
+    { [ os winnt? ] [ "tools.deploy.windows" ] }
+    { [ os unix? ] [ "tools.deploy.unix" ] }
+} cond require
\ No newline at end of file
diff --git a/extra/tools/deploy/macosx/macosx.factor b/extra/tools/deploy/macosx/macosx.factor
index 3121866d94..d38b40db4b 100755
--- a/extra/tools/deploy/macosx/macosx.factor
+++ b/extra/tools/deploy/macosx/macosx.factor
@@ -14,13 +14,6 @@ IN: tools.deploy.macosx
     bundle-dir over append-path -rot
     "Contents" prepend-path append-path copy-tree ;
 
-: copy-vm ( executable bundle-name -- vm )
-    "Contents/MacOS/" append-path prepend-path vm over copy-file ;
-
-: copy-fonts ( name -- )
-    "fonts/" resource-path
-    swap "Contents/Resources/" append-path copy-tree-into ;
-
 : app-plist ( executable bundle-name -- assoc )
     [
         "6.0" "CFBundleInfoDictionaryVersion" set
@@ -38,10 +31,14 @@ IN: tools.deploy.macosx
     write-plist ;
 
 : create-app-dir ( vocab bundle-name -- vm )
-    dup "Frameworks" copy-bundle-dir
-    dup "Resources/English.lproj/MiniFactor.nib" copy-bundle-dir
-    dup copy-fonts
-    2dup create-app-plist copy-vm ;
+    [
+        nip
+        [ "Frameworks" copy-bundle-dir ]
+        [ "Resources/English.lproj/MiniFactor.nib" copy-bundle-dir ]
+        [ "Contents/Resources/" copy-fonts ] tri
+    ]
+    [ create-app-plist ]
+    [ "Contents/MacOS/" append-path "" copy-vm ] 2tri ;
 
 : deploy.app-image ( vocab bundle-name -- str )
     [ % "/Contents/Resources/" % % ".image" % ] "" make ;
@@ -50,9 +47,8 @@ IN: tools.deploy.macosx
     deploy-name get ".app" append ;
 
 : show-in-finder ( path -- )
-    NSWorkspace
-    -> sharedWorkspace
-    over <NSString> rot parent-directory <NSString>
+    [ NSWorkspace -> sharedWorkspace ]
+    [ normalize-path [ <NSString> ] [ parent-directory <NSString> ] bi ] bi*
     -> selectFile:inFileViewerRootedAtPath: drop ;
 
 M: macosx deploy* ( vocab -- )
@@ -63,6 +59,6 @@ M: macosx deploy* ( vocab -- )
             [ bundle-name create-app-dir ] keep
             [ bundle-name deploy.app-image ] keep
             namespace make-deploy-image
-            bundle-name normalize-path show-in-finder
+            bundle-name show-in-finder
         ] bind
     ] with-directory ;
diff --git a/extra/tools/deploy/unix/authors.txt b/extra/tools/deploy/unix/authors.txt
new file mode 100644
index 0000000000..4b7af4aac0
--- /dev/null
+++ b/extra/tools/deploy/unix/authors.txt
@@ -0,0 +1 @@
+James Cash
diff --git a/extra/tools/deploy/unix/summary.txt b/extra/tools/deploy/unix/summary.txt
new file mode 100644
index 0000000000..7cd80c5e35
--- /dev/null
+++ b/extra/tools/deploy/unix/summary.txt
@@ -0,0 +1 @@
+Deploying minimal stand-alone binaries on *nix-like systems
diff --git a/extra/tools/deploy/unix/tags.txt b/extra/tools/deploy/unix/tags.txt
new file mode 100644
index 0000000000..ef1aab0d0e
--- /dev/null
+++ b/extra/tools/deploy/unix/tags.txt
@@ -0,0 +1 @@
+tools
diff --git a/extra/tools/deploy/unix/unix.factor b/extra/tools/deploy/unix/unix.factor
new file mode 100644
index 0000000000..6f5a0304a2
--- /dev/null
+++ b/extra/tools/deploy/unix/unix.factor
@@ -0,0 +1,23 @@
+! Copyright (C) 2008 James Cash
+! See http://factorcode.org/license.txt for BSD license.
+USING: io io.files io.backend kernel namespaces sequences
+system tools.deploy.backend tools.deploy.config assocs
+hashtables prettyprint ;
+IN: tools.deploy.unix
+
+: create-app-dir ( vocab bundle-name -- vm )
+    dup "" copy-fonts
+    "" copy-vm ;
+
+: bundle-name ( -- str )
+    deploy-name get ;
+
+M: unix deploy* ( vocab -- )
+    "." resource-path [
+        dup deploy-config [
+            [ bundle-name create-app-dir ] keep
+            [ bundle-name image-name ] keep
+            namespace make-deploy-image
+            bundle-name normalize-path [ "Binary deployed to " % % "." % ] "" make print
+        ] bind
+    ] with-directory ;
\ No newline at end of file
diff --git a/extra/tools/deploy/windows/windows.factor b/extra/tools/deploy/windows/windows.factor
index 68b106663c..5af3062e39 100755
--- a/extra/tools/deploy/windows/windows.factor
+++ b/extra/tools/deploy/windows/windows.factor
@@ -5,25 +5,14 @@ tools.deploy.backend tools.deploy.config assocs hashtables
 prettyprint windows.shell32 windows.user32 ;
 IN: tools.deploy.windows
 
-: copy-vm ( executable bundle-name -- vm )
-    prepend-path ".exe" append
-    vm over copy-file ;
-
-: copy-fonts ( bundle-name -- )
-    "fonts/" resource-path swap copy-tree-into ;
-
 : copy-dlls ( bundle-name -- )
-    { "freetype6.dll" "zlib1.dll" "factor.dll" }
-    [ resource-path ] map
+    { "resource:freetype6.dll" "resource:zlib1.dll" "resource:factor.dll" }
     swap copy-files-into ;
 
 : create-exe-dir ( vocab bundle-name -- vm )
     dup copy-dlls
-    dup copy-fonts
-    copy-vm ;
-
-: image-name ( vocab bundle-name -- str )
-    prepend-path ".image" append ;
+    dup "" copy-fonts
+    ".exe" copy-vm ;
 
 M: winnt deploy*
     "." resource-path [
@@ -31,6 +20,6 @@ M: winnt deploy*
             [ deploy-name get create-exe-dir ] keep
             [ deploy-name get image-name ] keep
             [ namespace make-deploy-image ] keep
-            (normalize-path) open-in-explorer
+            open-in-explorer
         ] bind
     ] with-directory ;
diff --git a/extra/tools/walker/walker.factor b/extra/tools/walker/walker.factor
index 8a5ab42767..6bf3c53768 100755
--- a/extra/tools/walker/walker.factor
+++ b/extra/tools/walker/walker.factor
@@ -138,7 +138,6 @@ SYMBOL: +stopped+
     >n ndrop >c c>
     continue continue-with
     stop yield suspend sleep (spawn)
-    suspend
 } [
     dup [ execute break ] curry
     "step-into" set-word-prop
diff --git a/extra/ui/commands/commands.factor b/extra/ui/commands/commands.factor
index 90eb6254cd..c7db687dc3 100755
--- a/extra/ui/commands/commands.factor
+++ b/extra/ui/commands/commands.factor
@@ -66,7 +66,7 @@ M: word command-description ( word -- str )
     H{ { +nullary+ f } { +listener+ f } { +description+ f } } ;
 
 : define-command ( word hash -- )
-    default-flags swap assoc-union >r word-props r> update ;
+    [ word-props ] [ default-flags swap assoc-union ] bi* update ;
 
 : command-quot ( target command -- quot )
     dup 1quotation swap +nullary+ word-prop
diff --git a/extra/ui/gadgets/grids/grids.factor b/extra/ui/gadgets/grids/grids.factor
index 342c360c83..9951256249 100644
--- a/extra/ui/gadgets/grids/grids.factor
+++ b/extra/ui/gadgets/grids/grids.factor
@@ -1,7 +1,7 @@
 ! Copyright (C) 2006 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: arrays kernel math namespaces sequences words io
-io.streams.string math.vectors ui.gadgets ;
+io.streams.string math.vectors ui.gadgets columns ;
 IN: ui.gadgets.grids
 
 TUPLE: grid children gap fill? ;
diff --git a/extra/ui/gestures/gestures.factor b/extra/ui/gestures/gestures.factor
index f68a70c2bd..ed0f38b743 100755
--- a/extra/ui/gestures/gestures.factor
+++ b/extra/ui/gestures/gestures.factor
@@ -3,7 +3,7 @@
 USING: arrays assocs kernel math models namespaces
 sequences words strings system hashtables math.parser
 math.vectors classes.tuple classes ui.gadgets boxes
-calendar alarms symbols combinators sets ;
+calendar alarms symbols combinators sets columns ;
 IN: ui.gestures
 
 : set-gestures ( class hash -- ) "gestures" set-word-prop ;
diff --git a/extra/ui/tools/listener/listener.factor b/extra/ui/tools/listener/listener.factor
index 6c2a5e317d..8e28739ccd 100755
--- a/extra/ui/tools/listener/listener.factor
+++ b/extra/ui/tools/listener/listener.factor
@@ -111,7 +111,7 @@ M: method-body word-completion-string
 
 USE: generic.standard.engines.tuple
 
-M: tuple-dispatch-engine-word word-completion-string
+M: engine-word word-completion-string
     "engine-generic" word-prop word-completion-string ;
 
 : use-if-necessary ( word seq -- )
diff --git a/extra/windows/shell32/shell32.factor b/extra/windows/shell32/shell32.factor
index d64fb68cb3..f938ca15e6 100644
--- a/extra/windows/shell32/shell32.factor
+++ b/extra/windows/shell32/shell32.factor
@@ -1,6 +1,6 @@
 USING: alien alien.c-types alien.syntax combinators
 kernel windows windows.user32 windows.ole32
-windows.com windows.com.syntax ;
+windows.com windows.com.syntax io.files ;
 IN: windows.shell32
 
 : CSIDL_DESKTOP HEX: 00 ; inline
@@ -83,7 +83,7 @@ FUNCTION: HINSTANCE ShellExecuteW ( HWND hwnd, LPCTSTR lpOperation, LPCTSTR lpFi
 : ShellExecute ShellExecuteW ; inline
 
 : open-in-explorer ( dir -- )
-    f "open" rot f f SW_SHOWNORMAL ShellExecute drop ;
+    f "open" rot (normalize-path) f f SW_SHOWNORMAL ShellExecute drop ;
 
 : shell32-error ( n -- )
     ole32-error ; inline
diff --git a/vm/data_gc.c b/vm/data_gc.c
index 86552d6401..5aa47c8c6c 100755
--- a/vm/data_gc.c
+++ b/vm/data_gc.c
@@ -122,7 +122,7 @@ void clear_cards(CELL from, CELL to)
 void set_data_heap(F_DATA_HEAP *data_heap_)
 {
 	data_heap = data_heap_;
-	nursery = &data_heap->generations[NURSERY];
+	nursery = data_heap->generations[NURSERY];
 	init_cards_offset();
 	clear_cards(NURSERY,TENURED);
 }
@@ -231,7 +231,7 @@ DEFINE_PRIMITIVE(data_room)
 
 	for(gen = 0; gen < data_heap->gen_count; gen++)
 	{
-		F_ZONE *z = &data_heap->generations[gen];
+		F_ZONE *z = (gen == NURSERY ? &nursery : &data_heap->generations[gen]);
 		set_array_nth(a,gen * 2,tag_fixnum((z->end - z->here) >> 10));
 		set_array_nth(a,gen * 2 + 1,tag_fixnum((z->size) >> 10));
 	}
@@ -583,7 +583,7 @@ CELL collect_next(CELL scan)
 
 INLINE void reset_generation(CELL i)
 {
-	F_ZONE *z = &data_heap->generations[i];
+	F_ZONE *z = (i == NURSERY ? &nursery : &data_heap->generations[i]);
 	z->here = z->start;
 	if(secure_gc)
 		memset((void*)z->start,69,z->size);
@@ -608,7 +608,7 @@ void begin_gc(CELL requested_bytes)
 
 		old_data_heap = data_heap;
 		set_data_heap(grow_data_heap(old_data_heap,requested_bytes));
-		newspace = &data_heap->generations[collecting_gen];
+		newspace = &data_heap->generations[TENURED];
 	}
 	else if(collecting_accumulation_gen_p())
 	{
@@ -783,6 +783,11 @@ void gc(void)
 	garbage_collection(TENURED,false,0);
 }
 
+void minor_gc(void)
+{
+	garbage_collection(NURSERY,false,0);
+}
+
 DEFINE_PRIMITIVE(gc)
 {
 	gc();
@@ -794,12 +799,6 @@ DEFINE_PRIMITIVE(gc_time)
 	box_unsigned_8(gc_time);
 }
 
-void simple_gc(void)
-{
-	if(nursery->here + ALLOT_BUFFER_ZONE > nursery->end)
-		garbage_collection(NURSERY,false,0);
-}
-
 DEFINE_PRIMITIVE(become)
 {
 	F_ARRAY *new_objects = untag_array(dpop());
diff --git a/vm/data_gc.h b/vm/data_gc.h
index 2490ed8805..be9ed159b7 100755
--- a/vm/data_gc.h
+++ b/vm/data_gc.h
@@ -20,6 +20,7 @@ DECLARE_PRIMITIVE(next_object);
 DECLARE_PRIMITIVE(end_scan);
 
 void gc(void);
+DLLEXPORT void minor_gc(void);
 
 /* generational copying GC divides memory into zones */
 typedef struct {
@@ -125,7 +126,7 @@ void collect_cards(void);
 F_ZONE *newspace;
 
 /* new objects are allocated here */
-DLLEXPORT F_ZONE *nursery;
+DLLEXPORT F_ZONE nursery;
 
 INLINE bool in_zone(F_ZONE *z, CELL pointer)
 {
@@ -200,7 +201,7 @@ INLINE bool should_copy(CELL untagged)
 	else if(HAVE_AGING_P && collecting_gen == AGING)
 		return !in_zone(&data_heap->generations[TENURED],untagged);
 	else if(HAVE_NURSERY_P && collecting_gen == NURSERY)
-		return in_zone(&data_heap->generations[NURSERY],untagged);
+		return in_zone(&nursery,untagged);
 	else
 	{
 		critical_error("Bug in should_copy",untagged);
@@ -315,13 +316,15 @@ INLINE void* allot_object(CELL type, CELL a)
 {
 	CELL *object;
 
-	if(HAVE_NURSERY_P && nursery->size - ALLOT_BUFFER_ZONE > a)
+	if(HAVE_NURSERY_P && nursery.size - ALLOT_BUFFER_ZONE > a)
 	{
 		/* If there is insufficient room, collect the nursery */
-		if(nursery->here + ALLOT_BUFFER_ZONE + a > nursery->end)
+		if(nursery.here + ALLOT_BUFFER_ZONE + a > nursery.end)
 			garbage_collection(NURSERY,false,0);
 
-		object = allot_zone(nursery,a);
+		CELL h = nursery.here;
+		nursery.here = h + align8(a);
+		object = (void*)h;
 	}
 	/* If the object is bigger than the nursery, allocate it in
 	tenured space */
@@ -360,8 +363,6 @@ INLINE void* allot_object(CELL type, CELL a)
 
 CELL collect_next(CELL scan);
 
-DLLEXPORT void simple_gc(void);
-
 DECLARE_PRIMITIVE(gc);
 DECLARE_PRIMITIVE(gc_time);
 DECLARE_PRIMITIVE(become);
diff --git a/vm/debug.c b/vm/debug.c
index 840d252769..b86ec808bc 100755
--- a/vm/debug.c
+++ b/vm/debug.c
@@ -227,7 +227,11 @@ void dump_zone(F_ZONE *z)
 void dump_generations(void)
 {
 	int i;
-	for(i = 0; i < data_heap->gen_count; i++)
+
+	printf("Nursery: ");
+	dump_zone(&nursery);
+	
+	for(i = 1; i < data_heap->gen_count; i++)
 	{
 		printf("Generation %d: ",i);
 		dump_zone(&data_heap->generations[i]);
diff --git a/vm/errors.c b/vm/errors.c
index 6d99d34766..57dc8b66a1 100755
--- a/vm/errors.c
+++ b/vm/errors.c
@@ -96,7 +96,7 @@ void memory_protection_error(CELL addr, F_STACK_FRAME *native_stack)
 		general_error(ERROR_RS_UNDERFLOW,F,F,native_stack);
 	else if(in_page(addr, rs_bot, rs_size, 0))
 		general_error(ERROR_RS_OVERFLOW,F,F,native_stack);
-	else if(in_page(addr, nursery->end, 0, 0))
+	else if(in_page(addr, nursery.end, 0, 0))
 		critical_error("allot_object() missed GC check",0);
 	else if(in_page(addr, gc_locals_region->start, 0, -1))
 		critical_error("gc locals underflow",0);
diff --git a/vm/ffi_test.c b/vm/ffi_test.c
index 9cec5ccbad..5dcff831df 100755
--- a/vm/ffi_test.c
+++ b/vm/ffi_test.c
@@ -250,3 +250,20 @@ double ffi_test_36(struct test_struct_12 x)
 {
 	return x.x;
 }
+
+int ffi_test_37(int (*f)(int, int, int))
+{
+	static int global_var = 0;
+	printf("ffi_test_37\n");
+	global_var = f(global_var,global_var * 2,global_var * 3);
+	printf("global_var is %d\n",global_var);
+	fflush(stdout);
+	return global_var;
+}
+
+unsigned long long ffi_test_38(unsigned long long x, unsigned long long y)
+{
+	return x * y;
+}
+
+
diff --git a/vm/ffi_test.h b/vm/ffi_test.h
index aac5d32f93..9a3f4dded2 100755
--- a/vm/ffi_test.h
+++ b/vm/ffi_test.h
@@ -61,3 +61,7 @@ DLLEXPORT double ffi_test_35(struct test_struct_11 x, int y);
 struct test_struct_12 { int a; double x; };
 
 DLLEXPORT double ffi_test_36(struct test_struct_12 x);
+
+DLLEXPORT int ffi_test_37(int (*f)(int, int, int));
+
+DLLEXPORT unsigned long long ffi_test_38(unsigned long long x, unsigned long long y);
diff --git a/vm/ffi_test.s b/vm/ffi_test.s
new file mode 100644
index 0000000000..ad02e0e74f
--- /dev/null
+++ b/vm/ffi_test.s
@@ -0,0 +1,1163 @@
+	.cstring
+LC0:
+	.ascii "ffi_test_0()\0"
+	.text
+.globl _ffi_test_0
+_ffi_test_0:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$20, %esp
+	call	L3
+"L00000000001$pb":
+L3:
+	popl	%ebx
+	leal	LC0-"L00000000001$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_puts$stub
+	addl	$20, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC1:
+	.ascii "ffi_test_1()\0"
+	.text
+.globl _ffi_test_1
+_ffi_test_1:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$20, %esp
+	call	L6
+"L00000000002$pb":
+L6:
+	popl	%ebx
+	leal	LC1-"L00000000002$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_puts$stub
+	movl	$3, %eax
+	addl	$20, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC2:
+	.ascii "ffi_test_2(%d,%d)\12\0"
+	.text
+.globl _ffi_test_2
+_ffi_test_2:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$20, %esp
+	call	L9
+"L00000000003$pb":
+L9:
+	popl	%ebx
+	movl	12(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, 4(%esp)
+	leal	LC2-"L00000000003$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movl	12(%ebp), %eax
+	addl	8(%ebp), %eax
+	addl	$20, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC3:
+	.ascii "ffi_test_3(%d,%d,%d,%d)\12\0"
+	.text
+.globl _ffi_test_3
+_ffi_test_3:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$36, %esp
+	call	L12
+"L00000000004$pb":
+L12:
+	popl	%ebx
+	movl	20(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, 4(%esp)
+	leal	LC3-"L00000000004$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movl	12(%ebp), %eax
+	movl	8(%ebp), %edx
+	addl	%eax, %edx
+	movl	16(%ebp), %eax
+	imull	20(%ebp), %eax
+	leal	(%edx,%eax), %eax
+	addl	$36, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC4:
+	.ascii "ffi_test_4()\0"
+	.literal4
+	.align 2
+LC5:
+	.long	1069547520
+	.text
+.globl _ffi_test_4
+_ffi_test_4:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$36, %esp
+	call	L15
+"L00000000005$pb":
+L15:
+	popl	%ebx
+	leal	LC4-"L00000000005$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_puts$stub
+	leal	LC5-"L00000000005$pb"(%ebx), %eax
+	movl	(%eax), %eax
+	movl	%eax, -12(%ebp)
+	movss	-12(%ebp), %xmm0
+	movss	%xmm0, -12(%ebp)
+	flds	-12(%ebp)
+	addl	$36, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC6:
+	.ascii "ffi_test_5()\0"
+	.literal8
+	.align 3
+LC7:
+	.long	0
+	.long	1073217536
+	.text
+.globl _ffi_test_5
+_ffi_test_5:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$36, %esp
+	call	L18
+"L00000000006$pb":
+L18:
+	popl	%ebx
+	leal	LC6-"L00000000006$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_puts$stub
+	leal	LC7-"L00000000006$pb"(%ebx), %eax
+	movsd	(%eax), %xmm0
+	movsd	%xmm0, -16(%ebp)
+	fldl	-16(%ebp)
+	addl	$36, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC8:
+	.ascii "ffi_test_6(%f,%f)\12\0"
+	.text
+.globl _ffi_test_6
+_ffi_test_6:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$52, %esp
+	call	L21
+"L00000000007$pb":
+L21:
+	popl	%ebx
+	cvtss2sd	12(%ebp), %xmm0
+	cvtss2sd	8(%ebp), %xmm1
+	movsd	%xmm0, 12(%esp)
+	movsd	%xmm1, 4(%esp)
+	leal	LC8-"L00000000007$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movss	8(%ebp), %xmm0
+	mulss	12(%ebp), %xmm0
+	cvtss2sd	%xmm0, %xmm0
+	movsd	%xmm0, -16(%ebp)
+	fldl	-16(%ebp)
+	addl	$52, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC9:
+	.ascii "ffi_test_7(%f,%f)\12\0"
+	.text
+.globl _ffi_test_7
+_ffi_test_7:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$68, %esp
+	call	L24
+"L00000000008$pb":
+L24:
+	popl	%ebx
+	movl	8(%ebp), %eax
+	movl	%eax, -16(%ebp)
+	movl	12(%ebp), %eax
+	movl	%eax, -12(%ebp)
+	movl	16(%ebp), %eax
+	movl	%eax, -24(%ebp)
+	movl	20(%ebp), %eax
+	movl	%eax, -20(%ebp)
+	movsd	-24(%ebp), %xmm0
+	movsd	%xmm0, 12(%esp)
+	movsd	-16(%ebp), %xmm0
+	movsd	%xmm0, 4(%esp)
+	leal	LC9-"L00000000008$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movsd	-16(%ebp), %xmm0
+	mulsd	-24(%ebp), %xmm0
+	movsd	%xmm0, -32(%ebp)
+	fldl	-32(%ebp)
+	addl	$68, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC10:
+	.ascii "ffi_test_8(%f,%f,%f,%f,%d)\12\0"
+	.text
+.globl _ffi_test_8
+_ffi_test_8:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$84, %esp
+	call	L27
+"L00000000009$pb":
+L27:
+	popl	%ebx
+	movl	8(%ebp), %eax
+	movl	%eax, -16(%ebp)
+	movl	12(%ebp), %eax
+	movl	%eax, -12(%ebp)
+	movl	20(%ebp), %eax
+	movl	%eax, -24(%ebp)
+	movl	24(%ebp), %eax
+	movl	%eax, -20(%ebp)
+	cvtss2sd	28(%ebp), %xmm0
+	cvtss2sd	16(%ebp), %xmm1
+	movl	32(%ebp), %eax
+	movl	%eax, 36(%esp)
+	movsd	%xmm0, 28(%esp)
+	movsd	-24(%ebp), %xmm0
+	movsd	%xmm0, 20(%esp)
+	movsd	%xmm1, 12(%esp)
+	movsd	-16(%ebp), %xmm0
+	movsd	%xmm0, 4(%esp)
+	leal	LC10-"L00000000009$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	cvtss2sd	16(%ebp), %xmm0
+	movapd	%xmm0, %xmm1
+	mulsd	-16(%ebp), %xmm1
+	cvtss2sd	28(%ebp), %xmm0
+	mulsd	-24(%ebp), %xmm0
+	addsd	%xmm0, %xmm1
+	cvtsi2sd	32(%ebp), %xmm0
+	addsd	%xmm1, %xmm0
+	movsd	%xmm0, -32(%ebp)
+	fldl	-32(%ebp)
+	addl	$84, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+	.align 2
+LC11:
+	.ascii "ffi_test_9(%d,%d,%d,%d,%d,%d,%d)\12\0"
+	.text
+.globl _ffi_test_9
+_ffi_test_9:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$36, %esp
+	call	L30
+"L00000000010$pb":
+L30:
+	popl	%ebx
+	movl	32(%ebp), %eax
+	movl	%eax, 28(%esp)
+	movl	28(%ebp), %eax
+	movl	%eax, 24(%esp)
+	movl	24(%ebp), %eax
+	movl	%eax, 20(%esp)
+	movl	20(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, 4(%esp)
+	leal	LC11-"L00000000010$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movl	12(%ebp), %eax
+	addl	8(%ebp), %eax
+	addl	16(%ebp), %eax
+	addl	20(%ebp), %eax
+	addl	24(%ebp), %eax
+	addl	28(%ebp), %eax
+	addl	32(%ebp), %eax
+	addl	$36, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+	.align 2
+LC12:
+	.ascii "ffi_test_10(%d,%d,%f,%d,%f,%d,%d,%d)\12\0"
+	.text
+.globl _ffi_test_10
+_ffi_test_10:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$68, %esp
+	call	L33
+"L00000000011$pb":
+L33:
+	popl	%ebx
+	movl	16(%ebp), %eax
+	movl	%eax, -16(%ebp)
+	movl	20(%ebp), %eax
+	movl	%eax, -12(%ebp)
+	cvtss2sd	28(%ebp), %xmm0
+	movl	40(%ebp), %eax
+	movl	%eax, 40(%esp)
+	movl	36(%ebp), %eax
+	movl	%eax, 36(%esp)
+	movl	32(%ebp), %eax
+	movl	%eax, 32(%esp)
+	movsd	%xmm0, 24(%esp)
+	movl	24(%ebp), %eax
+	movl	%eax, 20(%esp)
+	movsd	-16(%ebp), %xmm0
+	movsd	%xmm0, 12(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, 4(%esp)
+	leal	LC12-"L00000000011$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movl	12(%ebp), %edx
+	movl	8(%ebp), %eax
+	subl	%edx, %eax
+	cvtsi2sd	%eax, %xmm0
+	movapd	%xmm0, %xmm1
+	subsd	-16(%ebp), %xmm1
+	cvtsi2sd	24(%ebp), %xmm0
+	subsd	%xmm0, %xmm1
+	cvtss2sd	28(%ebp), %xmm0
+	subsd	%xmm0, %xmm1
+	cvtsi2sd	32(%ebp), %xmm0
+	subsd	%xmm0, %xmm1
+	cvtsi2sd	36(%ebp), %xmm0
+	subsd	%xmm0, %xmm1
+	cvtsi2sd	40(%ebp), %xmm0
+	movapd	%xmm1, %xmm2
+	subsd	%xmm0, %xmm2
+	movapd	%xmm2, %xmm0
+	cvttsd2si	%xmm0, %eax
+	addl	$68, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC13:
+	.ascii "ffi_test_11(%d,{%d,%d},%d)\12\0"
+	.text
+.globl _ffi_test_11
+_ffi_test_11:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$36, %esp
+	call	L36
+"L00000000012$pb":
+L36:
+	popl	%ebx
+	movl	16(%ebp), %edx
+	movl	12(%ebp), %ecx
+	movl	20(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	%edx, 12(%esp)
+	movl	%ecx, 8(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, 4(%esp)
+	leal	LC13-"L00000000012$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movl	12(%ebp), %eax
+	movl	%eax, %edx
+	imull	8(%ebp), %edx
+	movl	16(%ebp), %eax
+	imull	20(%ebp), %eax
+	leal	(%edx,%eax), %eax
+	addl	$36, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+	.align 2
+LC14:
+	.ascii "ffi_test_12(%d,%d,{%f,%f,%f,%f},%d,%d,%d)\12\0"
+	.text
+.globl _ffi_test_12
+_ffi_test_12:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$68, %esp
+	call	L39
+"L00000000013$pb":
+L39:
+	popl	%ebx
+	movss	28(%ebp), %xmm0
+	cvtss2sd	%xmm0, %xmm1
+	movss	24(%ebp), %xmm0
+	cvtss2sd	%xmm0, %xmm2
+	movss	20(%ebp), %xmm0
+	cvtss2sd	%xmm0, %xmm3
+	movss	16(%ebp), %xmm0
+	cvtss2sd	%xmm0, %xmm0
+	movl	40(%ebp), %eax
+	movl	%eax, 52(%esp)
+	movl	36(%ebp), %eax
+	movl	%eax, 48(%esp)
+	movl	32(%ebp), %eax
+	movl	%eax, 44(%esp)
+	movsd	%xmm1, 36(%esp)
+	movsd	%xmm2, 28(%esp)
+	movsd	%xmm3, 20(%esp)
+	movsd	%xmm0, 12(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, 4(%esp)
+	leal	LC14-"L00000000013$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movl	12(%ebp), %eax
+	addl	8(%ebp), %eax
+	cvtsi2ss	%eax, %xmm1
+	movss	16(%ebp), %xmm0
+	addss	%xmm0, %xmm1
+	movss	20(%ebp), %xmm0
+	addss	%xmm0, %xmm1
+	movss	24(%ebp), %xmm0
+	addss	%xmm0, %xmm1
+	movss	28(%ebp), %xmm0
+	addss	%xmm0, %xmm1
+	cvtsi2ss	32(%ebp), %xmm0
+	addss	%xmm0, %xmm1
+	cvtsi2ss	36(%ebp), %xmm0
+	addss	%xmm0, %xmm1
+	cvtsi2ss	40(%ebp), %xmm0
+	addss	%xmm1, %xmm0
+	cvttss2si	%xmm0, %eax
+	addl	$68, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+	.align 2
+LC15:
+	.ascii "ffi_test_13(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)\12\0"
+	.text
+.globl _ffi_test_13
+_ffi_test_13:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$52, %esp
+	call	L42
+"L00000000014$pb":
+L42:
+	popl	%ebx
+	movl	48(%ebp), %eax
+	movl	%eax, 44(%esp)
+	movl	44(%ebp), %eax
+	movl	%eax, 40(%esp)
+	movl	40(%ebp), %eax
+	movl	%eax, 36(%esp)
+	movl	36(%ebp), %eax
+	movl	%eax, 32(%esp)
+	movl	32(%ebp), %eax
+	movl	%eax, 28(%esp)
+	movl	28(%ebp), %eax
+	movl	%eax, 24(%esp)
+	movl	24(%ebp), %eax
+	movl	%eax, 20(%esp)
+	movl	20(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, 4(%esp)
+	leal	LC15-"L00000000014$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movl	12(%ebp), %eax
+	addl	8(%ebp), %eax
+	addl	16(%ebp), %eax
+	addl	20(%ebp), %eax
+	addl	24(%ebp), %eax
+	addl	28(%ebp), %eax
+	addl	32(%ebp), %eax
+	addl	36(%ebp), %eax
+	addl	40(%ebp), %eax
+	addl	44(%ebp), %eax
+	addl	48(%ebp), %eax
+	addl	$52, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC16:
+	.ascii "ffi_test_14(%d,%d)\12\0"
+	.text
+.globl _ffi_test_14
+_ffi_test_14:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$36, %esp
+	call	L45
+"L00000000015$pb":
+L45:
+	popl	%ebx
+	movl	12(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, 4(%esp)
+	leal	LC16-"L00000000015$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movl	8(%ebp), %eax
+	movl	%eax, -16(%ebp)
+	movl	12(%ebp), %eax
+	movl	%eax, -12(%ebp)
+	movl	-16(%ebp), %eax
+	movl	-12(%ebp), %edx
+	addl	$36, %esp
+	popl	%ebx
+	leave
+	ret
+	.cstring
+LC17:
+	.ascii "foo\0"
+LC18:
+	.ascii "bar\0"
+	.text
+.globl _ffi_test_15
+_ffi_test_15:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$36, %esp
+	call	L51
+"L00000000016$pb":
+L51:
+	popl	%ebx
+	movl	12(%ebp), %eax
+	movl	%eax, 4(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, (%esp)
+	call	L_strcmp$stub
+	testl	%eax, %eax
+	je	L47
+	leal	LC17-"L00000000016$pb"(%ebx), %eax
+	movl	%eax, -12(%ebp)
+	jmp	L49
+L47:
+	leal	LC18-"L00000000016$pb"(%ebx), %eax
+	movl	%eax, -12(%ebp)
+L49:
+	movl	-12(%ebp), %eax
+	addl	$36, %esp
+	popl	%ebx
+	leave
+	ret
+.globl _ffi_test_16
+_ffi_test_16:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movl	8(%ebp), %edx
+	movl	12(%ebp), %eax
+	movl	%eax, -20(%ebp)
+	movl	16(%ebp), %eax
+	movl	%eax, -16(%ebp)
+	movl	20(%ebp), %eax
+	movl	%eax, -12(%ebp)
+	movl	-20(%ebp), %eax
+	movl	%eax, (%edx)
+	movl	-16(%ebp), %eax
+	movl	%eax, 4(%edx)
+	movl	-12(%ebp), %eax
+	movl	%eax, 8(%edx)
+	movl	%edx, %eax
+	leave
+	ret	$4
+.globl _ffi_test_17
+_ffi_test_17:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movl	8(%ebp), %eax
+	movl	%eax, -12(%ebp)
+	movl	-12(%ebp), %eax
+	leave
+	ret
+	.cstring
+LC19:
+	.ascii "ffi_test_18(%d,%d,%d,%d)\12\0"
+	.text
+.globl _ffi_test_18
+_ffi_test_18:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$36, %esp
+	call	L58
+"L00000000017$pb":
+L58:
+	popl	%ebx
+	movl	20(%ebp), %eax
+	movl	%eax, 16(%esp)
+	movl	16(%ebp), %eax
+	movl	%eax, 12(%esp)
+	movl	12(%ebp), %eax
+	movl	%eax, 8(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, 4(%esp)
+	leal	LC19-"L00000000017$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movl	12(%ebp), %eax
+	movl	8(%ebp), %edx
+	addl	%eax, %edx
+	movl	16(%ebp), %eax
+	imull	20(%ebp), %eax
+	leal	(%edx,%eax), %eax
+	addl	$36, %esp
+	popl	%ebx
+	leave
+	ret	$16
+.globl _ffi_test_19
+_ffi_test_19:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movl	8(%ebp), %edx
+	movl	12(%ebp), %eax
+	movl	%eax, -20(%ebp)
+	movl	16(%ebp), %eax
+	movl	%eax, -16(%ebp)
+	movl	20(%ebp), %eax
+	movl	%eax, -12(%ebp)
+	movl	-20(%ebp), %eax
+	movl	%eax, (%edx)
+	movl	-16(%ebp), %eax
+	movl	%eax, 4(%edx)
+	movl	-12(%ebp), %eax
+	movl	%eax, 8(%edx)
+	movl	%edx, %eax
+	leave
+	ret	$16
+	.cstring
+	.align 2
+LC20:
+	.ascii "ffi_test_20(%f,%f,%f,%f,%f,%f,%f,%f,%f)\12\0"
+	.text
+.globl _ffi_test_20
+_ffi_test_20:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$164, %esp
+	call	L63
+"L00000000018$pb":
+L63:
+	popl	%ebx
+	movl	8(%ebp), %eax
+	movl	%eax, -16(%ebp)
+	movl	12(%ebp), %eax
+	movl	%eax, -12(%ebp)
+	movl	16(%ebp), %eax
+	movl	%eax, -24(%ebp)
+	movl	20(%ebp), %eax
+	movl	%eax, -20(%ebp)
+	movl	24(%ebp), %eax
+	movl	%eax, -32(%ebp)
+	movl	28(%ebp), %eax
+	movl	%eax, -28(%ebp)
+	movl	32(%ebp), %eax
+	movl	%eax, -40(%ebp)
+	movl	36(%ebp), %eax
+	movl	%eax, -36(%ebp)
+	movl	40(%ebp), %eax
+	movl	%eax, -48(%ebp)
+	movl	44(%ebp), %eax
+	movl	%eax, -44(%ebp)
+	movl	48(%ebp), %eax
+	movl	%eax, -56(%ebp)
+	movl	52(%ebp), %eax
+	movl	%eax, -52(%ebp)
+	movl	56(%ebp), %eax
+	movl	%eax, -64(%ebp)
+	movl	60(%ebp), %eax
+	movl	%eax, -60(%ebp)
+	movl	64(%ebp), %eax
+	movl	%eax, -72(%ebp)
+	movl	68(%ebp), %eax
+	movl	%eax, -68(%ebp)
+	movl	72(%ebp), %eax
+	movl	%eax, -80(%ebp)
+	movl	76(%ebp), %eax
+	movl	%eax, -76(%ebp)
+	movsd	-80(%ebp), %xmm0
+	movsd	%xmm0, 68(%esp)
+	movsd	-72(%ebp), %xmm0
+	movsd	%xmm0, 60(%esp)
+	movsd	-64(%ebp), %xmm0
+	movsd	%xmm0, 52(%esp)
+	movsd	-56(%ebp), %xmm0
+	movsd	%xmm0, 44(%esp)
+	movsd	-48(%ebp), %xmm0
+	movsd	%xmm0, 36(%esp)
+	movsd	-40(%ebp), %xmm0
+	movsd	%xmm0, 28(%esp)
+	movsd	-32(%ebp), %xmm0
+	movsd	%xmm0, 20(%esp)
+	movsd	-24(%ebp), %xmm0
+	movsd	%xmm0, 12(%esp)
+	movsd	-16(%ebp), %xmm0
+	movsd	%xmm0, 4(%esp)
+	leal	LC20-"L00000000018$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	addl	$164, %esp
+	popl	%ebx
+	leave
+	ret
+.globl _ffi_test_21
+_ffi_test_21:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$56, %esp
+	movl	8(%ebp), %eax
+	movl	%eax, -16(%ebp)
+	movl	%eax, %edx
+	sarl	$31, %edx
+	movl	%edx, -12(%ebp)
+	movl	12(%ebp), %eax
+	movl	%eax, -48(%ebp)
+	movl	%eax, %edx
+	sarl	$31, %edx
+	movl	%edx, -44(%ebp)
+	movl	-16(%ebp), %eax
+	mull	-48(%ebp)
+	movl	%eax, -24(%ebp)
+	movl	%edx, -20(%ebp)
+	movl	-16(%ebp), %edx
+	imull	-44(%ebp), %edx
+	movl	%edx, -28(%ebp)
+	movl	-20(%ebp), %ecx
+	addl	-28(%ebp), %ecx
+	movl	-48(%ebp), %eax
+	imull	-12(%ebp), %eax
+	addl	%eax, %ecx
+	movl	%ecx, -20(%ebp)
+	movl	-24(%ebp), %eax
+	movl	-20(%ebp), %edx
+	leave
+	ret
+	.cstring
+LC21:
+	.ascii "ffi_test_22(%ld,%lld,%lld)\12\0"
+	.text
+.globl _ffi_test_22
+_ffi_test_22:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$52, %esp
+	call	L68
+"L00000000019$pb":
+L68:
+	popl	%ebx
+	movl	12(%ebp), %eax
+	movl	%eax, -16(%ebp)
+	movl	16(%ebp), %eax
+	movl	%eax, -12(%ebp)
+	movl	20(%ebp), %eax
+	movl	%eax, -24(%ebp)
+	movl	24(%ebp), %eax
+	movl	%eax, -20(%ebp)
+	movl	-24(%ebp), %eax
+	movl	-20(%ebp), %edx
+	movl	%eax, 16(%esp)
+	movl	%edx, 20(%esp)
+	movl	-16(%ebp), %eax
+	movl	-12(%ebp), %edx
+	movl	%eax, 8(%esp)
+	movl	%edx, 12(%esp)
+	movl	8(%ebp), %eax
+	movl	%eax, 4(%esp)
+	leal	LC21-"L00000000019$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	movl	-24(%ebp), %eax
+	movl	-20(%ebp), %edx
+	movl	%eax, 8(%esp)
+	movl	%edx, 12(%esp)
+	movl	-16(%ebp), %eax
+	movl	-12(%ebp), %edx
+	movl	%eax, (%esp)
+	movl	%edx, 4(%esp)
+	call	L___divdi3$stub
+	addl	8(%ebp), %eax
+	addl	$52, %esp
+	popl	%ebx
+	leave
+	ret
+.globl _ffi_test_23
+_ffi_test_23:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movl	8(%ebp), %eax
+	movss	(%eax), %xmm1
+	movl	12(%ebp), %eax
+	movss	(%eax), %xmm0
+	movaps	%xmm1, %xmm2
+	mulss	%xmm0, %xmm2
+	movl	8(%ebp), %eax
+	addl	$4, %eax
+	movss	(%eax), %xmm1
+	movl	12(%ebp), %eax
+	addl	$4, %eax
+	movss	(%eax), %xmm0
+	mulss	%xmm1, %xmm0
+	addss	%xmm0, %xmm2
+	movl	8(%ebp), %eax
+	addl	$8, %eax
+	movss	(%eax), %xmm1
+	movl	12(%ebp), %eax
+	addl	$8, %eax
+	movss	(%eax), %xmm0
+	mulss	%xmm1, %xmm0
+	addss	%xmm2, %xmm0
+	movss	%xmm0, -12(%ebp)
+	flds	-12(%ebp)
+	leave
+	ret
+.globl _ffi_test_24
+_ffi_test_24:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movb	$1, -9(%ebp)
+	movzbl	-9(%ebp), %eax
+	leave
+	ret
+.globl _ffi_test_25
+_ffi_test_25:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movb	$1, -10(%ebp)
+	movb	$2, -9(%ebp)
+	movzwl	-10(%ebp), %eax
+	leave
+	ret
+.globl _ffi_test_26
+_ffi_test_26:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movl	8(%ebp), %eax
+	movb	$1, -11(%ebp)
+	movb	$2, -10(%ebp)
+	movb	$3, -9(%ebp)
+	movzwl	-11(%ebp), %edx
+	movw	%dx, (%eax)
+	movzbl	-9(%ebp), %edx
+	movb	%dl, 2(%eax)
+	leave
+	ret	$4
+.globl _ffi_test_27
+_ffi_test_27:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movb	$1, -12(%ebp)
+	movb	$2, -11(%ebp)
+	movb	$3, -10(%ebp)
+	movb	$4, -9(%ebp)
+	movl	-12(%ebp), %eax
+	leave
+	ret
+.globl _ffi_test_28
+_ffi_test_28:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movl	8(%ebp), %eax
+	movb	$1, -13(%ebp)
+	movb	$2, -12(%ebp)
+	movb	$3, -11(%ebp)
+	movb	$4, -10(%ebp)
+	movb	$5, -9(%ebp)
+	movl	-13(%ebp), %edx
+	movl	%edx, (%eax)
+	movzbl	-9(%ebp), %edx
+	movb	%dl, 4(%eax)
+	leave
+	ret	$4
+.globl _ffi_test_29
+_ffi_test_29:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movl	8(%ebp), %eax
+	movb	$1, -14(%ebp)
+	movb	$2, -13(%ebp)
+	movb	$3, -12(%ebp)
+	movb	$4, -11(%ebp)
+	movb	$5, -10(%ebp)
+	movb	$6, -9(%ebp)
+	movl	-14(%ebp), %edx
+	movl	%edx, (%eax)
+	movzwl	-10(%ebp), %edx
+	movw	%dx, 4(%eax)
+	leave
+	ret	$4
+.globl _ffi_test_30
+_ffi_test_30:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movl	8(%ebp), %edx
+	movb	$1, -15(%ebp)
+	movb	$2, -14(%ebp)
+	movb	$3, -13(%ebp)
+	movb	$4, -12(%ebp)
+	movb	$5, -11(%ebp)
+	movb	$6, -10(%ebp)
+	movb	$7, -9(%ebp)
+	movl	-15(%ebp), %eax
+	movl	%eax, (%edx)
+	movzwl	-11(%ebp), %eax
+	movw	%ax, 4(%edx)
+	movzbl	-9(%ebp), %eax
+	movb	%al, 6(%edx)
+	movl	%edx, %eax
+	leave
+	ret	$4
+.globl _ffi_test_31
+_ffi_test_31:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$8, %esp
+	leave
+	ret
+.globl _ffi_test_32
+_ffi_test_32:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movsd	8(%ebp), %xmm1
+	movsd	16(%ebp), %xmm0
+	addsd	%xmm0, %xmm1
+	cvtsi2sd	24(%ebp), %xmm0
+	mulsd	%xmm1, %xmm0
+	movsd	%xmm0, -16(%ebp)
+	fldl	-16(%ebp)
+	leave
+	ret
+.globl _ffi_test_33
+_ffi_test_33:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movss	8(%ebp), %xmm1
+	movss	12(%ebp), %xmm0
+	addss	%xmm0, %xmm1
+	cvtsi2ss	16(%ebp), %xmm0
+	mulss	%xmm1, %xmm0
+	cvtss2sd	%xmm0, %xmm0
+	movsd	%xmm0, -16(%ebp)
+	fldl	-16(%ebp)
+	leave
+	ret
+.globl _ffi_test_34
+_ffi_test_34:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movss	8(%ebp), %xmm1
+	movl	12(%ebp), %eax
+	cvtsi2ss	%eax, %xmm0
+	addss	%xmm0, %xmm1
+	cvtsi2ss	16(%ebp), %xmm0
+	mulss	%xmm1, %xmm0
+	cvtss2sd	%xmm0, %xmm0
+	movsd	%xmm0, -16(%ebp)
+	fldl	-16(%ebp)
+	leave
+	ret
+.globl _ffi_test_35
+_ffi_test_35:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movl	8(%ebp), %edx
+	movl	12(%ebp), %eax
+	leal	(%edx,%eax), %eax
+	imull	16(%ebp), %eax
+	cvtsi2sd	%eax, %xmm0
+	movsd	%xmm0, -16(%ebp)
+	fldl	-16(%ebp)
+	leave
+	ret
+.globl _ffi_test_36
+_ffi_test_36:
+	pushl	%ebp
+	movl	%esp, %ebp
+	subl	$24, %esp
+	movsd	12(%ebp), %xmm0
+	movsd	%xmm0, -16(%ebp)
+	fldl	-16(%ebp)
+	leave
+	ret
+.lcomm _global_var.12587,4,2
+	.cstring
+LC22:
+	.ascii "ffi_test_37\0"
+LC23:
+	.ascii "global_var is %d\12\0"
+	.text
+.globl _ffi_test_37
+_ffi_test_37:
+	pushl	%ebp
+	movl	%esp, %ebp
+	pushl	%ebx
+	subl	$20, %esp
+	call	L99
+"L00000000020$pb":
+L99:
+	popl	%ebx
+	leal	LC22-"L00000000020$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_puts$stub
+	leal	_global_var.12587-"L00000000020$pb"(%ebx), %eax
+	movl	(%eax), %edx
+	movl	%edx, %eax
+	addl	%eax, %eax
+	leal	(%eax,%edx), %ecx
+	leal	_global_var.12587-"L00000000020$pb"(%ebx), %eax
+	movl	(%eax), %eax
+	leal	(%eax,%eax), %edx
+	leal	_global_var.12587-"L00000000020$pb"(%ebx), %eax
+	movl	(%eax), %eax
+	movl	%ecx, 8(%esp)
+	movl	%edx, 4(%esp)
+	movl	%eax, (%esp)
+	movl	8(%ebp), %eax
+	call	*%eax
+	movl	%eax, %edx
+	leal	_global_var.12587-"L00000000020$pb"(%ebx), %eax
+	movl	%edx, (%eax)
+	leal	_global_var.12587-"L00000000020$pb"(%ebx), %eax
+	movl	(%eax), %eax
+	movl	%eax, 4(%esp)
+	leal	LC23-"L00000000020$pb"(%ebx), %eax
+	movl	%eax, (%esp)
+	call	L_printf$stub
+	leal	_global_var.12587-"L00000000020$pb"(%ebx), %eax
+	movl	(%eax), %eax
+	addl	$20, %esp
+	popl	%ebx
+	leave
+	ret
+.comm _our_exception_port,4,2
+.comm _userenv,256,5
+.comm _T,4,2
+.comm _stack_chain,4,2
+.comm _ds_size,4,2
+.comm _rs_size,4,2
+.comm _stage2,1,0
+.comm _profiling_p,1,0
+.comm _signal_number,4,2
+.comm _signal_fault_addr,4,2
+.comm _signal_callstack_top,4,2
+.comm _secure_gc,1,0
+.comm _data_heap,4,2
+.comm _cards_offset,4,2
+.comm _newspace,4,2
+.comm _nursery,4,2
+.comm _gc_time,8,3
+.comm _nursery_collections,4,2
+.comm _aging_collections,4,2
+.comm _cards_scanned,4,2
+.comm _performing_gc,1,0
+.comm _collecting_gen,4,2
+.comm _collecting_aging_again,1,0
+.comm _last_code_heap_scan,4,2
+.comm _growing_data_heap,1,0
+.comm _old_data_heap,4,2
+.comm _gc_jmp,72,5
+.comm _heap_scan_ptr,4,2
+.comm _gc_off,1,0
+.comm _gc_locals_region,4,2
+.comm _gc_locals,4,2
+.comm _extra_roots_region,4,2
+.comm _extra_roots,4,2
+.comm _bignum_zero,4,2
+.comm _bignum_pos_one,4,2
+.comm _bignum_neg_one,4,2
+.comm _code_heap,8,2
+.comm _data_relocation_base,4,2
+.comm _code_relocation_base,4,2
+.comm _posix_argc,4,2
+.comm _posix_argv,4,2
+	.section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5
+L___divdi3$stub:
+	.indirect_symbol ___divdi3
+	hlt ; hlt ; hlt ; hlt ; hlt
+L_printf$stub:
+	.indirect_symbol _printf
+	hlt ; hlt ; hlt ; hlt ; hlt
+L_puts$stub:
+	.indirect_symbol _puts
+	hlt ; hlt ; hlt ; hlt ; hlt
+L_strcmp$stub:
+	.indirect_symbol _strcmp
+	hlt ; hlt ; hlt ; hlt ; hlt
+	.subsections_via_symbols
diff --git a/vm/os-macosx-ppc.h b/vm/os-macosx-ppc.h
index 640aeb796d..13213acbbc 100644
--- a/vm/os-macosx-ppc.h
+++ b/vm/os-macosx-ppc.h
@@ -8,6 +8,8 @@ Used under BSD license with permission from Paolo Bonzini and Bruno Haible,
 http://sourceforge.net/mailarchive/message.php?msg_name=200503102200.32002.bruno%40clisp.org
 
 Modified for Factor by Slava Pestov */
+#include <ucontext.h>
+
 #define FRAME_RETURN_ADDRESS(frame) *((XT *)(frame_successor(frame) + 1) + 2)
 
 #define MACH_EXC_STATE_TYPE ppc_exception_state_t
diff --git a/vm/os-macosx-x86.32.h b/vm/os-macosx-x86.32.h
index d5e5827a5c..7c830c775d 100644
--- a/vm/os-macosx-x86.32.h
+++ b/vm/os-macosx-x86.32.h
@@ -8,6 +8,8 @@ Used under BSD license with permission from Paolo Bonzini and Bruno Haible,
 http://sourceforge.net/mailarchive/message.php?msg_name=200503102200.32002.bruno%40clisp.org
 
 Modified for Factor by Slava Pestov */
+#include <ucontext.h>
+
 #define MACH_EXC_STATE_TYPE i386_exception_state_t
 #define MACH_EXC_STATE_FLAVOR i386_EXCEPTION_STATE
 #define MACH_EXC_STATE_COUNT i386_EXCEPTION_STATE_COUNT
diff --git a/vm/os-macosx-x86.64.h b/vm/os-macosx-x86.64.h
index d2bb48c3fe..b11aa80ce8 100644
--- a/vm/os-macosx-x86.64.h
+++ b/vm/os-macosx-x86.64.h
@@ -8,6 +8,8 @@ Used under BSD license with permission from Paolo Bonzini and Bruno Haible,
 http://sourceforge.net/mailarchive/message.php?msg_name=200503102200.32002.bruno%40clisp.org
 
 Modified for Factor by Slava Pestov and Daniel Ehrenberg */
+#include <ucontext.h>
+
 #define MACH_EXC_STATE_TYPE x86_exception_state64_t
 #define MACH_EXC_STATE_FLAVOR x86_EXCEPTION_STATE64
 #define MACH_EXC_STATE_COUNT x86_EXCEPTION_STATE64_COUNT