(-iterator [coll]

"Returns an iterator for coll."))

(defprotocolIDrop

(^clj-or-nil -drop [coll n]

returned coll implements IDrop for subsequent use in a partition-like scenario."))

(deftypeStringBufferWriter [sb]

(IndexedSeq. arr (inc i)nil)

nil))

(-drop [coll n]

(if (pos? n)

(if (< (+ i n) (alength arr))

(IndexedSeq. arr (+ i n)nil)

nil)

coll))

(-count [_]

(max0 (- (alength arr) i)))

(defnnthrest

[coll n]

(loop [n n xs coll]

(if-let [xs (and (pos? n) (seq xs))]

(recur (dec n) (rest xs))

xs)))

(if (implements? IDrop coll)

(if (pos? n)

(or (-drop coll (Math/ceil n)) ())

coll)

(loop [n n xs coll]

(if-let [xs (and (pos? n) (seq xs))]

(recur (dec n) (rest xs))

xs))))

(defnget

(defnnthnext

[coll n]

(loop [n n xs (seq coll)]

(if (and xs (pos? n))

(recur (dec n) (next xs))

xs)))

(if (implements? IDrop coll)

(if (pos? n)

(-drop coll (Math/ceil n))

(seq coll))

(loop [n n xs (seq coll)]

(if (and xs (pos? n))

(recur (dec n) (next xs))

xs))))

(cons (first s) (take (dec n) (rest s))))))))

(defndrop

([n]

{:pre [(number? n)]}

(rf result input))))))))

([n coll]

{:pre [(number? n)]}

(let [step (fn [n coll]

(let [s (seq coll)]

(if (and (pos? n) s)

(recur (dec n) (rest s))

s)))]

(lazy-seq (step n coll)))))

(if (implements? IDrop coll)

(or

(if (pos? n)

(-drop coll (Math/ceil n))

(seq coll))

())

(let [step (fn [n coll]

(let [s (seq coll)]

(if (and (pos? n) s)

(recur (dec n) (rest s))

s)))]

(lazy-seq (step n coll))))))

(defndrop-last

(-conj [coll o] (cons o coll))

(-drop [coll n]

(if (== count-1)

coll

(let [dropped-count (- count n)]

(when (pos? dropped-count)

(Repeat.nil dropped-count valnilnil)))))

(-empty [coll] (.-EMPTY List))

(<= cnt32) (IndexedSeq. tail0nil)

:else (chunked-seq coll (first-array-for-longvec coll)00)))

(-drop [coll n]

(if (< n cnt)

(let [offset (js-mod n32)]

(chunked-seq coll (unchecked-array-for coll n) (- n offset) offset))

nil))

(-count [coll] cnt)

s))

(-chunked-next coll)))

(-drop [coll n]

(let [o (+ off n)]

(if (< o (alength node))

(chunked-seq vec node i o)

(let [i (+ i o)]

(if (< i (-count vec))

(let [new-offset (js-mod i32)]

(chunked-seq vec (unchecked-array-for vec i) (- i new-offset) new-offset))

nil)))))

(-conj [coll o]

(cons o coll))

(when (< i (- (alength arr)2))

(PersistentArrayMapSeq. arr (+ i2)nil)))

(-drop [coll n]

(when (< n (-count coll))

(PersistentArrayMapSeq. arr (+ i (*2 n))nil)))

(-reduce [coll f] (seq-reduce f coll))

(-reduce [coll f start] (seq-reduce f start coll)))

(-seq [coll]

(persistent-array-map-seq arr0nil))

(-drop [coll n]

(when-some [s (-seq coll)]

(-drop s n)))

(-count [coll] cnt)

(when-let [s (seq coll)]

(cons (take n s) (partition-all n step (drop step s)))))))

(defnsplitv-at

[n coll]

[(into [] (take n) coll) (drop n coll)])

(defnpartitionv

([n coll]

(partitionv n n coll))

([n step coll]

(lazy-seq

(when-let [s (seq coll)]

(let [p (into [] (take n) s)]

(when (= n (count p))

(cons p (partitionv n step (nthrest s step))))))))

([n step pad coll]

(lazy-seq

(when-let [s (seq coll)]

(let [p (into [] (take n) s)]

(if (= n (count p))

(cons p (partitionv n step pad (nthrest s step)))

(list (into [] (take n) (concat p pad)))))))))

(defnpartitionv-all

([n]

(partition-all n))

([n coll]

(partitionv-all n n coll))

([n step coll]

(lazy-seq

(when-let [s (seq coll)]

(let [seg (into [] (take n) coll)]

(cons seg (partitionv-all n step (drop step s))))))))

(defntake-while

(set! i (+ i step))

ret)))

(deftypeIntegerRange [meta start end step ^:mutable chunk ^:mutable chunk-next ^:mutable __hash]

(defn-range-count

[start end step]

(Math/ceil (/ (- end start) step)))

(deftypeIntegerRange [meta start end step cnt ^:mutable __hash]

(toString [coll]

(pr-str* coll))

(-lastIndexOf coll x (count coll)))

(lastIndexOf [coll x start]

(-lastIndexOf coll x start))

(forceChunk [coll]

(when (nil? chunk)

(let [count (-count coll)]

(if (> count32)

(do

(set! chunk-next (IntegerRange.nil (+ start (* step32)) end stepnilnilnil))

(set! chunk (IntegerRangeChunk. start step32)))

(set! chunk (IntegerRangeChunk. start step count))))))

(-clone [_] (IntegerRange. meta start end stepchunk chunk-next __hash))

(-clone [_] (IntegerRange. meta start end stepcnt __hash))

(-with-meta [rng new-meta]

(if (identical? new-meta meta)

rng

(IntegerRange. new-meta start end stepchunk chunk-next __hash)))

(IntegerRange. new-meta start end stepcnt __hash)))

(-meta [rng] meta)

(-next [rng]

(if (pos? step)

(when (< (+ start step) end)

(IntegerRange.nil (+ start step) end stepnilnilnil))

(IntegerRange.nil (+ start step) end step(range-count (+ start step) end step)nil))

(when (> (+ start step) end)

(IntegerRange.nil (+ start step) end stepnilnilnil))))

(IntegerRange.nil (+ start step) end step (range-count (+ start step) end step)nil))))

(-drop [rng n]

(if (pos? n)

(if (< n cnt)

(IntegerRange.nil (+ start (* step n)) end step (- cnt n)nil)

nil)

rng))

(-chunked-first [rng]

(.forceChunk rng)

chunk)

(IntegerRangeChunk. start step (min cnt32)))

(-chunked-rest [rng]

(.forceChunk rng)

(if (nil? chunk-next)

(if (<= cnt32)

()

chunk-next))

(let [start (+ start (* step32))]

(cond

(pos? step)

(if (<= end start)

()

(IntegerRange.nil start end step (range-count start end step)nil))

(neg? step)

(if (>= end start)

()

(IntegerRange.nil start end step (range-count start end step)nil))

(if (== end start)

()

(repeat start))))))

(-chunked-next [rng]

(-count [rng]

(Math/ceil (/ (- end start) step)))

cnt)

(-nth [rng n]

(if (<= end start)

()

(if (and (integer? start) (integer? end) (integer? step))

(IntegerRange.nil start end stepnilnilnil)

(IntegerRange.nil start end step(range-count start end step)nil)

(Range.nil start end stepnilnilnil)))

(neg? step)

(if (>= end start)

()

(if (and (integer? start) (integer? end) (integer? step))

(IntegerRange.nil start end stepnilnilnil)

(IntegerRange.nil start end step(range-count start end step)nil)

(Range.nil start end stepnilnilnil)))

IPrintWithWriter IPending IWatchable IEditableCollection ITransientCollection

ITransientAssociative ITransientMap ITransientVector ITransientSet

IMultiFn IChunkedSeq IChunkedNext IComparable INamed ICloneable IAtom

IReset ISwap IIterable])

IReset ISwap IIterable IDrop])

(iterate (core/fn [[p b]]

(if (core/==2147483648 b)

[(core/inc p)1]