Skip to content

Instantly share code, notes, and snippets.

@raek

raek/gist:517879

Created August 10, 2010 19:54
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save raek/517879 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save raek/517879 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
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"}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment