   [comp-f]
   (let [input (day-input-line-seq 9)
         distances (into {} (map #(let [[[_ from to dist]] (re-seq #"^(\w+) to (\w+) = (\d+)$" %)]
-                          [#{from to} (s->int dist)]) input))
+                                  [#{from to} (s->int dist)]) input))
         places (reduce #(let [[endpoints _] %2]
                          (conj % (first endpoints) (last endpoints))) #{} distances)
         all-routes (permutations places)

(defn- has-distinct-pairs?
  "Determines if sequence contains two distinct pairs (pairs consist of different chars)"
  [xs]
  (let [[one two] (filter #(= 2 (count %)) (partition-by identity xs))]
    (and one two (not= (first one) (first two)))))

(defn- has-inc-of-three?
  "Determines if provided input sequence containes increasing straight of at least three letters"
  [xs]
  (some
    #(>= (count %) 3)
    (reduce #(let [prev (first %)
                   lnum (last prev)]
              (if (> %2 lnum)
                (conj (rest %) (conj prev %2))
                (conj % [%2]))) [[(first xs)]] (rest xs))))

(defn- all-letters? [chs]
  (every? #(and (>= % 97) (<= % 122)) chs))

(defn day11 [input]
  (reduce #(let [ch-seq (big-int->ch-seq %2)]
            (when (all-letters? ch-seq)
              (println (ch-seq->str ch-seq))
              (if (and
                    (has-inc-of-three? ch-seq)
                    (no-iol? ch-seq)
                    (has-distinct-pairs? ch-seq))
                (reduced (ch-seq->str ch-seq)))))
          (iterate #(.add % BigInteger/ONE) (s->big-int input))))





;day 11
;just building blocks
(defn- no-iol? [ch-seq]
  (not-any? #(#{105 108 111} %) ch-seq))

(defn- s->ch-seq
  "Turns string into sequence of char (integer) codes"
  [s]
  (vec (map int s)))

(defn- ch-seq->str
  "Char sequence (ch here is 8bit int actually)"
