(let [g (->> (gensym)
             str
             (re-find #"\d+")
             (#(Integer/parseInt %))
             inc
             inc
             inc
             (str "G__")
             symbol)]
  ((juxt identity eval) `(let [~g (gensym)] ~g)))

[(clojure.core/let [G__1218876 (clojure.core/gensym)] G__1218876) G__1218876]

(#(if (= % 1)
    %2
    (if (even? %) (recur (/ % 2) (inc %2)) (recur (inc (* 3 %)) (inc %2))))
 27
 0)

111

(->> (inc a)
     (let [a 5]))

6

(map inc (take-nth 2 (range 10)))

(1 3 5 7 9)

(pr-str (map inc [1 2 3]))

"(2 3 4)"

(map #(% 1) [inc dec])

(2 0)

(let [brehaut (rand-int 10)] (inc brehaut))

7

(update-in [[1 2]] [0 1] inc)

[[1 3]]

(macroexpand '(-> inc (partial 1)))

(partial inc 1)

(defn f [v n] (inc v))

#'user/f

(macroexpand-1 '(cond-> 42 (even?) inc))

(clojure.core/let [G__3450722 42]
  (if (even?)
    (clojure.core/-> G__3450722
                     inc)
    G__3450722))

(-> "hello"
    count
    inc
    (* 5))

30

(map deliver [inc dec] [10 11])

(11 10)

(defn f [v t] (inc v))

#'user/f

(->> [1 2 3]
     (map inc))

(2 3 4)

((apply comp (repeat 10000 inc)) 1)

10001

(macroexpand '(fn [x] (inc x)))

(fn [x] (inc x))

(print (read-string "(inc brehaut)"))

nil

"(inc brehaut)"

(update-in [2010 5 4] [1] inc)

[2010 6 4]

((apply comp (repeat 20 inc)) 1)

21

(macroexpand-1 '(doto (inc 10) println))

(clojure.core/let [G__3083930 (inc 10)]
  (println G__3083930)
  G__3083930)

(-> 1
    list
    (->> (map inc)))

(2)

(defn coffee [sip] (coffee (inc sip)))

#'user/coffee

(reduce * (range 1 (inc 3)))

6

(doall (map inc [1 2 3]))

(2 3 4)

(update-in ["1" 2 3] [1] inc)

["1" 3 3]

(take 20 (map inc (repeat 5)))

(6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6)

((apply comp (repeat 5000 inc)) 42)

5042

(apply + (map inc [1 2]))

5

((apply juxt [inc identity dec]) 0)

[1 0 -1]

(update-in [1 2 3] [0] inc)

[2 2 3]

(reduce + (map inc (range 10)))

55

(println (inc 1) "is the number")

nil

"2 is the number\n"

(map (juxt inc dec) (range 5))

([1 -1] [2 0] [3 1] [4 2] [5 3])

(let [^Long o 0] (inc o))

1

(do (def a inc) (namespace `a))

"user"

(into #{} (map inc (range 10)))

#{1 2 3 4 5 6 7 8 9 10}

(map inc #{5 6 7})

(8 7 6)

(map deliver [inc dec] [1 2])

(2 1)

(for [b [dec dec dec dec] a [inc dec inc dec]] [(b 5) (a 5)])

([4 6]
 [4 4]
 [4 6]
 [4 4]
 [4 6]
 [4 4]
 [4 6]
 [4 4]
 [4 6]
 [4 4]
 [4 6]
 [4 4]
 [4 6]
 [4 4]
 [4 6]
 [4 4])

(reduce + (map inc (range 100)))

5050

(update [0 0 0] 1 inc)

[0 1 0]

((reduce comp (repeat 1e4 inc)) 0)

10000

(map (juxt fn? ifn?) [inc :inc])

([true true] [false true])

(->> 943
     range
     (map inc)
     coll?)

true

(macroexpand-1 '(cond-> 42 even? inc))

(clojure.core/let [G__130768 42]
  (if even?
    (clojure.core/-> G__130768
                     inc)
    G__130768))

(Integer/toString (inc (Integer/parseInt "z" 36)) 36)

"10"

(reduce ((map inc) conj) [] (range 10))

[1 2 3 4 5 6 7 8 9 10]

(println (str "##" ''(inc AtKaaZ)))

nil

"##(quote (inc AtKaaZ))\n"

(set? (map inc #{1 2}))

false