                                             []
                                             (reduce
                                              (fn [clusters-so-far x]
-                                               (let [to-assign (.indexOf
+                                               (let [x-xpaths  (:xpath-texts x)
+                                                     to-assign (.indexOf
                                                                 (map
                                                                  (fn [a-cluster]
-                                                                   (let [num-matched (count
-                                                                                      (filter
-                                                                                       (fn [c]
-                                                                                         (similarity/similar?
-                                                                                          (-> c new-corpus :body)
-                                                                                          (:body x)))
-                                                                                       a-cluster))]
-                                                                     (>= num-matched (/ (count a-cluster)
-                                                                                        2))))
+                                                                   ;; (let [num-matched (count
+                                                                   ;;                    (filter
+                                                                   ;;                     (fn [c]
+                                                                   ;;                       (similarity/similar?
+                                                                   ;;                        (-> c new-corpus :body)
+                                                                   ;;                        (:body x)))
+                                                                   ;;                     a-cluster))]
+                                                                   ;;   (>= num-matched (/ (count a-cluster)
+                                                                   ;;                      2)))
+                                                                   (some
+                                                                    (fn [c]
+                                                                      (similarity/similar-xpaths?
+                                                                       (-> c new-corpus :xpath-texts)
+                                                                       x-xpaths))
+                                                                    a-cluster))
                                                                  clusters-so-far)
                                                                 true)]
                                                  (if (neg? to-assign)

             url-ds (if (= pick-from :first)
                      (-> url-queue first)
                      (-> url-queue last))]

         (utils/sayln :url url)
         (utils/sayln :src-url src-url)
         (utils/sayln :src-path (:path url-ds))

  ([entry-point leaf? extract stop? build-model]
     (let [body           (do (utils/download-with-cookie entry-point)
                              (utils/download-with-cookie entry-point))
           xpath-texts    (if (:body body)
                            (similarity/char-frequency-representation
                             (similarity/page-text-xpaths
                              (:body body)))
                            {})
           body-queue-ele {:url  entry-point
                           :body (:body body)
                           :xpath-texts xpath-texts}]
       (crawl-with-estimation-example [body-queue-ele]
                                      [entry-point]
                                      leaf?
