       (.set ^BitSet (.get As 0) 0 (int object-count))
       (.add Bs 0 (BitSet.))
       (in-close attribute-count incidence-matrix As Bs last 0 0)
-      (map (fn [A B]
-             [(to-hashset object-vector A),
-              (to-hashset attribute-vector B)])
-           As Bs))))
+      (if *concepts-do-conversion*
+        (map (fn [A B]
+               [(to-hashset object-vector A),
+                (to-hashset attribute-vector B)])
+             As Bs)
+        (map vector As Bs)))))
 
 
 ;;; Parallel-Close-by-One (:pcbo)


;;; Compute Concepts of Formal Contexts efficiently

(defmulti concepts
  "Computes concepts with various algorithms, given as first
  argument. Default is :next-closure."
  {:arglists '([algorithm context] [context])}
  (fn [& args]
    (when-not (<= 1 (count args) 2)
      (illegal-argument "Wrong number of args passed to c.c.algorithms.concepts."))
    (when (and (= 1 (count args))
               (not (context? (first args))))
      (illegal-argument "Argument of concepts is not a context."))

                                                                incidence-matrix)
                                                       %)
                                     start))]
    (if *concepts-do-conversion*
      (map (fn [bitset]
             [(to-hashset object-vector (a-prime bitset)),
              (to-hashset attribute-vector bitset)])
           intents)
      intents)))


;;; Vychodil (:vychodil)
