```--- a/src/code/late-type.lisp
+++ b/src/code/late-type.lisp
@@ -1453,7 +1453,6 @@
;;;
;;; This is for comparing bounds of the same kind, e.g. upper and
;;; upper. Use NUMERIC-BOUND-TEST* for different kinds of bounds.
-#!-negative-zero-is-not-zero
(defmacro numeric-bound-test (x y closed open)
`(cond ((not ,y) t)
((not ,x) nil)
@@ -1466,32 +1465,12 @@
(,open ,x (car ,y))
(,closed ,x ,y)))))

-#!+negative-zero-is-not-zero
-(defmacro numeric-bound-test-zero (op x y)
-  `(if (and (zerop ,x) (zerop ,y) (floatp ,x) (floatp ,y))
-       (,op (float-sign ,x) (float-sign ,y))
-       (,op ,x ,y)))
-
-#!+negative-zero-is-not-zero
-(defmacro numeric-bound-test (x y closed open)
-  `(cond ((not ,y) t)
-	 ((not ,x) nil)
-	 ((consp ,x)
-	  (if (consp ,y)
-	      (numeric-bound-test-zero ,closed (car ,x) (car ,y))
-	      (numeric-bound-test-zero ,closed (car ,x) ,y)))
-	 (t
-	  (if (consp ,y)
-	      (numeric-bound-test-zero ,open ,x (car ,y))
-	      (numeric-bound-test-zero ,closed ,x ,y)))))
-
;;; This is used to compare upper and lower bounds. This is different
;;; from the same-bound case:
;;; -- Since X = NIL is -infinity, whereas y = NIL is +infinity, we
;;;    return true if *either* arg is NIL.
;;; -- an open inner bound is "greater" and also squeezes the interval,
;;;    causing us to use the OPEN test for those cases as well.
-#!-negative-zero-is-not-zero
(defmacro numeric-bound-test* (x y closed open)
`(cond ((not ,y) t)
((not ,x) t)
@@ -1503,19 +1482,6 @@
(if (consp ,y)
(,open ,x (car ,y))
(,closed ,x ,y)))))
-
-#!+negative-zero-is-not-zero
-(defmacro numeric-bound-test* (x y closed open)
-  `(cond ((not ,y) t)
-	 ((not ,x) t)
-	 ((consp ,x)
-	  (if (consp ,y)
-	      (numeric-bound-test-zero ,open (car ,x) (car ,y))
-	      (numeric-bound-test-zero ,open (car ,x) ,y)))
-	 (t
-	  (if (consp ,y)
-	      (numeric-bound-test-zero ,open ,x (car ,y))
-	      (numeric-bound-test-zero ,closed ,x ,y)))))

;;; Return whichever of the numeric bounds X and Y is "maximal"
;;; according to the predicates CLOSED (e.g. >=) and OPEN (e.g. >).
@@ -1580,28 +1546,19 @@
(cond ((not (and low-bound high-bound)) nil)
((and (consp low-bound) (consp high-bound)) nil)
((consp low-bound)
-	   #!-negative-zero-is-not-zero
(let ((low-value (car low-bound)))
(or (eql low-value high-bound)
(and (eql low-value -0f0) (eql high-bound 0f0))
(and (eql low-value 0f0) (eql high-bound -0f0))
(and (eql low-value -0d0) (eql high-bound 0d0))
-		 (and (eql low-value 0d0) (eql high-bound -0d0))))
-	   #!+negative-zero-is-not-zero
-	   (eql (car low-bound) high-bound))
+		 (and (eql low-value 0d0) (eql high-bound -0d0)))))
((consp high-bound)
-	   #!-negative-zero-is-not-zero
(let ((high-value (car high-bound)))
(or (eql high-value low-bound)
(and (eql high-value -0f0) (eql low-bound 0f0))
(and (eql high-value 0f0) (eql low-bound -0f0))
(and (eql high-value -0d0) (eql low-bound 0d0))
-		 (and (eql high-value 0d0) (eql low-bound -0d0))))
-	   #!+negative-zero-is-not-zero
-	   (eql (car high-bound) low-bound))
-	  #!+negative-zero-is-not-zero
-	  ((or (and (eql low-bound -0f0) (eql high-bound 0f0))
-	       (and (eql low-bound -0d0) (eql high-bound 0d0))))
+		 (and (eql high-value 0d0) (eql low-bound -0d0)))))
((and (eq (numeric-type-class low) 'integer)
(eq (numeric-type-class high) 'integer))
(eql (1+ low-bound) high-bound))
@@ -2358,7 +2315,6 @@
(let (ms numbers)
(dolist (m (remove-duplicates members))
(typecase m
-	    #!-negative-zero-is-not-zero
(float (if (zerop m)
(push m ms)
(push (ctype-of m) numbers)))
```