gistfile1.txt

{:constant-pool
 ([:method
   ["clojure.lang.Obj"
    ["<init>" {:params (), :return [:primitive :void]}]]]
  [:field
   ["clojure.lang.LazySeq" ["fn" [:reference "clojure.lang.IFn"]]]]
  [:method
   ["clojure.lang.Obj"
    ["<init>"
     {:params ([:reference "clojure.lang.IPersistentMap"]),
      :return [:primitive :void]}]]]
  [:field
   ["clojure.lang.LazySeq" ["s" [:reference "clojure.lang.ISeq"]]]]
  [:class "clojure.lang.LazySeq"]
  [:method
   ["clojure.lang.LazySeq"
    ["seq" {:params (), :return [:reference "clojure.lang.ISeq"]}]]]
  [:method
   ["clojure.lang.LazySeq"
    ["<init>"
     {:params
      ([:reference "clojure.lang.IPersistentMap"]
       [:reference "clojure.lang.ISeq"]),
      :return [:primitive :void]}]]]
  [:imethod
   ["clojure.lang.IFn"
    ["invoke" {:params (), :return [:reference "java.lang.Object"]}]]]
  [:field
   ["clojure.lang.LazySeq" ["sv" [:reference "java.lang.Object"]]]]
  [:class "java.lang.Exception"]
  [:class "java.lang.RuntimeException"]
  [:method
   ["java.lang.RuntimeException"
    ["<init>"
     {:params ([:reference "java.lang.Throwable"]),
      :return [:primitive :void]}]]]
  [:method
   ["clojure.lang.LazySeq"
    ["sval" {:params (), :return [:reference "java.lang.Object"]}]]]
  [:method
   ["clojure.lang.RT"
    ["seq"
     {:params ([:reference "java.lang.Object"]),
      :return [:reference "clojure.lang.ISeq"]}]]]
  [:imethod
   ["clojure.lang.ISeq"
    ["next" {:params (), :return [:reference "clojure.lang.ISeq"]}]]]
  [:imethod
   ["clojure.lang.ISeq"
    ["first" {:params (), :return [:reference "java.lang.Object"]}]]]
  [:field
   ["clojure.lang.PersistentList"
    ["EMPTY" [:reference "clojure.lang.PersistentList$EmptyList"]]]]
  [:imethod
   ["clojure.lang.ISeq"
    ["more" {:params (), :return [:reference "clojure.lang.ISeq"]}]]]
  [:method
   ["clojure.lang.RT"
    ["cons"
     {:params
      ([:reference "java.lang.Object"]
       [:reference "java.lang.Object"]),
      :return [:reference "clojure.lang.ISeq"]}]]]
  [:method
   ["clojure.lang.LazySeq"
    ["equals"
     {:params ([:reference "java.lang.Object"]),
      :return [:primitive :boolean]}]]]
  [:method
   ["clojure.lang.Util"
    ["hash"
     {:params ([:reference "java.lang.Object"]),
      :return [:primitive :int]}]]]
  [:imethod
   ["clojure.lang.ISeq"
    ["equiv"
     {:params ([:reference "java.lang.Object"]),
      :return [:primitive :boolean]}]]]
  [:class "clojure.lang.Sequential"]
  [:class "java.util.List"]
  [:method
   ["clojure.lang.RT"
    ["seqToArray"
     {:params ([:reference "clojure.lang.ISeq"]),
      :return [:array [:reference "java.lang.Object"] 1]}]]]
  [:class "java.lang.UnsupportedOperationException"]
  [:method
   ["java.lang.UnsupportedOperationException"
    ["<init>" {:params (), :return [:primitive :void]}]]]
  [:imethod
   ["java.util.Collection"
    ["iterator"
     {:params (), :return [:reference "java.util.Iterator"]}]]]
  [:imethod
   ["java.util.Iterator"
    ["hasNext" {:params (), :return [:primitive :boolean]}]]]
  [:imethod
   ["java.util.Iterator"
    ["next" {:params (), :return [:reference "java.lang.Object"]}]]]
  [:method
   ["clojure.lang.LazySeq"
    ["contains"
     {:params ([:reference "java.lang.Object"]),
      :return [:primitive :boolean]}]]]
  [:method
   ["clojure.lang.LazySeq"
    ["count" {:params (), :return [:primitive :int]}]]]
  [:method
   ["clojure.lang.LazySeq"
    ["toArray"
     {:params (),
      :return [:array [:reference "java.lang.Object"] 1]}]]]
  [:method
   ["clojure.lang.Util"
    ["equiv"
     {:params
      ([:reference "java.lang.Object"]
       [:reference "java.lang.Object"]),
      :return [:primitive :boolean]}]]]
  [:class "clojure.lang.SeqIterator"]
  [:method
   ["clojure.lang.SeqIterator"
    ["<init>"
     {:params ([:reference "clojure.lang.ISeq"]),
      :return [:primitive :void]}]]]
  [:class "java.util.ArrayList"]
  [:method
   ["java.util.ArrayList"
    ["<init>"
     {:params ([:reference "java.util.Collection"]),
      :return [:primitive :void]}]]]
  [:method
   ["clojure.lang.LazySeq"
    ["reify" {:params (), :return [:reference "java.util.List"]}]]]
  [:imethod
   ["java.util.List"
    ["subList"
     {:params ([:primitive :int] [:primitive :int]),
      :return [:reference "java.util.List"]}]]]
  [:imethod
   ["java.util.List"
    ["lastIndexOf"
     {:params ([:reference "java.lang.Object"]),
      :return [:primitive :int]}]]]
  [:imethod
   ["java.util.List"
    ["listIterator"
     {:params (), :return [:reference "java.util.ListIterator"]}]]]
  [:imethod
   ["java.util.List"
    ["listIterator"
     {:params ([:primitive :int]),
      :return [:reference "java.util.ListIterator"]}]]]
  [:method
   ["clojure.lang.RT"
    ["nth"
     {:params ([:reference "java.lang.Object"] [:primitive :int]),
      :return [:reference "java.lang.Object"]}]]]
  [:method
   ["clojure.lang.LazySeq"
    ["withMeta"
     {:params ([:reference "clojure.lang.IPersistentMap"]),
      :return [:reference "clojure.lang.Obj"]}]]]
  [:method
   ["clojure.lang.LazySeq"
    ["cons"
     {:params ([:reference "java.lang.Object"]),
      :return [:reference "clojure.lang.ISeq"]}]]]
  [:class "clojure.lang.Obj"]
  [:class "clojure.lang.ISeq"]
  [:text "fn"]
  [:text "Lclojure/lang/IFn;"]
  [:text "sv"]
  [:text "Ljava/lang/Object;"]
  [:text "s"]
  [:text "Lclojure/lang/ISeq;"]
  [:text "<init>"]
  [:text "(Lclojure/lang/IFn;)V"]
  [:text "Code"]
  [:text "LineNumberTable"]
  [:text "LocalVariableTable"]
  [:text "this"]
  [:text "Lclojure/lang/LazySeq;"]
  [:text "(Lclojure/lang/IPersistentMap;Lclojure/lang/ISeq;)V"]
  [:text "meta"]
  [:text "Lclojure/lang/IPersistentMap;"]
  [:text "withMeta"]
  [:text "(Lclojure/lang/IPersistentMap;)Lclojure/lang/Obj;"]
  [:text "sval"]
  [:text "()Ljava/lang/Object;"]
  [:text "e"]
  [:text "Ljava/lang/Exception;"]
  [:text "seq"]
  [:text "()Lclojure/lang/ISeq;"]
  [:text "ls"]
  [:text "count"]
  [:text "()I"]
  [:text "c"]
  [:text "I"]
  [:text "first"]
  [:text "next"]
  [:text "more"]
  [:text "cons"]
  [:text "(Ljava/lang/Object;)Lclojure/lang/ISeq;"]
  [:text "o"]
  [:text "empty"]
  [:text "()Lclojure/lang/IPersistentCollection;"]
  [:text "equiv"]
  [:text "(Ljava/lang/Object;)Z"]
  [:text "hashCode"]
  [:text "equals"]
  [:text "toArray"]
  [:text "()[Ljava/lang/Object;"]
  [:text "add"]
  [:text "remove"]
  [:text "addAll"]
  [:text "(Ljava/util/Collection;)Z"]
  [:text "Ljava/util/Collection;"]
  [:text "clear"]
  [:text "()V"]
  [:text "retainAll"]
  [:text "removeAll"]
  [:text "containsAll"]
  [:text "i$"]
  [:text "Ljava/util/Iterator;"]
  [:text "([Ljava/lang/Object;)[Ljava/lang/Object;"]
  [:text "i"]
  [:text "a"]
  [:text "[Ljava/lang/Object;"]
  [:text "size"]
  [:text "isEmpty"]
  [:text "()Z"]
  [:text "contains"]
  [:text "iterator"]
  [:text "()Ljava/util/Iterator;"]
  [:text "reify"]
  [:text "()Ljava/util/List;"]
  [:text "subList"]
  [:text "(II)Ljava/util/List;"]
  [:text "fromIndex"]
  [:text "toIndex"]
  [:text "set"]
  [:text "(ILjava/lang/Object;)Ljava/lang/Object;"]
  [:text "index"]
  [:text "element"]
  [:text "(I)Ljava/lang/Object;"]
  [:text "indexOf"]
  [:text "(Ljava/lang/Object;)I"]
  [:text "lastIndexOf"]
  [:text "listIterator"]
  [:text "()Ljava/util/ListIterator;"]
  [:text "(I)Ljava/util/ListIterator;"]
  [:text "get"]
  [:text "(ILjava/lang/Object;)V"]
  [:text "(ILjava/util/Collection;)Z"]
  [:text "(Lclojure/lang/IPersistentMap;)Lclojure/lang/IObj;"]
  [:text "x0"]
  [:text "(Ljava/lang/Object;)Lclojure/lang/IPersistentCollection;"]
  [:text "SourceFile"]
  [:text "LazySeq.java"]
  [:member ["<init>" {:params (), :return [:primitive :void]}]]
  [:member ["fn" [:reference "clojure.lang.IFn"]]]
  [:member
   ["<init>"
    {:params ([:reference "clojure.lang.IPersistentMap"]),
     :return [:primitive :void]}]]
  [:member ["s" [:reference "clojure.lang.ISeq"]]]
  [:text "clojure/lang/LazySeq"]
  [:member
   ["seq" {:params (), :return [:reference "clojure.lang.ISeq"]}]]
  [:member
   ["<init>"
    {:params
     ([:reference "clojure.lang.IPersistentMap"]
      [:reference "clojure.lang.ISeq"]),
     :return [:primitive :void]}]]
  [:class "clojure.lang.IFn"]
  [:member
   ["invoke" {:params (), :return [:reference "java.lang.Object"]}]]
  [:member ["sv" [:reference "java.lang.Object"]]]
  [:text "java/lang/Exception"]
  [:text "java/lang/RuntimeException"]
  [:member
   ["<init>"
    {:params ([:reference "java.lang.Throwable"]),
     :return [:primitive :void]}]]
  [:member
   ["sval" {:params (), :return [:reference "java.lang.Object"]}]]
  [:class "clojure.lang.RT"]
  [:member
   ["seq"
    {:params ([:reference "java.lang.Object"]),
     :return [:reference "clojure.lang.ISeq"]}]]
  [:member
   ["next" {:params (), :return [:reference "clojure.lang.ISeq"]}]]
  [:member
   ["first" {:params (), :return [:reference "java.lang.Object"]}]]
  [:class "clojure.lang.PersistentList"]
  [:member
   ["EMPTY" [:reference "clojure.lang.PersistentList$EmptyList"]]]
  [:member
   ["more" {:params (), :return [:reference "clojure.lang.ISeq"]}]]
  [:member
   ["cons"
    {:params
     ([:reference "java.lang.Object"] [:reference "java.lang.Object"]),
     :return [:reference "clojure.lang.ISeq"]}]]
  [:member
   ["equals"
    {:params ([:reference "java.lang.Object"]),
     :return [:primitive :boolean]}]]
  [:class "clojure.lang.Util"]
  [:member
   ["hash"
    {:params ([:reference "java.lang.Object"]),
     :return [:primitive :int]}]]
  [:member
   ["equiv"
    {:params ([:reference "java.lang.Object"]),
     :return [:primitive :boolean]}]]
  [:text "clojure/lang/Sequential"]
  [:text "java/util/List"]
  [:member
   ["seqToArray"
    {:params ([:reference "clojure.lang.ISeq"]),
     :return [:array [:reference "java.lang.Object"] 1]}]]
  [:text "java/lang/UnsupportedOperationException"]
  [:class "java.util.Collection"]
  [:member
   ["iterator"
    {:params (), :return [:reference "java.util.Iterator"]}]]
  [:class "java.util.Iterator"]
  [:member ["hasNext" {:params (), :return [:primitive :boolean]}]]
  [:member
   ["next" {:params (), :return [:reference "java.lang.Object"]}]]
  [:member
   ["contains"
    {:params ([:reference "java.lang.Object"]),
     :return [:primitive :boolean]}]]
  [:member ["count" {:params (), :return [:primitive :int]}]]
  [:member
   ["toArray"
    {:params (), :return [:array [:reference "java.lang.Object"] 1]}]]
  [:member
   ["equiv"
    {:params
     ([:reference "java.lang.Object"] [:reference "java.lang.Object"]),
     :return [:primitive :boolean]}]]
  [:text "clojure/lang/SeqIterator"]
  [:member
   ["<init>"
    {:params ([:reference "clojure.lang.ISeq"]),
     :return [:primitive :void]}]]
  [:text "java/util/ArrayList"]
  [:member
   ["<init>"
    {:params ([:reference "java.util.Collection"]),
     :return [:primitive :void]}]]
  [:member
   ["reify" {:params (), :return [:reference "java.util.List"]}]]
  [:member
   ["subList"
    {:params ([:primitive :int] [:primitive :int]),
     :return [:reference "java.util.List"]}]]
  [:member
   ["lastIndexOf"
    {:params ([:reference "java.lang.Object"]),
     :return [:primitive :int]}]]
  [:member
   ["listIterator"
    {:params (), :return [:reference "java.util.ListIterator"]}]]
  [:member
   ["listIterator"
    {:params ([:primitive :int]),
     :return [:reference "java.util.ListIterator"]}]]
  [:member
   ["nth"
    {:params ([:reference "java.lang.Object"] [:primitive :int]),
     :return [:reference "java.lang.Object"]}]]
  [:member
   ["withMeta"
    {:params ([:reference "clojure.lang.IPersistentMap"]),
     :return [:reference "clojure.lang.Obj"]}]]
  [:member
   ["cons"
    {:params ([:reference "java.lang.Object"]),
     :return [:reference "clojure.lang.ISeq"]}]]
  [:text "clojure/lang/Obj"]
  [:text "clojure/lang/ISeq"]
  [:text "(Lclojure/lang/IPersistentMap;)V"]
  [:text "clojure/lang/IFn"]
  [:text "invoke"]
  [:text "(Ljava/lang/Throwable;)V"]
  [:text "clojure/lang/RT"]
  [:text "clojure/lang/PersistentList"]
  [:text "EMPTY"]
  [:class "clojure.lang.PersistentList$EmptyList"]
  [:text "EmptyList"]
  [:text "InnerClasses"]
  [:text "Lclojure/lang/PersistentList$EmptyList;"]
  [:text "(Ljava/lang/Object;Ljava/lang/Object;)Lclojure/lang/ISeq;"]
  [:text "clojure/lang/Util"]
  [:text "hash"]
  [:text "seqToArray"]
  [:text "(Lclojure/lang/ISeq;)[Ljava/lang/Object;"]
  [:text "java/util/Collection"]
  [:text "java/util/Iterator"]
  [:text "hasNext"]
  [:text "(Ljava/lang/Object;Ljava/lang/Object;)Z"]
  [:text "(Lclojure/lang/ISeq;)V"]
  [:text "(Ljava/util/Collection;)V"]
  [:text "nth"]
  [:text "(Ljava/lang/Object;I)Ljava/lang/Object;"]
  [:text "clojure/lang/PersistentList$EmptyList"]),
 :name "clojure.lang.LazySeq",
 :interfaces ("clojure.lang.ISeq" "java.util.List"),
 :methods
 ({:flags #{:public},
   :name "<init>",
   :type
   {:params ([:reference "clojure.lang.IFn"]),
    :return [:primitive :void]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [42 183 0 1 42 43 181 0 2 177],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 23, :start-pc 0}
       {:line-number 24, :start-pc 4}
       {:line-number 25, :start-pc 9}),
      "LocalVariableTable"
      ({:name "this",
        :length 10,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "fn",
        :length 10,
        :start-pc 0,
        :type [:reference "clojure.lang.IFn"],
        :index 1})}}}}
  {:flags #{:private},
   :name "<init>",
   :type
   {:params
    ([:reference "clojure.lang.IPersistentMap"]
     [:reference "clojure.lang.ISeq"]),
    :return [:primitive :void]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 3,
     :instructions [42 43 183 0 3 42 1 181 0 2 42 44 181 0 4 177],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 28, :start-pc 0}
       {:line-number 29, :start-pc 5}
       {:line-number 30, :start-pc 10}
       {:line-number 31, :start-pc 15}),
      "LocalVariableTable"
      ({:name "this",
        :length 16,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "meta",
        :length 16,
        :start-pc 0,
        :type [:reference "clojure.lang.IPersistentMap"],
        :index 1}
       {:name "s",
        :length 16,
        :start-pc 0,
        :type [:reference "clojure.lang.ISeq"],
        :index 2})}}}}
  {:flags #{:public},
   :name "withMeta",
   :type
   {:params ([:reference "clojure.lang.IPersistentMap"]),
    :return [:reference "clojure.lang.Obj"]},
   :attributes
   {"Code"
    {:max-stack 4,
     :max-locals 2,
     :instructions [187 0 5 89 43 42 182 0 6 183 0 7 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 34, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 13,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "meta",
        :length 13,
        :start-pc 0,
        :type [:reference "clojure.lang.IPersistentMap"],
        :index 1})}}}}
  {:flags #{:synchronized :final},
   :name "sval",
   :type {:params (), :return [:reference "java.lang.Object"]},
   :attributes
   {"Code"
    {:max-stack 3,
     :max-locals 2,
     :instructions
     [42
      180
      0
      2
      198
      0
      34
      42
      42
      180
      0
      2
      185
      0
      8
      1
      0
      181
      0
      9
      42
      1
      181
      0
      2
      167
      0
      13
      76
      187
      0
      11
      89
      43
      183
      0
      12
      191
      42
      180
      0
      9
      198
      0
      8
      42
      180
      0
      9
      176
      42
      180
      0
      4
      176],
     :exception-table
     ({:catch-type "java.lang.Exception",
       :start-pc 7,
       :end-pc 25,
       :handler-pc 28}),
     :attributes
     {"LineNumberTable"
      ({:line-number 38, :start-pc 0}
       {:line-number 42, :start-pc 7}
       {:line-number 43, :start-pc 20}
       {:line-number 48, :start-pc 25}
       {:line-number 45, :start-pc 28}
       {:line-number 47, :start-pc 29}
       {:line-number 50, :start-pc 38}
       {:line-number 51, :start-pc 45}
       {:line-number 52, :start-pc 50}),
      "LocalVariableTable"
      ({:name "e",
        :length 9,
        :start-pc 29,
        :type [:reference "java.lang.Exception"],
        :index 1}
       {:name "this",
        :length 55,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:synchronized :public :final},
   :name "seq",
   :type {:params (), :return [:reference "clojure.lang.ISeq"]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions
     [42
      182
      0
      13
      87
      42
      180
      0
      9
      198
      0
      39
      42
      180
      0
      9
      76
      42
      1
      181
      0
      9
      43
      193
      0
      5
      153
      0
      14
      43
      192
      0
      5
      182
      0
      13
      76
      167
      255
      241
      42
      43
      184
      0
      14
      181
      0
      4
      42
      180
      0
      4
      176],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 56, :start-pc 0}
       {:line-number 57, :start-pc 5}
       {:line-number 59, :start-pc 12}
       {:line-number 60, :start-pc 17}
       {:line-number 61, :start-pc 22}
       {:line-number 63, :start-pc 29}
       {:line-number 65, :start-pc 40}
       {:line-number 67, :start-pc 48}),
      "LocalVariableTable"
      ({:name "ls",
        :length 31,
        :start-pc 17,
        :type [:reference "java.lang.Object"],
        :index 1}
       {:name "this",
        :length 53,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "count",
   :type {:params (), :return [:primitive :int]},
   :attributes
   {"Code"
    {:max-stack 1,
     :max-locals 3,
     :instructions
     [3
      60
      42
      182
      0
      6
      77
      44
      198
      0
      16
      132
      1
      1
      44
      185
      0
      15
      1
      0
      77
      167
      255
      242
      27
      172],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 71, :start-pc 0}
       {:line-number 72, :start-pc 2}
       {:line-number 73, :start-pc 11}
       {:line-number 72, :start-pc 14}
       {:line-number 74, :start-pc 24}),
      "LocalVariableTable"
      ({:name "s",
        :length 17,
        :start-pc 7,
        :type [:reference "clojure.lang.ISeq"],
        :index 2}
       {:name "this",
        :length 26,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "c",
        :length 24,
        :start-pc 2,
        :type [:primitive :int],
        :index 1})}}}}
  {:flags #{:public},
   :name "first",
   :type {:params (), :return [:reference "java.lang.Object"]},
   :attributes
   {"Code"
    {:max-stack 1,
     :max-locals 1,
     :instructions
     [42
      182
      0
      6
      87
      42
      180
      0
      4
      199
      0
      5
      1
      176
      42
      180
      0
      4
      185
      0
      16
      1
      0
      176],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 78, :start-pc 0}
       {:line-number 79, :start-pc 5}
       {:line-number 80, :start-pc 12}
       {:line-number 81, :start-pc 14}),
      "LocalVariableTable"
      ({:name "this",
        :length 24,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "next",
   :type {:params (), :return [:reference "clojure.lang.ISeq"]},
   :attributes
   {"Code"
    {:max-stack 1,
     :max-locals 1,
     :instructions
     [42
      182
      0
      6
      87
      42
      180
      0
      4
      199
      0
      5
      1
      176
      42
      180
      0
      4
      185
      0
      15
      1
      0
      176],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 85, :start-pc 0}
       {:line-number 86, :start-pc 5}
       {:line-number 87, :start-pc 12}
       {:line-number 88, :start-pc 14}),
      "LocalVariableTable"
      ({:name "this",
        :length 24,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "more",
   :type {:params (), :return [:reference "clojure.lang.ISeq"]},
   :attributes
   {"Code"
    {:max-stack 1,
     :max-locals 1,
     :instructions
     [42
      182
      0
      6
      87
      42
      180
      0
      4
      199
      0
      7
      178
      0
      17
      176
      42
      180
      0
      4
      185
      0
      18
      1
      0
      176],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 92, :start-pc 0}
       {:line-number 93, :start-pc 5}
       {:line-number 94, :start-pc 12}
       {:line-number 95, :start-pc 16}),
      "LocalVariableTable"
      ({:name "this",
        :length 26,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "cons",
   :type
   {:params ([:reference "java.lang.Object"]),
    :return [:reference "clojure.lang.ISeq"]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [43 42 182 0 6 184 0 19 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 99, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 9,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "o",
        :length 9,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 1})}}}}
  {:flags #{:public},
   :name "empty",
   :type
   {:params (),
    :return [:reference "clojure.lang.IPersistentCollection"]},
   :attributes
   {"Code"
    {:max-stack 1,
     :max-locals 1,
     :instructions [178 0 17 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 103, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 4,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "equiv",
   :type
   {:params ([:reference "java.lang.Object"]),
    :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [42 43 182 0 20 172],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 107, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 6,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "o",
        :length 6,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 1})}}}}
  {:flags #{:public},
   :name "hashCode",
   :type {:params (), :return [:primitive :int]},
   :attributes
   {"Code"
    {:max-stack 1,
     :max-locals 1,
     :instructions [42 182 0 6 184 0 21 172],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 111, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "equals",
   :type
   {:params ([:reference "java.lang.Object"]),
    :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 3,
     :instructions
     [42
      182
      0
      6
      77
      44
      198
      0
      11
      44
      43
      185
      0
      22
      2
      0
      172
      43
      193
      0
      23
      154
      0
      10
      43
      193
      0
      24
      153
      0
      14
      43
      184
      0
      14
      199
      0
      7
      4
      167
      0
      4
      3
      172],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 115, :start-pc 0}
       {:line-number 116, :start-pc 5}
       {:line-number 117, :start-pc 9}
       {:line-number 119, :start-pc 17}),
      "LocalVariableTable"
      ({:name "this",
        :length 44,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "o",
        :length 44,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 1}
       {:name "s",
        :length 39,
        :start-pc 5,
        :type [:reference "clojure.lang.ISeq"],
        :index 2})}}}}
  {:flags #{:public},
   :name "toArray",
   :type
   {:params (), :return [:array [:reference "java.lang.Object"] 1]},
   :attributes
   {"Code"
    {:max-stack 1,
     :max-locals 1,
     :instructions [42 182 0 6 184 0 25 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 126, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "add",
   :type
   {:params ([:reference "java.lang.Object"]),
    :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [187 0 26 89 183 0 27 191],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 130, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "o",
        :length 8,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 1})}}}}
  {:flags #{:public},
   :name "remove",
   :type
   {:params ([:reference "java.lang.Object"]),
    :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [187 0 26 89 183 0 27 191],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 134, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "o",
        :length 8,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 1})}}}}
  {:flags #{:public},
   :name "addAll",
   :type
   {:params ([:reference "java.util.Collection"]),
    :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [187 0 26 89 183 0 27 191],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 138, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "c",
        :length 8,
        :start-pc 0,
        :type [:reference "java.util.Collection"],
        :index 1})}}}}
  {:flags #{:public},
   :name "clear",
   :type {:params (), :return [:primitive :void]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 1,
     :instructions [187 0 26 89 183 0 27 191],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 142, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "retainAll",
   :type
   {:params ([:reference "java.util.Collection"]),
    :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [187 0 26 89 183 0 27 191],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 146, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "c",
        :length 8,
        :start-pc 0,
        :type [:reference "java.util.Collection"],
        :index 1})}}}}
  {:flags #{:public},
   :name "removeAll",
   :type
   {:params ([:reference "java.util.Collection"]),
    :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [187 0 26 89 183 0 27 191],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 150, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "c",
        :length 8,
        :start-pc 0,
        :type [:reference "java.util.Collection"],
        :index 1})}}}}
  {:flags #{:public},
   :name "containsAll",
   :type
   {:params ([:reference "java.util.Collection"]),
    :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 4,
     :instructions
     [43
      185
      0
      28
      1
      0
      77
      44
      185
      0
      29
      1
      0
      153
      0
      23
      44
      185
      0
      30
      1
      0
      78
      42
      45
      182
      0
      31
      154
      0
      5
      3
      172
      167
      255
      230
      4
      172],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 154, :start-pc 0}
       {:line-number 156, :start-pc 23}
       {:line-number 157, :start-pc 31}
       {:line-number 159, :start-pc 36}),
      "LocalVariableTable"
      ({:name "o",
        :length 10,
        :start-pc 23,
        :type [:reference "java.lang.Object"],
        :index 3}
       {:name "i$",
        :length 29,
        :start-pc 7,
        :type [:reference "java.util.Iterator"],
        :index 2}
       {:name "this",
        :length 38,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "c",
        :length 38,
        :start-pc 0,
        :type [:reference "java.util.Collection"],
        :index 1})}}}}
  {:flags #{:public},
   :name "toArray",
   :type
   {:params ([:array [:reference "java.lang.Object"] 1]),
    :return [:array [:reference "java.lang.Object"] 1]},
   :attributes
   {"Code"
    {:max-stack 3,
     :max-locals 4,
     :instructions
     [43
      190
      42
      182
      0
      32
      161
      0
      54
      42
      182
      0
      6
      77
      3
      62
      44
      198
      0
      25
      43
      29
      44
      185
      0
      16
      1
      0
      83
      132
      3
      1
      44
      185
      0
      15
      1
      0
      77
      167
      255
      233
      43
      190
      42
      182
      0
      32
      164
      0
      10
      43
      42
      182
      0
      32
      1
      83
      43
      176
      42
      182
      0
      33
      176],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 163, :start-pc 0}
       {:line-number 165, :start-pc 9}
       {:line-number 166, :start-pc 14}
       {:line-number 168, :start-pc 20}
       {:line-number 166, :start-pc 29}
       {:line-number 170, :start-pc 42}
       {:line-number 171, :start-pc 51}
       {:line-number 172, :start-pc 58}
       {:line-number 175, :start-pc 60}),
      "LocalVariableTable"
      ({:name "i",
        :length 26,
        :start-pc 16,
        :type [:primitive :int],
        :index 3}
       {:name "s",
        :length 46,
        :start-pc 14,
        :type [:reference "clojure.lang.ISeq"],
        :index 2}
       {:name "this",
        :length 65,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "a",
        :length 65,
        :start-pc 0,
        :type [:array [:reference "java.lang.Object"] 1],
        :index 1})}}}}
  {:flags #{:public},
   :name "size",
   :type {:params (), :return [:primitive :int]},
   :attributes
   {"Code"
    {:max-stack 1,
     :max-locals 1,
     :instructions [42 182 0 32 172],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 179, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 5,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "isEmpty",
   :type {:params (), :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 1,
     :max-locals 1,
     :instructions [42 182 0 6 199 0 7 4 167 0 4 3 172],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 183, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 13,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "contains",
   :type
   {:params ([:reference "java.lang.Object"]),
    :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 3,
     :instructions
     [42
      182
      0
      6
      77
      44
      198
      0
      28
      44
      185
      0
      16
      1
      0
      43
      184
      0
      34
      153
      0
      5
      4
      172
      44
      185
      0
      15
      1
      0
      77
      167
      255
      230
      3
      172],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 187, :start-pc 0}
       {:line-number 189, :start-pc 9}
       {:line-number 190, :start-pc 22}
       {:line-number 187, :start-pc 24}
       {:line-number 192, :start-pc 34}),
      "LocalVariableTable"
      ({:name "s",
        :length 29,
        :start-pc 5,
        :type [:reference "clojure.lang.ISeq"],
        :index 2}
       {:name "this",
        :length 36,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "o",
        :length 36,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 1})}}}}
  {:flags #{:public},
   :name "iterator",
   :type {:params (), :return [:reference "java.util.Iterator"]},
   :attributes
   {"Code"
    {:max-stack 3,
     :max-locals 1,
     :instructions [187 0 35 89 42 182 0 6 183 0 36 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 196, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 12,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:private},
   :name "reify",
   :type {:params (), :return [:reference "java.util.List"]},
   :attributes
   {"Code"
    {:max-stack 3,
     :max-locals 1,
     :instructions [187 0 37 89 42 183 0 38 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 201, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 9,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "subList",
   :type
   {:params ([:primitive :int] [:primitive :int]),
    :return [:reference "java.util.List"]},
   :attributes
   {"Code"
    {:max-stack 3,
     :max-locals 3,
     :instructions [42 183 0 39 27 28 185 0 40 3 0 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 205, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 12,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "fromIndex",
        :length 12,
        :start-pc 0,
        :type [:primitive :int],
        :index 1}
       {:name "toIndex",
        :length 12,
        :start-pc 0,
        :type [:primitive :int],
        :index 2})}}}}
  {:flags #{:public},
   :name "set",
   :type
   {:params ([:primitive :int] [:reference "java.lang.Object"]),
    :return [:reference "java.lang.Object"]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 3,
     :instructions [187 0 26 89 183 0 27 191],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 209, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "index",
        :length 8,
        :start-pc 0,
        :type [:primitive :int],
        :index 1}
       {:name "element",
        :length 8,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 2})}}}}
  {:flags #{:public},
   :name "remove",
   :type
   {:params ([:primitive :int]),
    :return [:reference "java.lang.Object"]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [187 0 26 89 183 0 27 191],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 213, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "index",
        :length 8,
        :start-pc 0,
        :type [:primitive :int],
        :index 1})}}}}
  {:flags #{:public},
   :name "indexOf",
   :type
   {:params ([:reference "java.lang.Object"]),
    :return [:primitive :int]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 4,
     :instructions
     [42
      182
      0
      6
      77
      3
      62
      44
      198
      0
      31
      44
      185
      0
      16
      1
      0
      43
      184
      0
      34
      153
      0
      5
      29
      172
      44
      185
      0
      15
      1
      0
      77
      132
      3
      1
      167
      255
      227
      2
      172],
     :exception-table (),
     :attributes
     {"LineNumberTable"
      ({:line-number 217, :start-pc 0}
       {:line-number 218, :start-pc 5}
       {:line-number 220, :start-pc 11}
       {:line-number 221, :start-pc 24}
       {:line-number 218, :start-pc 26}
       {:line-number 223, :start-pc 39}),
      "LocalVariableTable"
      ({:name "i",
        :length 32,
        :start-pc 7,
        :type [:primitive :int],
        :index 3}
       {:name "this",
        :length 41,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "o",
        :length 41,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 1}
       {:name "s",
        :length 36,
        :start-pc 5,
        :type [:reference "clojure.lang.ISeq"],
        :index 2})}}}}
  {:flags #{:public},
   :name "lastIndexOf",
   :type
   {:params ([:reference "java.lang.Object"]),
    :return [:primitive :int]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [42 183 0 39 43 185 0 41 2 0 172],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 227, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 11,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "o",
        :length 11,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 1})}}}}
  {:flags #{:public},
   :name "listIterator",
   :type {:params (), :return [:reference "java.util.ListIterator"]},
   :attributes
   {"Code"
    {:max-stack 1,
     :max-locals 1,
     :instructions [42 183 0 39 185 0 42 1 0 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 231, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 10,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0})}}}}
  {:flags #{:public},
   :name "listIterator",
   :type
   {:params ([:primitive :int]),
    :return [:reference "java.util.ListIterator"]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [42 183 0 39 27 185 0 43 2 0 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 235, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 11,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "index",
        :length 11,
        :start-pc 0,
        :type [:primitive :int],
        :index 1})}}}}
  {:flags #{:public},
   :name "get",
   :type
   {:params ([:primitive :int]),
    :return [:reference "java.lang.Object"]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [42 27 184 0 44 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 239, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 6,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "index",
        :length 6,
        :start-pc 0,
        :type [:primitive :int],
        :index 1})}}}}
  {:flags #{:public},
   :name "add",
   :type
   {:params ([:primitive :int] [:reference "java.lang.Object"]),
    :return [:primitive :void]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 3,
     :instructions [187 0 26 89 183 0 27 191],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 243, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "index",
        :length 8,
        :start-pc 0,
        :type [:primitive :int],
        :index 1}
       {:name "element",
        :length 8,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 2})}}}}
  {:flags #{:public},
   :name "addAll",
   :type
   {:params ([:primitive :int] [:reference "java.util.Collection"]),
    :return [:primitive :boolean]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 3,
     :instructions [187 0 26 89 183 0 27 191],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 247, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 8,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "index",
        :length 8,
        :start-pc 0,
        :type [:primitive :int],
        :index 1}
       {:name "c",
        :length 8,
        :start-pc 0,
        :type [:reference "java.util.Collection"],
        :index 2})}}}}
  {:flags #{:unknown6 :unknown12 :public},
   :name "withMeta",
   :type
   {:params ([:reference "clojure.lang.IPersistentMap"]),
    :return [:reference "clojure.lang.IObj"]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [42 43 182 0 45 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 17, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 6,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "x0",
        :length 6,
        :start-pc 0,
        :type [:reference "clojure.lang.IPersistentMap"],
        :index 1})}}}}
  {:flags #{:unknown6 :unknown12 :public},
   :name "cons",
   :type
   {:params ([:reference "java.lang.Object"]),
    :return [:reference "clojure.lang.IPersistentCollection"]},
   :attributes
   {"Code"
    {:max-stack 2,
     :max-locals 2,
     :instructions [42 43 182 0 46 176],
     :exception-table (),
     :attributes
     {"LineNumberTable" ({:line-number 17, :start-pc 0}),
      "LocalVariableTable"
      ({:name "this",
        :length 6,
        :start-pc 0,
        :type [:reference "clojure.lang.LazySeq"],
        :index 0}
       {:name "x0",
        :length 6,
        :start-pc 0,
        :type [:reference "java.lang.Object"],
        :index 1})}}}}),
 :version [49 0],
 :attributes
 {"SourceFile" "LazySeq.java",
  "InnerClasses" [0 1 0 199 0 157 0 200 0 8]},
 :flags #{:super :public :final},
 :fields
 ({:flags #{:private},
   :name "fn",
   :type [:reference "clojure.lang.IFn"],
   :attributes {}}
  {:flags #{:private},
   :name "sv",
   :type [:reference "java.lang.Object"],
   :attributes {}}
  {:flags #{:private},
   :name "s",
   :type [:reference "clojure.lang.ISeq"],
   :attributes {}}),
 :super-class "clojure.lang.Obj"}