• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This code is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License version 2 only, as
8  * published by the Free Software Foundation.  Oracle designates this
9  * particular file as subject to the "Classpath" exception as provided
10  * by Oracle in the LICENSE file that accompanied this code.
11  *
12  * This code is distributed in the hope that it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15  * version 2 for more details (a copy is included in the LICENSE file that
16  * accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License version
19  * 2 along with this work; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21  *
22  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
23  * or visit www.oracle.com if you need additional information or have any
24  * questions.
25  */
26 
27 package java.util;
28 
29 import android.compat.annotation.UnsupportedAppUsage;
30 
31 @SuppressWarnings({"unchecked", "deprecation", "all"})
32 public class Collections {
33 
Collections()34     private Collections() {
35         throw new RuntimeException("Stub!");
36     }
37 
sort(java.util.List<T> list)38     public static <T extends java.lang.Comparable<? super T>> void sort(java.util.List<T> list) {
39         throw new RuntimeException("Stub!");
40     }
41 
sort(java.util.List<T> list, java.util.Comparator<? super T> c)42     public static <T> void sort(java.util.List<T> list, java.util.Comparator<? super T> c) {
43         throw new RuntimeException("Stub!");
44     }
45 
binarySearch( java.util.List<? extends java.lang.Comparable<? super T>> list, T key)46     public static <T> int binarySearch(
47             java.util.List<? extends java.lang.Comparable<? super T>> list, T key) {
48         throw new RuntimeException("Stub!");
49     }
50 
indexedBinarySearch( java.util.List<? extends java.lang.Comparable<? super T>> list, T key)51     private static <T> int indexedBinarySearch(
52             java.util.List<? extends java.lang.Comparable<? super T>> list, T key) {
53         throw new RuntimeException("Stub!");
54     }
55 
iteratorBinarySearch( java.util.List<? extends java.lang.Comparable<? super T>> list, T key)56     private static <T> int iteratorBinarySearch(
57             java.util.List<? extends java.lang.Comparable<? super T>> list, T key) {
58         throw new RuntimeException("Stub!");
59     }
60 
get(java.util.ListIterator<? extends T> i, int index)61     private static <T> T get(java.util.ListIterator<? extends T> i, int index) {
62         throw new RuntimeException("Stub!");
63     }
64 
binarySearch( java.util.List<? extends T> list, T key, java.util.Comparator<? super T> c)65     public static <T> int binarySearch(
66             java.util.List<? extends T> list, T key, java.util.Comparator<? super T> c) {
67         throw new RuntimeException("Stub!");
68     }
69 
indexedBinarySearch( java.util.List<? extends T> l, T key, java.util.Comparator<? super T> c)70     private static <T> int indexedBinarySearch(
71             java.util.List<? extends T> l, T key, java.util.Comparator<? super T> c) {
72         throw new RuntimeException("Stub!");
73     }
74 
iteratorBinarySearch( java.util.List<? extends T> l, T key, java.util.Comparator<? super T> c)75     private static <T> int iteratorBinarySearch(
76             java.util.List<? extends T> l, T key, java.util.Comparator<? super T> c) {
77         throw new RuntimeException("Stub!");
78     }
79 
reverse(java.util.List<?> list)80     public static void reverse(java.util.List<?> list) {
81         throw new RuntimeException("Stub!");
82     }
83 
shuffle(java.util.List<?> list)84     public static void shuffle(java.util.List<?> list) {
85         throw new RuntimeException("Stub!");
86     }
87 
shuffle(java.util.List<?> list, java.util.Random rnd)88     public static void shuffle(java.util.List<?> list, java.util.Random rnd) {
89         throw new RuntimeException("Stub!");
90     }
91 
swap(java.util.List<?> list, int i, int j)92     public static void swap(java.util.List<?> list, int i, int j) {
93         throw new RuntimeException("Stub!");
94     }
95 
swap(java.lang.Object[] arr, int i, int j)96     private static void swap(java.lang.Object[] arr, int i, int j) {
97         throw new RuntimeException("Stub!");
98     }
99 
fill(java.util.List<? super T> list, T obj)100     public static <T> void fill(java.util.List<? super T> list, T obj) {
101         throw new RuntimeException("Stub!");
102     }
103 
copy(java.util.List<? super T> dest, java.util.List<? extends T> src)104     public static <T> void copy(java.util.List<? super T> dest, java.util.List<? extends T> src) {
105         throw new RuntimeException("Stub!");
106     }
107 
min( java.util.Collection<? extends T> coll)108     public static <T extends java.lang.Object & java.lang.Comparable<? super T>> T min(
109             java.util.Collection<? extends T> coll) {
110         throw new RuntimeException("Stub!");
111     }
112 
min( java.util.Collection<? extends T> coll, java.util.Comparator<? super T> comp)113     public static <T> T min(
114             java.util.Collection<? extends T> coll, java.util.Comparator<? super T> comp) {
115         throw new RuntimeException("Stub!");
116     }
117 
max( java.util.Collection<? extends T> coll)118     public static <T extends java.lang.Object & java.lang.Comparable<? super T>> T max(
119             java.util.Collection<? extends T> coll) {
120         throw new RuntimeException("Stub!");
121     }
122 
max( java.util.Collection<? extends T> coll, java.util.Comparator<? super T> comp)123     public static <T> T max(
124             java.util.Collection<? extends T> coll, java.util.Comparator<? super T> comp) {
125         throw new RuntimeException("Stub!");
126     }
127 
rotate(java.util.List<?> list, int distance)128     public static void rotate(java.util.List<?> list, int distance) {
129         throw new RuntimeException("Stub!");
130     }
131 
rotate1(java.util.List<T> list, int distance)132     private static <T> void rotate1(java.util.List<T> list, int distance) {
133         throw new RuntimeException("Stub!");
134     }
135 
rotate2(java.util.List<?> list, int distance)136     private static void rotate2(java.util.List<?> list, int distance) {
137         throw new RuntimeException("Stub!");
138     }
139 
replaceAll(java.util.List<T> list, T oldVal, T newVal)140     public static <T> boolean replaceAll(java.util.List<T> list, T oldVal, T newVal) {
141         throw new RuntimeException("Stub!");
142     }
143 
indexOfSubList(java.util.List<?> source, java.util.List<?> target)144     public static int indexOfSubList(java.util.List<?> source, java.util.List<?> target) {
145         throw new RuntimeException("Stub!");
146     }
147 
lastIndexOfSubList(java.util.List<?> source, java.util.List<?> target)148     public static int lastIndexOfSubList(java.util.List<?> source, java.util.List<?> target) {
149         throw new RuntimeException("Stub!");
150     }
151 
unmodifiableCollection( java.util.Collection<? extends T> c)152     public static <T> java.util.Collection<T> unmodifiableCollection(
153             java.util.Collection<? extends T> c) {
154         throw new RuntimeException("Stub!");
155     }
156 
unmodifiableSet(java.util.Set<? extends T> s)157     public static <T> java.util.Set<T> unmodifiableSet(java.util.Set<? extends T> s) {
158         throw new RuntimeException("Stub!");
159     }
160 
unmodifiableSortedSet(java.util.SortedSet<T> s)161     public static <T> java.util.SortedSet<T> unmodifiableSortedSet(java.util.SortedSet<T> s) {
162         throw new RuntimeException("Stub!");
163     }
164 
unmodifiableNavigableSet( java.util.NavigableSet<T> s)165     public static <T> java.util.NavigableSet<T> unmodifiableNavigableSet(
166             java.util.NavigableSet<T> s) {
167         throw new RuntimeException("Stub!");
168     }
169 
unmodifiableList(java.util.List<? extends T> list)170     public static <T> java.util.List<T> unmodifiableList(java.util.List<? extends T> list) {
171         throw new RuntimeException("Stub!");
172     }
173 
unmodifiableMap( java.util.Map<? extends K, ? extends V> m)174     public static <K, V> java.util.Map<K, V> unmodifiableMap(
175             java.util.Map<? extends K, ? extends V> m) {
176         throw new RuntimeException("Stub!");
177     }
178 
unmodifiableSortedMap( java.util.SortedMap<K, ? extends V> m)179     public static <K, V> java.util.SortedMap<K, V> unmodifiableSortedMap(
180             java.util.SortedMap<K, ? extends V> m) {
181         throw new RuntimeException("Stub!");
182     }
183 
unmodifiableNavigableMap( java.util.NavigableMap<K, ? extends V> m)184     public static <K, V> java.util.NavigableMap<K, V> unmodifiableNavigableMap(
185             java.util.NavigableMap<K, ? extends V> m) {
186         throw new RuntimeException("Stub!");
187     }
188 
synchronizedCollection(java.util.Collection<T> c)189     public static <T> java.util.Collection<T> synchronizedCollection(java.util.Collection<T> c) {
190         throw new RuntimeException("Stub!");
191     }
192 
synchronizedCollection( java.util.Collection<T> c, java.lang.Object mutex)193     static <T> java.util.Collection<T> synchronizedCollection(
194             java.util.Collection<T> c, java.lang.Object mutex) {
195         throw new RuntimeException("Stub!");
196     }
197 
synchronizedSet(java.util.Set<T> s)198     public static <T> java.util.Set<T> synchronizedSet(java.util.Set<T> s) {
199         throw new RuntimeException("Stub!");
200     }
201 
synchronizedSet(java.util.Set<T> s, java.lang.Object mutex)202     static <T> java.util.Set<T> synchronizedSet(java.util.Set<T> s, java.lang.Object mutex) {
203         throw new RuntimeException("Stub!");
204     }
205 
synchronizedSortedSet(java.util.SortedSet<T> s)206     public static <T> java.util.SortedSet<T> synchronizedSortedSet(java.util.SortedSet<T> s) {
207         throw new RuntimeException("Stub!");
208     }
209 
synchronizedNavigableSet( java.util.NavigableSet<T> s)210     public static <T> java.util.NavigableSet<T> synchronizedNavigableSet(
211             java.util.NavigableSet<T> s) {
212         throw new RuntimeException("Stub!");
213     }
214 
synchronizedList(java.util.List<T> list)215     public static <T> java.util.List<T> synchronizedList(java.util.List<T> list) {
216         throw new RuntimeException("Stub!");
217     }
218 
synchronizedList(java.util.List<T> list, java.lang.Object mutex)219     static <T> java.util.List<T> synchronizedList(java.util.List<T> list, java.lang.Object mutex) {
220         throw new RuntimeException("Stub!");
221     }
222 
synchronizedMap(java.util.Map<K, V> m)223     public static <K, V> java.util.Map<K, V> synchronizedMap(java.util.Map<K, V> m) {
224         throw new RuntimeException("Stub!");
225     }
226 
synchronizedSortedMap( java.util.SortedMap<K, V> m)227     public static <K, V> java.util.SortedMap<K, V> synchronizedSortedMap(
228             java.util.SortedMap<K, V> m) {
229         throw new RuntimeException("Stub!");
230     }
231 
synchronizedNavigableMap( java.util.NavigableMap<K, V> m)232     public static <K, V> java.util.NavigableMap<K, V> synchronizedNavigableMap(
233             java.util.NavigableMap<K, V> m) {
234         throw new RuntimeException("Stub!");
235     }
236 
checkedCollection( java.util.Collection<E> c, java.lang.Class<E> type)237     public static <E> java.util.Collection<E> checkedCollection(
238             java.util.Collection<E> c, java.lang.Class<E> type) {
239         throw new RuntimeException("Stub!");
240     }
241 
zeroLengthArray(java.lang.Class<T> type)242     static <T> T[] zeroLengthArray(java.lang.Class<T> type) {
243         throw new RuntimeException("Stub!");
244     }
245 
checkedQueue( java.util.Queue<E> queue, java.lang.Class<E> type)246     public static <E> java.util.Queue<E> checkedQueue(
247             java.util.Queue<E> queue, java.lang.Class<E> type) {
248         throw new RuntimeException("Stub!");
249     }
250 
checkedSet(java.util.Set<E> s, java.lang.Class<E> type)251     public static <E> java.util.Set<E> checkedSet(java.util.Set<E> s, java.lang.Class<E> type) {
252         throw new RuntimeException("Stub!");
253     }
254 
checkedSortedSet( java.util.SortedSet<E> s, java.lang.Class<E> type)255     public static <E> java.util.SortedSet<E> checkedSortedSet(
256             java.util.SortedSet<E> s, java.lang.Class<E> type) {
257         throw new RuntimeException("Stub!");
258     }
259 
checkedNavigableSet( java.util.NavigableSet<E> s, java.lang.Class<E> type)260     public static <E> java.util.NavigableSet<E> checkedNavigableSet(
261             java.util.NavigableSet<E> s, java.lang.Class<E> type) {
262         throw new RuntimeException("Stub!");
263     }
264 
checkedList( java.util.List<E> list, java.lang.Class<E> type)265     public static <E> java.util.List<E> checkedList(
266             java.util.List<E> list, java.lang.Class<E> type) {
267         throw new RuntimeException("Stub!");
268     }
269 
checkedMap( java.util.Map<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType)270     public static <K, V> java.util.Map<K, V> checkedMap(
271             java.util.Map<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) {
272         throw new RuntimeException("Stub!");
273     }
274 
checkedSortedMap( java.util.SortedMap<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType)275     public static <K, V> java.util.SortedMap<K, V> checkedSortedMap(
276             java.util.SortedMap<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) {
277         throw new RuntimeException("Stub!");
278     }
279 
checkedNavigableMap( java.util.NavigableMap<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType)280     public static <K, V> java.util.NavigableMap<K, V> checkedNavigableMap(
281             java.util.NavigableMap<K, V> m,
282             java.lang.Class<K> keyType,
283             java.lang.Class<V> valueType) {
284         throw new RuntimeException("Stub!");
285     }
286 
emptyIterator()287     public static <T> java.util.Iterator<T> emptyIterator() {
288         throw new RuntimeException("Stub!");
289     }
290 
emptyListIterator()291     public static <T> java.util.ListIterator<T> emptyListIterator() {
292         throw new RuntimeException("Stub!");
293     }
294 
emptyEnumeration()295     public static <T> java.util.Enumeration<T> emptyEnumeration() {
296         throw new RuntimeException("Stub!");
297     }
298 
emptySet()299     public static final <T> java.util.Set<T> emptySet() {
300         throw new RuntimeException("Stub!");
301     }
302 
emptySortedSet()303     public static <E> java.util.SortedSet<E> emptySortedSet() {
304         throw new RuntimeException("Stub!");
305     }
306 
emptyNavigableSet()307     public static <E> java.util.NavigableSet<E> emptyNavigableSet() {
308         throw new RuntimeException("Stub!");
309     }
310 
emptyList()311     public static final <T> java.util.List<T> emptyList() {
312         throw new RuntimeException("Stub!");
313     }
314 
emptyMap()315     public static final <K, V> java.util.Map<K, V> emptyMap() {
316         throw new RuntimeException("Stub!");
317     }
318 
emptySortedMap()319     public static final <K, V> java.util.SortedMap<K, V> emptySortedMap() {
320         throw new RuntimeException("Stub!");
321     }
322 
emptyNavigableMap()323     public static final <K, V> java.util.NavigableMap<K, V> emptyNavigableMap() {
324         throw new RuntimeException("Stub!");
325     }
326 
singleton(T o)327     public static <T> java.util.Set<T> singleton(T o) {
328         throw new RuntimeException("Stub!");
329     }
330 
singletonIterator(E e)331     static <E> java.util.Iterator<E> singletonIterator(E e) {
332         throw new RuntimeException("Stub!");
333     }
334 
singletonSpliterator(T element)335     static <T> java.util.Spliterator<T> singletonSpliterator(T element) {
336         throw new RuntimeException("Stub!");
337     }
338 
singletonList(T o)339     public static <T> java.util.List<T> singletonList(T o) {
340         throw new RuntimeException("Stub!");
341     }
342 
singletonMap(K key, V value)343     public static <K, V> java.util.Map<K, V> singletonMap(K key, V value) {
344         throw new RuntimeException("Stub!");
345     }
346 
nCopies(int n, T o)347     public static <T> java.util.List<T> nCopies(int n, T o) {
348         throw new RuntimeException("Stub!");
349     }
350 
reverseOrder()351     public static <T> java.util.Comparator<T> reverseOrder() {
352         throw new RuntimeException("Stub!");
353     }
354 
reverseOrder(java.util.Comparator<T> cmp)355     public static <T> java.util.Comparator<T> reverseOrder(java.util.Comparator<T> cmp) {
356         throw new RuntimeException("Stub!");
357     }
358 
enumeration(java.util.Collection<T> c)359     public static <T> java.util.Enumeration<T> enumeration(java.util.Collection<T> c) {
360         throw new RuntimeException("Stub!");
361     }
362 
list(java.util.Enumeration<T> e)363     public static <T> java.util.ArrayList<T> list(java.util.Enumeration<T> e) {
364         throw new RuntimeException("Stub!");
365     }
366 
eq(java.lang.Object o1, java.lang.Object o2)367     static boolean eq(java.lang.Object o1, java.lang.Object o2) {
368         throw new RuntimeException("Stub!");
369     }
370 
frequency(java.util.Collection<?> c, java.lang.Object o)371     public static int frequency(java.util.Collection<?> c, java.lang.Object o) {
372         throw new RuntimeException("Stub!");
373     }
374 
disjoint(java.util.Collection<?> c1, java.util.Collection<?> c2)375     public static boolean disjoint(java.util.Collection<?> c1, java.util.Collection<?> c2) {
376         throw new RuntimeException("Stub!");
377     }
378 
addAll(java.util.Collection<? super T> c, T... elements)379     public static <T> boolean addAll(java.util.Collection<? super T> c, T... elements) {
380         throw new RuntimeException("Stub!");
381     }
382 
newSetFromMap(java.util.Map<E, java.lang.Boolean> map)383     public static <E> java.util.Set<E> newSetFromMap(java.util.Map<E, java.lang.Boolean> map) {
384         throw new RuntimeException("Stub!");
385     }
386 
asLifoQueue(java.util.Deque<T> deque)387     public static <T> java.util.Queue<T> asLifoQueue(java.util.Deque<T> deque) {
388         throw new RuntimeException("Stub!");
389     }
390 
391     private static final int BINARYSEARCH_THRESHOLD = 5000; // 0x1388
392 
393     private static final int COPY_THRESHOLD = 10; // 0xa
394 
395     public static final java.util.List EMPTY_LIST;
396 
397     static {
398         EMPTY_LIST = null;
399     }
400 
401     public static final java.util.Map EMPTY_MAP;
402 
403     static {
404         EMPTY_MAP = null;
405     }
406 
407     public static final java.util.Set EMPTY_SET;
408 
409     static {
410         EMPTY_SET = null;
411     }
412 
413     private static final int FILL_THRESHOLD = 25; // 0x19
414 
415     private static final int INDEXOFSUBLIST_THRESHOLD = 35; // 0x23
416 
417     private static final int REPLACEALL_THRESHOLD = 11; // 0xb
418 
419     private static final int REVERSE_THRESHOLD = 18; // 0x12
420 
421     private static final int ROTATE_THRESHOLD = 100; // 0x64
422 
423     private static final int SHUFFLE_THRESHOLD = 5; // 0x5
424 
425     private static java.util.Random r;
426 
427     @SuppressWarnings({"unchecked", "deprecation", "all"})
428     static class AsLIFOQueue<E> extends java.util.AbstractQueue<E>
429             implements java.util.Queue<E>, java.io.Serializable {
430 
AsLIFOQueue(java.util.Deque<E> q)431         AsLIFOQueue(java.util.Deque<E> q) {
432             throw new RuntimeException("Stub!");
433         }
434 
add(E e)435         public boolean add(E e) {
436             throw new RuntimeException("Stub!");
437         }
438 
offer(E e)439         public boolean offer(E e) {
440             throw new RuntimeException("Stub!");
441         }
442 
poll()443         public E poll() {
444             throw new RuntimeException("Stub!");
445         }
446 
remove()447         public E remove() {
448             throw new RuntimeException("Stub!");
449         }
450 
peek()451         public E peek() {
452             throw new RuntimeException("Stub!");
453         }
454 
element()455         public E element() {
456             throw new RuntimeException("Stub!");
457         }
458 
clear()459         public void clear() {
460             throw new RuntimeException("Stub!");
461         }
462 
size()463         public int size() {
464             throw new RuntimeException("Stub!");
465         }
466 
isEmpty()467         public boolean isEmpty() {
468             throw new RuntimeException("Stub!");
469         }
470 
contains(java.lang.Object o)471         public boolean contains(java.lang.Object o) {
472             throw new RuntimeException("Stub!");
473         }
474 
remove(java.lang.Object o)475         public boolean remove(java.lang.Object o) {
476             throw new RuntimeException("Stub!");
477         }
478 
iterator()479         public java.util.Iterator<E> iterator() {
480             throw new RuntimeException("Stub!");
481         }
482 
toArray()483         public java.lang.Object[] toArray() {
484             throw new RuntimeException("Stub!");
485         }
486 
toArray(T[] a)487         public <T> T[] toArray(T[] a) {
488             throw new RuntimeException("Stub!");
489         }
490 
toString()491         public java.lang.String toString() {
492             throw new RuntimeException("Stub!");
493         }
494 
containsAll(java.util.Collection<?> c)495         public boolean containsAll(java.util.Collection<?> c) {
496             throw new RuntimeException("Stub!");
497         }
498 
removeAll(java.util.Collection<?> c)499         public boolean removeAll(java.util.Collection<?> c) {
500             throw new RuntimeException("Stub!");
501         }
502 
retainAll(java.util.Collection<?> c)503         public boolean retainAll(java.util.Collection<?> c) {
504             throw new RuntimeException("Stub!");
505         }
506 
forEach(java.util.function.Consumer<? super E> action)507         public void forEach(java.util.function.Consumer<? super E> action) {
508             throw new RuntimeException("Stub!");
509         }
510 
removeIf(java.util.function.Predicate<? super E> filter)511         public boolean removeIf(java.util.function.Predicate<? super E> filter) {
512             throw new RuntimeException("Stub!");
513         }
514 
spliterator()515         public java.util.Spliterator<E> spliterator() {
516             throw new RuntimeException("Stub!");
517         }
518 
stream()519         public java.util.stream.Stream<E> stream() {
520             throw new RuntimeException("Stub!");
521         }
522 
parallelStream()523         public java.util.stream.Stream<E> parallelStream() {
524             throw new RuntimeException("Stub!");
525         }
526 
527         private final java.util.Deque<E> q;
528 
529         {
530             q = null;
531         }
532 
533         private static final long serialVersionUID = 1802017725587941708L; // 0x19020d92eca0694cL
534     }
535 
536     @SuppressWarnings({"unchecked", "deprecation", "all"})
537     static class CheckedCollection<E> implements java.util.Collection<E>, java.io.Serializable {
538 
CheckedCollection(java.util.Collection<E> c, java.lang.Class<E> type)539         CheckedCollection(java.util.Collection<E> c, java.lang.Class<E> type) {
540             throw new RuntimeException("Stub!");
541         }
542 
typeCheck(java.lang.Object o)543         E typeCheck(java.lang.Object o) {
544             throw new RuntimeException("Stub!");
545         }
546 
badElementMsg(java.lang.Object o)547         private java.lang.String badElementMsg(java.lang.Object o) {
548             throw new RuntimeException("Stub!");
549         }
550 
size()551         public int size() {
552             throw new RuntimeException("Stub!");
553         }
554 
isEmpty()555         public boolean isEmpty() {
556             throw new RuntimeException("Stub!");
557         }
558 
contains(java.lang.Object o)559         public boolean contains(java.lang.Object o) {
560             throw new RuntimeException("Stub!");
561         }
562 
toArray()563         public java.lang.Object[] toArray() {
564             throw new RuntimeException("Stub!");
565         }
566 
toArray(T[] a)567         public <T> T[] toArray(T[] a) {
568             throw new RuntimeException("Stub!");
569         }
570 
toString()571         public java.lang.String toString() {
572             throw new RuntimeException("Stub!");
573         }
574 
remove(java.lang.Object o)575         public boolean remove(java.lang.Object o) {
576             throw new RuntimeException("Stub!");
577         }
578 
clear()579         public void clear() {
580             throw new RuntimeException("Stub!");
581         }
582 
containsAll(java.util.Collection<?> coll)583         public boolean containsAll(java.util.Collection<?> coll) {
584             throw new RuntimeException("Stub!");
585         }
586 
removeAll(java.util.Collection<?> coll)587         public boolean removeAll(java.util.Collection<?> coll) {
588             throw new RuntimeException("Stub!");
589         }
590 
retainAll(java.util.Collection<?> coll)591         public boolean retainAll(java.util.Collection<?> coll) {
592             throw new RuntimeException("Stub!");
593         }
594 
iterator()595         public java.util.Iterator<E> iterator() {
596             throw new RuntimeException("Stub!");
597         }
598 
add(E e)599         public boolean add(E e) {
600             throw new RuntimeException("Stub!");
601         }
602 
zeroLengthElementArray()603         private E[] zeroLengthElementArray() {
604             throw new RuntimeException("Stub!");
605         }
606 
checkedCopyOf(java.util.Collection<? extends E> coll)607         java.util.Collection<E> checkedCopyOf(java.util.Collection<? extends E> coll) {
608             throw new RuntimeException("Stub!");
609         }
610 
addAll(java.util.Collection<? extends E> coll)611         public boolean addAll(java.util.Collection<? extends E> coll) {
612             throw new RuntimeException("Stub!");
613         }
614 
forEach(java.util.function.Consumer<? super E> action)615         public void forEach(java.util.function.Consumer<? super E> action) {
616             throw new RuntimeException("Stub!");
617         }
618 
removeIf(java.util.function.Predicate<? super E> filter)619         public boolean removeIf(java.util.function.Predicate<? super E> filter) {
620             throw new RuntimeException("Stub!");
621         }
622 
spliterator()623         public java.util.Spliterator<E> spliterator() {
624             throw new RuntimeException("Stub!");
625         }
626 
stream()627         public java.util.stream.Stream<E> stream() {
628             throw new RuntimeException("Stub!");
629         }
630 
parallelStream()631         public java.util.stream.Stream<E> parallelStream() {
632             throw new RuntimeException("Stub!");
633         }
634 
635         final java.util.Collection<E> c;
636 
637         {
638             c = null;
639         }
640 
641         private static final long serialVersionUID = 1578914078182001775L; // 0x15e96dfd18e6cc6fL
642 
643         final java.lang.Class<E> type;
644 
645         {
646             type = null;
647         }
648 
649         private E[] zeroLengthElementArray;
650     }
651 
652     @SuppressWarnings({"unchecked", "deprecation", "all"})
653     static class CheckedList<E> extends java.util.Collections.CheckedCollection<E>
654             implements java.util.List<E> {
655 
CheckedList(java.util.List<E> list, java.lang.Class<E> type)656         CheckedList(java.util.List<E> list, java.lang.Class<E> type) {
657             super(null, null);
658             throw new RuntimeException("Stub!");
659         }
660 
equals(java.lang.Object o)661         public boolean equals(java.lang.Object o) {
662             throw new RuntimeException("Stub!");
663         }
664 
hashCode()665         public int hashCode() {
666             throw new RuntimeException("Stub!");
667         }
668 
get(int index)669         public E get(int index) {
670             throw new RuntimeException("Stub!");
671         }
672 
remove(int index)673         public E remove(int index) {
674             throw new RuntimeException("Stub!");
675         }
676 
indexOf(java.lang.Object o)677         public int indexOf(java.lang.Object o) {
678             throw new RuntimeException("Stub!");
679         }
680 
lastIndexOf(java.lang.Object o)681         public int lastIndexOf(java.lang.Object o) {
682             throw new RuntimeException("Stub!");
683         }
684 
set(int index, E element)685         public E set(int index, E element) {
686             throw new RuntimeException("Stub!");
687         }
688 
add(int index, E element)689         public void add(int index, E element) {
690             throw new RuntimeException("Stub!");
691         }
692 
addAll(int index, java.util.Collection<? extends E> c)693         public boolean addAll(int index, java.util.Collection<? extends E> c) {
694             throw new RuntimeException("Stub!");
695         }
696 
listIterator()697         public java.util.ListIterator<E> listIterator() {
698             throw new RuntimeException("Stub!");
699         }
700 
listIterator(int index)701         public java.util.ListIterator<E> listIterator(int index) {
702             throw new RuntimeException("Stub!");
703         }
704 
subList(int fromIndex, int toIndex)705         public java.util.List<E> subList(int fromIndex, int toIndex) {
706             throw new RuntimeException("Stub!");
707         }
708 
replaceAll(java.util.function.UnaryOperator<E> operator)709         public void replaceAll(java.util.function.UnaryOperator<E> operator) {
710             throw new RuntimeException("Stub!");
711         }
712 
sort(java.util.Comparator<? super E> c)713         public void sort(java.util.Comparator<? super E> c) {
714             throw new RuntimeException("Stub!");
715         }
716 
717         final java.util.List<E> list;
718 
719         {
720             list = null;
721         }
722 
723         private static final long serialVersionUID = 65247728283967356L; // 0xe7ce7692c45f7cL
724     }
725 
726     @SuppressWarnings({"unchecked", "deprecation", "all"})
727     private static class CheckedMap<K, V> implements java.util.Map<K, V>, java.io.Serializable {
728 
CheckedMap( java.util.Map<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType)729         CheckedMap(
730                 java.util.Map<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) {
731             throw new RuntimeException("Stub!");
732         }
733 
typeCheck(java.lang.Object key, java.lang.Object value)734         private void typeCheck(java.lang.Object key, java.lang.Object value) {
735             throw new RuntimeException("Stub!");
736         }
737 
typeCheck( java.util.function.BiFunction<? super K, ? super V, ? extends V> func)738         private java.util.function.BiFunction<? super K, ? super V, ? extends V> typeCheck(
739                 java.util.function.BiFunction<? super K, ? super V, ? extends V> func) {
740             throw new RuntimeException("Stub!");
741         }
742 
badKeyMsg(java.lang.Object key)743         private java.lang.String badKeyMsg(java.lang.Object key) {
744             throw new RuntimeException("Stub!");
745         }
746 
badValueMsg(java.lang.Object value)747         private java.lang.String badValueMsg(java.lang.Object value) {
748             throw new RuntimeException("Stub!");
749         }
750 
size()751         public int size() {
752             throw new RuntimeException("Stub!");
753         }
754 
isEmpty()755         public boolean isEmpty() {
756             throw new RuntimeException("Stub!");
757         }
758 
containsKey(java.lang.Object key)759         public boolean containsKey(java.lang.Object key) {
760             throw new RuntimeException("Stub!");
761         }
762 
containsValue(java.lang.Object v)763         public boolean containsValue(java.lang.Object v) {
764             throw new RuntimeException("Stub!");
765         }
766 
get(java.lang.Object key)767         public V get(java.lang.Object key) {
768             throw new RuntimeException("Stub!");
769         }
770 
remove(java.lang.Object key)771         public V remove(java.lang.Object key) {
772             throw new RuntimeException("Stub!");
773         }
774 
clear()775         public void clear() {
776             throw new RuntimeException("Stub!");
777         }
778 
keySet()779         public java.util.Set<K> keySet() {
780             throw new RuntimeException("Stub!");
781         }
782 
values()783         public java.util.Collection<V> values() {
784             throw new RuntimeException("Stub!");
785         }
786 
equals(java.lang.Object o)787         public boolean equals(java.lang.Object o) {
788             throw new RuntimeException("Stub!");
789         }
790 
hashCode()791         public int hashCode() {
792             throw new RuntimeException("Stub!");
793         }
794 
toString()795         public java.lang.String toString() {
796             throw new RuntimeException("Stub!");
797         }
798 
put(K key, V value)799         public V put(K key, V value) {
800             throw new RuntimeException("Stub!");
801         }
802 
putAll(java.util.Map<? extends K, ? extends V> t)803         public void putAll(java.util.Map<? extends K, ? extends V> t) {
804             throw new RuntimeException("Stub!");
805         }
806 
entrySet()807         public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
808             throw new RuntimeException("Stub!");
809         }
810 
forEach(java.util.function.BiConsumer<? super K, ? super V> action)811         public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
812             throw new RuntimeException("Stub!");
813         }
814 
replaceAll( java.util.function.BiFunction<? super K, ? super V, ? extends V> function)815         public void replaceAll(
816                 java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
817             throw new RuntimeException("Stub!");
818         }
819 
putIfAbsent(K key, V value)820         public V putIfAbsent(K key, V value) {
821             throw new RuntimeException("Stub!");
822         }
823 
remove(java.lang.Object key, java.lang.Object value)824         public boolean remove(java.lang.Object key, java.lang.Object value) {
825             throw new RuntimeException("Stub!");
826         }
827 
replace(K key, V oldValue, V newValue)828         public boolean replace(K key, V oldValue, V newValue) {
829             throw new RuntimeException("Stub!");
830         }
831 
replace(K key, V value)832         public V replace(K key, V value) {
833             throw new RuntimeException("Stub!");
834         }
835 
computeIfAbsent( K key, java.util.function.Function<? super K, ? extends V> mappingFunction)836         public V computeIfAbsent(
837                 K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
838             throw new RuntimeException("Stub!");
839         }
840 
computeIfPresent( K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction)841         public V computeIfPresent(
842                 K key,
843                 java.util.function.BiFunction<? super K, ? super V, ? extends V>
844                         remappingFunction) {
845             throw new RuntimeException("Stub!");
846         }
847 
compute( K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction)848         public V compute(
849                 K key,
850                 java.util.function.BiFunction<? super K, ? super V, ? extends V>
851                         remappingFunction) {
852             throw new RuntimeException("Stub!");
853         }
854 
merge( K key, V value, java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction)855         public V merge(
856                 K key,
857                 V value,
858                 java.util.function.BiFunction<? super V, ? super V, ? extends V>
859                         remappingFunction) {
860             throw new RuntimeException("Stub!");
861         }
862 
863         private transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;
864 
865         final java.lang.Class<K> keyType;
866 
867         {
868             keyType = null;
869         }
870 
871         private final java.util.Map<K, V> m;
872 
873         {
874             m = null;
875         }
876 
877         private static final long serialVersionUID = 5742860141034234728L; // 0x4fb2bcdf0d186368L
878 
879         final java.lang.Class<V> valueType;
880 
881         {
882             valueType = null;
883         }
884 
885         @SuppressWarnings({"unchecked", "deprecation", "all"})
886         static class CheckedEntrySet<K, V> implements java.util.Set<java.util.Map.Entry<K, V>> {
887 
CheckedEntrySet( java.util.Set<java.util.Map.Entry<K, V>> s, java.lang.Class<V> valueType)888             CheckedEntrySet(
889                     java.util.Set<java.util.Map.Entry<K, V>> s, java.lang.Class<V> valueType) {
890                 throw new RuntimeException("Stub!");
891             }
892 
size()893             public int size() {
894                 throw new RuntimeException("Stub!");
895             }
896 
isEmpty()897             public boolean isEmpty() {
898                 throw new RuntimeException("Stub!");
899             }
900 
toString()901             public java.lang.String toString() {
902                 throw new RuntimeException("Stub!");
903             }
904 
hashCode()905             public int hashCode() {
906                 throw new RuntimeException("Stub!");
907             }
908 
clear()909             public void clear() {
910                 throw new RuntimeException("Stub!");
911             }
912 
add(java.util.Map.Entry<K, V> e)913             public boolean add(java.util.Map.Entry<K, V> e) {
914                 throw new RuntimeException("Stub!");
915             }
916 
addAll(java.util.Collection<? extends java.util.Map.Entry<K, V>> coll)917             public boolean addAll(java.util.Collection<? extends java.util.Map.Entry<K, V>> coll) {
918                 throw new RuntimeException("Stub!");
919             }
920 
iterator()921             public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
922                 throw new RuntimeException("Stub!");
923             }
924 
toArray()925             public java.lang.Object[] toArray() {
926                 throw new RuntimeException("Stub!");
927             }
928 
toArray(T[] a)929             public <T> T[] toArray(T[] a) {
930                 throw new RuntimeException("Stub!");
931             }
932 
contains(java.lang.Object o)933             public boolean contains(java.lang.Object o) {
934                 throw new RuntimeException("Stub!");
935             }
936 
containsAll(java.util.Collection<?> c)937             public boolean containsAll(java.util.Collection<?> c) {
938                 throw new RuntimeException("Stub!");
939             }
940 
remove(java.lang.Object o)941             public boolean remove(java.lang.Object o) {
942                 throw new RuntimeException("Stub!");
943             }
944 
removeAll(java.util.Collection<?> c)945             public boolean removeAll(java.util.Collection<?> c) {
946                 throw new RuntimeException("Stub!");
947             }
948 
retainAll(java.util.Collection<?> c)949             public boolean retainAll(java.util.Collection<?> c) {
950                 throw new RuntimeException("Stub!");
951             }
952 
batchRemove(java.util.Collection<?> c, boolean complement)953             private boolean batchRemove(java.util.Collection<?> c, boolean complement) {
954                 throw new RuntimeException("Stub!");
955             }
956 
equals(java.lang.Object o)957             public boolean equals(java.lang.Object o) {
958                 throw new RuntimeException("Stub!");
959             }
960 
961             static <K, V, T>
962                     java.util.Collections.CheckedMap.CheckedEntrySet.CheckedEntry<K, V, T>
checkedEntry( java.util.Map.Entry<K, V> e, java.lang.Class<T> valueType)963                             checkedEntry(
964                                     java.util.Map.Entry<K, V> e, java.lang.Class<T> valueType) {
965                 throw new RuntimeException("Stub!");
966             }
967 
968             private final java.util.Set<java.util.Map.Entry<K, V>> s;
969 
970             {
971                 s = null;
972             }
973 
974             private final java.lang.Class<V> valueType;
975 
976             {
977                 valueType = null;
978             }
979 
980             @SuppressWarnings({"unchecked", "deprecation", "all"})
981             private static class CheckedEntry<K, V, T> implements java.util.Map.Entry<K, V> {
982 
CheckedEntry(java.util.Map.Entry<K, V> e, java.lang.Class<T> valueType)983                 CheckedEntry(java.util.Map.Entry<K, V> e, java.lang.Class<T> valueType) {
984                     throw new RuntimeException("Stub!");
985                 }
986 
getKey()987                 public K getKey() {
988                     throw new RuntimeException("Stub!");
989                 }
990 
getValue()991                 public V getValue() {
992                     throw new RuntimeException("Stub!");
993                 }
994 
hashCode()995                 public int hashCode() {
996                     throw new RuntimeException("Stub!");
997                 }
998 
toString()999                 public java.lang.String toString() {
1000                     throw new RuntimeException("Stub!");
1001                 }
1002 
setValue(V value)1003                 public V setValue(V value) {
1004                     throw new RuntimeException("Stub!");
1005                 }
1006 
badValueMsg(java.lang.Object value)1007                 private java.lang.String badValueMsg(java.lang.Object value) {
1008                     throw new RuntimeException("Stub!");
1009                 }
1010 
equals(java.lang.Object o)1011                 public boolean equals(java.lang.Object o) {
1012                     throw new RuntimeException("Stub!");
1013                 }
1014 
1015                 private final java.util.Map.Entry<K, V> e;
1016 
1017                 {
1018                     e = null;
1019                 }
1020 
1021                 private final java.lang.Class<T> valueType;
1022 
1023                 {
1024                     valueType = null;
1025                 }
1026             }
1027         }
1028     }
1029 
1030     @SuppressWarnings({"unchecked", "deprecation", "all"})
1031     static class CheckedNavigableMap<K, V> extends java.util.Collections.CheckedSortedMap<K, V>
1032             implements java.util.NavigableMap<K, V>, java.io.Serializable {
1033 
CheckedNavigableMap( java.util.NavigableMap<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType)1034         CheckedNavigableMap(
1035                 java.util.NavigableMap<K, V> m,
1036                 java.lang.Class<K> keyType,
1037                 java.lang.Class<V> valueType) {
1038             super(null, null, null);
1039             throw new RuntimeException("Stub!");
1040         }
1041 
comparator()1042         public java.util.Comparator<? super K> comparator() {
1043             throw new RuntimeException("Stub!");
1044         }
1045 
firstKey()1046         public K firstKey() {
1047             throw new RuntimeException("Stub!");
1048         }
1049 
lastKey()1050         public K lastKey() {
1051             throw new RuntimeException("Stub!");
1052         }
1053 
lowerEntry(K key)1054         public java.util.Map.Entry<K, V> lowerEntry(K key) {
1055             throw new RuntimeException("Stub!");
1056         }
1057 
lowerKey(K key)1058         public K lowerKey(K key) {
1059             throw new RuntimeException("Stub!");
1060         }
1061 
floorEntry(K key)1062         public java.util.Map.Entry<K, V> floorEntry(K key) {
1063             throw new RuntimeException("Stub!");
1064         }
1065 
floorKey(K key)1066         public K floorKey(K key) {
1067             throw new RuntimeException("Stub!");
1068         }
1069 
ceilingEntry(K key)1070         public java.util.Map.Entry<K, V> ceilingEntry(K key) {
1071             throw new RuntimeException("Stub!");
1072         }
1073 
ceilingKey(K key)1074         public K ceilingKey(K key) {
1075             throw new RuntimeException("Stub!");
1076         }
1077 
higherEntry(K key)1078         public java.util.Map.Entry<K, V> higherEntry(K key) {
1079             throw new RuntimeException("Stub!");
1080         }
1081 
higherKey(K key)1082         public K higherKey(K key) {
1083             throw new RuntimeException("Stub!");
1084         }
1085 
firstEntry()1086         public java.util.Map.Entry<K, V> firstEntry() {
1087             throw new RuntimeException("Stub!");
1088         }
1089 
lastEntry()1090         public java.util.Map.Entry<K, V> lastEntry() {
1091             throw new RuntimeException("Stub!");
1092         }
1093 
pollFirstEntry()1094         public java.util.Map.Entry<K, V> pollFirstEntry() {
1095             throw new RuntimeException("Stub!");
1096         }
1097 
pollLastEntry()1098         public java.util.Map.Entry<K, V> pollLastEntry() {
1099             throw new RuntimeException("Stub!");
1100         }
1101 
descendingMap()1102         public java.util.NavigableMap<K, V> descendingMap() {
1103             throw new RuntimeException("Stub!");
1104         }
1105 
keySet()1106         public java.util.NavigableSet<K> keySet() {
1107             throw new RuntimeException("Stub!");
1108         }
1109 
navigableKeySet()1110         public java.util.NavigableSet<K> navigableKeySet() {
1111             throw new RuntimeException("Stub!");
1112         }
1113 
descendingKeySet()1114         public java.util.NavigableSet<K> descendingKeySet() {
1115             throw new RuntimeException("Stub!");
1116         }
1117 
subMap(K fromKey, K toKey)1118         public java.util.NavigableMap<K, V> subMap(K fromKey, K toKey) {
1119             throw new RuntimeException("Stub!");
1120         }
1121 
headMap(K toKey)1122         public java.util.NavigableMap<K, V> headMap(K toKey) {
1123             throw new RuntimeException("Stub!");
1124         }
1125 
tailMap(K fromKey)1126         public java.util.NavigableMap<K, V> tailMap(K fromKey) {
1127             throw new RuntimeException("Stub!");
1128         }
1129 
subMap( K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)1130         public java.util.NavigableMap<K, V> subMap(
1131                 K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
1132             throw new RuntimeException("Stub!");
1133         }
1134 
headMap(K toKey, boolean inclusive)1135         public java.util.NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
1136             throw new RuntimeException("Stub!");
1137         }
1138 
tailMap(K fromKey, boolean inclusive)1139         public java.util.NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
1140             throw new RuntimeException("Stub!");
1141         }
1142 
1143         private final java.util.NavigableMap<K, V> nm;
1144 
1145         {
1146             nm = null;
1147         }
1148 
1149         private static final long serialVersionUID = -4852462692372534096L; // 0xbca896e4074cacb0L
1150     }
1151 
1152     @SuppressWarnings({"unchecked", "deprecation", "all"})
1153     static class CheckedNavigableSet<E> extends java.util.Collections.CheckedSortedSet<E>
1154             implements java.util.NavigableSet<E>, java.io.Serializable {
1155 
CheckedNavigableSet(java.util.NavigableSet<E> s, java.lang.Class<E> type)1156         CheckedNavigableSet(java.util.NavigableSet<E> s, java.lang.Class<E> type) {
1157             super(null, null);
1158             throw new RuntimeException("Stub!");
1159         }
1160 
lower(E e)1161         public E lower(E e) {
1162             throw new RuntimeException("Stub!");
1163         }
1164 
floor(E e)1165         public E floor(E e) {
1166             throw new RuntimeException("Stub!");
1167         }
1168 
ceiling(E e)1169         public E ceiling(E e) {
1170             throw new RuntimeException("Stub!");
1171         }
1172 
higher(E e)1173         public E higher(E e) {
1174             throw new RuntimeException("Stub!");
1175         }
1176 
pollFirst()1177         public E pollFirst() {
1178             throw new RuntimeException("Stub!");
1179         }
1180 
pollLast()1181         public E pollLast() {
1182             throw new RuntimeException("Stub!");
1183         }
1184 
descendingSet()1185         public java.util.NavigableSet<E> descendingSet() {
1186             throw new RuntimeException("Stub!");
1187         }
1188 
descendingIterator()1189         public java.util.Iterator<E> descendingIterator() {
1190             throw new RuntimeException("Stub!");
1191         }
1192 
subSet(E fromElement, E toElement)1193         public java.util.NavigableSet<E> subSet(E fromElement, E toElement) {
1194             throw new RuntimeException("Stub!");
1195         }
1196 
headSet(E toElement)1197         public java.util.NavigableSet<E> headSet(E toElement) {
1198             throw new RuntimeException("Stub!");
1199         }
1200 
tailSet(E fromElement)1201         public java.util.NavigableSet<E> tailSet(E fromElement) {
1202             throw new RuntimeException("Stub!");
1203         }
1204 
subSet( E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)1205         public java.util.NavigableSet<E> subSet(
1206                 E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
1207             throw new RuntimeException("Stub!");
1208         }
1209 
headSet(E toElement, boolean inclusive)1210         public java.util.NavigableSet<E> headSet(E toElement, boolean inclusive) {
1211             throw new RuntimeException("Stub!");
1212         }
1213 
tailSet(E fromElement, boolean inclusive)1214         public java.util.NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
1215             throw new RuntimeException("Stub!");
1216         }
1217 
1218         private final java.util.NavigableSet<E> ns;
1219 
1220         {
1221             ns = null;
1222         }
1223 
1224         private static final long serialVersionUID = -5429120189805438922L; // 0xb4a7e3f3bbbed836L
1225     }
1226 
1227     @SuppressWarnings({"unchecked", "deprecation", "all"})
1228     static class CheckedQueue<E> extends java.util.Collections.CheckedCollection<E>
1229             implements java.util.Queue<E>, java.io.Serializable {
1230 
CheckedQueue(java.util.Queue<E> queue, java.lang.Class<E> elementType)1231         CheckedQueue(java.util.Queue<E> queue, java.lang.Class<E> elementType) {
1232             super(null, null);
1233             throw new RuntimeException("Stub!");
1234         }
1235 
element()1236         public E element() {
1237             throw new RuntimeException("Stub!");
1238         }
1239 
equals(java.lang.Object o)1240         public boolean equals(java.lang.Object o) {
1241             throw new RuntimeException("Stub!");
1242         }
1243 
hashCode()1244         public int hashCode() {
1245             throw new RuntimeException("Stub!");
1246         }
1247 
peek()1248         public E peek() {
1249             throw new RuntimeException("Stub!");
1250         }
1251 
poll()1252         public E poll() {
1253             throw new RuntimeException("Stub!");
1254         }
1255 
remove()1256         public E remove() {
1257             throw new RuntimeException("Stub!");
1258         }
1259 
offer(E e)1260         public boolean offer(E e) {
1261             throw new RuntimeException("Stub!");
1262         }
1263 
1264         final java.util.Queue<E> queue;
1265 
1266         {
1267             queue = null;
1268         }
1269 
1270         private static final long serialVersionUID = 1433151992604707767L; // 0x13e39424e458cbb7L
1271     }
1272 
1273     @SuppressWarnings({"unchecked", "deprecation", "all"})
1274     static class CheckedRandomAccessList<E> extends java.util.Collections.CheckedList<E>
1275             implements java.util.RandomAccess {
1276 
CheckedRandomAccessList(java.util.List<E> list, java.lang.Class<E> type)1277         CheckedRandomAccessList(java.util.List<E> list, java.lang.Class<E> type) {
1278             super(null, null);
1279             throw new RuntimeException("Stub!");
1280         }
1281 
subList(int fromIndex, int toIndex)1282         public java.util.List<E> subList(int fromIndex, int toIndex) {
1283             throw new RuntimeException("Stub!");
1284         }
1285 
1286         private static final long serialVersionUID = 1638200125423088369L; // 0x16bc0e55a2d7f2f1L
1287     }
1288 
1289     @SuppressWarnings({"unchecked", "deprecation", "all"})
1290     static class CheckedSet<E> extends java.util.Collections.CheckedCollection<E>
1291             implements java.util.Set<E>, java.io.Serializable {
1292 
CheckedSet(java.util.Set<E> s, java.lang.Class<E> elementType)1293         CheckedSet(java.util.Set<E> s, java.lang.Class<E> elementType) {
1294             super(null, null);
1295             throw new RuntimeException("Stub!");
1296         }
1297 
equals(java.lang.Object o)1298         public boolean equals(java.lang.Object o) {
1299             throw new RuntimeException("Stub!");
1300         }
1301 
hashCode()1302         public int hashCode() {
1303             throw new RuntimeException("Stub!");
1304         }
1305 
1306         private static final long serialVersionUID = 4694047833775013803L; // 0x41249ba27ad9ffabL
1307     }
1308 
1309     @SuppressWarnings({"unchecked", "deprecation", "all"})
1310     static class CheckedSortedMap<K, V> extends java.util.Collections.CheckedMap<K, V>
1311             implements java.util.SortedMap<K, V>, java.io.Serializable {
1312 
CheckedSortedMap( java.util.SortedMap<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType)1313         CheckedSortedMap(
1314                 java.util.SortedMap<K, V> m,
1315                 java.lang.Class<K> keyType,
1316                 java.lang.Class<V> valueType) {
1317             super(null, null, null);
1318             throw new RuntimeException("Stub!");
1319         }
1320 
comparator()1321         public java.util.Comparator<? super K> comparator() {
1322             throw new RuntimeException("Stub!");
1323         }
1324 
firstKey()1325         public K firstKey() {
1326             throw new RuntimeException("Stub!");
1327         }
1328 
lastKey()1329         public K lastKey() {
1330             throw new RuntimeException("Stub!");
1331         }
1332 
subMap(K fromKey, K toKey)1333         public java.util.SortedMap<K, V> subMap(K fromKey, K toKey) {
1334             throw new RuntimeException("Stub!");
1335         }
1336 
headMap(K toKey)1337         public java.util.SortedMap<K, V> headMap(K toKey) {
1338             throw new RuntimeException("Stub!");
1339         }
1340 
tailMap(K fromKey)1341         public java.util.SortedMap<K, V> tailMap(K fromKey) {
1342             throw new RuntimeException("Stub!");
1343         }
1344 
1345         private static final long serialVersionUID = 1599671320688067438L; // 0x16332c973afe036eL
1346 
1347         private final java.util.SortedMap<K, V> sm;
1348 
1349         {
1350             sm = null;
1351         }
1352     }
1353 
1354     @SuppressWarnings({"unchecked", "deprecation", "all"})
1355     static class CheckedSortedSet<E> extends java.util.Collections.CheckedSet<E>
1356             implements java.util.SortedSet<E>, java.io.Serializable {
1357 
CheckedSortedSet(java.util.SortedSet<E> s, java.lang.Class<E> type)1358         CheckedSortedSet(java.util.SortedSet<E> s, java.lang.Class<E> type) {
1359             super(null, null);
1360             throw new RuntimeException("Stub!");
1361         }
1362 
comparator()1363         public java.util.Comparator<? super E> comparator() {
1364             throw new RuntimeException("Stub!");
1365         }
1366 
first()1367         public E first() {
1368             throw new RuntimeException("Stub!");
1369         }
1370 
last()1371         public E last() {
1372             throw new RuntimeException("Stub!");
1373         }
1374 
subSet(E fromElement, E toElement)1375         public java.util.SortedSet<E> subSet(E fromElement, E toElement) {
1376             throw new RuntimeException("Stub!");
1377         }
1378 
headSet(E toElement)1379         public java.util.SortedSet<E> headSet(E toElement) {
1380             throw new RuntimeException("Stub!");
1381         }
1382 
tailSet(E fromElement)1383         public java.util.SortedSet<E> tailSet(E fromElement) {
1384             throw new RuntimeException("Stub!");
1385         }
1386 
1387         private static final long serialVersionUID = 1599911165492914959L; // 0x163406ba7362eb0fL
1388 
1389         private final java.util.SortedSet<E> ss;
1390 
1391         {
1392             ss = null;
1393         }
1394     }
1395 
1396     @SuppressWarnings({"unchecked", "deprecation", "all"})
1397     private static class CopiesList<E> extends java.util.AbstractList<E>
1398             implements java.util.RandomAccess, java.io.Serializable {
1399 
CopiesList(int n, E e)1400         CopiesList(int n, E e) {
1401             throw new RuntimeException("Stub!");
1402         }
1403 
size()1404         public int size() {
1405             throw new RuntimeException("Stub!");
1406         }
1407 
contains(java.lang.Object obj)1408         public boolean contains(java.lang.Object obj) {
1409             throw new RuntimeException("Stub!");
1410         }
1411 
indexOf(java.lang.Object o)1412         public int indexOf(java.lang.Object o) {
1413             throw new RuntimeException("Stub!");
1414         }
1415 
lastIndexOf(java.lang.Object o)1416         public int lastIndexOf(java.lang.Object o) {
1417             throw new RuntimeException("Stub!");
1418         }
1419 
get(int index)1420         public E get(int index) {
1421             throw new RuntimeException("Stub!");
1422         }
1423 
toArray()1424         public java.lang.Object[] toArray() {
1425             throw new RuntimeException("Stub!");
1426         }
1427 
toArray(T[] a)1428         public <T> T[] toArray(T[] a) {
1429             throw new RuntimeException("Stub!");
1430         }
1431 
subList(int fromIndex, int toIndex)1432         public java.util.List<E> subList(int fromIndex, int toIndex) {
1433             throw new RuntimeException("Stub!");
1434         }
1435 
stream()1436         public java.util.stream.Stream<E> stream() {
1437             throw new RuntimeException("Stub!");
1438         }
1439 
parallelStream()1440         public java.util.stream.Stream<E> parallelStream() {
1441             throw new RuntimeException("Stub!");
1442         }
1443 
spliterator()1444         public java.util.Spliterator<E> spliterator() {
1445             throw new RuntimeException("Stub!");
1446         }
1447 
1448         final E element;
1449 
1450         {
1451             element = null;
1452         }
1453 
1454         final int n;
1455 
1456         {
1457             n = 0;
1458         }
1459 
1460         private static final long serialVersionUID = 2739099268398711800L; // 0x26033c45b17003f8L
1461     }
1462 
1463     @SuppressWarnings({"unchecked", "deprecation", "all"})
1464     private static class EmptyEnumeration<E> implements java.util.Enumeration<E> {
1465 
EmptyEnumeration()1466         private EmptyEnumeration() {
1467             throw new RuntimeException("Stub!");
1468         }
1469 
hasMoreElements()1470         public boolean hasMoreElements() {
1471             throw new RuntimeException("Stub!");
1472         }
1473 
nextElement()1474         public E nextElement() {
1475             throw new RuntimeException("Stub!");
1476         }
1477 
1478         static final java.util.Collections.EmptyEnumeration<java.lang.Object> EMPTY_ENUMERATION;
1479 
1480         static {
1481             EMPTY_ENUMERATION = null;
1482         }
1483     }
1484 
1485     @SuppressWarnings({"unchecked", "deprecation", "all"})
1486     private static class EmptyIterator<E> implements java.util.Iterator<E> {
1487 
EmptyIterator()1488         private EmptyIterator() {
1489             throw new RuntimeException("Stub!");
1490         }
1491 
hasNext()1492         public boolean hasNext() {
1493             throw new RuntimeException("Stub!");
1494         }
1495 
next()1496         public E next() {
1497             throw new RuntimeException("Stub!");
1498         }
1499 
remove()1500         public void remove() {
1501             throw new RuntimeException("Stub!");
1502         }
1503 
forEachRemaining(java.util.function.Consumer<? super E> action)1504         public void forEachRemaining(java.util.function.Consumer<? super E> action) {
1505             throw new RuntimeException("Stub!");
1506         }
1507 
1508         static final java.util.Collections.EmptyIterator<java.lang.Object> EMPTY_ITERATOR;
1509 
1510         static {
1511             EMPTY_ITERATOR = null;
1512         }
1513     }
1514 
1515     @SuppressWarnings({"unchecked", "deprecation", "all"})
1516     private static class EmptyList<E> extends java.util.AbstractList<E>
1517             implements java.util.RandomAccess, java.io.Serializable {
1518 
1519         @UnsupportedAppUsage
EmptyList()1520         private EmptyList() {
1521             throw new RuntimeException("Stub!");
1522         }
1523 
iterator()1524         public java.util.Iterator<E> iterator() {
1525             throw new RuntimeException("Stub!");
1526         }
1527 
listIterator()1528         public java.util.ListIterator<E> listIterator() {
1529             throw new RuntimeException("Stub!");
1530         }
1531 
size()1532         public int size() {
1533             throw new RuntimeException("Stub!");
1534         }
1535 
isEmpty()1536         public boolean isEmpty() {
1537             throw new RuntimeException("Stub!");
1538         }
1539 
contains(java.lang.Object obj)1540         public boolean contains(java.lang.Object obj) {
1541             throw new RuntimeException("Stub!");
1542         }
1543 
containsAll(java.util.Collection<?> c)1544         public boolean containsAll(java.util.Collection<?> c) {
1545             throw new RuntimeException("Stub!");
1546         }
1547 
toArray()1548         public java.lang.Object[] toArray() {
1549             throw new RuntimeException("Stub!");
1550         }
1551 
toArray(T[] a)1552         public <T> T[] toArray(T[] a) {
1553             throw new RuntimeException("Stub!");
1554         }
1555 
get(int index)1556         public E get(int index) {
1557             throw new RuntimeException("Stub!");
1558         }
1559 
equals(java.lang.Object o)1560         public boolean equals(java.lang.Object o) {
1561             throw new RuntimeException("Stub!");
1562         }
1563 
hashCode()1564         public int hashCode() {
1565             throw new RuntimeException("Stub!");
1566         }
1567 
removeIf(java.util.function.Predicate<? super E> filter)1568         public boolean removeIf(java.util.function.Predicate<? super E> filter) {
1569             throw new RuntimeException("Stub!");
1570         }
1571 
replaceAll(java.util.function.UnaryOperator<E> operator)1572         public void replaceAll(java.util.function.UnaryOperator<E> operator) {
1573             throw new RuntimeException("Stub!");
1574         }
1575 
sort(java.util.Comparator<? super E> c)1576         public void sort(java.util.Comparator<? super E> c) {
1577             throw new RuntimeException("Stub!");
1578         }
1579 
forEach(java.util.function.Consumer<? super E> action)1580         public void forEach(java.util.function.Consumer<? super E> action) {
1581             throw new RuntimeException("Stub!");
1582         }
1583 
spliterator()1584         public java.util.Spliterator<E> spliterator() {
1585             throw new RuntimeException("Stub!");
1586         }
1587 
readResolve()1588         private java.lang.Object readResolve() {
1589             throw new RuntimeException("Stub!");
1590         }
1591 
1592         private static final long serialVersionUID = 8842843931221139166L; // 0x7ab817b43ca79edeL
1593     }
1594 
1595     @SuppressWarnings({"unchecked", "deprecation", "all"})
1596     private static class EmptyListIterator<E> extends java.util.Collections.EmptyIterator<E>
1597             implements java.util.ListIterator<E> {
1598 
EmptyListIterator()1599         private EmptyListIterator() {
1600             throw new RuntimeException("Stub!");
1601         }
1602 
hasPrevious()1603         public boolean hasPrevious() {
1604             throw new RuntimeException("Stub!");
1605         }
1606 
previous()1607         public E previous() {
1608             throw new RuntimeException("Stub!");
1609         }
1610 
nextIndex()1611         public int nextIndex() {
1612             throw new RuntimeException("Stub!");
1613         }
1614 
previousIndex()1615         public int previousIndex() {
1616             throw new RuntimeException("Stub!");
1617         }
1618 
set(E e)1619         public void set(E e) {
1620             throw new RuntimeException("Stub!");
1621         }
1622 
add(E e)1623         public void add(E e) {
1624             throw new RuntimeException("Stub!");
1625         }
1626 
1627         static final java.util.Collections.EmptyListIterator<java.lang.Object> EMPTY_ITERATOR;
1628 
1629         static {
1630             EMPTY_ITERATOR = null;
1631         }
1632     }
1633 
1634     @SuppressWarnings({"unchecked", "deprecation", "all"})
1635     private static class EmptyMap<K, V> extends java.util.AbstractMap<K, V>
1636             implements java.io.Serializable {
1637 
1638         @UnsupportedAppUsage
EmptyMap()1639         private EmptyMap() {
1640             throw new RuntimeException("Stub!");
1641         }
1642 
size()1643         public int size() {
1644             throw new RuntimeException("Stub!");
1645         }
1646 
isEmpty()1647         public boolean isEmpty() {
1648             throw new RuntimeException("Stub!");
1649         }
1650 
containsKey(java.lang.Object key)1651         public boolean containsKey(java.lang.Object key) {
1652             throw new RuntimeException("Stub!");
1653         }
1654 
containsValue(java.lang.Object value)1655         public boolean containsValue(java.lang.Object value) {
1656             throw new RuntimeException("Stub!");
1657         }
1658 
get(java.lang.Object key)1659         public V get(java.lang.Object key) {
1660             throw new RuntimeException("Stub!");
1661         }
1662 
keySet()1663         public java.util.Set<K> keySet() {
1664             throw new RuntimeException("Stub!");
1665         }
1666 
values()1667         public java.util.Collection<V> values() {
1668             throw new RuntimeException("Stub!");
1669         }
1670 
entrySet()1671         public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
1672             throw new RuntimeException("Stub!");
1673         }
1674 
equals(java.lang.Object o)1675         public boolean equals(java.lang.Object o) {
1676             throw new RuntimeException("Stub!");
1677         }
1678 
hashCode()1679         public int hashCode() {
1680             throw new RuntimeException("Stub!");
1681         }
1682 
getOrDefault(java.lang.Object k, V defaultValue)1683         public V getOrDefault(java.lang.Object k, V defaultValue) {
1684             throw new RuntimeException("Stub!");
1685         }
1686 
forEach(java.util.function.BiConsumer<? super K, ? super V> action)1687         public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
1688             throw new RuntimeException("Stub!");
1689         }
1690 
replaceAll( java.util.function.BiFunction<? super K, ? super V, ? extends V> function)1691         public void replaceAll(
1692                 java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
1693             throw new RuntimeException("Stub!");
1694         }
1695 
putIfAbsent(K key, V value)1696         public V putIfAbsent(K key, V value) {
1697             throw new RuntimeException("Stub!");
1698         }
1699 
remove(java.lang.Object key, java.lang.Object value)1700         public boolean remove(java.lang.Object key, java.lang.Object value) {
1701             throw new RuntimeException("Stub!");
1702         }
1703 
replace(K key, V oldValue, V newValue)1704         public boolean replace(K key, V oldValue, V newValue) {
1705             throw new RuntimeException("Stub!");
1706         }
1707 
replace(K key, V value)1708         public V replace(K key, V value) {
1709             throw new RuntimeException("Stub!");
1710         }
1711 
computeIfAbsent( K key, java.util.function.Function<? super K, ? extends V> mappingFunction)1712         public V computeIfAbsent(
1713                 K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
1714             throw new RuntimeException("Stub!");
1715         }
1716 
computeIfPresent( K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction)1717         public V computeIfPresent(
1718                 K key,
1719                 java.util.function.BiFunction<? super K, ? super V, ? extends V>
1720                         remappingFunction) {
1721             throw new RuntimeException("Stub!");
1722         }
1723 
compute( K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction)1724         public V compute(
1725                 K key,
1726                 java.util.function.BiFunction<? super K, ? super V, ? extends V>
1727                         remappingFunction) {
1728             throw new RuntimeException("Stub!");
1729         }
1730 
merge( K key, V value, java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction)1731         public V merge(
1732                 K key,
1733                 V value,
1734                 java.util.function.BiFunction<? super V, ? super V, ? extends V>
1735                         remappingFunction) {
1736             throw new RuntimeException("Stub!");
1737         }
1738 
readResolve()1739         private java.lang.Object readResolve() {
1740             throw new RuntimeException("Stub!");
1741         }
1742 
1743         private static final long serialVersionUID = 6428348081105594320L; // 0x593614855adce7d0L
1744     }
1745 
1746     @SuppressWarnings({"unchecked", "deprecation", "all"})
1747     private static class EmptySet<E> extends java.util.AbstractSet<E>
1748             implements java.io.Serializable {
1749 
EmptySet()1750         private EmptySet() {
1751             throw new RuntimeException("Stub!");
1752         }
1753 
iterator()1754         public java.util.Iterator<E> iterator() {
1755             throw new RuntimeException("Stub!");
1756         }
1757 
size()1758         public int size() {
1759             throw new RuntimeException("Stub!");
1760         }
1761 
isEmpty()1762         public boolean isEmpty() {
1763             throw new RuntimeException("Stub!");
1764         }
1765 
contains(java.lang.Object obj)1766         public boolean contains(java.lang.Object obj) {
1767             throw new RuntimeException("Stub!");
1768         }
1769 
containsAll(java.util.Collection<?> c)1770         public boolean containsAll(java.util.Collection<?> c) {
1771             throw new RuntimeException("Stub!");
1772         }
1773 
toArray()1774         public java.lang.Object[] toArray() {
1775             throw new RuntimeException("Stub!");
1776         }
1777 
toArray(T[] a)1778         public <T> T[] toArray(T[] a) {
1779             throw new RuntimeException("Stub!");
1780         }
1781 
forEach(java.util.function.Consumer<? super E> action)1782         public void forEach(java.util.function.Consumer<? super E> action) {
1783             throw new RuntimeException("Stub!");
1784         }
1785 
removeIf(java.util.function.Predicate<? super E> filter)1786         public boolean removeIf(java.util.function.Predicate<? super E> filter) {
1787             throw new RuntimeException("Stub!");
1788         }
1789 
spliterator()1790         public java.util.Spliterator<E> spliterator() {
1791             throw new RuntimeException("Stub!");
1792         }
1793 
readResolve()1794         private java.lang.Object readResolve() {
1795             throw new RuntimeException("Stub!");
1796         }
1797 
1798         private static final long serialVersionUID = 1582296315990362920L; // 0x15f5721db403cb28L
1799     }
1800 
1801     @SuppressWarnings({"unchecked", "deprecation", "all"})
1802     private static class ReverseComparator
1803             implements java.util.Comparator<java.lang.Comparable<java.lang.Object>>,
1804                     java.io.Serializable {
1805 
ReverseComparator()1806         private ReverseComparator() {
1807             throw new RuntimeException("Stub!");
1808         }
1809 
compare( java.lang.Comparable<java.lang.Object> c1, java.lang.Comparable<java.lang.Object> c2)1810         public int compare(
1811                 java.lang.Comparable<java.lang.Object> c1,
1812                 java.lang.Comparable<java.lang.Object> c2) {
1813             throw new RuntimeException("Stub!");
1814         }
1815 
readResolve()1816         private java.lang.Object readResolve() {
1817             throw new RuntimeException("Stub!");
1818         }
1819 
reversed()1820         public java.util.Comparator<java.lang.Comparable<java.lang.Object>> reversed() {
1821             throw new RuntimeException("Stub!");
1822         }
1823 
1824         static final java.util.Collections.ReverseComparator REVERSE_ORDER;
1825 
1826         static {
1827             REVERSE_ORDER = null;
1828         }
1829 
1830         private static final long serialVersionUID = 7207038068494060240L; // 0x64048af0534e4ad0L
1831     }
1832 
1833     @SuppressWarnings({"unchecked", "deprecation", "all"})
1834     private static class ReverseComparator2<T>
1835             implements java.util.Comparator<T>, java.io.Serializable {
1836 
ReverseComparator2(java.util.Comparator<T> cmp)1837         ReverseComparator2(java.util.Comparator<T> cmp) {
1838             throw new RuntimeException("Stub!");
1839         }
1840 
compare(T t1, T t2)1841         public int compare(T t1, T t2) {
1842             throw new RuntimeException("Stub!");
1843         }
1844 
equals(java.lang.Object o)1845         public boolean equals(java.lang.Object o) {
1846             throw new RuntimeException("Stub!");
1847         }
1848 
hashCode()1849         public int hashCode() {
1850             throw new RuntimeException("Stub!");
1851         }
1852 
reversed()1853         public java.util.Comparator<T> reversed() {
1854             throw new RuntimeException("Stub!");
1855         }
1856 
1857         final java.util.Comparator<T> cmp;
1858 
1859         {
1860             cmp = null;
1861         }
1862 
1863         private static final long serialVersionUID = 4374092139857L; // 0x3fa6c354d51L
1864     }
1865 
1866     @SuppressWarnings({"unchecked", "deprecation", "all"})
1867     private static class SetFromMap<E> extends java.util.AbstractSet<E>
1868             implements java.util.Set<E>, java.io.Serializable {
1869 
SetFromMap(java.util.Map<E, java.lang.Boolean> map)1870         SetFromMap(java.util.Map<E, java.lang.Boolean> map) {
1871             throw new RuntimeException("Stub!");
1872         }
1873 
clear()1874         public void clear() {
1875             throw new RuntimeException("Stub!");
1876         }
1877 
size()1878         public int size() {
1879             throw new RuntimeException("Stub!");
1880         }
1881 
isEmpty()1882         public boolean isEmpty() {
1883             throw new RuntimeException("Stub!");
1884         }
1885 
contains(java.lang.Object o)1886         public boolean contains(java.lang.Object o) {
1887             throw new RuntimeException("Stub!");
1888         }
1889 
remove(java.lang.Object o)1890         public boolean remove(java.lang.Object o) {
1891             throw new RuntimeException("Stub!");
1892         }
1893 
add(E e)1894         public boolean add(E e) {
1895             throw new RuntimeException("Stub!");
1896         }
1897 
iterator()1898         public java.util.Iterator<E> iterator() {
1899             throw new RuntimeException("Stub!");
1900         }
1901 
toArray()1902         public java.lang.Object[] toArray() {
1903             throw new RuntimeException("Stub!");
1904         }
1905 
toArray(T[] a)1906         public <T> T[] toArray(T[] a) {
1907             throw new RuntimeException("Stub!");
1908         }
1909 
toString()1910         public java.lang.String toString() {
1911             throw new RuntimeException("Stub!");
1912         }
1913 
hashCode()1914         public int hashCode() {
1915             throw new RuntimeException("Stub!");
1916         }
1917 
equals(java.lang.Object o)1918         public boolean equals(java.lang.Object o) {
1919             throw new RuntimeException("Stub!");
1920         }
1921 
containsAll(java.util.Collection<?> c)1922         public boolean containsAll(java.util.Collection<?> c) {
1923             throw new RuntimeException("Stub!");
1924         }
1925 
removeAll(java.util.Collection<?> c)1926         public boolean removeAll(java.util.Collection<?> c) {
1927             throw new RuntimeException("Stub!");
1928         }
1929 
retainAll(java.util.Collection<?> c)1930         public boolean retainAll(java.util.Collection<?> c) {
1931             throw new RuntimeException("Stub!");
1932         }
1933 
forEach(java.util.function.Consumer<? super E> action)1934         public void forEach(java.util.function.Consumer<? super E> action) {
1935             throw new RuntimeException("Stub!");
1936         }
1937 
removeIf(java.util.function.Predicate<? super E> filter)1938         public boolean removeIf(java.util.function.Predicate<? super E> filter) {
1939             throw new RuntimeException("Stub!");
1940         }
1941 
spliterator()1942         public java.util.Spliterator<E> spliterator() {
1943             throw new RuntimeException("Stub!");
1944         }
1945 
stream()1946         public java.util.stream.Stream<E> stream() {
1947             throw new RuntimeException("Stub!");
1948         }
1949 
parallelStream()1950         public java.util.stream.Stream<E> parallelStream() {
1951             throw new RuntimeException("Stub!");
1952         }
1953 
readObject(java.io.ObjectInputStream stream)1954         private void readObject(java.io.ObjectInputStream stream)
1955                 throws java.lang.ClassNotFoundException, java.io.IOException {
1956             throw new RuntimeException("Stub!");
1957         }
1958 
1959         private final java.util.Map<E, java.lang.Boolean> m;
1960 
1961         {
1962             m = null;
1963         }
1964 
1965         private transient java.util.Set<E> s;
1966 
1967         private static final long serialVersionUID = 2454657854757543876L; // 0x2210b25045f21fc4L
1968     }
1969 
1970     @SuppressWarnings({"unchecked", "deprecation", "all"})
1971     private static class SingletonList<E> extends java.util.AbstractList<E>
1972             implements java.util.RandomAccess, java.io.Serializable {
1973 
SingletonList(E obj)1974         SingletonList(E obj) {
1975             throw new RuntimeException("Stub!");
1976         }
1977 
iterator()1978         public java.util.Iterator<E> iterator() {
1979             throw new RuntimeException("Stub!");
1980         }
1981 
size()1982         public int size() {
1983             throw new RuntimeException("Stub!");
1984         }
1985 
contains(java.lang.Object obj)1986         public boolean contains(java.lang.Object obj) {
1987             throw new RuntimeException("Stub!");
1988         }
1989 
get(int index)1990         public E get(int index) {
1991             throw new RuntimeException("Stub!");
1992         }
1993 
forEach(java.util.function.Consumer<? super E> action)1994         public void forEach(java.util.function.Consumer<? super E> action) {
1995             throw new RuntimeException("Stub!");
1996         }
1997 
removeIf(java.util.function.Predicate<? super E> filter)1998         public boolean removeIf(java.util.function.Predicate<? super E> filter) {
1999             throw new RuntimeException("Stub!");
2000         }
2001 
replaceAll(java.util.function.UnaryOperator<E> operator)2002         public void replaceAll(java.util.function.UnaryOperator<E> operator) {
2003             throw new RuntimeException("Stub!");
2004         }
2005 
sort(java.util.Comparator<? super E> c)2006         public void sort(java.util.Comparator<? super E> c) {
2007             throw new RuntimeException("Stub!");
2008         }
2009 
spliterator()2010         public java.util.Spliterator<E> spliterator() {
2011             throw new RuntimeException("Stub!");
2012         }
2013 
2014         private final E element;
2015 
2016         {
2017             element = null;
2018         }
2019 
2020         private static final long serialVersionUID = 3093736618740652951L; // 0x2aef29103ca79b97L
2021     }
2022 
2023     @SuppressWarnings({"unchecked", "deprecation", "all"})
2024     private static class SingletonMap<K, V> extends java.util.AbstractMap<K, V>
2025             implements java.io.Serializable {
2026 
SingletonMap(K key, V value)2027         SingletonMap(K key, V value) {
2028             throw new RuntimeException("Stub!");
2029         }
2030 
size()2031         public int size() {
2032             throw new RuntimeException("Stub!");
2033         }
2034 
isEmpty()2035         public boolean isEmpty() {
2036             throw new RuntimeException("Stub!");
2037         }
2038 
containsKey(java.lang.Object key)2039         public boolean containsKey(java.lang.Object key) {
2040             throw new RuntimeException("Stub!");
2041         }
2042 
containsValue(java.lang.Object value)2043         public boolean containsValue(java.lang.Object value) {
2044             throw new RuntimeException("Stub!");
2045         }
2046 
get(java.lang.Object key)2047         public V get(java.lang.Object key) {
2048             throw new RuntimeException("Stub!");
2049         }
2050 
keySet()2051         public java.util.Set<K> keySet() {
2052             throw new RuntimeException("Stub!");
2053         }
2054 
entrySet()2055         public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
2056             throw new RuntimeException("Stub!");
2057         }
2058 
values()2059         public java.util.Collection<V> values() {
2060             throw new RuntimeException("Stub!");
2061         }
2062 
getOrDefault(java.lang.Object key, V defaultValue)2063         public V getOrDefault(java.lang.Object key, V defaultValue) {
2064             throw new RuntimeException("Stub!");
2065         }
2066 
forEach(java.util.function.BiConsumer<? super K, ? super V> action)2067         public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
2068             throw new RuntimeException("Stub!");
2069         }
2070 
replaceAll( java.util.function.BiFunction<? super K, ? super V, ? extends V> function)2071         public void replaceAll(
2072                 java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
2073             throw new RuntimeException("Stub!");
2074         }
2075 
putIfAbsent(K key, V value)2076         public V putIfAbsent(K key, V value) {
2077             throw new RuntimeException("Stub!");
2078         }
2079 
remove(java.lang.Object key, java.lang.Object value)2080         public boolean remove(java.lang.Object key, java.lang.Object value) {
2081             throw new RuntimeException("Stub!");
2082         }
2083 
replace(K key, V oldValue, V newValue)2084         public boolean replace(K key, V oldValue, V newValue) {
2085             throw new RuntimeException("Stub!");
2086         }
2087 
replace(K key, V value)2088         public V replace(K key, V value) {
2089             throw new RuntimeException("Stub!");
2090         }
2091 
computeIfAbsent( K key, java.util.function.Function<? super K, ? extends V> mappingFunction)2092         public V computeIfAbsent(
2093                 K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
2094             throw new RuntimeException("Stub!");
2095         }
2096 
computeIfPresent( K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction)2097         public V computeIfPresent(
2098                 K key,
2099                 java.util.function.BiFunction<? super K, ? super V, ? extends V>
2100                         remappingFunction) {
2101             throw new RuntimeException("Stub!");
2102         }
2103 
compute( K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction)2104         public V compute(
2105                 K key,
2106                 java.util.function.BiFunction<? super K, ? super V, ? extends V>
2107                         remappingFunction) {
2108             throw new RuntimeException("Stub!");
2109         }
2110 
merge( K key, V value, java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction)2111         public V merge(
2112                 K key,
2113                 V value,
2114                 java.util.function.BiFunction<? super V, ? super V, ? extends V>
2115                         remappingFunction) {
2116             throw new RuntimeException("Stub!");
2117         }
2118 
2119         private transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;
2120 
2121         private final K k;
2122 
2123         {
2124             k = null;
2125         }
2126 
2127         private transient java.util.Set<K> keySet;
2128 
2129         private static final long serialVersionUID = -6979724477215052911L; // 0x9f230991717f6b91L
2130 
2131         private final V v;
2132 
2133         {
2134             v = null;
2135         }
2136 
2137         private transient java.util.Collection<V> values;
2138     }
2139 
2140     @SuppressWarnings({"unchecked", "deprecation", "all"})
2141     private static class SingletonSet<E> extends java.util.AbstractSet<E>
2142             implements java.io.Serializable {
2143 
SingletonSet(E e)2144         SingletonSet(E e) {
2145             throw new RuntimeException("Stub!");
2146         }
2147 
iterator()2148         public java.util.Iterator<E> iterator() {
2149             throw new RuntimeException("Stub!");
2150         }
2151 
size()2152         public int size() {
2153             throw new RuntimeException("Stub!");
2154         }
2155 
contains(java.lang.Object o)2156         public boolean contains(java.lang.Object o) {
2157             throw new RuntimeException("Stub!");
2158         }
2159 
forEach(java.util.function.Consumer<? super E> action)2160         public void forEach(java.util.function.Consumer<? super E> action) {
2161             throw new RuntimeException("Stub!");
2162         }
2163 
spliterator()2164         public java.util.Spliterator<E> spliterator() {
2165             throw new RuntimeException("Stub!");
2166         }
2167 
removeIf(java.util.function.Predicate<? super E> filter)2168         public boolean removeIf(java.util.function.Predicate<? super E> filter) {
2169             throw new RuntimeException("Stub!");
2170         }
2171 
2172         private final E element;
2173 
2174         {
2175             element = null;
2176         }
2177 
2178         private static final long serialVersionUID = 3193687207550431679L; // 0x2c52419829c0b1bfL
2179     }
2180 
2181     @SuppressWarnings({"unchecked", "deprecation", "all"})
2182     static class SynchronizedCollection<E>
2183             implements java.util.Collection<E>, java.io.Serializable {
2184 
SynchronizedCollection(java.util.Collection<E> c)2185         SynchronizedCollection(java.util.Collection<E> c) {
2186             throw new RuntimeException("Stub!");
2187         }
2188 
SynchronizedCollection(java.util.Collection<E> c, java.lang.Object mutex)2189         SynchronizedCollection(java.util.Collection<E> c, java.lang.Object mutex) {
2190             throw new RuntimeException("Stub!");
2191         }
2192 
size()2193         public int size() {
2194             throw new RuntimeException("Stub!");
2195         }
2196 
isEmpty()2197         public boolean isEmpty() {
2198             throw new RuntimeException("Stub!");
2199         }
2200 
contains(java.lang.Object o)2201         public boolean contains(java.lang.Object o) {
2202             throw new RuntimeException("Stub!");
2203         }
2204 
toArray()2205         public java.lang.Object[] toArray() {
2206             throw new RuntimeException("Stub!");
2207         }
2208 
toArray(T[] a)2209         public <T> T[] toArray(T[] a) {
2210             throw new RuntimeException("Stub!");
2211         }
2212 
iterator()2213         public java.util.Iterator<E> iterator() {
2214             throw new RuntimeException("Stub!");
2215         }
2216 
add(E e)2217         public boolean add(E e) {
2218             throw new RuntimeException("Stub!");
2219         }
2220 
remove(java.lang.Object o)2221         public boolean remove(java.lang.Object o) {
2222             throw new RuntimeException("Stub!");
2223         }
2224 
containsAll(java.util.Collection<?> coll)2225         public boolean containsAll(java.util.Collection<?> coll) {
2226             throw new RuntimeException("Stub!");
2227         }
2228 
addAll(java.util.Collection<? extends E> coll)2229         public boolean addAll(java.util.Collection<? extends E> coll) {
2230             throw new RuntimeException("Stub!");
2231         }
2232 
removeAll(java.util.Collection<?> coll)2233         public boolean removeAll(java.util.Collection<?> coll) {
2234             throw new RuntimeException("Stub!");
2235         }
2236 
retainAll(java.util.Collection<?> coll)2237         public boolean retainAll(java.util.Collection<?> coll) {
2238             throw new RuntimeException("Stub!");
2239         }
2240 
clear()2241         public void clear() {
2242             throw new RuntimeException("Stub!");
2243         }
2244 
toString()2245         public java.lang.String toString() {
2246             throw new RuntimeException("Stub!");
2247         }
2248 
forEach(java.util.function.Consumer<? super E> consumer)2249         public void forEach(java.util.function.Consumer<? super E> consumer) {
2250             throw new RuntimeException("Stub!");
2251         }
2252 
removeIf(java.util.function.Predicate<? super E> filter)2253         public boolean removeIf(java.util.function.Predicate<? super E> filter) {
2254             throw new RuntimeException("Stub!");
2255         }
2256 
spliterator()2257         public java.util.Spliterator<E> spliterator() {
2258             throw new RuntimeException("Stub!");
2259         }
2260 
stream()2261         public java.util.stream.Stream<E> stream() {
2262             throw new RuntimeException("Stub!");
2263         }
2264 
parallelStream()2265         public java.util.stream.Stream<E> parallelStream() {
2266             throw new RuntimeException("Stub!");
2267         }
2268 
writeObject(java.io.ObjectOutputStream s)2269         private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
2270             throw new RuntimeException("Stub!");
2271         }
2272 
2273         @UnsupportedAppUsage
2274         final java.util.Collection<E> c;
2275 
2276         {
2277             c = null;
2278         }
2279 
2280         final java.lang.Object mutex;
2281 
2282         {
2283             mutex = null;
2284         }
2285 
2286         private static final long serialVersionUID = 3053995032091335093L; // 0x2a61f84d099c99b5L
2287     }
2288 
2289     @SuppressWarnings({"unchecked", "deprecation", "all"})
2290     static class SynchronizedList<E> extends java.util.Collections.SynchronizedCollection<E>
2291             implements java.util.List<E> {
2292 
SynchronizedList(java.util.List<E> list)2293         SynchronizedList(java.util.List<E> list) {
2294             super((java.util.Collection) null);
2295             throw new RuntimeException("Stub!");
2296         }
2297 
SynchronizedList(java.util.List<E> list, java.lang.Object mutex)2298         SynchronizedList(java.util.List<E> list, java.lang.Object mutex) {
2299             super((java.util.Collection) null);
2300             throw new RuntimeException("Stub!");
2301         }
2302 
equals(java.lang.Object o)2303         public boolean equals(java.lang.Object o) {
2304             throw new RuntimeException("Stub!");
2305         }
2306 
hashCode()2307         public int hashCode() {
2308             throw new RuntimeException("Stub!");
2309         }
2310 
get(int index)2311         public E get(int index) {
2312             throw new RuntimeException("Stub!");
2313         }
2314 
set(int index, E element)2315         public E set(int index, E element) {
2316             throw new RuntimeException("Stub!");
2317         }
2318 
add(int index, E element)2319         public void add(int index, E element) {
2320             throw new RuntimeException("Stub!");
2321         }
2322 
remove(int index)2323         public E remove(int index) {
2324             throw new RuntimeException("Stub!");
2325         }
2326 
indexOf(java.lang.Object o)2327         public int indexOf(java.lang.Object o) {
2328             throw new RuntimeException("Stub!");
2329         }
2330 
lastIndexOf(java.lang.Object o)2331         public int lastIndexOf(java.lang.Object o) {
2332             throw new RuntimeException("Stub!");
2333         }
2334 
addAll(int index, java.util.Collection<? extends E> c)2335         public boolean addAll(int index, java.util.Collection<? extends E> c) {
2336             throw new RuntimeException("Stub!");
2337         }
2338 
listIterator()2339         public java.util.ListIterator<E> listIterator() {
2340             throw new RuntimeException("Stub!");
2341         }
2342 
listIterator(int index)2343         public java.util.ListIterator<E> listIterator(int index) {
2344             throw new RuntimeException("Stub!");
2345         }
2346 
subList(int fromIndex, int toIndex)2347         public java.util.List<E> subList(int fromIndex, int toIndex) {
2348             throw new RuntimeException("Stub!");
2349         }
2350 
replaceAll(java.util.function.UnaryOperator<E> operator)2351         public void replaceAll(java.util.function.UnaryOperator<E> operator) {
2352             throw new RuntimeException("Stub!");
2353         }
2354 
sort(java.util.Comparator<? super E> c)2355         public void sort(java.util.Comparator<? super E> c) {
2356             throw new RuntimeException("Stub!");
2357         }
2358 
readResolve()2359         private java.lang.Object readResolve() {
2360             throw new RuntimeException("Stub!");
2361         }
2362 
2363         @UnsupportedAppUsage
2364         final java.util.List<E> list;
2365 
2366         {
2367             list = null;
2368         }
2369 
2370         private static final long serialVersionUID = -7754090372962971524L; // 0x9463efe38344107cL
2371     }
2372 
2373     @SuppressWarnings({"unchecked", "deprecation", "all"})
2374     private static class SynchronizedMap<K, V>
2375             implements java.util.Map<K, V>, java.io.Serializable {
2376 
SynchronizedMap(java.util.Map<K, V> m)2377         SynchronizedMap(java.util.Map<K, V> m) {
2378             throw new RuntimeException("Stub!");
2379         }
2380 
SynchronizedMap(java.util.Map<K, V> m, java.lang.Object mutex)2381         SynchronizedMap(java.util.Map<K, V> m, java.lang.Object mutex) {
2382             throw new RuntimeException("Stub!");
2383         }
2384 
size()2385         public int size() {
2386             throw new RuntimeException("Stub!");
2387         }
2388 
isEmpty()2389         public boolean isEmpty() {
2390             throw new RuntimeException("Stub!");
2391         }
2392 
containsKey(java.lang.Object key)2393         public boolean containsKey(java.lang.Object key) {
2394             throw new RuntimeException("Stub!");
2395         }
2396 
containsValue(java.lang.Object value)2397         public boolean containsValue(java.lang.Object value) {
2398             throw new RuntimeException("Stub!");
2399         }
2400 
get(java.lang.Object key)2401         public V get(java.lang.Object key) {
2402             throw new RuntimeException("Stub!");
2403         }
2404 
put(K key, V value)2405         public V put(K key, V value) {
2406             throw new RuntimeException("Stub!");
2407         }
2408 
remove(java.lang.Object key)2409         public V remove(java.lang.Object key) {
2410             throw new RuntimeException("Stub!");
2411         }
2412 
putAll(java.util.Map<? extends K, ? extends V> map)2413         public void putAll(java.util.Map<? extends K, ? extends V> map) {
2414             throw new RuntimeException("Stub!");
2415         }
2416 
clear()2417         public void clear() {
2418             throw new RuntimeException("Stub!");
2419         }
2420 
keySet()2421         public java.util.Set<K> keySet() {
2422             throw new RuntimeException("Stub!");
2423         }
2424 
entrySet()2425         public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
2426             throw new RuntimeException("Stub!");
2427         }
2428 
values()2429         public java.util.Collection<V> values() {
2430             throw new RuntimeException("Stub!");
2431         }
2432 
equals(java.lang.Object o)2433         public boolean equals(java.lang.Object o) {
2434             throw new RuntimeException("Stub!");
2435         }
2436 
hashCode()2437         public int hashCode() {
2438             throw new RuntimeException("Stub!");
2439         }
2440 
toString()2441         public java.lang.String toString() {
2442             throw new RuntimeException("Stub!");
2443         }
2444 
getOrDefault(java.lang.Object k, V defaultValue)2445         public V getOrDefault(java.lang.Object k, V defaultValue) {
2446             throw new RuntimeException("Stub!");
2447         }
2448 
forEach(java.util.function.BiConsumer<? super K, ? super V> action)2449         public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
2450             throw new RuntimeException("Stub!");
2451         }
2452 
replaceAll( java.util.function.BiFunction<? super K, ? super V, ? extends V> function)2453         public void replaceAll(
2454                 java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
2455             throw new RuntimeException("Stub!");
2456         }
2457 
putIfAbsent(K key, V value)2458         public V putIfAbsent(K key, V value) {
2459             throw new RuntimeException("Stub!");
2460         }
2461 
remove(java.lang.Object key, java.lang.Object value)2462         public boolean remove(java.lang.Object key, java.lang.Object value) {
2463             throw new RuntimeException("Stub!");
2464         }
2465 
replace(K key, V oldValue, V newValue)2466         public boolean replace(K key, V oldValue, V newValue) {
2467             throw new RuntimeException("Stub!");
2468         }
2469 
replace(K key, V value)2470         public V replace(K key, V value) {
2471             throw new RuntimeException("Stub!");
2472         }
2473 
computeIfAbsent( K key, java.util.function.Function<? super K, ? extends V> mappingFunction)2474         public V computeIfAbsent(
2475                 K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
2476             throw new RuntimeException("Stub!");
2477         }
2478 
computeIfPresent( K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction)2479         public V computeIfPresent(
2480                 K key,
2481                 java.util.function.BiFunction<? super K, ? super V, ? extends V>
2482                         remappingFunction) {
2483             throw new RuntimeException("Stub!");
2484         }
2485 
compute( K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction)2486         public V compute(
2487                 K key,
2488                 java.util.function.BiFunction<? super K, ? super V, ? extends V>
2489                         remappingFunction) {
2490             throw new RuntimeException("Stub!");
2491         }
2492 
merge( K key, V value, java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction)2493         public V merge(
2494                 K key,
2495                 V value,
2496                 java.util.function.BiFunction<? super V, ? super V, ? extends V>
2497                         remappingFunction) {
2498             throw new RuntimeException("Stub!");
2499         }
2500 
writeObject(java.io.ObjectOutputStream s)2501         private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
2502             throw new RuntimeException("Stub!");
2503         }
2504 
2505         private transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;
2506 
2507         private transient java.util.Set<K> keySet;
2508 
2509         @UnsupportedAppUsage
2510         private final java.util.Map<K, V> m;
2511 
2512         {
2513             m = null;
2514         }
2515 
2516         final java.lang.Object mutex;
2517 
2518         {
2519             mutex = null;
2520         }
2521 
2522         private static final long serialVersionUID = 1978198479659022715L; // 0x1b73f9094b4b397bL
2523 
2524         private transient java.util.Collection<V> values;
2525     }
2526 
2527     @SuppressWarnings({"unchecked", "deprecation", "all"})
2528     static class SynchronizedNavigableMap<K, V>
2529             extends java.util.Collections.SynchronizedSortedMap<K, V>
2530             implements java.util.NavigableMap<K, V> {
2531 
SynchronizedNavigableMap(java.util.NavigableMap<K, V> m)2532         SynchronizedNavigableMap(java.util.NavigableMap<K, V> m) {
2533             super((java.util.SortedMap) null);
2534             throw new RuntimeException("Stub!");
2535         }
2536 
SynchronizedNavigableMap(java.util.NavigableMap<K, V> m, java.lang.Object mutex)2537         SynchronizedNavigableMap(java.util.NavigableMap<K, V> m, java.lang.Object mutex) {
2538             super((java.util.SortedMap) null);
2539             throw new RuntimeException("Stub!");
2540         }
2541 
lowerEntry(K key)2542         public java.util.Map.Entry<K, V> lowerEntry(K key) {
2543             throw new RuntimeException("Stub!");
2544         }
2545 
lowerKey(K key)2546         public K lowerKey(K key) {
2547             throw new RuntimeException("Stub!");
2548         }
2549 
floorEntry(K key)2550         public java.util.Map.Entry<K, V> floorEntry(K key) {
2551             throw new RuntimeException("Stub!");
2552         }
2553 
floorKey(K key)2554         public K floorKey(K key) {
2555             throw new RuntimeException("Stub!");
2556         }
2557 
ceilingEntry(K key)2558         public java.util.Map.Entry<K, V> ceilingEntry(K key) {
2559             throw new RuntimeException("Stub!");
2560         }
2561 
ceilingKey(K key)2562         public K ceilingKey(K key) {
2563             throw new RuntimeException("Stub!");
2564         }
2565 
higherEntry(K key)2566         public java.util.Map.Entry<K, V> higherEntry(K key) {
2567             throw new RuntimeException("Stub!");
2568         }
2569 
higherKey(K key)2570         public K higherKey(K key) {
2571             throw new RuntimeException("Stub!");
2572         }
2573 
firstEntry()2574         public java.util.Map.Entry<K, V> firstEntry() {
2575             throw new RuntimeException("Stub!");
2576         }
2577 
lastEntry()2578         public java.util.Map.Entry<K, V> lastEntry() {
2579             throw new RuntimeException("Stub!");
2580         }
2581 
pollFirstEntry()2582         public java.util.Map.Entry<K, V> pollFirstEntry() {
2583             throw new RuntimeException("Stub!");
2584         }
2585 
pollLastEntry()2586         public java.util.Map.Entry<K, V> pollLastEntry() {
2587             throw new RuntimeException("Stub!");
2588         }
2589 
descendingMap()2590         public java.util.NavigableMap<K, V> descendingMap() {
2591             throw new RuntimeException("Stub!");
2592         }
2593 
keySet()2594         public java.util.NavigableSet<K> keySet() {
2595             throw new RuntimeException("Stub!");
2596         }
2597 
navigableKeySet()2598         public java.util.NavigableSet<K> navigableKeySet() {
2599             throw new RuntimeException("Stub!");
2600         }
2601 
descendingKeySet()2602         public java.util.NavigableSet<K> descendingKeySet() {
2603             throw new RuntimeException("Stub!");
2604         }
2605 
subMap(K fromKey, K toKey)2606         public java.util.SortedMap<K, V> subMap(K fromKey, K toKey) {
2607             throw new RuntimeException("Stub!");
2608         }
2609 
headMap(K toKey)2610         public java.util.SortedMap<K, V> headMap(K toKey) {
2611             throw new RuntimeException("Stub!");
2612         }
2613 
tailMap(K fromKey)2614         public java.util.SortedMap<K, V> tailMap(K fromKey) {
2615             throw new RuntimeException("Stub!");
2616         }
2617 
subMap( K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)2618         public java.util.NavigableMap<K, V> subMap(
2619                 K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
2620             throw new RuntimeException("Stub!");
2621         }
2622 
headMap(K toKey, boolean inclusive)2623         public java.util.NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
2624             throw new RuntimeException("Stub!");
2625         }
2626 
tailMap(K fromKey, boolean inclusive)2627         public java.util.NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
2628             throw new RuntimeException("Stub!");
2629         }
2630 
2631         private final java.util.NavigableMap<K, V> nm;
2632 
2633         {
2634             nm = null;
2635         }
2636 
2637         private static final long serialVersionUID = 699392247599746807L; // 0x9b4bd8b2cd84ef7L
2638     }
2639 
2640     @SuppressWarnings({"unchecked", "deprecation", "all"})
2641     static class SynchronizedNavigableSet<E> extends java.util.Collections.SynchronizedSortedSet<E>
2642             implements java.util.NavigableSet<E> {
2643 
SynchronizedNavigableSet(java.util.NavigableSet<E> s)2644         SynchronizedNavigableSet(java.util.NavigableSet<E> s) {
2645             super((java.util.SortedSet) null);
2646             throw new RuntimeException("Stub!");
2647         }
2648 
SynchronizedNavigableSet(java.util.NavigableSet<E> s, java.lang.Object mutex)2649         SynchronizedNavigableSet(java.util.NavigableSet<E> s, java.lang.Object mutex) {
2650             super((java.util.SortedSet) null);
2651             throw new RuntimeException("Stub!");
2652         }
2653 
lower(E e)2654         public E lower(E e) {
2655             throw new RuntimeException("Stub!");
2656         }
2657 
floor(E e)2658         public E floor(E e) {
2659             throw new RuntimeException("Stub!");
2660         }
2661 
ceiling(E e)2662         public E ceiling(E e) {
2663             throw new RuntimeException("Stub!");
2664         }
2665 
higher(E e)2666         public E higher(E e) {
2667             throw new RuntimeException("Stub!");
2668         }
2669 
pollFirst()2670         public E pollFirst() {
2671             throw new RuntimeException("Stub!");
2672         }
2673 
pollLast()2674         public E pollLast() {
2675             throw new RuntimeException("Stub!");
2676         }
2677 
descendingSet()2678         public java.util.NavigableSet<E> descendingSet() {
2679             throw new RuntimeException("Stub!");
2680         }
2681 
descendingIterator()2682         public java.util.Iterator<E> descendingIterator() {
2683             throw new RuntimeException("Stub!");
2684         }
2685 
subSet(E fromElement, E toElement)2686         public java.util.NavigableSet<E> subSet(E fromElement, E toElement) {
2687             throw new RuntimeException("Stub!");
2688         }
2689 
headSet(E toElement)2690         public java.util.NavigableSet<E> headSet(E toElement) {
2691             throw new RuntimeException("Stub!");
2692         }
2693 
tailSet(E fromElement)2694         public java.util.NavigableSet<E> tailSet(E fromElement) {
2695             throw new RuntimeException("Stub!");
2696         }
2697 
subSet( E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)2698         public java.util.NavigableSet<E> subSet(
2699                 E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
2700             throw new RuntimeException("Stub!");
2701         }
2702 
headSet(E toElement, boolean inclusive)2703         public java.util.NavigableSet<E> headSet(E toElement, boolean inclusive) {
2704             throw new RuntimeException("Stub!");
2705         }
2706 
tailSet(E fromElement, boolean inclusive)2707         public java.util.NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
2708             throw new RuntimeException("Stub!");
2709         }
2710 
2711         private final java.util.NavigableSet<E> ns;
2712 
2713         {
2714             ns = null;
2715         }
2716 
2717         private static final long serialVersionUID = -5505529816273629798L; // 0xb3986dcd38b04d9aL
2718     }
2719 
2720     @SuppressWarnings({"unchecked", "deprecation", "all"})
2721     static class SynchronizedRandomAccessList<E> extends java.util.Collections.SynchronizedList<E>
2722             implements java.util.RandomAccess {
2723 
SynchronizedRandomAccessList(java.util.List<E> list)2724         SynchronizedRandomAccessList(java.util.List<E> list) {
2725             super((java.util.List) null);
2726             throw new RuntimeException("Stub!");
2727         }
2728 
SynchronizedRandomAccessList(java.util.List<E> list, java.lang.Object mutex)2729         SynchronizedRandomAccessList(java.util.List<E> list, java.lang.Object mutex) {
2730             super((java.util.List) null);
2731             throw new RuntimeException("Stub!");
2732         }
2733 
subList(int fromIndex, int toIndex)2734         public java.util.List<E> subList(int fromIndex, int toIndex) {
2735             throw new RuntimeException("Stub!");
2736         }
2737 
writeReplace()2738         private java.lang.Object writeReplace() {
2739             throw new RuntimeException("Stub!");
2740         }
2741 
2742         private static final long serialVersionUID = 1530674583602358482L; // 0x153e0c6c865668d2L
2743     }
2744 
2745     @SuppressWarnings({"unchecked", "deprecation", "all"})
2746     static class SynchronizedSet<E> extends java.util.Collections.SynchronizedCollection<E>
2747             implements java.util.Set<E> {
2748 
SynchronizedSet(java.util.Set<E> s)2749         SynchronizedSet(java.util.Set<E> s) {
2750             super((java.util.Collection) null);
2751             throw new RuntimeException("Stub!");
2752         }
2753 
SynchronizedSet(java.util.Set<E> s, java.lang.Object mutex)2754         SynchronizedSet(java.util.Set<E> s, java.lang.Object mutex) {
2755             super((java.util.Collection) null);
2756             throw new RuntimeException("Stub!");
2757         }
2758 
equals(java.lang.Object o)2759         public boolean equals(java.lang.Object o) {
2760             throw new RuntimeException("Stub!");
2761         }
2762 
hashCode()2763         public int hashCode() {
2764             throw new RuntimeException("Stub!");
2765         }
2766 
2767         private static final long serialVersionUID = 487447009682186044L; // 0x6c3c27902eedf3cL
2768     }
2769 
2770     @SuppressWarnings({"unchecked", "deprecation", "all"})
2771     static class SynchronizedSortedMap<K, V> extends java.util.Collections.SynchronizedMap<K, V>
2772             implements java.util.SortedMap<K, V> {
2773 
SynchronizedSortedMap(java.util.SortedMap<K, V> m)2774         SynchronizedSortedMap(java.util.SortedMap<K, V> m) {
2775             super((java.util.Map) null);
2776             throw new RuntimeException("Stub!");
2777         }
2778 
SynchronizedSortedMap(java.util.SortedMap<K, V> m, java.lang.Object mutex)2779         SynchronizedSortedMap(java.util.SortedMap<K, V> m, java.lang.Object mutex) {
2780             super((java.util.Map) null);
2781             throw new RuntimeException("Stub!");
2782         }
2783 
comparator()2784         public java.util.Comparator<? super K> comparator() {
2785             throw new RuntimeException("Stub!");
2786         }
2787 
subMap(K fromKey, K toKey)2788         public java.util.SortedMap<K, V> subMap(K fromKey, K toKey) {
2789             throw new RuntimeException("Stub!");
2790         }
2791 
headMap(K toKey)2792         public java.util.SortedMap<K, V> headMap(K toKey) {
2793             throw new RuntimeException("Stub!");
2794         }
2795 
tailMap(K fromKey)2796         public java.util.SortedMap<K, V> tailMap(K fromKey) {
2797             throw new RuntimeException("Stub!");
2798         }
2799 
firstKey()2800         public K firstKey() {
2801             throw new RuntimeException("Stub!");
2802         }
2803 
lastKey()2804         public K lastKey() {
2805             throw new RuntimeException("Stub!");
2806         }
2807 
2808         private static final long serialVersionUID = -8798146769416483793L; // 0x85e6b420b72e0c2fL
2809 
2810         private final java.util.SortedMap<K, V> sm;
2811 
2812         {
2813             sm = null;
2814         }
2815     }
2816 
2817     @SuppressWarnings({"unchecked", "deprecation", "all"})
2818     static class SynchronizedSortedSet<E> extends java.util.Collections.SynchronizedSet<E>
2819             implements java.util.SortedSet<E> {
2820 
SynchronizedSortedSet(java.util.SortedSet<E> s)2821         SynchronizedSortedSet(java.util.SortedSet<E> s) {
2822             super((java.util.Set) null);
2823             throw new RuntimeException("Stub!");
2824         }
2825 
SynchronizedSortedSet(java.util.SortedSet<E> s, java.lang.Object mutex)2826         SynchronizedSortedSet(java.util.SortedSet<E> s, java.lang.Object mutex) {
2827             super((java.util.Set) null);
2828             throw new RuntimeException("Stub!");
2829         }
2830 
comparator()2831         public java.util.Comparator<? super E> comparator() {
2832             throw new RuntimeException("Stub!");
2833         }
2834 
subSet(E fromElement, E toElement)2835         public java.util.SortedSet<E> subSet(E fromElement, E toElement) {
2836             throw new RuntimeException("Stub!");
2837         }
2838 
headSet(E toElement)2839         public java.util.SortedSet<E> headSet(E toElement) {
2840             throw new RuntimeException("Stub!");
2841         }
2842 
tailSet(E fromElement)2843         public java.util.SortedSet<E> tailSet(E fromElement) {
2844             throw new RuntimeException("Stub!");
2845         }
2846 
first()2847         public E first() {
2848             throw new RuntimeException("Stub!");
2849         }
2850 
last()2851         public E last() {
2852             throw new RuntimeException("Stub!");
2853         }
2854 
2855         private static final long serialVersionUID = 8695801310862127406L; // 0x78adb1384b50312eL
2856 
2857         private final java.util.SortedSet<E> ss;
2858 
2859         {
2860             ss = null;
2861         }
2862     }
2863 
2864     @SuppressWarnings({"unchecked", "deprecation", "all"})
2865     static class UnmodifiableCollection<E>
2866             implements java.util.Collection<E>, java.io.Serializable {
2867 
UnmodifiableCollection(java.util.Collection<? extends E> c)2868         UnmodifiableCollection(java.util.Collection<? extends E> c) {
2869             throw new RuntimeException("Stub!");
2870         }
2871 
size()2872         public int size() {
2873             throw new RuntimeException("Stub!");
2874         }
2875 
isEmpty()2876         public boolean isEmpty() {
2877             throw new RuntimeException("Stub!");
2878         }
2879 
contains(java.lang.Object o)2880         public boolean contains(java.lang.Object o) {
2881             throw new RuntimeException("Stub!");
2882         }
2883 
toArray()2884         public java.lang.Object[] toArray() {
2885             throw new RuntimeException("Stub!");
2886         }
2887 
toArray(T[] a)2888         public <T> T[] toArray(T[] a) {
2889             throw new RuntimeException("Stub!");
2890         }
2891 
toString()2892         public java.lang.String toString() {
2893             throw new RuntimeException("Stub!");
2894         }
2895 
iterator()2896         public java.util.Iterator<E> iterator() {
2897             throw new RuntimeException("Stub!");
2898         }
2899 
add(E e)2900         public boolean add(E e) {
2901             throw new RuntimeException("Stub!");
2902         }
2903 
remove(java.lang.Object o)2904         public boolean remove(java.lang.Object o) {
2905             throw new RuntimeException("Stub!");
2906         }
2907 
containsAll(java.util.Collection<?> coll)2908         public boolean containsAll(java.util.Collection<?> coll) {
2909             throw new RuntimeException("Stub!");
2910         }
2911 
addAll(java.util.Collection<? extends E> coll)2912         public boolean addAll(java.util.Collection<? extends E> coll) {
2913             throw new RuntimeException("Stub!");
2914         }
2915 
removeAll(java.util.Collection<?> coll)2916         public boolean removeAll(java.util.Collection<?> coll) {
2917             throw new RuntimeException("Stub!");
2918         }
2919 
retainAll(java.util.Collection<?> coll)2920         public boolean retainAll(java.util.Collection<?> coll) {
2921             throw new RuntimeException("Stub!");
2922         }
2923 
clear()2924         public void clear() {
2925             throw new RuntimeException("Stub!");
2926         }
2927 
forEach(java.util.function.Consumer<? super E> action)2928         public void forEach(java.util.function.Consumer<? super E> action) {
2929             throw new RuntimeException("Stub!");
2930         }
2931 
removeIf(java.util.function.Predicate<? super E> filter)2932         public boolean removeIf(java.util.function.Predicate<? super E> filter) {
2933             throw new RuntimeException("Stub!");
2934         }
2935 
spliterator()2936         public java.util.Spliterator<E> spliterator() {
2937             throw new RuntimeException("Stub!");
2938         }
2939 
stream()2940         public java.util.stream.Stream<E> stream() {
2941             throw new RuntimeException("Stub!");
2942         }
2943 
parallelStream()2944         public java.util.stream.Stream<E> parallelStream() {
2945             throw new RuntimeException("Stub!");
2946         }
2947 
2948         @UnsupportedAppUsage
2949         final java.util.Collection<? extends E> c;
2950 
2951         {
2952             c = null;
2953         }
2954 
2955         private static final long serialVersionUID = 1820017752578914078L; // 0x19420080cb5ef71eL
2956     }
2957 
2958     @SuppressWarnings({"unchecked", "deprecation", "all"})
2959     static class UnmodifiableList<E> extends java.util.Collections.UnmodifiableCollection<E>
2960             implements java.util.List<E> {
2961 
UnmodifiableList(java.util.List<? extends E> list)2962         UnmodifiableList(java.util.List<? extends E> list) {
2963             super(null);
2964             throw new RuntimeException("Stub!");
2965         }
2966 
equals(java.lang.Object o)2967         public boolean equals(java.lang.Object o) {
2968             throw new RuntimeException("Stub!");
2969         }
2970 
hashCode()2971         public int hashCode() {
2972             throw new RuntimeException("Stub!");
2973         }
2974 
get(int index)2975         public E get(int index) {
2976             throw new RuntimeException("Stub!");
2977         }
2978 
set(int index, E element)2979         public E set(int index, E element) {
2980             throw new RuntimeException("Stub!");
2981         }
2982 
add(int index, E element)2983         public void add(int index, E element) {
2984             throw new RuntimeException("Stub!");
2985         }
2986 
remove(int index)2987         public E remove(int index) {
2988             throw new RuntimeException("Stub!");
2989         }
2990 
indexOf(java.lang.Object o)2991         public int indexOf(java.lang.Object o) {
2992             throw new RuntimeException("Stub!");
2993         }
2994 
lastIndexOf(java.lang.Object o)2995         public int lastIndexOf(java.lang.Object o) {
2996             throw new RuntimeException("Stub!");
2997         }
2998 
addAll(int index, java.util.Collection<? extends E> c)2999         public boolean addAll(int index, java.util.Collection<? extends E> c) {
3000             throw new RuntimeException("Stub!");
3001         }
3002 
replaceAll(java.util.function.UnaryOperator<E> operator)3003         public void replaceAll(java.util.function.UnaryOperator<E> operator) {
3004             throw new RuntimeException("Stub!");
3005         }
3006 
sort(java.util.Comparator<? super E> c)3007         public void sort(java.util.Comparator<? super E> c) {
3008             throw new RuntimeException("Stub!");
3009         }
3010 
listIterator()3011         public java.util.ListIterator<E> listIterator() {
3012             throw new RuntimeException("Stub!");
3013         }
3014 
listIterator(int index)3015         public java.util.ListIterator<E> listIterator(int index) {
3016             throw new RuntimeException("Stub!");
3017         }
3018 
subList(int fromIndex, int toIndex)3019         public java.util.List<E> subList(int fromIndex, int toIndex) {
3020             throw new RuntimeException("Stub!");
3021         }
3022 
readResolve()3023         private java.lang.Object readResolve() {
3024             throw new RuntimeException("Stub!");
3025         }
3026 
3027         final java.util.List<? extends E> list;
3028 
3029         {
3030             list = null;
3031         }
3032 
3033         private static final long serialVersionUID = -283967356065247728L; // 0xfc0f2531b5ec8e10L
3034     }
3035 
3036     @SuppressWarnings({"unchecked", "deprecation", "all"})
3037     private static class UnmodifiableMap<K, V>
3038             implements java.util.Map<K, V>, java.io.Serializable {
3039 
UnmodifiableMap(java.util.Map<? extends K, ? extends V> m)3040         UnmodifiableMap(java.util.Map<? extends K, ? extends V> m) {
3041             throw new RuntimeException("Stub!");
3042         }
3043 
size()3044         public int size() {
3045             throw new RuntimeException("Stub!");
3046         }
3047 
isEmpty()3048         public boolean isEmpty() {
3049             throw new RuntimeException("Stub!");
3050         }
3051 
containsKey(java.lang.Object key)3052         public boolean containsKey(java.lang.Object key) {
3053             throw new RuntimeException("Stub!");
3054         }
3055 
containsValue(java.lang.Object val)3056         public boolean containsValue(java.lang.Object val) {
3057             throw new RuntimeException("Stub!");
3058         }
3059 
get(java.lang.Object key)3060         public V get(java.lang.Object key) {
3061             throw new RuntimeException("Stub!");
3062         }
3063 
put(K key, V value)3064         public V put(K key, V value) {
3065             throw new RuntimeException("Stub!");
3066         }
3067 
remove(java.lang.Object key)3068         public V remove(java.lang.Object key) {
3069             throw new RuntimeException("Stub!");
3070         }
3071 
putAll(java.util.Map<? extends K, ? extends V> m)3072         public void putAll(java.util.Map<? extends K, ? extends V> m) {
3073             throw new RuntimeException("Stub!");
3074         }
3075 
clear()3076         public void clear() {
3077             throw new RuntimeException("Stub!");
3078         }
3079 
keySet()3080         public java.util.Set<K> keySet() {
3081             throw new RuntimeException("Stub!");
3082         }
3083 
entrySet()3084         public java.util.Set<java.util.Map.Entry<K, V>> entrySet() {
3085             throw new RuntimeException("Stub!");
3086         }
3087 
values()3088         public java.util.Collection<V> values() {
3089             throw new RuntimeException("Stub!");
3090         }
3091 
equals(java.lang.Object o)3092         public boolean equals(java.lang.Object o) {
3093             throw new RuntimeException("Stub!");
3094         }
3095 
hashCode()3096         public int hashCode() {
3097             throw new RuntimeException("Stub!");
3098         }
3099 
toString()3100         public java.lang.String toString() {
3101             throw new RuntimeException("Stub!");
3102         }
3103 
getOrDefault(java.lang.Object k, V defaultValue)3104         public V getOrDefault(java.lang.Object k, V defaultValue) {
3105             throw new RuntimeException("Stub!");
3106         }
3107 
forEach(java.util.function.BiConsumer<? super K, ? super V> action)3108         public void forEach(java.util.function.BiConsumer<? super K, ? super V> action) {
3109             throw new RuntimeException("Stub!");
3110         }
3111 
replaceAll( java.util.function.BiFunction<? super K, ? super V, ? extends V> function)3112         public void replaceAll(
3113                 java.util.function.BiFunction<? super K, ? super V, ? extends V> function) {
3114             throw new RuntimeException("Stub!");
3115         }
3116 
putIfAbsent(K key, V value)3117         public V putIfAbsent(K key, V value) {
3118             throw new RuntimeException("Stub!");
3119         }
3120 
remove(java.lang.Object key, java.lang.Object value)3121         public boolean remove(java.lang.Object key, java.lang.Object value) {
3122             throw new RuntimeException("Stub!");
3123         }
3124 
replace(K key, V oldValue, V newValue)3125         public boolean replace(K key, V oldValue, V newValue) {
3126             throw new RuntimeException("Stub!");
3127         }
3128 
replace(K key, V value)3129         public V replace(K key, V value) {
3130             throw new RuntimeException("Stub!");
3131         }
3132 
computeIfAbsent( K key, java.util.function.Function<? super K, ? extends V> mappingFunction)3133         public V computeIfAbsent(
3134                 K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
3135             throw new RuntimeException("Stub!");
3136         }
3137 
computeIfPresent( K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction)3138         public V computeIfPresent(
3139                 K key,
3140                 java.util.function.BiFunction<? super K, ? super V, ? extends V>
3141                         remappingFunction) {
3142             throw new RuntimeException("Stub!");
3143         }
3144 
compute( K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remappingFunction)3145         public V compute(
3146                 K key,
3147                 java.util.function.BiFunction<? super K, ? super V, ? extends V>
3148                         remappingFunction) {
3149             throw new RuntimeException("Stub!");
3150         }
3151 
merge( K key, V value, java.util.function.BiFunction<? super V, ? super V, ? extends V> remappingFunction)3152         public V merge(
3153                 K key,
3154                 V value,
3155                 java.util.function.BiFunction<? super V, ? super V, ? extends V>
3156                         remappingFunction) {
3157             throw new RuntimeException("Stub!");
3158         }
3159 
3160         private transient java.util.Set<java.util.Map.Entry<K, V>> entrySet;
3161 
3162         private transient java.util.Set<K> keySet;
3163 
3164         @UnsupportedAppUsage
3165         private final java.util.Map<? extends K, ? extends V> m;
3166 
3167         {
3168             m = null;
3169         }
3170 
3171         private static final long serialVersionUID = -1034234728574286014L; // 0xf1a5a8fe74f50742L
3172 
3173         private transient java.util.Collection<V> values;
3174 
3175         @SuppressWarnings({"unchecked", "deprecation", "all"})
3176         static class UnmodifiableEntrySet<K, V>
3177                 extends java.util.Collections.UnmodifiableSet<java.util.Map.Entry<K, V>> {
3178 
UnmodifiableEntrySet( java.util.Set<? extends java.util.Map.Entry<? extends K, ? extends V>> s)3179             UnmodifiableEntrySet(
3180                     java.util.Set<? extends java.util.Map.Entry<? extends K, ? extends V>> s) {
3181                 super(null);
3182                 throw new RuntimeException("Stub!");
3183             }
3184 
entryConsumer( java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action)3185             static <K, V> java.util.function.Consumer<java.util.Map.Entry<K, V>> entryConsumer(
3186                     java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
3187                 throw new RuntimeException("Stub!");
3188             }
3189 
forEach( java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action)3190             public void forEach(
3191                     java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
3192                 throw new RuntimeException("Stub!");
3193             }
3194 
spliterator()3195             public java.util.Spliterator<java.util.Map.Entry<K, V>> spliterator() {
3196                 throw new RuntimeException("Stub!");
3197             }
3198 
stream()3199             public java.util.stream.Stream<java.util.Map.Entry<K, V>> stream() {
3200                 throw new RuntimeException("Stub!");
3201             }
3202 
parallelStream()3203             public java.util.stream.Stream<java.util.Map.Entry<K, V>> parallelStream() {
3204                 throw new RuntimeException("Stub!");
3205             }
3206 
iterator()3207             public java.util.Iterator<java.util.Map.Entry<K, V>> iterator() {
3208                 throw new RuntimeException("Stub!");
3209             }
3210 
toArray()3211             public java.lang.Object[] toArray() {
3212                 throw new RuntimeException("Stub!");
3213             }
3214 
toArray(T[] a)3215             public <T> T[] toArray(T[] a) {
3216                 throw new RuntimeException("Stub!");
3217             }
3218 
contains(java.lang.Object o)3219             public boolean contains(java.lang.Object o) {
3220                 throw new RuntimeException("Stub!");
3221             }
3222 
containsAll(java.util.Collection<?> coll)3223             public boolean containsAll(java.util.Collection<?> coll) {
3224                 throw new RuntimeException("Stub!");
3225             }
3226 
equals(java.lang.Object o)3227             public boolean equals(java.lang.Object o) {
3228                 throw new RuntimeException("Stub!");
3229             }
3230 
3231             private static final long serialVersionUID =
3232                     7854390611657943733L; // 0x6d0066a59f08eab5L
3233 
3234             @SuppressWarnings({"unchecked", "deprecation", "all"})
3235             private static class UnmodifiableEntry<K, V> implements java.util.Map.Entry<K, V> {
3236 
UnmodifiableEntry(java.util.Map.Entry<? extends K, ? extends V> e)3237                 UnmodifiableEntry(java.util.Map.Entry<? extends K, ? extends V> e) {
3238                     throw new RuntimeException("Stub!");
3239                 }
3240 
getKey()3241                 public K getKey() {
3242                     throw new RuntimeException("Stub!");
3243                 }
3244 
getValue()3245                 public V getValue() {
3246                     throw new RuntimeException("Stub!");
3247                 }
3248 
setValue(V value)3249                 public V setValue(V value) {
3250                     throw new RuntimeException("Stub!");
3251                 }
3252 
hashCode()3253                 public int hashCode() {
3254                     throw new RuntimeException("Stub!");
3255                 }
3256 
equals(java.lang.Object o)3257                 public boolean equals(java.lang.Object o) {
3258                     throw new RuntimeException("Stub!");
3259                 }
3260 
toString()3261                 public java.lang.String toString() {
3262                     throw new RuntimeException("Stub!");
3263                 }
3264 
3265                 private java.util.Map.Entry<? extends K, ? extends V> e;
3266             }
3267 
3268             @SuppressWarnings({"unchecked", "deprecation", "all"})
3269             static final class UnmodifiableEntrySetSpliterator<K, V>
3270                     implements java.util.Spliterator<java.util.Map.Entry<K, V>> {
3271 
UnmodifiableEntrySetSpliterator( java.util.Spliterator<java.util.Map.Entry<K, V>> s)3272                 UnmodifiableEntrySetSpliterator(
3273                         java.util.Spliterator<java.util.Map.Entry<K, V>> s) {
3274                     throw new RuntimeException("Stub!");
3275                 }
3276 
tryAdvance( java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action)3277                 public boolean tryAdvance(
3278                         java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
3279                     throw new RuntimeException("Stub!");
3280                 }
3281 
forEachRemaining( java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action)3282                 public void forEachRemaining(
3283                         java.util.function.Consumer<? super java.util.Map.Entry<K, V>> action) {
3284                     throw new RuntimeException("Stub!");
3285                 }
3286 
trySplit()3287                 public java.util.Spliterator<java.util.Map.Entry<K, V>> trySplit() {
3288                     throw new RuntimeException("Stub!");
3289                 }
3290 
estimateSize()3291                 public long estimateSize() {
3292                     throw new RuntimeException("Stub!");
3293                 }
3294 
getExactSizeIfKnown()3295                 public long getExactSizeIfKnown() {
3296                     throw new RuntimeException("Stub!");
3297                 }
3298 
characteristics()3299                 public int characteristics() {
3300                     throw new RuntimeException("Stub!");
3301                 }
3302 
hasCharacteristics(int characteristics)3303                 public boolean hasCharacteristics(int characteristics) {
3304                     throw new RuntimeException("Stub!");
3305                 }
3306 
getComparator()3307                 public java.util.Comparator<? super java.util.Map.Entry<K, V>> getComparator() {
3308                     throw new RuntimeException("Stub!");
3309                 }
3310 
3311                 final java.util.Spliterator<java.util.Map.Entry<K, V>> s;
3312 
3313                 {
3314                     s = null;
3315                 }
3316             }
3317         }
3318     }
3319 
3320     @SuppressWarnings({"unchecked", "deprecation", "all"})
3321     static class UnmodifiableNavigableMap<K, V>
3322             extends java.util.Collections.UnmodifiableSortedMap<K, V>
3323             implements java.util.NavigableMap<K, V>, java.io.Serializable {
3324 
UnmodifiableNavigableMap(java.util.NavigableMap<K, ? extends V> m)3325         UnmodifiableNavigableMap(java.util.NavigableMap<K, ? extends V> m) {
3326             super(null);
3327             throw new RuntimeException("Stub!");
3328         }
3329 
lowerKey(K key)3330         public K lowerKey(K key) {
3331             throw new RuntimeException("Stub!");
3332         }
3333 
floorKey(K key)3334         public K floorKey(K key) {
3335             throw new RuntimeException("Stub!");
3336         }
3337 
ceilingKey(K key)3338         public K ceilingKey(K key) {
3339             throw new RuntimeException("Stub!");
3340         }
3341 
higherKey(K key)3342         public K higherKey(K key) {
3343             throw new RuntimeException("Stub!");
3344         }
3345 
lowerEntry(K key)3346         public java.util.Map.Entry<K, V> lowerEntry(K key) {
3347             throw new RuntimeException("Stub!");
3348         }
3349 
floorEntry(K key)3350         public java.util.Map.Entry<K, V> floorEntry(K key) {
3351             throw new RuntimeException("Stub!");
3352         }
3353 
ceilingEntry(K key)3354         public java.util.Map.Entry<K, V> ceilingEntry(K key) {
3355             throw new RuntimeException("Stub!");
3356         }
3357 
higherEntry(K key)3358         public java.util.Map.Entry<K, V> higherEntry(K key) {
3359             throw new RuntimeException("Stub!");
3360         }
3361 
firstEntry()3362         public java.util.Map.Entry<K, V> firstEntry() {
3363             throw new RuntimeException("Stub!");
3364         }
3365 
lastEntry()3366         public java.util.Map.Entry<K, V> lastEntry() {
3367             throw new RuntimeException("Stub!");
3368         }
3369 
pollFirstEntry()3370         public java.util.Map.Entry<K, V> pollFirstEntry() {
3371             throw new RuntimeException("Stub!");
3372         }
3373 
pollLastEntry()3374         public java.util.Map.Entry<K, V> pollLastEntry() {
3375             throw new RuntimeException("Stub!");
3376         }
3377 
descendingMap()3378         public java.util.NavigableMap<K, V> descendingMap() {
3379             throw new RuntimeException("Stub!");
3380         }
3381 
navigableKeySet()3382         public java.util.NavigableSet<K> navigableKeySet() {
3383             throw new RuntimeException("Stub!");
3384         }
3385 
descendingKeySet()3386         public java.util.NavigableSet<K> descendingKeySet() {
3387             throw new RuntimeException("Stub!");
3388         }
3389 
subMap( K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)3390         public java.util.NavigableMap<K, V> subMap(
3391                 K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
3392             throw new RuntimeException("Stub!");
3393         }
3394 
headMap(K toKey, boolean inclusive)3395         public java.util.NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
3396             throw new RuntimeException("Stub!");
3397         }
3398 
tailMap(K fromKey, boolean inclusive)3399         public java.util.NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
3400             throw new RuntimeException("Stub!");
3401         }
3402 
3403         private static final java.util.Collections.UnmodifiableNavigableMap.EmptyNavigableMap<?, ?>
3404                 EMPTY_NAVIGABLE_MAP;
3405 
3406         static {
3407             EMPTY_NAVIGABLE_MAP = null;
3408         }
3409 
3410         private final java.util.NavigableMap<K, ? extends V> nm;
3411 
3412         {
3413             nm = null;
3414         }
3415 
3416         private static final long serialVersionUID = -4858195264774772197L; // 0xbc943925819d6a1bL
3417 
3418         @SuppressWarnings({"unchecked", "deprecation", "all"})
3419         private static class EmptyNavigableMap<K, V>
3420                 extends java.util.Collections.UnmodifiableNavigableMap<K, V>
3421                 implements java.io.Serializable {
3422 
EmptyNavigableMap()3423             EmptyNavigableMap() {
3424                 super(null);
3425                 throw new RuntimeException("Stub!");
3426             }
3427 
navigableKeySet()3428             public java.util.NavigableSet<K> navigableKeySet() {
3429                 throw new RuntimeException("Stub!");
3430             }
3431 
readResolve()3432             private java.lang.Object readResolve() {
3433                 throw new RuntimeException("Stub!");
3434             }
3435 
3436             private static final long serialVersionUID =
3437                     -2239321462712562324L; // 0xe0ec54fe7d1c0d6cL
3438         }
3439     }
3440 
3441     @SuppressWarnings({"unchecked", "deprecation", "all"})
3442     static class UnmodifiableNavigableSet<E> extends java.util.Collections.UnmodifiableSortedSet<E>
3443             implements java.util.NavigableSet<E>, java.io.Serializable {
3444 
UnmodifiableNavigableSet(java.util.NavigableSet<E> s)3445         UnmodifiableNavigableSet(java.util.NavigableSet<E> s) {
3446             super(null);
3447             throw new RuntimeException("Stub!");
3448         }
3449 
lower(E e)3450         public E lower(E e) {
3451             throw new RuntimeException("Stub!");
3452         }
3453 
floor(E e)3454         public E floor(E e) {
3455             throw new RuntimeException("Stub!");
3456         }
3457 
ceiling(E e)3458         public E ceiling(E e) {
3459             throw new RuntimeException("Stub!");
3460         }
3461 
higher(E e)3462         public E higher(E e) {
3463             throw new RuntimeException("Stub!");
3464         }
3465 
pollFirst()3466         public E pollFirst() {
3467             throw new RuntimeException("Stub!");
3468         }
3469 
pollLast()3470         public E pollLast() {
3471             throw new RuntimeException("Stub!");
3472         }
3473 
descendingSet()3474         public java.util.NavigableSet<E> descendingSet() {
3475             throw new RuntimeException("Stub!");
3476         }
3477 
descendingIterator()3478         public java.util.Iterator<E> descendingIterator() {
3479             throw new RuntimeException("Stub!");
3480         }
3481 
subSet( E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)3482         public java.util.NavigableSet<E> subSet(
3483                 E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
3484             throw new RuntimeException("Stub!");
3485         }
3486 
headSet(E toElement, boolean inclusive)3487         public java.util.NavigableSet<E> headSet(E toElement, boolean inclusive) {
3488             throw new RuntimeException("Stub!");
3489         }
3490 
tailSet(E fromElement, boolean inclusive)3491         public java.util.NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
3492             throw new RuntimeException("Stub!");
3493         }
3494 
3495         private static final java.util.NavigableSet<?> EMPTY_NAVIGABLE_SET;
3496 
3497         static {
3498             EMPTY_NAVIGABLE_SET = null;
3499         }
3500 
3501         private final java.util.NavigableSet<E> ns;
3502 
3503         {
3504             ns = null;
3505         }
3506 
3507         private static final long serialVersionUID = -6027448201786391929L; // 0xac5a33cb96748287L
3508 
3509         @SuppressWarnings({"unchecked", "deprecation", "all"})
3510         private static class EmptyNavigableSet<E>
3511                 extends java.util.Collections.UnmodifiableNavigableSet<E>
3512                 implements java.io.Serializable {
3513 
EmptyNavigableSet()3514             public EmptyNavigableSet() {
3515                 super(null);
3516                 throw new RuntimeException("Stub!");
3517             }
3518 
readResolve()3519             private java.lang.Object readResolve() {
3520                 throw new RuntimeException("Stub!");
3521             }
3522 
3523             private static final long serialVersionUID =
3524                     -6291252904449939134L; // 0xa8b0fad0de1de942L
3525         }
3526     }
3527 
3528     @SuppressWarnings({"unchecked", "deprecation", "all"})
3529     static class UnmodifiableRandomAccessList<E> extends java.util.Collections.UnmodifiableList<E>
3530             implements java.util.RandomAccess {
3531 
UnmodifiableRandomAccessList(java.util.List<? extends E> list)3532         UnmodifiableRandomAccessList(java.util.List<? extends E> list) {
3533             super(null);
3534             throw new RuntimeException("Stub!");
3535         }
3536 
subList(int fromIndex, int toIndex)3537         public java.util.List<E> subList(int fromIndex, int toIndex) {
3538             throw new RuntimeException("Stub!");
3539         }
3540 
writeReplace()3541         private java.lang.Object writeReplace() {
3542             throw new RuntimeException("Stub!");
3543         }
3544 
3545         private static final long serialVersionUID = -2542308836966382001L; // 0xdcb7e7951f48464fL
3546     }
3547 
3548     @SuppressWarnings({"unchecked", "deprecation", "all"})
3549     static class UnmodifiableSet<E> extends java.util.Collections.UnmodifiableCollection<E>
3550             implements java.util.Set<E>, java.io.Serializable {
3551 
UnmodifiableSet(java.util.Set<? extends E> s)3552         UnmodifiableSet(java.util.Set<? extends E> s) {
3553             super(null);
3554             throw new RuntimeException("Stub!");
3555         }
3556 
equals(java.lang.Object o)3557         public boolean equals(java.lang.Object o) {
3558             throw new RuntimeException("Stub!");
3559         }
3560 
hashCode()3561         public int hashCode() {
3562             throw new RuntimeException("Stub!");
3563         }
3564 
3565         private static final long serialVersionUID = -9215047833775013803L; // 0x801d92d18f9b8055L
3566     }
3567 
3568     @SuppressWarnings({"unchecked", "deprecation", "all"})
3569     static class UnmodifiableSortedMap<K, V> extends java.util.Collections.UnmodifiableMap<K, V>
3570             implements java.util.SortedMap<K, V>, java.io.Serializable {
3571 
UnmodifiableSortedMap(java.util.SortedMap<K, ? extends V> m)3572         UnmodifiableSortedMap(java.util.SortedMap<K, ? extends V> m) {
3573             super(null);
3574             throw new RuntimeException("Stub!");
3575         }
3576 
comparator()3577         public java.util.Comparator<? super K> comparator() {
3578             throw new RuntimeException("Stub!");
3579         }
3580 
subMap(K fromKey, K toKey)3581         public java.util.SortedMap<K, V> subMap(K fromKey, K toKey) {
3582             throw new RuntimeException("Stub!");
3583         }
3584 
headMap(K toKey)3585         public java.util.SortedMap<K, V> headMap(K toKey) {
3586             throw new RuntimeException("Stub!");
3587         }
3588 
tailMap(K fromKey)3589         public java.util.SortedMap<K, V> tailMap(K fromKey) {
3590             throw new RuntimeException("Stub!");
3591         }
3592 
firstKey()3593         public K firstKey() {
3594             throw new RuntimeException("Stub!");
3595         }
3596 
lastKey()3597         public K lastKey() {
3598             throw new RuntimeException("Stub!");
3599         }
3600 
3601         private static final long serialVersionUID = -8806743815996713206L; // 0x85c82928d3a5d70aL
3602 
3603         private final java.util.SortedMap<K, ? extends V> sm;
3604 
3605         {
3606             sm = null;
3607         }
3608     }
3609 
3610     @SuppressWarnings({"unchecked", "deprecation", "all"})
3611     static class UnmodifiableSortedSet<E> extends java.util.Collections.UnmodifiableSet<E>
3612             implements java.util.SortedSet<E>, java.io.Serializable {
3613 
UnmodifiableSortedSet(java.util.SortedSet<E> s)3614         UnmodifiableSortedSet(java.util.SortedSet<E> s) {
3615             super(null);
3616             throw new RuntimeException("Stub!");
3617         }
3618 
comparator()3619         public java.util.Comparator<? super E> comparator() {
3620             throw new RuntimeException("Stub!");
3621         }
3622 
subSet(E fromElement, E toElement)3623         public java.util.SortedSet<E> subSet(E fromElement, E toElement) {
3624             throw new RuntimeException("Stub!");
3625         }
3626 
headSet(E toElement)3627         public java.util.SortedSet<E> headSet(E toElement) {
3628             throw new RuntimeException("Stub!");
3629         }
3630 
tailSet(E fromElement)3631         public java.util.SortedSet<E> tailSet(E fromElement) {
3632             throw new RuntimeException("Stub!");
3633         }
3634 
first()3635         public E first() {
3636             throw new RuntimeException("Stub!");
3637         }
3638 
last()3639         public E last() {
3640             throw new RuntimeException("Stub!");
3641         }
3642 
3643         private static final long serialVersionUID = -4929149591599911165L; // 0xbb98248febecef03L
3644 
3645         private final java.util.SortedSet<E> ss;
3646 
3647         {
3648             ss = null;
3649         }
3650     }
3651 }
3652