My code is spending most of its time scoring bisections: determining how many edges of a graph cross from one set of nodes to the other.

Assume `bisect`

is a set of half of a graph's nodes (ints), and `edges`

is a list of (directed) edges `[ [n1 n2] ...]`

where `n1,n2`

are also nodes.

```
(defn tstBisectScore
"number of edges crossing bisect"
([bisect edges]
(tstBisectScore bisect 0 edges))
([bisect nx edge2check]
(if (empty? edge2check)
nx
(let [[n1 n2] (first edge2check)
inb1 (contains? bisect n1)
inb2 (contains? bisect n2)]
(if (or (and inb1 inb2)
(and (not inb1) (not inb2)))
(recur bisect nx (rest edge2check))
(recur bisect (inc nx) (rest edge2check))))
)))
```

The only clues I have via sampling the execution of this code (using VisualVM) shows most of the time spent in `clojure.core$empty_QMARK_`

, and most of the rest in `clojure.core$contains_QMARK_`

. (`first`

and `rest`

take only a small fraction of the time.)

Any suggestions as to how I could tighten the code?