diff --git a/sources/dylan/integer.dylan b/sources/dylan/integer.dylan
index 87f8c6abea..df06afb038 100644
--- a/sources/dylan/integer.dylan
+++ b/sources/dylan/integer.dylan
@@ -241,23 +241,23 @@ define method \^
   end if
 end method \^;
 
-define function logior (#rest integers) => (logior :: <integer>)
+define sealed method logior (#rest integers) => (logior :: <integer>)
   reduce(binary-logior, 0, integers)
-end function logior;
+end method logior;
 
-define function logxor (#rest integers) => (logxor :: <integer>)
+define sealed method logxor (#rest integers) => (logxor :: <integer>)
   reduce(binary-logxor, 0, integers)
-end function logxor;
+end method logxor;
 
-define function logand (#rest integers) => (logand :: <integer>)
+define sealed method logand (#rest integers) => (logand :: <integer>)
   reduce(binary-logand, -1, integers)
-end function logand;
+end method logand;
 
 // TODO: These can't be inline-only until reduce is inlined.
 
 define macro integer-binary-logical-definer
   { define integer-binary-logical ?:name ?lowlevel:name ?tagger:name }
-    => { define inline /* -only */ function ?name
+    => { define sealed inline /* -only */ method ?name
              (x :: <integer>, y :: <integer>)
           => (result :: <integer>)
            let mx = interpret-integer-as-machine-word(x);
@@ -272,16 +272,16 @@ define integer-binary-logical binary-logior machine-word-logior identity;
 define integer-binary-logical binary-logand machine-word-logand identity;
 define integer-binary-logical binary-logxor machine-word-logxor force-integer-tag;
 
-define inline function lognot (x :: <integer>) => (result :: <integer>)
+define sealed inline method lognot (x :: <integer>) => (result :: <integer>)
   let mw = interpret-integer-as-machine-word(x);
   interpret-machine-word-as-integer(force-integer-tag(machine-word-lognot(mw)))
-end function lognot;
+end method lognot;
 
-define inline function logbit? (index :: <integer>, integer :: <integer>)
+define sealed inline method logbit? (index :: <integer>, integer :: <integer>)
  => (set? :: <boolean>)
   machine-word-logbit?
     (as-offset-for-tagged-integer(index), interpret-integer-as-machine-word(integer))
-end function logbit?;
+end method logbit?;
 
 define inline function logbit-deposit
     (z :: <boolean>, index :: <integer>, integer :: <integer>) => (res :: <integer>)
@@ -315,13 +315,13 @@ define inline function bit-field-deposit
         interpret-integer-as-machine-word(x)))
 end function bit-field-deposit;
 
-define may-inline function ash (x :: <integer>, shift :: <integer>) => (result :: <integer>)
+define sealed may-inline method ash (x :: <integer>, shift :: <integer>) => (result :: <integer>)
   if (negative?(shift))
     ash-right(x, -shift)
   else
     ash-left(x, shift)
   end
-end function ash;
+end method ash;
 
 define inline function ash-right (x :: <integer>, shift :: <integer>)
  => (result :: <integer>)
@@ -353,13 +353,13 @@ define inline function ash-left (x :: <integer>, shift :: <integer>)
   interpret-machine-word-as-integer(tagged-result)
 end function ash-left;
 
-define may-inline function lsh (x :: <integer>, shift :: <integer>) => (result :: <integer>)
+define sealed may-inline method lsh (x :: <integer>, shift :: <integer>) => (result :: <integer>)
   if (negative?(shift))
     lsh-right(x, -shift)
   else
     lsh-left(x, shift)
   end
-end function lsh;
+end method lsh;
 
 define inline function lsh-right (x :: <integer>, shift :: <integer>)
  => (result :: <integer>)
diff --git a/sources/dylan/number.dylan b/sources/dylan/number.dylan
index e5958cb377..3cb33a5e97 100644
--- a/sources/dylan/number.dylan
+++ b/sources/dylan/number.dylan
@@ -27,9 +27,9 @@ define macro numeric-properties-predicate-definer
   { define numeric-properties-predicate ?:name (?domain:name) }
   => { define open generic ?name (x :: <object>) => (result :: <boolean>);
        define sealed domain ?name (?domain) }
-  // Default sealed domain to <complex>
+  // Default sealed domain to <machine-number>
   { define numeric-properties-predicate ?:name }
-  => { define numeric-properties-predicate ?name (<complex>) }
+  => { define numeric-properties-predicate ?name (<machine-number>) }
 end macro numeric-properties-predicate-definer;
 
 define numeric-properties-predicate zero?;
@@ -47,56 +47,91 @@ define macro binary-arithmetic-function-definer
   => { define open generic ?name (x :: <object>, y :: <object>)
          => (#rest values :: <object>);
        define sealed domain ?name (?domain1, ?domain2) }
-  // Default sealed domain to (<complex>, <complex>)
+  // Default sealed domain to (<machine-number>, <machine-number>)
   { define binary-arithmetic-function ?:name }
-  => { define binary-arithmetic-function ?name (<complex>, <complex>) }
+  => { define binary-arithmetic-function ?name (<machine-number>, <machine-number>) }
 end macro binary-arithmetic-function-definer;
 
 define binary-arithmetic-function \+;
 define binary-arithmetic-function \-;
 define binary-arithmetic-function \*;
 define binary-arithmetic-function \/;
-define binary-arithmetic-function \^ (<complex>, <integer>);
+define binary-arithmetic-function \^ (<machine-number>, <integer>);
 
 define macro unary-arithmetic-function-definer
   { define unary-arithmetic-function ?:name (?domain:name) }
   => { define open generic ?name (x :: <object>)
          => (#rest values :: <object>);
        define sealed domain ?name (?domain) }
-  // Default sealed domain to <complex>
+  // Default sealed domain to <machine-number>
   { define unary-arithmetic-function ?:name }
-  => { define unary-arithmetic-function ?name (<complex>) }
+  => { define unary-arithmetic-function ?name (<machine-number>) }
 end macro unary-arithmetic-function-definer;
 
 define unary-arithmetic-function negative;
 define unary-arithmetic-function abs;
 
-define generic floor
-    (real :: <machine-number>) => (result :: <integer>, remainder :: <machine-number>);
-define generic ceiling
-    (real :: <machine-number>) => (result :: <integer>, remainder :: <machine-number>);
-define generic round
-    (real :: <machine-number>) => (result :: <integer>, remainder :: <machine-number>);
-define generic truncate
-    (real :: <machine-number>) => (result :: <integer>, remainder :: <machine-number>);
-
-define generic floor/
-    (real1 :: <machine-number>, real2 :: <machine-number>)
- => (result :: <integer>, remainder :: <machine-number>);
-define generic ceiling/
-    (real1 :: <machine-number>, real2 :: <machine-number>)
- => (result :: <integer>, remainder :: <machine-number>);
-define generic round/
-    (real1 :: <machine-number>, real2 :: <machine-number>)
- => (result :: <integer>, remainder :: <machine-number>);
-define generic truncate/
-    (real1 :: <machine-number>, real2 :: <machine-number>)
- => (result :: <integer>, remainder :: <machine-number>);
-
-define generic modulo
-    (real1 :: <machine-number>, real2 :: <machine-number>) => (result :: <machine-number>);
-define generic remainder
-    (real1 :: <machine-number>, real2 :: <machine-number>) => (result :: <machine-number>);
+define macro unary-division-function-definer
+  { define unary-division-function ?:name (?domain:name) }
+  => { define open generic ?name (real :: <real>)
+         => (result :: <integer>, remainder :: <real>);
+       define sealed domain ?name (?domain) }
+  // Default sealed domain to <machine-number>
+  { define unary-division-function ?:name }
+  => { define unary-division-function ?name (<machine-number>) }
+end macro unary-division-function-definer;
+
+define unary-division-function floor;
+define unary-division-function ceiling;
+define unary-division-function round;
+define unary-division-function truncate;
+
+define macro binary-division-function-definer
+  { define binary-division-function ?:name (?domain1:name, ?domain2:name) }
+  => { define open generic ?name (real1 :: <real>, real2 :: <real>)
+         => (#rest values :: <object>);
+       define sealed domain ?name (?domain1, ?domain2) }
+  // Default sealed domain to (<machine-number>, <machine-number>)
+  { define binary-division-function ?:name }
+  => { define binary-division-function ?name (<machine-number>, <machine-number>) }
+end macro binary-division-function-definer;
+
+define binary-division-function floor/;
+define binary-division-function ceiling/;
+define binary-division-function round/;
+define binary-division-function truncate/;
+define binary-division-function modulo;
+define binary-division-function remainder;
+
+define open generic ash (integer1 :: <abstract-integer>, count :: <integer>)
+ => (#rest values :: <object>);
+define sealed domain ash (<machine-number>);
+
+define open generic lsh (integer1 :: <abstract-integer>, count :: <integer>)
+ => (#rest values :: <object>);
+define sealed domain lsh (<machine-number>);
+
+define macro n-ary-logical-function-definer
+  { define n-ary-logical-function ?:name (?domain:name) }
+  => { define open generic ?name (#rest integers :: <abstract-integer>)
+         => (#rest values :: <object>);
+       define sealed domain ?name (?domain) }
+  // Default sealed domain to (<machine-number>)
+  { define n-ary-logical-function ?:name }
+  => { define n-ary-logical-function ?name (<machine-number>) }
+end macro n-ary-logical-function-definer;
+
+define n-ary-logical-function logior;
+define n-ary-logical-function logxor;
+define n-ary-logical-function logand;
+
+define open generic lognot (integer1 :: <abstract-integer>)
+ => (#rest values :: <object>);
+define sealed domain lognot (<machine-number>);
+
+define open generic logbit? (index :: <integer>, integer :: <abstract-integer>)
+ => (#rest values :: <object>);
+define sealed domain logbit? (<integer>, <machine-number>);
 
 //// CONDITIONS