   {:added "1.0"}
   ([x y] (bit-and* x y))
   ([x y & more]
-   (reduce1 bit-and (bit-and x y) more)))
+   (reduce bit-and (bit-and x y) more)))
 
 (defn bit-or
   "Bitwise or"
   {:added "1.0"}
   ([x y] (bit-or* x y))
   ([x y & more]
-   (reduce1 bit-or (bit-or x y) more)))
+   (reduce bit-or (bit-or x y) more)))
 
 (defn bit-xor
   "Bitwise exclusive or"
   {:added "1.0"}
   ([x y] (bit-xor* x y))
   ([x y & more]
-   (reduce1 bit-xor (bit-xor x y) more)))
+   (reduce bit-xor (bit-xor x y) more)))
 
 (defn bit-and-not
   "Bitwise and with complement"
   {:added "1.0"}
   ([x y] (bit-and-not* x y))
   ([x y & more]
-   (reduce1 bit-and-not (bit-and-not x y) more)))
+   (reduce bit-and-not (bit-and-not x y) more)))
 
 (defn bit-clear
   "Clear bit at index n"

  ([x] (/ 1 x))
  ([x y] (divide* x y))
  ([x y & more]
   (reduce1 / (/ x y) more)))

(defn -'
  "If no ys are supplied, returns the negation of x, else subtracts

                                         (if (:as b)
                                           (conj ret (:as b) gmap)
                                           ret))))
                              bes (reduce
                                   (fn [bes entry]
                                     (reduce #(assoc %1 %2 ((val entry) %2))
                                              (dissoc bes (key entry))
                                              ((key entry) bes)))
                                   (dissoc b :as :or)
