0 JBC
↳1 JBCToGraph (⇒, 4926 ms)
↳2 JBCTerminationGraph
↳3 TerminationGraphToSCCProof (⇒, 0 ms)
↳4 AND
↳5 JBCTerminationSCC
↳6 SCCToIntTRSProof (⇒, 792 ms)
↳7 intTRS
↳8 PolynomialOrderProcessor (⇒, 71 ms)
↳9 intTRS
↳10 TerminationGraphProcessor (⇒, 0 ms)
↳11 intTRS
↳12 PolynomialOrderProcessor (⇔, 0 ms)
↳13 YES
↳14 JBCTerminationSCC
↳15 SCCToIntTRSProof (⇒, 225 ms)
↳16 intTRS
↳17 PolynomialOrderProcessor (⇔, 27 ms)
↳18 YES
↳19 JBCTerminationSCC
↳20 SCCToIntTRSProof (⇒, 2990 ms)
↳21 intTRS
↳22 PolynomialOrderProcessor (⇔, 0 ms)
↳23 YES
/*
* Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* This class provides a skeletal implementation of the <tt>Collection</tt>
* interface, to minimize the effort required to implement this interface. <p>
*
* To implement an unmodifiable collection, the programmer needs only to
* extend this class and provide implementations for the <tt>iterator</tt> and
* <tt>size</tt> methods. (The iterator returned by the <tt>iterator</tt>
* method must implement <tt>hasNext</tt> and <tt>next</tt>.)<p>
*
* To implement a modifiable collection, the programmer must additionally
* override this class's <tt>add</tt> method (which otherwise throws an
* <tt>UnsupportedOperationException</tt>), and the iterator returned by the
* <tt>iterator</tt> method must additionally implement its <tt>remove</tt>
* method.<p>
*
* The programmer should generally provide a void (no argument) and
* <tt>Collection</tt> constructor, as per the recommendation in the
* <tt>Collection</tt> interface specification.<p>
*
* The documentation for each non-abstract method in this class describes its
* implementation in detail. Each of these methods may be overridden if
* the collection being implemented admits a more efficient implementation.<p>
*
* This class is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* @author Josh Bloch
* @author Neal Gafter
* @see Collection
* @since 1.2
*/
public abstract class AbstractCollection<E> implements Collection<E> {
/**
* Sole constructor. (For invocation by subclass constructors, typically
* implicit.)
*/
protected AbstractCollection() {
}
// Query Operations
/**
* Returns an iterator over the elements contained in this collection.
*
* @return an iterator over the elements contained in this collection
*/
public abstract Iterator<E> iterator();
public abstract int size();
/**
* {@inheritDoc}
*
* <p>This implementation returns <tt>size() == 0</tt>.
*/
public boolean isEmpty() {
return size() == 0;
}
/**
* {@inheritDoc}
*
* <p>This implementation iterates over the elements in the collection,
* checking each element in turn for equality with the specified element.
*
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public boolean contains(Object o) {
Iterator<E> e = iterator();
if (o==null) {
while (e.hasNext())
if (e.next()==null)
return true;
} else {
while (e.hasNext())
if (o.equals(e.next()))
return true;
}
return false;
}
// Modification Operations
/**
* {@inheritDoc}
*
* <p>This implementation always throws an
* <tt>UnsupportedOperationException</tt>.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
* @throws IllegalStateException {@inheritDoc}
*/
public boolean add(E e) {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* <p>This implementation iterates over the collection looking for the
* specified element. If it finds the element, it removes the element
* from the collection using the iterator's remove method.
*
* <p>Note that this implementation throws an
* <tt>UnsupportedOperationException</tt> if the iterator returned by this
* collection's iterator method does not implement the <tt>remove</tt>
* method and this collection contains the specified object.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public boolean remove(Object o) {
Iterator<E> e = iterator();
if (o==null) {
while (e.hasNext()) {
if (e.next()==null) {
e.remove();
return true;
}
}
} else {
while (e.hasNext()) {
if (o.equals(e.next())) {
e.remove();
return true;
}
}
}
return false;
}
// Bulk Operations
/**
* {@inheritDoc}
*
* <p>This implementation iterates over the specified collection,
* checking each element returned by the iterator in turn to see
* if it's contained in this collection. If all elements are so
* contained <tt>true</tt> is returned, otherwise <tt>false</tt>.
*
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @see #contains(Object)
*/
public boolean containsAll(Collection<?> c) {
Iterator<?> e = c.iterator();
while (e.hasNext())
if (!contains(e.next()))
return false;
return true;
}
/**
* {@inheritDoc}
*
* <p>This implementation iterates over the specified collection, and adds
* each object returned by the iterator to this collection, in turn.
*
* <p>Note that this implementation will throw an
* <tt>UnsupportedOperationException</tt> unless <tt>add</tt> is
* overridden (assuming the specified collection is non-empty).
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
* @throws IllegalStateException {@inheritDoc}
*
* @see #add(Object)
*/
public boolean addAll(Collection<? extends E> c) {
boolean modified = false;
Iterator<? extends E> e = c.iterator();
while (e.hasNext()) {
if (add(e.next()))
modified = true;
}
return modified;
}
/**
* {@inheritDoc}
*
* <p>This implementation iterates over this collection, checking each
* element returned by the iterator in turn to see if it's contained
* in the specified collection. If it's so contained, it's removed from
* this collection with the iterator's <tt>remove</tt> method.
*
* <p>Note that this implementation will throw an
* <tt>UnsupportedOperationException</tt> if the iterator returned by the
* <tt>iterator</tt> method does not implement the <tt>remove</tt> method
* and this collection contains one or more elements in common with the
* specified collection.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*
* @see #remove(Object)
* @see #contains(Object)
*/
public boolean removeAll(Collection<?> c) {
boolean modified = false;
Iterator<?> e = iterator();
while (e.hasNext()) {
if (c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
/**
* {@inheritDoc}
*
* <p>This implementation iterates over this collection, checking each
* element returned by the iterator in turn to see if it's contained
* in the specified collection. If it's not so contained, it's removed
* from this collection with the iterator's <tt>remove</tt> method.
*
* <p>Note that this implementation will throw an
* <tt>UnsupportedOperationException</tt> if the iterator returned by the
* <tt>iterator</tt> method does not implement the <tt>remove</tt> method
* and this collection contains one or more elements not present in the
* specified collection.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*
* @see #remove(Object)
* @see #contains(Object)
*/
public boolean retainAll(Collection<?> c) {
boolean modified = false;
Iterator<E> e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
/**
* {@inheritDoc}
*
* <p>This implementation iterates over this collection, removing each
* element using the <tt>Iterator.remove</tt> operation. Most
* implementations will probably choose to override this method for
* efficiency.
*
* <p>Note that this implementation will throw an
* <tt>UnsupportedOperationException</tt> if the iterator returned by this
* collection's <tt>iterator</tt> method does not implement the
* <tt>remove</tt> method and this collection is non-empty.
*
* @throws UnsupportedOperationException {@inheritDoc}
*/
public void clear() {
Iterator<E> e = iterator();
while (e.hasNext()) {
e.next();
e.remove();
}
}
// String conversion
/**
* Returns a string representation of this collection. The string
* representation consists of a list of the collection's elements in the
* order they are returned by its iterator, enclosed in square brackets
* (<tt>"[]"</tt>). Adjacent elements are separated by the characters
* <tt>", "</tt> (comma and space). Elements are converted to strings as
* by {@link String#valueOf(Object)}.
*
* @return a string representation of this collection
*/
public String toString() {
Iterator<E> i = iterator();
if (! i.hasNext())
return "[]";
String sb = "";
sb = sb + "[";
for (;;) {
E e = i.next();
sb = sb + (e == this ? "(this Collection)" : e);
if (! i.hasNext()) {
sb = sb + "]";
return sb;
}
sb = sb + ", ";
}
}
}
/*
* Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
import javaUtilEx.Map.Entry;
/**
* This class provides a skeletal implementation of the <tt>Map</tt>
* interface, to minimize the effort required to implement this interface.
*
* <p>To implement an unmodifiable map, the programmer needs only to extend this
* class and provide an implementation for the <tt>entrySet</tt> method, which
* returns a set-view of the map's mappings. Typically, the returned set
* will, in turn, be implemented atop <tt>AbstractSet</tt>. This set should
* not support the <tt>add</tt> or <tt>remove</tt> methods, and its iterator
* should not support the <tt>remove</tt> method.
*
* <p>To implement a modifiable map, the programmer must additionally override
* this class's <tt>put</tt> method (which otherwise throws an
* <tt>UnsupportedOperationException</tt>), and the iterator returned by
* <tt>entrySet().iterator()</tt> must additionally implement its
* <tt>remove</tt> method.
*
* <p>The programmer should generally provide a void (no argument) and map
* constructor, as per the recommendation in the <tt>Map</tt> interface
* specification.
*
* <p>The documentation for each non-abstract method in this class describes its
* implementation in detail. Each of these methods may be overridden if the
* map being implemented admits a more efficient implementation.
*
* <p>This class is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* @param <K> the type of keys maintained by this map
* @param <V> the type of mapped values
*
* @author Josh Bloch
* @author Neal Gafter
* @see Map
* @see Collection
* @since 1.2
*/
public abstract class AbstractMap<K,V> implements Map<K,V> {
/**
* Sole constructor. (For invocation by subclass constructors, typically
* implicit.)
*/
protected AbstractMap() {
}
// Query Operations
/**
* {@inheritDoc}
*
* <p>This implementation returns <tt>entrySet().size()</tt>.
*/
public int size() {
return entrySet().size();
}
/**
* {@inheritDoc}
*
* <p>This implementation returns <tt>size() == 0</tt>.
*/
public boolean isEmpty() {
return size() == 0;
}
/**
* {@inheritDoc}
*
* <p>This implementation iterates over <tt>entrySet()</tt> searching
* for an entry with the specified value. If such an entry is found,
* <tt>true</tt> is returned. If the iteration terminates without
* finding such an entry, <tt>false</tt> is returned. Note that this
* implementation requires linear time in the size of the map.
*
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public boolean containsValue(Object value) {
Iterator<Entry<K,V>> i = entrySet().iterator();
if (value==null) {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (e.getValue()==null)
return true;
}
} else {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (value.equals(e.getValue()))
return true;
}
}
return false;
}
/**
* {@inheritDoc}
*
* <p>This implementation iterates over <tt>entrySet()</tt> searching
* for an entry with the specified key. If such an entry is found,
* <tt>true</tt> is returned. If the iteration terminates without
* finding such an entry, <tt>false</tt> is returned. Note that this
* implementation requires linear time in the size of the map; many
* implementations will override this method.
*
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public boolean containsKey(Object key) {
Iterator<Map.Entry<K,V>> i = entrySet().iterator();
if (key==null) {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (e.getKey()==null)
return true;
}
} else {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (key.equals(e.getKey()))
return true;
}
}
return false;
}
/**
* {@inheritDoc}
*
* <p>This implementation iterates over <tt>entrySet()</tt> searching
* for an entry with the specified key. If such an entry is found,
* the entry's value is returned. If the iteration terminates without
* finding such an entry, <tt>null</tt> is returned. Note that this
* implementation requires linear time in the size of the map; many
* implementations will override this method.
*
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public V get(Object key) {
Iterator<Entry<K,V>> i = entrySet().iterator();
if (key==null) {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (e.getKey()==null)
return e.getValue();
}
} else {
while (i.hasNext()) {
Entry<K,V> e = i.next();
if (key.equals(e.getKey()))
return e.getValue();
}
}
return null;
}
// Modification Operations
/**
* {@inheritDoc}
*
* <p>This implementation always throws an
* <tt>UnsupportedOperationException</tt>.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
*/
public V put(K key, V value) {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* <p>This implementation iterates over <tt>entrySet()</tt> searching for an
* entry with the specified key. If such an entry is found, its value is
* obtained with its <tt>getValue</tt> operation, the entry is removed
* from the collection (and the backing map) with the iterator's
* <tt>remove</tt> operation, and the saved value is returned. If the
* iteration terminates without finding such an entry, <tt>null</tt> is
* returned. Note that this implementation requires linear time in the
* size of the map; many implementations will override this method.
*
* <p>Note that this implementation throws an
* <tt>UnsupportedOperationException</tt> if the <tt>entrySet</tt>
* iterator does not support the <tt>remove</tt> method and this map
* contains a mapping for the specified key.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public V remove(Object key) {
Iterator<Entry<K,V>> i = entrySet().iterator();
Entry<K,V> correctEntry = null;
if (key==null) {
while (correctEntry==null && i.hasNext()) {
Entry<K,V> e = i.next();
if (e.getKey()==null)
correctEntry = e;
}
} else {
while (correctEntry==null && i.hasNext()) {
Entry<K,V> e = i.next();
if (key.equals(e.getKey()))
correctEntry = e;
}
}
V oldValue = null;
if (correctEntry !=null) {
oldValue = correctEntry.getValue();
i.remove();
}
return oldValue;
}
// Bulk Operations
/**
* {@inheritDoc}
*
* <p>This implementation iterates over the specified map's
* <tt>entrySet()</tt> collection, and calls this map's <tt>put</tt>
* operation once for each entry returned by the iteration.
*
* <p>Note that this implementation throws an
* <tt>UnsupportedOperationException</tt> if this map does not support
* the <tt>put</tt> operation and the specified map is nonempty.
*
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
*/
public void putAll(Map<? extends K, ? extends V> m) {
Iterator it = m.entrySet().iterator();
while (it.hasNext()) {
Map.Entry e = (Map.Entry) it.next();
put((K) e.getKey(), (V) e.getValue());
}
}
/**
* {@inheritDoc}
*
* <p>This implementation calls <tt>entrySet().clear()</tt>.
*
* <p>Note that this implementation throws an
* <tt>UnsupportedOperationException</tt> if the <tt>entrySet</tt>
* does not support the <tt>clear</tt> operation.
*
* @throws UnsupportedOperationException {@inheritDoc}
*/
public void clear() {
entrySet().clear();
}
// Views
/**
* Each of these fields are initialized to contain an instance of the
* appropriate view the first time this view is requested. The views are
* stateless, so there's no reason to create more than one of each.
*/
transient volatile Set<K> keySet = null;
transient volatile Collection<V> values = null;
/**
* {@inheritDoc}
*
* <p>This implementation returns a set that subclasses {@link AbstractSet}.
* The subclass's iterator method returns a "wrapper object" over this
* map's <tt>entrySet()</tt> iterator. The <tt>size</tt> method
* delegates to this map's <tt>size</tt> method and the
* <tt>contains</tt> method delegates to this map's
* <tt>containsKey</tt> method.
*
* <p>The set is created the first time this method is called,
* and returned in response to all subsequent calls. No synchronization
* is performed, so there is a slight chance that multiple calls to this
* method will not all return the same set.
*/
public Set<K> keySet() {
if (keySet == null) {
keySet = new AbstractSet<K>() {
public Iterator<K> iterator() {
return new Iterator<K>() {
private Iterator<Entry<K,V>> i = entrySet().iterator();
public boolean hasNext() {
return i.hasNext();
}
public K next() {
return i.next().getKey();
}
public void remove() {
i.remove();
}
};
}
public int size() {
return AbstractMap.this.size();
}
public boolean isEmpty() {
return AbstractMap.this.isEmpty();
}
public void clear() {
AbstractMap.this.clear();
}
public boolean contains(Object k) {
return AbstractMap.this.containsKey(k);
}
public Object[] toArray() {
Object[] res = new Object[AbstractMap.this.size()];
Iterator<Entry<K,V>> it = entrySet().iterator();
int i = 0;
while (it.hasNext())
res[i++] = it.next().getKey();
return res;
}
public <T> T[] toArray(T[] a) {
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), AbstractMap.this.size());
Object[] res = a;
Iterator<Entry<K,V>> it = entrySet().iterator();
int i = 0;
while (it.hasNext())
res[i++] = it.next().getKey();
return a;
}
};
}
return keySet;
}
/**
* {@inheritDoc}
*
* <p>This implementation returns a collection that subclasses {@link
* AbstractCollection}. The subclass's iterator method returns a
* "wrapper object" over this map's <tt>entrySet()</tt> iterator.
* The <tt>size</tt> method delegates to this map's <tt>size</tt>
* method and the <tt>contains</tt> method delegates to this map's
* <tt>containsValue</tt> method.
*
* <p>The collection is created the first time this method is called, and
* returned in response to all subsequent calls. No synchronization is
* performed, so there is a slight chance that multiple calls to this
* method will not all return the same collection.
*/
public Collection<V> values() {
if (values == null) {
values = new AbstractCollection<V>() {
public Iterator<V> iterator() {
return new Iterator<V>() {
private Iterator<Entry<K,V>> i = entrySet().iterator();
public boolean hasNext() {
return i.hasNext();
}
public V next() {
return i.next().getValue();
}
public void remove() {
i.remove();
}
};
}
public int size() {
return AbstractMap.this.size();
}
public boolean isEmpty() {
return AbstractMap.this.isEmpty();
}
public void clear() {
AbstractMap.this.clear();
}
public boolean contains(Object v) {
return AbstractMap.this.containsValue(v);
}
};
}
return values;
}
public abstract Set<Entry<K,V>> entrySet();
// Comparison and hashing
/**
* Compares the specified object with this map for equality. Returns
* <tt>true</tt> if the given object is also a map and the two maps
* represent the same mappings. More formally, two maps <tt>m1</tt> and
* <tt>m2</tt> represent the same mappings if
* <tt>m1.entrySet().equals(m2.entrySet())</tt>. This ensures that the
* <tt>equals</tt> method works properly across different implementations
* of the <tt>Map</tt> interface.
*
* <p>This implementation first checks if the specified object is this map;
* if so it returns <tt>true</tt>. Then, it checks if the specified
* object is a map whose size is identical to the size of this map; if
* not, it returns <tt>false</tt>. If so, it iterates over this map's
* <tt>entrySet</tt> collection, and checks that the specified map
* contains each mapping that this map contains. If the specified map
* fails to contain such a mapping, <tt>false</tt> is returned. If the
* iteration completes, <tt>true</tt> is returned.
*
* @param o object to be compared for equality with this map
* @return <tt>true</tt> if the specified object is equal to this map
*/
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<K,V> m = (Map<K,V>) o;
if (m.size() != size())
return false;
try {
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext()) {
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
if (value == null) {
if (!(m.get(key)==null && m.containsKey(key)))
return false;
} else {
if (!value.equals(m.get(key)))
return false;
}
}
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
return true;
}
/**
* Returns the hash code value for this map. The hash code of a map is
* defined to be the sum of the hash codes of each entry in the map's
* <tt>entrySet()</tt> view. This ensures that <tt>m1.equals(m2)</tt>
* implies that <tt>m1.hashCode()==m2.hashCode()</tt> for any two maps
* <tt>m1</tt> and <tt>m2</tt>, as required by the general contract of
* {@link Object#hashCode}.
*
* <p>This implementation iterates over <tt>entrySet()</tt>, calling
* {@link Map.Entry#hashCode hashCode()} on each element (entry) in the
* set, and adding up the results.
*
* @return the hash code value for this map
* @see Map.Entry#hashCode()
* @see Object#equals(Object)
* @see Set#equals(Object)
*/
public int hashCode() {
int h = 0;
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext())
h += i.next().hashCode();
return h;
}
/**
* Returns a string representation of this map. The string representation
* consists of a list of key-value mappings in the order returned by the
* map's <tt>entrySet</tt> view's iterator, enclosed in braces
* (<tt>"{}"</tt>). Adjacent mappings are separated by the characters
* <tt>", "</tt> (comma and space). Each key-value mapping is rendered as
* the key followed by an equals sign (<tt>"="</tt>) followed by the
* associated value. Keys and values are converted to strings as by
* {@link String#valueOf(Object)}.
*
* @return a string representation of this map
*/
public String toString() {
Iterator<Entry<K,V>> i = entrySet().iterator();
if (! i.hasNext())
return "{}";
StringBuilder sb = new StringBuilder();
sb.append('{');
for (;;) {
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
sb.append(key == this ? "(this Map)" : key);
sb.append('=');
sb.append(value == this ? "(this Map)" : value);
if (! i.hasNext())
return sb.append('}').toString();
sb.append(", ");
}
}
/**
* Returns a shallow copy of this <tt>AbstractMap</tt> instance: the keys
* and values themselves are not cloned.
*
* @return a shallow copy of this map
*/
protected Object clone() throws CloneNotSupportedException {
AbstractMap<K,V> result = (AbstractMap<K,V>)super.clone();
result.keySet = null;
result.values = null;
return result;
}
/**
* Utility method for SimpleEntry and SimpleImmutableEntry.
* Test for equality, checking for nulls.
*/
private static boolean eq(Object o1, Object o2) {
return o1 == null ? o2 == null : o1.equals(o2);
}
// Implementation Note: SimpleEntry and SimpleImmutableEntry
// are distinct unrelated classes, even though they share
// some code. Since you can't add or subtract final-ness
// of a field in a subclass, they can't share representations,
// and the amount of duplicated code is too small to warrant
// exposing a common abstract class.
/**
* An Entry maintaining a key and a value. The value may be
* changed using the <tt>setValue</tt> method. This class
* facilitates the process of building custom map
* implementations. For example, it may be convenient to return
* arrays of <tt>SimpleEntry</tt> instances in method
* <tt>Map.entrySet().toArray</tt>.
*
* @since 1.6
*/
public static class SimpleEntry<K,V>
implements Entry<K,V>, java.io.Serializable
{
private static final long serialVersionUID = -8499721149061103585L;
private final K key;
private V value;
/**
* Creates an entry representing a mapping from the specified
* key to the specified value.
*
* @param key the key represented by this entry
* @param value the value represented by this entry
*/
public SimpleEntry(K key, V value) {
this.key = key;
this.value = value;
}
/**
* Creates an entry representing the same mapping as the
* specified entry.
*
* @param entry the entry to copy
*/
public SimpleEntry(Entry<? extends K, ? extends V> entry) {
this.key = entry.getKey();
this.value = entry.getValue();
}
/**
* Returns the key corresponding to this entry.
*
* @return the key corresponding to this entry
*/
public K getKey() {
return key;
}
/**
* Returns the value corresponding to this entry.
*
* @return the value corresponding to this entry
*/
public V getValue() {
return value;
}
/**
* Replaces the value corresponding to this entry with the specified
* value.
*
* @param value new value to be stored in this entry
* @return the old value corresponding to the entry
*/
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
/**
* Compares the specified object with this entry for equality.
* Returns {@code true} if the given object is also a map entry and
* the two entries represent the same mapping. More formally, two
* entries {@code e1} and {@code e2} represent the same mapping
* if<pre>
* (e1.getKey()==null ?
* e2.getKey()==null :
* e1.getKey().equals(e2.getKey()))
* &&
* (e1.getValue()==null ?
* e2.getValue()==null :
* e1.getValue().equals(e2.getValue()))</pre>
* This ensures that the {@code equals} method works properly across
* different implementations of the {@code Map.Entry} interface.
*
* @param o object to be compared for equality with this map entry
* @return {@code true} if the specified object is equal to this map
* entry
* @see #hashCode
*/
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
return eq(key, e.getKey()) && eq(value, e.getValue());
}
/**
* Returns the hash code value for this map entry. The hash code
* of a map entry {@code e} is defined to be: <pre>
* (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
* (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
* This ensures that {@code e1.equals(e2)} implies that
* {@code e1.hashCode()==e2.hashCode()} for any two Entries
* {@code e1} and {@code e2}, as required by the general
* contract of {@link Object#hashCode}.
*
* @return the hash code value for this map entry
* @see #equals
*/
public int hashCode() {
return (key == null ? 0 : key.hashCode()) ^
(value == null ? 0 : value.hashCode());
}
/**
* Returns a String representation of this map entry. This
* implementation returns the string representation of this
* entry's key followed by the equals character ("<tt>=</tt>")
* followed by the string representation of this entry's value.
*
* @return a String representation of this map entry
*/
public String toString() {
return key + "=" + value;
}
}
/**
* An Entry maintaining an immutable key and value. This class
* does not support method <tt>setValue</tt>. This class may be
* convenient in methods that return thread-safe snapshots of
* key-value mappings.
*
* @since 1.6
*/
public static class SimpleImmutableEntry<K,V>
implements Entry<K,V>, java.io.Serializable
{
private static final long serialVersionUID = 7138329143949025153L;
private final K key;
private final V value;
/**
* Creates an entry representing a mapping from the specified
* key to the specified value.
*
* @param key the key represented by this entry
* @param value the value represented by this entry
*/
public SimpleImmutableEntry(K key, V value) {
this.key = key;
this.value = value;
}
/**
* Creates an entry representing the same mapping as the
* specified entry.
*
* @param entry the entry to copy
*/
public SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
this.key = entry.getKey();
this.value = entry.getValue();
}
/**
* Returns the key corresponding to this entry.
*
* @return the key corresponding to this entry
*/
public K getKey() {
return key;
}
/**
* Returns the value corresponding to this entry.
*
* @return the value corresponding to this entry
*/
public V getValue() {
return value;
}
/**
* Replaces the value corresponding to this entry with the specified
* value (optional operation). This implementation simply throws
* <tt>UnsupportedOperationException</tt>, as this class implements
* an <i>immutable</i> map entry.
*
* @param value new value to be stored in this entry
* @return (Does not return)
* @throws UnsupportedOperationException always
*/
public V setValue(V value) {
throw new UnsupportedOperationException();
}
/**
* Compares the specified object with this entry for equality.
* Returns {@code true} if the given object is also a map entry and
* the two entries represent the same mapping. More formally, two
* entries {@code e1} and {@code e2} represent the same mapping
* if<pre>
* (e1.getKey()==null ?
* e2.getKey()==null :
* e1.getKey().equals(e2.getKey()))
* &&
* (e1.getValue()==null ?
* e2.getValue()==null :
* e1.getValue().equals(e2.getValue()))</pre>
* This ensures that the {@code equals} method works properly across
* different implementations of the {@code Map.Entry} interface.
*
* @param o object to be compared for equality with this map entry
* @return {@code true} if the specified object is equal to this map
* entry
* @see #hashCode
*/
public boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
return eq(key, e.getKey()) && eq(value, e.getValue());
}
/**
* Returns the hash code value for this map entry. The hash code
* of a map entry {@code e} is defined to be: <pre>
* (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
* (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
* This ensures that {@code e1.equals(e2)} implies that
* {@code e1.hashCode()==e2.hashCode()} for any two Entries
* {@code e1} and {@code e2}, as required by the general
* contract of {@link Object#hashCode}.
*
* @return the hash code value for this map entry
* @see #equals
*/
public int hashCode() {
return (key == null ? 0 : key.hashCode()) ^
(value == null ? 0 : value.hashCode());
}
/**
* Returns a String representation of this map entry. This
* implementation returns the string representation of this
* entry's key followed by the equals character ("<tt>=</tt>")
* followed by the string representation of this entry's value.
*
* @return a String representation of this map entry
*/
public String toString() {
return key + "=" + value;
}
}
}
/*
* Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* This class provides a skeletal implementation of the <tt>Set</tt>
* interface to minimize the effort required to implement this
* interface. <p>
*
* The process of implementing a set by extending this class is identical
* to that of implementing a Collection by extending AbstractCollection,
* except that all of the methods and constructors in subclasses of this
* class must obey the additional constraints imposed by the <tt>Set</tt>
* interface (for instance, the add method must not permit addition of
* multiple instances of an object to a set).<p>
*
* Note that this class does not override any of the implementations from
* the <tt>AbstractCollection</tt> class. It merely adds implementations
* for <tt>equals</tt> and <tt>hashCode</tt>.<p>
*
* This class is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* @param <E> the type of elements maintained by this set
*
* @author Josh Bloch
* @author Neal Gafter
* @see Collection
* @see AbstractCollection
* @see Set
* @since 1.2
*/
public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {
/**
* Sole constructor. (For invocation by subclass constructors, typically
* implicit.)
*/
protected AbstractSet() {
}
// Comparison and hashing
/**
* Compares the specified object with this set for equality. Returns
* <tt>true</tt> if the given object is also a set, the two sets have
* the same size, and every member of the given set is contained in
* this set. This ensures that the <tt>equals</tt> method works
* properly across different implementations of the <tt>Set</tt>
* interface.<p>
*
* This implementation first checks if the specified object is this
* set; if so it returns <tt>true</tt>. Then, it checks if the
* specified object is a set whose size is identical to the size of
* this set; if not, it returns false. If so, it returns
* <tt>containsAll((Collection) o)</tt>.
*
* @param o object to be compared for equality with this set
* @return <tt>true</tt> if the specified object is equal to this set
*/
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Set))
return false;
Collection c = (Collection) o;
if (c.size() != size())
return false;
try {
return containsAll(c);
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
}
/**
* Returns the hash code value for this set. The hash code of a set is
* defined to be the sum of the hash codes of the elements in the set,
* where the hash code of a <tt>null</tt> element is defined to be zero.
* This ensures that <tt>s1.equals(s2)</tt> implies that
* <tt>s1.hashCode()==s2.hashCode()</tt> for any two sets <tt>s1</tt>
* and <tt>s2</tt>, as required by the general contract of
* {@link Object#hashCode}.
*
* <p>This implementation iterates over the set, calling the
* <tt>hashCode</tt> method on each element in the set, and adding up
* the results.
*
* @return the hash code value for this set
* @see Object#equals(Object)
* @see Set#equals(Object)
*/
public int hashCode() {
int h = 0;
Iterator<E> i = iterator();
while (i.hasNext()) {
E obj = i.next();
if (obj != null)
h += obj.hashCode();
}
return h;
}
/**
* Removes from this set all of its elements that are contained in the
* specified collection (optional operation). If the specified
* collection is also a set, this operation effectively modifies this
* set so that its value is the <i>asymmetric set difference</i> of
* the two sets.
*
* <p>This implementation determines which is the smaller of this set
* and the specified collection, by invoking the <tt>size</tt>
* method on each. If this set has fewer elements, then the
* implementation iterates over this set, checking each element
* returned by the iterator in turn to see if it is contained in
* the specified collection. If it is so contained, it is removed
* from this set with the iterator's <tt>remove</tt> method. If
* the specified collection has fewer elements, then the
* implementation iterates over the specified collection, removing
* from this set each element returned by the iterator, using this
* set's <tt>remove</tt> method.
*
* <p>Note that this implementation will throw an
* <tt>UnsupportedOperationException</tt> if the iterator returned by the
* <tt>iterator</tt> method does not implement the <tt>remove</tt> method.
*
* @param c collection containing elements to be removed from this set
* @return <tt>true</tt> if this set changed as a result of the call
* @throws UnsupportedOperationException if the <tt>removeAll</tt> operation
* is not supported by this set
* @throws ClassCastException if the class of an element of this set
* is incompatible with the specified collection (optional)
* @throws NullPointerException if this set contains a null element and the
* specified collection does not permit null elements (optional),
* or if the specified collection is null
* @see #remove(Object)
* @see #contains(Object)
*/
public boolean removeAll(Collection<?> c) {
boolean modified = false;
if (size() > c.size()) {
for (Iterator<?> i = c.iterator(); i.hasNext(); )
modified |= remove(i.next());
} else {
for (Iterator<?> i = iterator(); i.hasNext(); ) {
if (c.contains(i.next())) {
i.remove();
modified = true;
}
}
}
return modified;
}
}
/*
* Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* The root interface in the <i>collection hierarchy</i>. A collection
* represents a group of objects, known as its <i>elements</i>. Some
* collections allow duplicate elements and others do not. Some are ordered
* and others unordered. The JDK does not provide any <i>direct</i>
* implementations of this interface: it provides implementations of more
* specific subinterfaces like <tt>Set</tt> and <tt>List</tt>. This interface
* is typically used to pass collections around and manipulate them where
* maximum generality is desired.
*
* <p><i>Bags</i> or <i>multisets</i> (unordered collections that may contain
* duplicate elements) should implement this interface directly.
*
* <p>All general-purpose <tt>Collection</tt> implementation classes (which
* typically implement <tt>Collection</tt> indirectly through one of its
* subinterfaces) should provide two "standard" constructors: a void (no
* arguments) constructor, which creates an empty collection, and a
* constructor with a single argument of type <tt>Collection</tt>, which
* creates a new collection with the same elements as its argument. In
* effect, the latter constructor allows the user to copy any collection,
* producing an equivalent collection of the desired implementation type.
* There is no way to enforce this convention (as interfaces cannot contain
* constructors) but all of the general-purpose <tt>Collection</tt>
* implementations in the Java platform libraries comply.
*
* <p>The "destructive" methods contained in this interface, that is, the
* methods that modify the collection on which they operate, are specified to
* throw <tt>UnsupportedOperationException</tt> if this collection does not
* support the operation. If this is the case, these methods may, but are not
* required to, throw an <tt>UnsupportedOperationException</tt> if the
* invocation would have no effect on the collection. For example, invoking
* the {@link #addAll(Collection)} method on an unmodifiable collection may,
* but is not required to, throw the exception if the collection to be added
* is empty.
*
* <p>Some collection implementations have restrictions on the elements that
* they may contain. For example, some implementations prohibit null elements,
* and some have restrictions on the types of their elements. Attempting to
* add an ineligible element throws an unchecked exception, typically
* <tt>NullPointerException</tt> or <tt>ClassCastException</tt>. Attempting
* to query the presence of an ineligible element may throw an exception,
* or it may simply return false; some implementations will exhibit the former
* behavior and some will exhibit the latter. More generally, attempting an
* operation on an ineligible element whose completion would not result in
* the insertion of an ineligible element into the collection may throw an
* exception or it may succeed, at the option of the implementation.
* Such exceptions are marked as "optional" in the specification for this
* interface.
*
* <p>It is up to each collection to determine its own synchronization
* policy. In the absence of a stronger guarantee by the
* implementation, undefined behavior may result from the invocation
* of any method on a collection that is being mutated by another
* thread; this includes direct invocations, passing the collection to
* a method that might perform invocations, and using an existing
* iterator to examine the collection.
*
* <p>Many methods in Collections Framework interfaces are defined in
* terms of the {@link Object#equals(Object) equals} method. For example,
* the specification for the {@link #contains(Object) contains(Object o)}
* method says: "returns <tt>true</tt> if and only if this collection
* contains at least one element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>." This specification should
* <i>not</i> be construed to imply that invoking <tt>Collection.contains</tt>
* with a non-null argument <tt>o</tt> will cause <tt>o.equals(e)</tt> to be
* invoked for any element <tt>e</tt>. Implementations are free to implement
* optimizations whereby the <tt>equals</tt> invocation is avoided, for
* example, by first comparing the hash codes of the two elements. (The
* {@link Object#hashCode()} specification guarantees that two objects with
* unequal hash codes cannot be equal.) More generally, implementations of
* the various Collections Framework interfaces are free to take advantage of
* the specified behavior of underlying {@link Object} methods wherever the
* implementor deems it appropriate.
*
* <p>This interface is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* @author Josh Bloch
* @author Neal Gafter
* @see Set
* @see List
* @see Map
* @see SortedSet
* @see SortedMap
* @see HashSet
* @see TreeSet
* @see ArrayList
* @see LinkedList
* @see Vector
* @see Collections
* @see Arrays
* @see AbstractCollection
* @since 1.2
*/
public interface Collection<E> {
// Query Operations
/**
* Returns the number of elements in this collection. If this collection
* contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
* <tt>Integer.MAX_VALUE</tt>.
*
* @return the number of elements in this collection
*/
int size();
/**
* Returns <tt>true</tt> if this collection contains no elements.
*
* @return <tt>true</tt> if this collection contains no elements
*/
boolean isEmpty();
/**
* Returns <tt>true</tt> if this collection contains the specified element.
* More formally, returns <tt>true</tt> if and only if this collection
* contains at least one element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>.
*
* @param o element whose presence in this collection is to be tested
* @return <tt>true</tt> if this collection contains the specified
* element
* @throws ClassCastException if the type of the specified element
* is incompatible with this collection (optional)
* @throws NullPointerException if the specified element is null and this
* collection does not permit null elements (optional)
*/
boolean contains(Object o);
/**
* Returns an iterator over the elements in this collection. There are no
* guarantees concerning the order in which the elements are returned
* (unless this collection is an instance of some class that provides a
* guarantee).
*
* @return an <tt>Iterator</tt> over the elements in this collection
*/
Iterator<E> iterator();
// Modification Operations
/**
* Ensures that this collection contains the specified element (optional
* operation). Returns <tt>true</tt> if this collection changed as a
* result of the call. (Returns <tt>false</tt> if this collection does
* not permit duplicates and already contains the specified element.)<p>
*
* Collections that support this operation may place limitations on what
* elements may be added to this collection. In particular, some
* collections will refuse to add <tt>null</tt> elements, and others will
* impose restrictions on the type of elements that may be added.
* Collection classes should clearly specify in their documentation any
* restrictions on what elements may be added.<p>
*
* If a collection refuses to add a particular element for any reason
* other than that it already contains the element, it <i>must</i> throw
* an exception (rather than returning <tt>false</tt>). This preserves
* the invariant that a collection always contains the specified element
* after this call returns.
*
* @param e element whose presence in this collection is to be ensured
* @return <tt>true</tt> if this collection changed as a result of the
* call
* @throws UnsupportedOperationException if the <tt>add</tt> operation
* is not supported by this collection
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this collection
* @throws NullPointerException if the specified element is null and this
* collection does not permit null elements
* @throws IllegalArgumentException if some property of the element
* prevents it from being added to this collection
* @throws IllegalStateException if the element cannot be added at this
* time due to insertion restrictions
*/
boolean add(E e);
/**
* Removes a single instance of the specified element from this
* collection, if it is present (optional operation). More formally,
* removes an element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>, if
* this collection contains one or more such elements. Returns
* <tt>true</tt> if this collection contained the specified element (or
* equivalently, if this collection changed as a result of the call).
*
* @param o element to be removed from this collection, if present
* @return <tt>true</tt> if an element was removed as a result of this call
* @throws ClassCastException if the type of the specified element
* is incompatible with this collection (optional)
* @throws NullPointerException if the specified element is null and this
* collection does not permit null elements (optional)
* @throws UnsupportedOperationException if the <tt>remove</tt> operation
* is not supported by this collection
*/
boolean remove(Object o);
// Bulk Operations
/**
* Returns <tt>true</tt> if this collection contains all of the elements
* in the specified collection.
*
* @param c collection to be checked for containment in this collection
* @return <tt>true</tt> if this collection contains all of the elements
* in the specified collection
* @throws ClassCastException if the types of one or more elements
* in the specified collection are incompatible with this
* collection (optional)
* @throws NullPointerException if the specified collection contains one
* or more null elements and this collection does not permit null
* elements (optional), or if the specified collection is null
* @see #contains(Object)
*/
boolean containsAll(Collection<?> c);
/**
* Adds all of the elements in the specified collection to this collection
* (optional operation). The behavior of this operation is undefined if
* the specified collection is modified while the operation is in progress.
* (This implies that the behavior of this call is undefined if the
* specified collection is this collection, and this collection is
* nonempty.)
*
* @param c collection containing elements to be added to this collection
* @return <tt>true</tt> if this collection changed as a result of the call
* @throws UnsupportedOperationException if the <tt>addAll</tt> operation
* is not supported by this collection
* @throws ClassCastException if the class of an element of the specified
* collection prevents it from being added to this collection
* @throws NullPointerException if the specified collection contains a
* null element and this collection does not permit null elements,
* or if the specified collection is null
* @throws IllegalArgumentException if some property of an element of the
* specified collection prevents it from being added to this
* collection
* @throws IllegalStateException if not all the elements can be added at
* this time due to insertion restrictions
* @see #add(Object)
*/
boolean addAll(Collection<? extends E> c);
/**
* Removes all of this collection's elements that are also contained in the
* specified collection (optional operation). After this call returns,
* this collection will contain no elements in common with the specified
* collection.
*
* @param c collection containing elements to be removed from this collection
* @return <tt>true</tt> if this collection changed as a result of the
* call
* @throws UnsupportedOperationException if the <tt>removeAll</tt> method
* is not supported by this collection
* @throws ClassCastException if the types of one or more elements
* in this collection are incompatible with the specified
* collection (optional)
* @throws NullPointerException if this collection contains one or more
* null elements and the specified collection does not support
* null elements (optional), or if the specified collection is null
* @see #remove(Object)
* @see #contains(Object)
*/
boolean removeAll(Collection<?> c);
/**
* Retains only the elements in this collection that are contained in the
* specified collection (optional operation). In other words, removes from
* this collection all of its elements that are not contained in the
* specified collection.
*
* @param c collection containing elements to be retained in this collection
* @return <tt>true</tt> if this collection changed as a result of the call
* @throws UnsupportedOperationException if the <tt>retainAll</tt> operation
* is not supported by this collection
* @throws ClassCastException if the types of one or more elements
* in this collection are incompatible with the specified
* collection (optional)
* @throws NullPointerException if this collection contains one or more
* null elements and the specified collection does not permit null
* elements (optional), or if the specified collection is null
* @see #remove(Object)
* @see #contains(Object)
*/
boolean retainAll(Collection<?> c);
/**
* Removes all of the elements from this collection (optional operation).
* The collection will be empty after this method returns.
*
* @throws UnsupportedOperationException if the <tt>clear</tt> operation
* is not supported by this collection
*/
void clear();
// Comparison and hashing
/**
* Compares the specified object with this collection for equality. <p>
*
* While the <tt>Collection</tt> interface adds no stipulations to the
* general contract for the <tt>Object.equals</tt>, programmers who
* implement the <tt>Collection</tt> interface "directly" (in other words,
* create a class that is a <tt>Collection</tt> but is not a <tt>Set</tt>
* or a <tt>List</tt>) must exercise care if they choose to override the
* <tt>Object.equals</tt>. It is not necessary to do so, and the simplest
* course of action is to rely on <tt>Object</tt>'s implementation, but
* the implementor may wish to implement a "value comparison" in place of
* the default "reference comparison." (The <tt>List</tt> and
* <tt>Set</tt> interfaces mandate such value comparisons.)<p>
*
* The general contract for the <tt>Object.equals</tt> method states that
* equals must be symmetric (in other words, <tt>a.equals(b)</tt> if and
* only if <tt>b.equals(a)</tt>). The contracts for <tt>List.equals</tt>
* and <tt>Set.equals</tt> state that lists are only equal to other lists,
* and sets to other sets. Thus, a custom <tt>equals</tt> method for a
* collection class that implements neither the <tt>List</tt> nor
* <tt>Set</tt> interface must return <tt>false</tt> when this collection
* is compared to any list or set. (By the same logic, it is not possible
* to write a class that correctly implements both the <tt>Set</tt> and
* <tt>List</tt> interfaces.)
*
* @param o object to be compared for equality with this collection
* @return <tt>true</tt> if the specified object is equal to this
* collection
*
* @see Object#equals(Object)
* @see Set#equals(Object)
* @see List#equals(Object)
*/
boolean equals(Object o);
/**
* Returns the hash code value for this collection. While the
* <tt>Collection</tt> interface adds no stipulations to the general
* contract for the <tt>Object.hashCode</tt> method, programmers should
* take note that any class that overrides the <tt>Object.equals</tt>
* method must also override the <tt>Object.hashCode</tt> method in order
* to satisfy the general contract for the <tt>Object.hashCode</tt>method.
* In particular, <tt>c1.equals(c2)</tt> implies that
* <tt>c1.hashCode()==c2.hashCode()</tt>.
*
* @return the hash code value for this collection
*
* @see Object#hashCode()
* @see Object#equals(Object)
*/
int hashCode();
}
/*
* Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* This exception may be thrown by methods that have detected concurrent
* modification of an object when such modification is not permissible.
* <p>
* For example, it is not generally permissible for one thread to modify a Collection
* while another thread is iterating over it. In general, the results of the
* iteration are undefined under these circumstances. Some Iterator
* implementations (including those of all the general purpose collection implementations
* provided by the JRE) may choose to throw this exception if this behavior is
* detected. Iterators that do this are known as <i>fail-fast</i> iterators,
* as they fail quickly and cleanly, rather that risking arbitrary,
* non-deterministic behavior at an undetermined time in the future.
* <p>
* Note that this exception does not always indicate that an object has
* been concurrently modified by a <i>different</i> thread. If a single
* thread issues a sequence of method invocations that violates the
* contract of an object, the object may throw this exception. For
* example, if a thread modifies a collection directly while it is
* iterating over the collection with a fail-fast iterator, the iterator
* will throw this exception.
*
* <p>Note that fail-fast behavior cannot be guaranteed as it is, generally
* speaking, impossible to make any hard guarantees in the presence of
* unsynchronized concurrent modification. Fail-fast operations
* throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
* Therefore, it would be wrong to write a program that depended on this
* exception for its correctness: <i><tt>ConcurrentModificationException</tt>
* should be used only to detect bugs.</i>
*
* @author Josh Bloch
* @see Collection
* @see Iterator
* @see ListIterator
* @see Vector
* @see LinkedList
* @see HashSet
* @see Hashtable
* @see TreeMap
* @see AbstractList
* @since 1.2
*/
public class ConcurrentModificationException extends RuntimeException {
/**
* Constructs a ConcurrentModificationException with no
* detail message.
*/
public ConcurrentModificationException() {
}
/**
* Constructs a <tt>ConcurrentModificationException</tt> with the
* specified detail message.
*
* @param message the detail message pertaining to this exception.
*/
public ConcurrentModificationException(String message) {
super(message);
}
}
/*
* Copyright 1997-2007 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* Hash table based implementation of the <tt>Map</tt> interface. This
* implementation provides all of the optional map operations, and permits
* <tt>null</tt> values and the <tt>null</tt> key. (The <tt>HashMap</tt>
* class is roughly equivalent to <tt>Hashtable</tt>, except that it is
* unsynchronized and permits nulls.) This class makes no guarantees as to
* the order of the map; in particular, it does not guarantee that the order
* will remain constant over time.
*
* <p>This implementation provides constant-time performance for the basic
* operations (<tt>get</tt> and <tt>put</tt>), assuming the hash function
* disperses the elements properly among the buckets. Iteration over
* collection views requires time proportional to the "capacity" of the
* <tt>HashMap</tt> instance (the number of buckets) plus its size (the number
* of key-value mappings). Thus, it's very important not to set the initial
* capacity too high (or the load factor too low) if iteration performance is
* important.
*
* <p>An instance of <tt>HashMap</tt> has two parameters that affect its
* performance: <i>initial capacity</i> and <i>load factor</i>. The
* <i>capacity</i> is the number of buckets in the hash table, and the initial
* capacity is simply the capacity at the time the hash table is created. The
* <i>load factor</i> is a measure of how full the hash table is allowed to
* get before its capacity is automatically increased. When the number of
* entries in the hash table exceeds the product of the load factor and the
* current capacity, the hash table is <i>rehashed</i> (that is, internal data
* structures are rebuilt) so that the hash table has approximately twice the
* number of buckets.
*
* <p>As a general rule, the default load factor (.75) offers a good tradeoff
* between time and space costs. Higher values decrease the space overhead
* but increase the lookup cost (reflected in most of the operations of the
* <tt>HashMap</tt> class, including <tt>get</tt> and <tt>put</tt>). The
* expected number of entries in the map and its load factor should be taken
* into account when setting its initial capacity, so as to minimize the
* number of rehash operations. If the initial capacity is greater
* than the maximum number of entries divided by the load factor, no
* rehash operations will ever occur.
*
* <p>If many mappings are to be stored in a <tt>HashMap</tt> instance,
* creating it with a sufficiently large capacity will allow the mappings to
* be stored more efficiently than letting it perform automatic rehashing as
* needed to grow the table.
*
* <p><strong>Note that this implementation is not synchronized.</strong>
* If multiple threads access a hash map concurrently, and at least one of
* the threads modifies the map structurally, it <i>must</i> be
* synchronized externally. (A structural modification is any operation
* that adds or deletes one or more mappings; merely changing the value
* associated with a key that an instance already contains is not a
* structural modification.) This is typically accomplished by
* synchronizing on some object that naturally encapsulates the map.
*
* If no such object exists, the map should be "wrapped" using the
* {@link Collections#synchronizedMap Collections.synchronizedMap}
* method. This is best done at creation time, to prevent accidental
* unsynchronized access to the map:<pre>
* Map m = Collections.synchronizedMap(new HashMap(...));</pre>
*
* <p>The iterators returned by all of this class's "collection view methods"
* are <i>fail-fast</i>: if the map is structurally modified at any time after
* the iterator is created, in any way except through the iterator's own
* <tt>remove</tt> method, the iterator will throw a
* {@link ConcurrentModificationException}. Thus, in the face of concurrent
* modification, the iterator fails quickly and cleanly, rather than risking
* arbitrary, non-deterministic behavior at an undetermined time in the
* future.
*
* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
* as it is, generally speaking, impossible to make any hard guarantees in the
* presence of unsynchronized concurrent modification. Fail-fast iterators
* throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
* Therefore, it would be wrong to write a program that depended on this
* exception for its correctness: <i>the fail-fast behavior of iterators
* should be used only to detect bugs.</i>
*
* <p>This class is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* @param <K> the type of keys maintained by this map
* @param <V> the type of mapped values
*
* @author Doug Lea
* @author Josh Bloch
* @author Arthur van Hoff
* @author Neal Gafter
* @see Object#hashCode()
* @see Collection
* @see Map
* @see TreeMap
* @see Hashtable
* @since 1.2
*/
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable
{
/**
* The default initial capacity - MUST be a power of two.
*/
static final int DEFAULT_INITIAL_CAPACITY = 16;
/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* The load factor used when none specified in constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* The table, resized as necessary. Length MUST Always be a power of two.
*/
transient Entry[] table;
/**
* The number of key-value mappings contained in this map.
*/
transient int size;
/**
* The next size value at which to resize (capacity * load factor).
* @serial
*/
int threshold;
/**
* The load factor for the hash table.
*
* @serial
*/
final float loadFactor;
/**
* The number of times this HashMap has been structurally modified
* Structural modifications are those that change the number of mappings in
* the HashMap or otherwise modify its internal structure (e.g.,
* rehash). This field is used to make iterators on Collection-views of
* the HashMap fail-fast. (See ConcurrentModificationException).
*/
transient volatile int modCount;
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and load factor.
*
* @param initialCapacity the initial capacity
* @param loadFactor the load factor
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// Find a power of 2 >= initialCapacity
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
this.loadFactor = loadFactor;
threshold = (int)(capacity * loadFactor);
table = new Entry[capacity];
init();
}
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and the default load factor (0.75).
*
* @param initialCapacity the initial capacity.
* @throws IllegalArgumentException if the initial capacity is negative.
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init();
}
/**
* Constructs a new <tt>HashMap</tt> with the same mappings as the
* specified <tt>Map</tt>. The <tt>HashMap</tt> is created with
* default load factor (0.75) and an initial capacity sufficient to
* hold the mappings in the specified <tt>Map</tt>.
*
* @param m the map whose mappings are to be placed in this map
* @throws NullPointerException if the specified map is null
*/
public HashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
putAllForCreate(m);
}
// internal utilities
/**
* Initialization hook for subclasses. This method is called
* in all constructors and pseudo-constructors (clone, readObject)
* after HashMap has been initialized but before any entries have
* been inserted. (In the absence of this method, readObject would
* require explicit knowledge of subclasses.)
*/
void init() {
}
/**
* Applies a supplemental hash function to a given hashCode, which
* defends against poor quality hash functions. This is critical
* because HashMap uses power-of-two length hash tables, that
* otherwise encounter collisions for hashCodes that do not differ
* in lower bits. Note: Null keys always map to hash 0, thus index 0.
*/
static int hash(int h) {
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
/**
* Returns index for hash code h.
*/
static int indexFor(int h, int length) {
return h & (length-1);
}
/**
* Returns the number of key-value mappings in this map.
*
* @return the number of key-value mappings in this map
*/
public int size() {
return size;
}
/**
* Returns <tt>true</tt> if this map contains no key-value mappings.
*
* @return <tt>true</tt> if this map contains no key-value mappings
*/
public boolean isEmpty() {
return size == 0;
}
/**
* Returns the value to which the specified key is mapped,
* or {@code null} if this map contains no mapping for the key.
*
* <p>More formally, if this map contains a mapping from a key
* {@code k} to a value {@code v} such that {@code (key==null ? k==null :
* key.equals(k))}, then this method returns {@code v}; otherwise
* it returns {@code null}. (There can be at most one such mapping.)
*
* <p>A return value of {@code null} does not <i>necessarily</i>
* indicate that the map contains no mapping for the key; it's also
* possible that the map explicitly maps the key to {@code null}.
* The {@link #containsKey containsKey} operation may be used to
* distinguish these two cases.
*
* @see #put(Object, Object)
*/
public V get(Object key) {
if (key == null)
return getForNullKey();
int hash = hash(key.hashCode());
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
return e.value;
}
return null;
}
/**
* Offloaded version of get() to look up null keys. Null keys map
* to index 0. This null case is split out into separate methods
* for the sake of performance in the two most commonly used
* operations (get and put), but incorporated with conditionals in
* others.
*/
private V getForNullKey() {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
/**
* Returns <tt>true</tt> if this map contains a mapping for the
* specified key.
*
* @param key The key whose presence in this map is to be tested
* @return <tt>true</tt> if this map contains a mapping for the specified
* key.
*/
public boolean containsKey(Object key) {
return getEntry(key) != null;
}
/**
* Returns the entry associated with the specified key in the
* HashMap. Returns null if the HashMap contains no mapping
* for the key.
*/
final Entry<K,V> getEntry(Object key) {
int hash = (key == null) ? 0 : hash(key.hashCode());
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
/**
* Associates the specified value with the specified key in this map.
* If the map previously contained a mapping for the key, the old
* value is replaced.
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
* @return the previous value associated with <tt>key</tt>, or
* <tt>null</tt> if there was no mapping for <tt>key</tt>.
* (A <tt>null</tt> return can also indicate that the map
* previously associated <tt>null</tt> with <tt>key</tt>.)
*/
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
/**
* Offloaded version of put for null keys
*/
private V putForNullKey(V value) {
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(0, null, value, 0);
return null;
}
/**
* This method is used instead of put by constructors and
* pseudoconstructors (clone, readObject). It does not resize the table,
* check for comodification, etc. It calls createEntry rather than
* addEntry.
*/
private void putForCreate(K key, V value) {
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
/**
* Look for preexisting entry for key. This will never happen for
* clone or deserialize. It will only happen for construction if the
* input Map is a sorted map whose ordering is inconsistent w/ equals.
*/
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
createEntry(hash, key, value, i);
}
private void putAllForCreate(Map<? extends K, ? extends V> m) {
for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
Map.Entry<? extends K, ? extends V> e = i.next();
putForCreate(e.getKey(), e.getValue());
}
}
/**
* Rehashes the contents of this map into a new array with a
* larger capacity. This method is called automatically when the
* number of keys in this map reaches its threshold.
*
* If current capacity is MAXIMUM_CAPACITY, this method does not
* resize the map, but sets threshold to Integer.MAX_VALUE.
* This has the effect of preventing future calls.
*
* @param newCapacity the new capacity, MUST be a power of two;
* must be greater than current capacity unless current
* capacity is MAXIMUM_CAPACITY (in which case value
* is irrelevant).
*/
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable);
table = newTable;
threshold = (int)(newCapacity * loadFactor);
}
/**
* Transfers all entries from current table to newTable.
*/
void transfer(Entry[] newTable) {
Entry[] src = table;
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) {
Entry<K,V> e = src[j];
if (e != null) {
src[j] = null;
do {
Entry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
} while (e != null);
}
}
}
/**
* Copies all of the mappings from the specified map to this map.
* These mappings will replace any mappings that this map had for
* any of the keys currently in the specified map.
*
* @param m mappings to be stored in this map
* @throws NullPointerException if the specified map is null
*/
public void putAll(Map<? extends K, ? extends V> m) {
int numKeysToBeAdded = m.size();
if (numKeysToBeAdded == 0)
return;
/*
* Expand the map if the map if the number of mappings to be added
* is greater than or equal to threshold. This is conservative; the
* obvious condition is (m.size() + size) >= threshold, but this
* condition could result in a map with twice the appropriate capacity,
* if the keys to be added overlap with the keys already in this map.
* By using the conservative calculation, we subject ourself
* to at most one extra resize.
*/
if (numKeysToBeAdded > threshold) {
int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
if (targetCapacity > MAXIMUM_CAPACITY)
targetCapacity = MAXIMUM_CAPACITY;
int newCapacity = table.length;
while (newCapacity < targetCapacity)
newCapacity <<= 1;
if (newCapacity > table.length)
resize(newCapacity);
}
for (Iterator<? extends Map.Entry<? extends K, ? extends V>> i = m.entrySet().iterator(); i.hasNext(); ) {
Map.Entry<? extends K, ? extends V> e = i.next();
put(e.getKey(), e.getValue());
}
}
/**
* Removes the mapping for the specified key from this map if present.
*
* @param key key whose mapping is to be removed from the map
* @return the previous value associated with <tt>key</tt>, or
* <tt>null</tt> if there was no mapping for <tt>key</tt>.
* (A <tt>null</tt> return can also indicate that the map
* previously associated <tt>null</tt> with <tt>key</tt>.)
*/
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
/**
* Removes and returns the entry associated with the specified key
* in the HashMap. Returns null if the HashMap contains no mapping
* for this key.
*/
final Entry<K,V> removeEntryForKey(Object key) {
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
Entry<K,V> prev = table[i];
Entry<K,V> e = prev;
while (e != null) {
Entry<K,V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
/**
* Special version of remove for EntrySet.
*/
final Entry<K,V> removeMapping(Object o) {
if (!(o instanceof Map.Entry))
return null;
Map.Entry<K,V> entry = (Map.Entry<K,V>) o;
Object key = entry.getKey();
int hash = (key == null) ? 0 : hash(key.hashCode());
int i = indexFor(hash, table.length);
Entry<K,V> prev = table[i];
Entry<K,V> e = prev;
while (e != null) {
Entry<K,V> next = e.next;
if (e.hash == hash && e.equals(entry)) {
modCount++;
size--;
if (prev == e)
table[i] = next;
else
prev.next = next;
e.recordRemoval(this);
return e;
}
prev = e;
e = next;
}
return e;
}
/**
* Removes all of the mappings from this map.
* The map will be empty after this call returns.
*/
public void clear() {
modCount++;
Entry[] tab = table;
for (int i = 0; i < tab.length; i++)
tab[i] = null;
size = 0;
}
/**
* Returns <tt>true</tt> if this map maps one or more keys to the
* specified value.
*
* @param value value whose presence in this map is to be tested
* @return <tt>true</tt> if this map maps one or more keys to the
* specified value
*/
public boolean containsValue(Object value) {
if (value == null)
return containsNullValue();
Entry[] tab = table;
for (int i = 0; i < tab.length ; i++)
for (Entry e = tab[i] ; e != null ; e = e.next)
if (value.equals(e.value))
return true;
return false;
}
/**
* Special-case code for containsValue with null argument
*/
private boolean containsNullValue() {
Entry[] tab = table;
for (int i = 0; i < tab.length ; i++)
for (Entry e = tab[i] ; e != null ; e = e.next)
if (e.value == null)
return true;
return false;
}
/**
* Returns a shallow copy of this <tt>HashMap</tt> instance: the keys and
* values themselves are not cloned.
*
* @return a shallow copy of this map
*/
public Object clone() {
HashMap<K,V> result = null;
try {
result = (HashMap<K,V>)super.clone();
} catch (CloneNotSupportedException e) {
// assert false;
}
result.table = new Entry[table.length];
result.entrySet = null;
result.modCount = 0;
result.size = 0;
result.init();
result.putAllForCreate(this);
return result;
}
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;
final int hash;
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
public final K getKey() {
return key;
}
public final V getValue() {
return value;
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry e = (Map.Entry)o;
Object k1 = getKey();
Object k2 = e.getKey();
if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue();
if (v1 == v2 || (v1 != null && v1.equals(v2)))
return true;
}
return false;
}
public final int hashCode() {
return (key==null ? 0 : key.hashCode()) ^
(value==null ? 0 : value.hashCode());
}
public final String toString() {
return getKey() + "=" + getValue();
}
/**
* This method is invoked whenever the value in an entry is
* overwritten by an invocation of put(k,v) for a key k that's already
* in the HashMap.
*/
void recordAccess(HashMap<K,V> m) {
}
/**
* This method is invoked whenever the entry is
* removed from the table.
*/
void recordRemoval(HashMap<K,V> m) {
}
}
/**
* Adds a new entry with the specified key, value and hash code to
* the specified bucket. It is the responsibility of this
* method to resize the table if appropriate.
*
* Subclass overrides this to alter the behavior of put method.
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}
/**
* Like addEntry except that this version is used when creating entries
* as part of Map construction or "pseudo-construction" (cloning,
* deserialization). This version needn't worry about resizing the table.
*
* Subclass overrides this to alter the behavior of HashMap(Map),
* clone, and readObject.
*/
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
size++;
}
private abstract class HashIterator<E> implements Iterator<E> {
Entry<K,V> next; // next entry to return
int expectedModCount; // For fast-fail
int index; // current slot
Entry<K,V> current; // current entry
HashIterator() {
expectedModCount = modCount;
if (size > 0) { // advance to first entry
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
final Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
if ((next = e.next) == null) {
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
public void remove() {
if (current == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Object k = current.key;
current = null;
HashMap.this.removeEntryForKey(k);
expectedModCount = modCount;
}
}
private final class ValueIterator extends HashIterator<V> {
public V next() {
return nextEntry().value;
}
}
private final class KeyIterator extends HashIterator<K> {
public K next() {
return nextEntry().getKey();
}
}
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}
// Subclass overrides these to alter behavior of views' iterator() method
Iterator<K> newKeyIterator() {
return new KeyIterator();
}
Iterator<V> newValueIterator() {
return new ValueIterator();
}
Iterator<Map.Entry<K,V>> newEntryIterator() {
return new EntryIterator();
}
// Views
private transient Set<Map.Entry<K,V>> entrySet = null;
/**
* Returns a {@link Set} view of the keys contained in this map.
* The set is backed by the map, so changes to the map are
* reflected in the set, and vice-versa. If the map is modified
* while an iteration over the set is in progress (except through
* the iterator's own <tt>remove</tt> operation), the results of
* the iteration are undefined. The set supports element removal,
* which removes the corresponding mapping from the map, via the
* <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
* <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>
* operations. It does not support the <tt>add</tt> or <tt>addAll</tt>
* operations.
*/
public Set<K> keySet() {
Set<K> ks = keySet;
return (ks != null ? ks : (keySet = new KeySet()));
}
private final class KeySet extends AbstractSet<K> {
public Iterator<K> iterator() {
return newKeyIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsKey(o);
}
public boolean remove(Object o) {
return HashMap.this.removeEntryForKey(o) != null;
}
public void clear() {
HashMap.this.clear();
}
public Object[] toArray() {
Object[] res = new Object[size];
Iterator<K> it = iterator();
int i = 0;
while (it.hasNext())
res[i++] = it.next();
return res;
}
public <T> T[] toArray(T[] a) {
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
Object[] res = a;
Iterator<K> it = iterator();
int i = 0;
while (it.hasNext())
res[i++] = it.next();
return a;
}
}
/**
* Returns a {@link Collection} view of the values contained in this map.
* The collection is backed by the map, so changes to the map are
* reflected in the collection, and vice-versa. If the map is
* modified while an iteration over the collection is in progress
* (except through the iterator's own <tt>remove</tt> operation),
* the results of the iteration are undefined. The collection
* supports element removal, which removes the corresponding
* mapping from the map, via the <tt>Iterator.remove</tt>,
* <tt>Collection.remove</tt>, <tt>removeAll</tt>,
* <tt>retainAll</tt> and <tt>clear</tt> operations. It does not
* support the <tt>add</tt> or <tt>addAll</tt> operations.
*/
public Collection<V> values() {
Collection<V> vs = values;
return (vs != null ? vs : (values = new Values()));
}
private final class Values extends AbstractCollection<V> {
public Iterator<V> iterator() {
return newValueIterator();
}
public int size() {
return size;
}
public boolean contains(Object o) {
return containsValue(o);
}
public void clear() {
HashMap.this.clear();
}
}
/**
* Returns a {@link Set} view of the mappings contained in this map.
* The set is backed by the map, so changes to the map are
* reflected in the set, and vice-versa. If the map is modified
* while an iteration over the set is in progress (except through
* the iterator's own <tt>remove</tt> operation, or through the
* <tt>setValue</tt> operation on a map entry returned by the
* iterator) the results of the iteration are undefined. The set
* supports element removal, which removes the corresponding
* mapping from the map, via the <tt>Iterator.remove</tt>,
* <tt>Set.remove</tt>, <tt>removeAll</tt>, <tt>retainAll</tt> and
* <tt>clear</tt> operations. It does not support the
* <tt>add</tt> or <tt>addAll</tt> operations.
*
* @return a set view of the mappings contained in this map
*/
public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet());
}
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator();
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<K,V> e = (Map.Entry<K,V>) o;
Entry<K,V> candidate = getEntry(e.getKey());
return candidate != null && candidate.equals(e);
}
public boolean remove(Object o) {
return removeMapping(o) != null;
}
public int size() {
return size;
}
public void clear() {
HashMap.this.clear();
}
public Object[] toArray() {
Object[] res = new Object[size];
Iterator<Map.Entry<K,V>> it = iterator();
int i = 0;
while (it.hasNext())
res[i++] = it.next();
return res;
}
public <T> T[] toArray(T[] a) {
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
Object[] res = a;
Iterator<Map.Entry<K,V>> it = iterator();
int i = 0;
while (it.hasNext())
res[i++] = it.next();
return a;
}
}
private static final long serialVersionUID = 362498820763181265L;
}
/*
* Copyright 1994-2003 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* Thrown to indicate that a method has been passed an illegal or
* inappropriate argument.
*
* @author unascribed
* @see java.lang.Thread#setPriority(int)
* @since JDK1.0
*/
public
class IllegalArgumentException extends RuntimeException {
/**
* Constructs an <code>IllegalArgumentException</code> with no
* detail message.
*/
public IllegalArgumentException() {
super();
}
/**
* Constructs an <code>IllegalArgumentException</code> with the
* specified detail message.
*
* @param s the detail message.
*/
public IllegalArgumentException(String s) {
super(s);
}
/**
* Constructs a new exception with the specified detail message and
* cause.
*
* <p>Note that the detail message associated with <code>cause</code> is
* <i>not</i> automatically incorporated in this exception's detail
* message.
*
* @param message the detail message (which is saved for later retrieval
* by the {@link Throwable#getMessage()} method).
* @param cause the cause (which is saved for later retrieval by the
* {@link Throwable#getCause()} method). (A <tt>null</tt> value
* is permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.5
*/
public IllegalArgumentException(String message, Throwable cause) {
super(message, cause);
}
/**
* Constructs a new exception with the specified cause and a detail
* message of <tt>(cause==null ? null : cause.toString())</tt> (which
* typically contains the class and detail message of <tt>cause</tt>).
* This constructor is useful for exceptions that are little more than
* wrappers for other throwables (for example, {@link
* java.security.PrivilegedActionException}).
*
* @param cause the cause (which is saved for later retrieval by the
* {@link Throwable#getCause()} method). (A <tt>null</tt> value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.5
*/
public IllegalArgumentException(Throwable cause) {
super(cause);
}
private static final long serialVersionUID = -5365630128856068164L;
}
/*
* Copyright 1996-2003 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* Signals that a method has been invoked at an illegal or
* inappropriate time. In other words, the Java environment or
* Java application is not in an appropriate state for the requested
* operation.
*
* @author Jonni Kanerva
* @since JDK1.1
*/
public
class IllegalStateException extends RuntimeException {
/**
* Constructs an IllegalStateException with no detail message.
* A detail message is a String that describes this particular exception.
*/
public IllegalStateException() {
super();
}
/**
* Constructs an IllegalStateException with the specified detail
* message. A detail message is a String that describes this particular
* exception.
*
* @param s the String that contains a detailed message
*/
public IllegalStateException(String s) {
super(s);
}
/**
* Constructs a new exception with the specified detail message and
* cause.
*
* <p>Note that the detail message associated with <code>cause</code> is
* <i>not</i> automatically incorporated in this exception's detail
* message.
*
* @param message the detail message (which is saved for later retrieval
* by the {@link Throwable#getMessage()} method).
* @param cause the cause (which is saved for later retrieval by the
* {@link Throwable#getCause()} method). (A <tt>null</tt> value
* is permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.5
*/
public IllegalStateException(String message, Throwable cause) {
super(message, cause);
}
/**
* Constructs a new exception with the specified cause and a detail
* message of <tt>(cause==null ? null : cause.toString())</tt> (which
* typically contains the class and detail message of <tt>cause</tt>).
* This constructor is useful for exceptions that are little more than
* wrappers for other throwables (for example, {@link
* java.security.PrivilegedActionException}).
*
* @param cause the cause (which is saved for later retrieval by the
* {@link Throwable#getCause()} method). (A <tt>null</tt> value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.5
*/
public IllegalStateException(Throwable cause) {
super(cause);
}
static final long serialVersionUID = -1848914673093119416L;
}
/*
* Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* An iterator over a collection. {@code Iterator} takes the place of
* {@link Enumeration} in the Java Collections Framework. Iterators
* differ from enumerations in two ways:
*
* <ul>
* <li> Iterators allow the caller to remove elements from the
* underlying collection during the iteration with well-defined
* semantics.
* <li> Method names have been improved.
* </ul>
*
* <p>This interface is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* @author Josh Bloch
* @see Collection
* @see ListIterator
* @see Iterable
* @since 1.2
*/
public interface Iterator<E> {
/**
* Returns {@code true} if the iteration has more elements.
* (In other words, returns {@code true} if {@link #next} would
* return an element rather than throwing an exception.)
*
* @return {@code true} if the iteration has more elements
*/
boolean hasNext();
/**
* Returns the next element in the iteration.
*
* @return the next element in the iteration
* @throws NoSuchElementException if the iteration has no more elements
*/
E next();
/**
* Removes from the underlying collection the last element returned
* by this iterator (optional operation). This method can be called
* only once per call to {@link #next}. The behavior of an iterator
* is unspecified if the underlying collection is modified while the
* iteration is in progress in any way other than by calling this
* method.
*
* @throws UnsupportedOperationException if the {@code remove}
* operation is not supported by this iterator
*
* @throws IllegalStateException if the {@code next} method has not
* yet been called, or the {@code remove} method has already
* been called after the last call to the {@code next}
* method
*/
void remove();
}
package javaUtilEx;
public class juHashMapCreateIsEmpty {
public static void main(String[] args) {
Random.args = args;
HashMap<Content,Content> m = createMap(Random.random());
m.isEmpty();
}
public static HashMap<Content, Content> createMap(int n) {
HashMap<Content,Content> m = new HashMap<Content,Content>();
while (n > 0) {
Content key = new Content(Random.random());
Content val = new Content(Random.random());
m.put(key, val);
n--;
}
return m;
}
}
final class Content {
int val;
public Content(int v) {
this.val = v;
}
public int hashCode() {
return val^31;
}
public boolean equals(Object o) {
if (o instanceof Content) {
return this.val == ((Content) o).val;
}
return false;
}
}
/*
* Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* An object that maps keys to values. A map cannot contain duplicate keys;
* each key can map to at most one value.
*
* <p>This interface takes the place of the <tt>Dictionary</tt> class, which
* was a totally abstract class rather than an interface.
*
* <p>The <tt>Map</tt> interface provides three <i>collection views</i>, which
* allow a map's contents to be viewed as a set of keys, collection of values,
* or set of key-value mappings. The <i>order</i> of a map is defined as
* the order in which the iterators on the map's collection views return their
* elements. Some map implementations, like the <tt>TreeMap</tt> class, make
* specific guarantees as to their order; others, like the <tt>HashMap</tt>
* class, do not.
*
* <p>Note: great care must be exercised if mutable objects are used as map
* keys. The behavior of a map is not specified if the value of an object is
* changed in a manner that affects <tt>equals</tt> comparisons while the
* object is a key in the map. A special case of this prohibition is that it
* is not permissible for a map to contain itself as a key. While it is
* permissible for a map to contain itself as a value, extreme caution is
* advised: the <tt>equals</tt> and <tt>hashCode</tt> methods are no longer
* well defined on such a map.
*
* <p>All general-purpose map implementation classes should provide two
* "standard" constructors: a void (no arguments) constructor which creates an
* empty map, and a constructor with a single argument of type <tt>Map</tt>,
* which creates a new map with the same key-value mappings as its argument.
* In effect, the latter constructor allows the user to copy any map,
* producing an equivalent map of the desired class. There is no way to
* enforce this recommendation (as interfaces cannot contain constructors) but
* all of the general-purpose map implementations in the JDK comply.
*
* <p>The "destructive" methods contained in this interface, that is, the
* methods that modify the map on which they operate, are specified to throw
* <tt>UnsupportedOperationException</tt> if this map does not support the
* operation. If this is the case, these methods may, but are not required
* to, throw an <tt>UnsupportedOperationException</tt> if the invocation would
* have no effect on the map. For example, invoking the {@link #putAll(Map)}
* method on an unmodifiable map may, but is not required to, throw the
* exception if the map whose mappings are to be "superimposed" is empty.
*
* <p>Some map implementations have restrictions on the keys and values they
* may contain. For example, some implementations prohibit null keys and
* values, and some have restrictions on the types of their keys. Attempting
* to insert an ineligible key or value throws an unchecked exception,
* typically <tt>NullPointerException</tt> or <tt>ClassCastException</tt>.
* Attempting to query the presence of an ineligible key or value may throw an
* exception, or it may simply return false; some implementations will exhibit
* the former behavior and some will exhibit the latter. More generally,
* attempting an operation on an ineligible key or value whose completion
* would not result in the insertion of an ineligible element into the map may
* throw an exception or it may succeed, at the option of the implementation.
* Such exceptions are marked as "optional" in the specification for this
* interface.
*
* <p>This interface is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* <p>Many methods in Collections Framework interfaces are defined
* in terms of the {@link Object#equals(Object) equals} method. For
* example, the specification for the {@link #containsKey(Object)
* containsKey(Object key)} method says: "returns <tt>true</tt> if and
* only if this map contains a mapping for a key <tt>k</tt> such that
* <tt>(key==null ? k==null : key.equals(k))</tt>." This specification should
* <i>not</i> be construed to imply that invoking <tt>Map.containsKey</tt>
* with a non-null argument <tt>key</tt> will cause <tt>key.equals(k)</tt> to
* be invoked for any key <tt>k</tt>. Implementations are free to
* implement optimizations whereby the <tt>equals</tt> invocation is avoided,
* for example, by first comparing the hash codes of the two keys. (The
* {@link Object#hashCode()} specification guarantees that two objects with
* unequal hash codes cannot be equal.) More generally, implementations of
* the various Collections Framework interfaces are free to take advantage of
* the specified behavior of underlying {@link Object} methods wherever the
* implementor deems it appropriate.
*
* @param <K> the type of keys maintained by this map
* @param <V> the type of mapped values
*
* @author Josh Bloch
* @see HashMap
* @see TreeMap
* @see Hashtable
* @see SortedMap
* @see Collection
* @see Set
* @since 1.2
*/
public interface Map<K,V> {
// Query Operations
/**
* Returns the number of key-value mappings in this map. If the
* map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
* <tt>Integer.MAX_VALUE</tt>.
*
* @return the number of key-value mappings in this map
*/
int size();
/**
* Returns <tt>true</tt> if this map contains no key-value mappings.
*
* @return <tt>true</tt> if this map contains no key-value mappings
*/
boolean isEmpty();
/**
* Returns <tt>true</tt> if this map contains a mapping for the specified
* key. More formally, returns <tt>true</tt> if and only if
* this map contains a mapping for a key <tt>k</tt> such that
* <tt>(key==null ? k==null : key.equals(k))</tt>. (There can be
* at most one such mapping.)
*
* @param key key whose presence in this map is to be tested
* @return <tt>true</tt> if this map contains a mapping for the specified
* key
* @throws ClassCastException if the key is of an inappropriate type for
* this map (optional)
* @throws NullPointerException if the specified key is null and this map
* does not permit null keys (optional)
*/
boolean containsKey(Object key);
/**
* Returns <tt>true</tt> if this map maps one or more keys to the
* specified value. More formally, returns <tt>true</tt> if and only if
* this map contains at least one mapping to a value <tt>v</tt> such that
* <tt>(value==null ? v==null : value.equals(v))</tt>. This operation
* will probably require time linear in the map size for most
* implementations of the <tt>Map</tt> interface.
*
* @param value value whose presence in this map is to be tested
* @return <tt>true</tt> if this map maps one or more keys to the
* specified value
* @throws ClassCastException if the value is of an inappropriate type for
* this map (optional)
* @throws NullPointerException if the specified value is null and this
* map does not permit null values (optional)
*/
boolean containsValue(Object value);
/**
* Returns the value to which the specified key is mapped,
* or {@code null} if this map contains no mapping for the key.
*
* <p>More formally, if this map contains a mapping from a key
* {@code k} to a value {@code v} such that {@code (key==null ? k==null :
* key.equals(k))}, then this method returns {@code v}; otherwise
* it returns {@code null}. (There can be at most one such mapping.)
*
* <p>If this map permits null values, then a return value of
* {@code null} does not <i>necessarily</i> indicate that the map
* contains no mapping for the key; it's also possible that the map
* explicitly maps the key to {@code null}. The {@link #containsKey
* containsKey} operation may be used to distinguish these two cases.
*
* @param key the key whose associated value is to be returned
* @return the value to which the specified key is mapped, or
* {@code null} if this map contains no mapping for the key
* @throws ClassCastException if the key is of an inappropriate type for
* this map (optional)
* @throws NullPointerException if the specified key is null and this map
* does not permit null keys (optional)
*/
V get(Object key);
// Modification Operations
/**
* Associates the specified value with the specified key in this map
* (optional operation). If the map previously contained a mapping for
* the key, the old value is replaced by the specified value. (A map
* <tt>m</tt> is said to contain a mapping for a key <tt>k</tt> if and only
* if {@link #containsKey(Object) m.containsKey(k)} would return
* <tt>true</tt>.)
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
* @return the previous value associated with <tt>key</tt>, or
* <tt>null</tt> if there was no mapping for <tt>key</tt>.
* (A <tt>null</tt> return can also indicate that the map
* previously associated <tt>null</tt> with <tt>key</tt>,
* if the implementation supports <tt>null</tt> values.)
* @throws UnsupportedOperationException if the <tt>put</tt> operation
* is not supported by this map
* @throws ClassCastException if the class of the specified key or value
* prevents it from being stored in this map
* @throws NullPointerException if the specified key or value is null
* and this map does not permit null keys or values
* @throws IllegalArgumentException if some property of the specified key
* or value prevents it from being stored in this map
*/
V put(K key, V value);
/**
* Removes the mapping for a key from this map if it is present
* (optional operation). More formally, if this map contains a mapping
* from key <tt>k</tt> to value <tt>v</tt> such that
* <code>(key==null ? k==null : key.equals(k))</code>, that mapping
* is removed. (The map can contain at most one such mapping.)
*
* <p>Returns the value to which this map previously associated the key,
* or <tt>null</tt> if the map contained no mapping for the key.
*
* <p>If this map permits null values, then a return value of
* <tt>null</tt> does not <i>necessarily</i> indicate that the map
* contained no mapping for the key; it's also possible that the map
* explicitly mapped the key to <tt>null</tt>.
*
* <p>The map will not contain a mapping for the specified key once the
* call returns.
*
* @param key key whose mapping is to be removed from the map
* @return the previous value associated with <tt>key</tt>, or
* <tt>null</tt> if there was no mapping for <tt>key</tt>.
* @throws UnsupportedOperationException if the <tt>remove</tt> operation
* is not supported by this map
* @throws ClassCastException if the key is of an inappropriate type for
* this map (optional)
* @throws NullPointerException if the specified key is null and this
* map does not permit null keys (optional)
*/
V remove(Object key);
// Bulk Operations
/**
* Copies all of the mappings from the specified map to this map
* (optional operation). The effect of this call is equivalent to that
* of calling {@link #put(Object,Object) put(k, v)} on this map once
* for each mapping from key <tt>k</tt> to value <tt>v</tt> in the
* specified map. The behavior of this operation is undefined if the
* specified map is modified while the operation is in progress.
*
* @param m mappings to be stored in this map
* @throws UnsupportedOperationException if the <tt>putAll</tt> operation
* is not supported by this map
* @throws ClassCastException if the class of a key or value in the
* specified map prevents it from being stored in this map
* @throws NullPointerException if the specified map is null, or if
* this map does not permit null keys or values, and the
* specified map contains null keys or values
* @throws IllegalArgumentException if some property of a key or value in
* the specified map prevents it from being stored in this map
*/
void putAll(Map<? extends K, ? extends V> m);
/**
* Removes all of the mappings from this map (optional operation).
* The map will be empty after this call returns.
*
* @throws UnsupportedOperationException if the <tt>clear</tt> operation
* is not supported by this map
*/
void clear();
// Views
/**
* Returns a {@link Set} view of the keys contained in this map.
* The set is backed by the map, so changes to the map are
* reflected in the set, and vice-versa. If the map is modified
* while an iteration over the set is in progress (except through
* the iterator's own <tt>remove</tt> operation), the results of
* the iteration are undefined. The set supports element removal,
* which removes the corresponding mapping from the map, via the
* <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
* <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>
* operations. It does not support the <tt>add</tt> or <tt>addAll</tt>
* operations.
*
* @return a set view of the keys contained in this map
*/
Set<K> keySet();
/**
* Returns a {@link Collection} view of the values contained in this map.
* The collection is backed by the map, so changes to the map are
* reflected in the collection, and vice-versa. If the map is
* modified while an iteration over the collection is in progress
* (except through the iterator's own <tt>remove</tt> operation),
* the results of the iteration are undefined. The collection
* supports element removal, which removes the corresponding
* mapping from the map, via the <tt>Iterator.remove</tt>,
* <tt>Collection.remove</tt>, <tt>removeAll</tt>,
* <tt>retainAll</tt> and <tt>clear</tt> operations. It does not
* support the <tt>add</tt> or <tt>addAll</tt> operations.
*
* @return a collection view of the values contained in this map
*/
Collection<V> values();
/**
* Returns a {@link Set} view of the mappings contained in this map.
* The set is backed by the map, so changes to the map are
* reflected in the set, and vice-versa. If the map is modified
* while an iteration over the set is in progress (except through
* the iterator's own <tt>remove</tt> operation, or through the
* <tt>setValue</tt> operation on a map entry returned by the
* iterator) the results of the iteration are undefined. The set
* supports element removal, which removes the corresponding
* mapping from the map, via the <tt>Iterator.remove</tt>,
* <tt>Set.remove</tt>, <tt>removeAll</tt>, <tt>retainAll</tt> and
* <tt>clear</tt> operations. It does not support the
* <tt>add</tt> or <tt>addAll</tt> operations.
*
* @return a set view of the mappings contained in this map
*/
Set<Map.Entry<K, V>> entrySet();
/**
* A map entry (key-value pair). The <tt>Map.entrySet</tt> method returns
* a collection-view of the map, whose elements are of this class. The
* <i>only</i> way to obtain a reference to a map entry is from the
* iterator of this collection-view. These <tt>Map.Entry</tt> objects are
* valid <i>only</i> for the duration of the iteration; more formally,
* the behavior of a map entry is undefined if the backing map has been
* modified after the entry was returned by the iterator, except through
* the <tt>setValue</tt> operation on the map entry.
*
* @see Map#entrySet()
* @since 1.2
*/
interface Entry<K,V> {
/**
* Returns the key corresponding to this entry.
*
* @return the key corresponding to this entry
* @throws IllegalStateException implementations may, but are not
* required to, throw this exception if the entry has been
* removed from the backing map.
*/
K getKey();
/**
* Returns the value corresponding to this entry. If the mapping
* has been removed from the backing map (by the iterator's
* <tt>remove</tt> operation), the results of this call are undefined.
*
* @return the value corresponding to this entry
* @throws IllegalStateException implementations may, but are not
* required to, throw this exception if the entry has been
* removed from the backing map.
*/
V getValue();
/**
* Replaces the value corresponding to this entry with the specified
* value (optional operation). (Writes through to the map.) The
* behavior of this call is undefined if the mapping has already been
* removed from the map (by the iterator's <tt>remove</tt> operation).
*
* @param value new value to be stored in this entry
* @return old value corresponding to the entry
* @throws UnsupportedOperationException if the <tt>put</tt> operation
* is not supported by the backing map
* @throws ClassCastException if the class of the specified value
* prevents it from being stored in the backing map
* @throws NullPointerException if the backing map does not permit
* null values, and the specified value is null
* @throws IllegalArgumentException if some property of this value
* prevents it from being stored in the backing map
* @throws IllegalStateException implementations may, but are not
* required to, throw this exception if the entry has been
* removed from the backing map.
*/
V setValue(V value);
/**
* Compares the specified object with this entry for equality.
* Returns <tt>true</tt> if the given object is also a map entry and
* the two entries represent the same mapping. More formally, two
* entries <tt>e1</tt> and <tt>e2</tt> represent the same mapping
* if<pre>
* (e1.getKey()==null ?
* e2.getKey()==null : e1.getKey().equals(e2.getKey())) &&
* (e1.getValue()==null ?
* e2.getValue()==null : e1.getValue().equals(e2.getValue()))
* </pre>
* This ensures that the <tt>equals</tt> method works properly across
* different implementations of the <tt>Map.Entry</tt> interface.
*
* @param o object to be compared for equality with this map entry
* @return <tt>true</tt> if the specified object is equal to this map
* entry
*/
boolean equals(Object o);
/**
* Returns the hash code value for this map entry. The hash code
* of a map entry <tt>e</tt> is defined to be: <pre>
* (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
* (e.getValue()==null ? 0 : e.getValue().hashCode())
* </pre>
* This ensures that <tt>e1.equals(e2)</tt> implies that
* <tt>e1.hashCode()==e2.hashCode()</tt> for any two Entries
* <tt>e1</tt> and <tt>e2</tt>, as required by the general
* contract of <tt>Object.hashCode</tt>.
*
* @return the hash code value for this map entry
* @see Object#hashCode()
* @see Object#equals(Object)
* @see #equals(Object)
*/
int hashCode();
}
// Comparison and hashing
/**
* Compares the specified object with this map for equality. Returns
* <tt>true</tt> if the given object is also a map and the two maps
* represent the same mappings. More formally, two maps <tt>m1</tt> and
* <tt>m2</tt> represent the same mappings if
* <tt>m1.entrySet().equals(m2.entrySet())</tt>. This ensures that the
* <tt>equals</tt> method works properly across different implementations
* of the <tt>Map</tt> interface.
*
* @param o object to be compared for equality with this map
* @return <tt>true</tt> if the specified object is equal to this map
*/
boolean equals(Object o);
/**
* Returns the hash code value for this map. The hash code of a map is
* defined to be the sum of the hash codes of each entry in the map's
* <tt>entrySet()</tt> view. This ensures that <tt>m1.equals(m2)</tt>
* implies that <tt>m1.hashCode()==m2.hashCode()</tt> for any two maps
* <tt>m1</tt> and <tt>m2</tt>, as required by the general contract of
* {@link Object#hashCode}.
*
* @return the hash code value for this map
* @see Map.Entry#hashCode()
* @see Object#equals(Object)
* @see #equals(Object)
*/
int hashCode();
}
/*
* Copyright 1994-1998 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* Thrown by the <code>nextElement</code> method of an
* <code>Enumeration</code> to indicate that there are no more
* elements in the enumeration.
*
* @author unascribed
* @see java.util.Enumeration
* @see java.util.Enumeration#nextElement()
* @since JDK1.0
*/
public
class NoSuchElementException extends RuntimeException {
/**
* Constructs a <code>NoSuchElementException</code> with <tt>null</tt>
* as its error message string.
*/
public NoSuchElementException() {
super();
}
/**
* Constructs a <code>NoSuchElementException</code>, saving a reference
* to the error message string <tt>s</tt> for later retrieval by the
* <tt>getMessage</tt> method.
*
* @param s the detail message.
*/
public NoSuchElementException(String s) {
super(s);
}
}
package javaUtilEx;
public class Random {
static String[] args;
static int index = 0;
public static int random() {
String string = args[index];
index++;
return string.length();
}
}
/*
* Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* A collection that contains no duplicate elements. More formally, sets
* contain no pair of elements <code>e1</code> and <code>e2</code> such that
* <code>e1.equals(e2)</code>, and at most one null element. As implied by
* its name, this interface models the mathematical <i>set</i> abstraction.
*
* <p>The <tt>Set</tt> interface places additional stipulations, beyond those
* inherited from the <tt>Collection</tt> interface, on the contracts of all
* constructors and on the contracts of the <tt>add</tt>, <tt>equals</tt> and
* <tt>hashCode</tt> methods. Declarations for other inherited methods are
* also included here for convenience. (The specifications accompanying these
* declarations have been tailored to the <tt>Set</tt> interface, but they do
* not contain any additional stipulations.)
*
* <p>The additional stipulation on constructors is, not surprisingly,
* that all constructors must create a set that contains no duplicate elements
* (as defined above).
*
* <p>Note: Great care must be exercised if mutable objects are used as set
* elements. The behavior of a set is not specified if the value of an object
* is changed in a manner that affects <tt>equals</tt> comparisons while the
* object is an element in the set. A special case of this prohibition is
* that it is not permissible for a set to contain itself as an element.
*
* <p>Some set implementations have restrictions on the elements that
* they may contain. For example, some implementations prohibit null elements,
* and some have restrictions on the types of their elements. Attempting to
* add an ineligible element throws an unchecked exception, typically
* <tt>NullPointerException</tt> or <tt>ClassCastException</tt>. Attempting
* to query the presence of an ineligible element may throw an exception,
* or it may simply return false; some implementations will exhibit the former
* behavior and some will exhibit the latter. More generally, attempting an
* operation on an ineligible element whose completion would not result in
* the insertion of an ineligible element into the set may throw an
* exception or it may succeed, at the option of the implementation.
* Such exceptions are marked as "optional" in the specification for this
* interface.
*
* <p>This interface is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* @param <E> the type of elements maintained by this set
*
* @author Josh Bloch
* @author Neal Gafter
* @see Collection
* @see List
* @see SortedSet
* @see HashSet
* @see TreeSet
* @see AbstractSet
* @see Collections#singleton(java.lang.Object)
* @see Collections#EMPTY_SET
* @since 1.2
*/
public interface Set<E> extends Collection<E> {
// Query Operations
/**
* Returns the number of elements in this set (its cardinality). If this
* set contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
* <tt>Integer.MAX_VALUE</tt>.
*
* @return the number of elements in this set (its cardinality)
*/
int size();
/**
* Returns <tt>true</tt> if this set contains no elements.
*
* @return <tt>true</tt> if this set contains no elements
*/
boolean isEmpty();
/**
* Returns <tt>true</tt> if this set contains the specified element.
* More formally, returns <tt>true</tt> if and only if this set
* contains an element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>.
*
* @param o element whose presence in this set is to be tested
* @return <tt>true</tt> if this set contains the specified element
* @throws ClassCastException if the type of the specified element
* is incompatible with this set (optional)
* @throws NullPointerException if the specified element is null and this
* set does not permit null elements (optional)
*/
boolean contains(Object o);
/**
* Returns an iterator over the elements in this set. The elements are
* returned in no particular order (unless this set is an instance of some
* class that provides a guarantee).
*
* @return an iterator over the elements in this set
*/
Iterator<E> iterator();
/**
* Returns an array containing all of the elements in this set.
* If this set makes any guarantees as to what order its elements
* are returned by its iterator, this method must return the
* elements in the same order.
*
* <p>The returned array will be "safe" in that no references to it
* are maintained by this set. (In other words, this method must
* allocate a new array even if this set is backed by an array).
* The caller is thus free to modify the returned array.
*
* <p>This method acts as bridge between array-based and collection-based
* APIs.
*
* @return an array containing all the elements in this set
*/
Object[] toArray();
/**
* Returns an array containing all of the elements in this set; the
* runtime type of the returned array is that of the specified array.
* If the set fits in the specified array, it is returned therein.
* Otherwise, a new array is allocated with the runtime type of the
* specified array and the size of this set.
*
* <p>If this set fits in the specified array with room to spare
* (i.e., the array has more elements than this set), the element in
* the array immediately following the end of the set is set to
* <tt>null</tt>. (This is useful in determining the length of this
* set <i>only</i> if the caller knows that this set does not contain
* any null elements.)
*
* <p>If this set makes any guarantees as to what order its elements
* are returned by its iterator, this method must return the elements
* in the same order.
*
* <p>Like the {@link #toArray()} method, this method acts as bridge between
* array-based and collection-based APIs. Further, this method allows
* precise control over the runtime type of the output array, and may,
* under certain circumstances, be used to save allocation costs.
*
* <p>Suppose <tt>x</tt> is a set known to contain only strings.
* The following code can be used to dump the set into a newly allocated
* array of <tt>String</tt>:
*
* <pre>
* String[] y = x.toArray(new String[0]);</pre>
*
* Note that <tt>toArray(new Object[0])</tt> is identical in function to
* <tt>toArray()</tt>.
*
* @param a the array into which the elements of this set are to be
* stored, if it is big enough; otherwise, a new array of the same
* runtime type is allocated for this purpose.
* @return an array containing all the elements in this set
* @throws ArrayStoreException if the runtime type of the specified array
* is not a supertype of the runtime type of every element in this
* set
* @throws NullPointerException if the specified array is null
*/
<T> T[] toArray(T[] a);
// Modification Operations
/**
* Adds the specified element to this set if it is not already present
* (optional operation). More formally, adds the specified element
* <tt>e</tt> to this set if the set contains no element <tt>e2</tt>
* such that
* <tt>(e==null ? e2==null : e.equals(e2))</tt>.
* If this set already contains the element, the call leaves the set
* unchanged and returns <tt>false</tt>. In combination with the
* restriction on constructors, this ensures that sets never contain
* duplicate elements.
*
* <p>The stipulation above does not imply that sets must accept all
* elements; sets may refuse to add any particular element, including
* <tt>null</tt>, and throw an exception, as described in the
* specification for {@link Collection#add Collection.add}.
* Individual set implementations should clearly document any
* restrictions on the elements that they may contain.
*
* @param e element to be added to this set
* @return <tt>true</tt> if this set did not already contain the specified
* element
* @throws UnsupportedOperationException if the <tt>add</tt> operation
* is not supported by this set
* @throws ClassCastException if the class of the specified element
* prevents it from being added to this set
* @throws NullPointerException if the specified element is null and this
* set does not permit null elements
* @throws IllegalArgumentException if some property of the specified element
* prevents it from being added to this set
*/
boolean add(E e);
/**
* Removes the specified element from this set if it is present
* (optional operation). More formally, removes an element <tt>e</tt>
* such that
* <tt>(o==null ? e==null : o.equals(e))</tt>, if
* this set contains such an element. Returns <tt>true</tt> if this set
* contained the element (or equivalently, if this set changed as a
* result of the call). (This set will not contain the element once the
* call returns.)
*
* @param o object to be removed from this set, if present
* @return <tt>true</tt> if this set contained the specified element
* @throws ClassCastException if the type of the specified element
* is incompatible with this set (optional)
* @throws NullPointerException if the specified element is null and this
* set does not permit null elements (optional)
* @throws UnsupportedOperationException if the <tt>remove</tt> operation
* is not supported by this set
*/
boolean remove(Object o);
// Bulk Operations
/**
* Returns <tt>true</tt> if this set contains all of the elements of the
* specified collection. If the specified collection is also a set, this
* method returns <tt>true</tt> if it is a <i>subset</i> of this set.
*
* @param c collection to be checked for containment in this set
* @return <tt>true</tt> if this set contains all of the elements of the
* specified collection
* @throws ClassCastException if the types of one or more elements
* in the specified collection are incompatible with this
* set (optional)
* @throws NullPointerException if the specified collection contains one
* or more null elements and this set does not permit null
* elements (optional), or if the specified collection is null
* @see #contains(Object)
*/
boolean containsAll(Collection<?> c);
/**
* Adds all of the elements in the specified collection to this set if
* they're not already present (optional operation). If the specified
* collection is also a set, the <tt>addAll</tt> operation effectively
* modifies this set so that its value is the <i>union</i> of the two
* sets. The behavior of this operation is undefined if the specified
* collection is modified while the operation is in progress.
*
* @param c collection containing elements to be added to this set
* @return <tt>true</tt> if this set changed as a result of the call
*
* @throws UnsupportedOperationException if the <tt>addAll</tt> operation
* is not supported by this set
* @throws ClassCastException if the class of an element of the
* specified collection prevents it from being added to this set
* @throws NullPointerException if the specified collection contains one
* or more null elements and this set does not permit null
* elements, or if the specified collection is null
* @throws IllegalArgumentException if some property of an element of the
* specified collection prevents it from being added to this set
* @see #add(Object)
*/
boolean addAll(Collection<? extends E> c);
/**
* Retains only the elements in this set that are contained in the
* specified collection (optional operation). In other words, removes
* from this set all of its elements that are not contained in the
* specified collection. If the specified collection is also a set, this
* operation effectively modifies this set so that its value is the
* <i>intersection</i> of the two sets.
*
* @param c collection containing elements to be retained in this set
* @return <tt>true</tt> if this set changed as a result of the call
* @throws UnsupportedOperationException if the <tt>retainAll</tt> operation
* is not supported by this set
* @throws ClassCastException if the class of an element of this set
* is incompatible with the specified collection (optional)
* @throws NullPointerException if this set contains a null element and the
* specified collection does not permit null elements (optional),
* or if the specified collection is null
* @see #remove(Object)
*/
boolean retainAll(Collection<?> c);
/**
* Removes from this set all of its elements that are contained in the
* specified collection (optional operation). If the specified
* collection is also a set, this operation effectively modifies this
* set so that its value is the <i>asymmetric set difference</i> of
* the two sets.
*
* @param c collection containing elements to be removed from this set
* @return <tt>true</tt> if this set changed as a result of the call
* @throws UnsupportedOperationException if the <tt>removeAll</tt> operation
* is not supported by this set
* @throws ClassCastException if the class of an element of this set
* is incompatible with the specified collection (optional)
* @throws NullPointerException if this set contains a null element and the
* specified collection does not permit null elements (optional),
* or if the specified collection is null
* @see #remove(Object)
* @see #contains(Object)
*/
boolean removeAll(Collection<?> c);
/**
* Removes all of the elements from this set (optional operation).
* The set will be empty after this call returns.
*
* @throws UnsupportedOperationException if the <tt>clear</tt> method
* is not supported by this set
*/
void clear();
// Comparison and hashing
/**
* Compares the specified object with this set for equality. Returns
* <tt>true</tt> if the specified object is also a set, the two sets
* have the same size, and every member of the specified set is
* contained in this set (or equivalently, every member of this set is
* contained in the specified set). This definition ensures that the
* equals method works properly across different implementations of the
* set interface.
*
* @param o object to be compared for equality with this set
* @return <tt>true</tt> if the specified object is equal to this set
*/
boolean equals(Object o);
/**
* Returns the hash code value for this set. The hash code of a set is
* defined to be the sum of the hash codes of the elements in the set,
* where the hash code of a <tt>null</tt> element is defined to be zero.
* This ensures that <tt>s1.equals(s2)</tt> implies that
* <tt>s1.hashCode()==s2.hashCode()</tt> for any two sets <tt>s1</tt>
* and <tt>s2</tt>, as required by the general contract of
* {@link Object#hashCode}.
*
* @return the hash code value for this set
* @see Object#equals(Object)
* @see Set#equals(Object)
*/
int hashCode();
}
/*
* Copyright 1997-2006 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package javaUtilEx;
/**
* Thrown to indicate that the requested operation is not supported.<p>
*
* This class is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework</a>.
*
* @author Josh Bloch
* @since 1.2
*/
public class UnsupportedOperationException extends RuntimeException {
/**
* Constructs an UnsupportedOperationException with no detail message.
*/
public UnsupportedOperationException() {
}
/**
* Constructs an UnsupportedOperationException with the specified
* detail message.
*
* @param message the detail message
*/
public UnsupportedOperationException(String message) {
super(message);
}
/**
* Constructs a new exception with the specified detail message and
* cause.
*
* <p>Note that the detail message associated with <code>cause</code> is
* <i>not</i> automatically incorporated in this exception's detail
* message.
*
* @param message the detail message (which is saved for later retrieval
* by the {@link Throwable#getMessage()} method).
* @param cause the cause (which is saved for later retrieval by the
* {@link Throwable#getCause()} method). (A <tt>null</tt> value
* is permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.5
*/
public UnsupportedOperationException(String message, Throwable cause) {
super(message, cause);
}
/**
* Constructs a new exception with the specified cause and a detail
* message of <tt>(cause==null ? null : cause.toString())</tt> (which
* typically contains the class and detail message of <tt>cause</tt>).
* This constructor is useful for exceptions that are little more than
* wrappers for other throwables (for example, {@link
* java.security.PrivilegedActionException}).
*
* @param cause the cause (which is saved for later retrieval by the
* {@link Throwable#getCause()} method). (A <tt>null</tt> value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.5
*/
public UnsupportedOperationException(Throwable cause) {
super(cause);
}
static final long serialVersionUID = -1242599979055084673L;
}
Generated rules. Obtained 58 IRules
P rules:
f19300_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, i5894) → f19301_0_transfer_ArrayLength(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, i5894, java.lang.Object(ARRAY(i5700)))
f19301_0_transfer_ArrayLength(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, i5894, java.lang.Object(ARRAY(i5700))) → f19303_0_transfer_GE(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, i5894, i5700) | >=(i5700, 0)
f19303_0_transfer_GE(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, i5894, i5700) → f19306_0_transfer_GE(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, i5894, i5700)
f19306_0_transfer_GE(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, i5894, i5700) → f19310_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894) | <(i5894, i5700)
f19310_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894) → f19313_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(ARRAY(i5700)))
f19313_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(ARRAY(i5700))) → f19318_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(ARRAY(i5700)), i5894)
f19318_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(ARRAY(i5700)), i5894) → f19321_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(ARRAY(i5700)), i5894)
f19321_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(ARRAY(i5700)), i5894) → f19330_0_transfer_Store(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11762) | <(i5894, i5700)
f19330_0_transfer_Store(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11762) → f19336_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11762)
f19336_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11762) → f19341_0_transfer_NULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11762, o11762)
f19341_0_transfer_NULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(o11768sub)) → f19349_0_transfer_NULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(o11768sub))
f19341_0_transfer_NULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, NULL, NULL) → f19350_0_transfer_NULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, NULL, NULL)
f19349_0_transfer_NULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(o11768sub)) → f19356_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub))
f19356_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub)) → f19361_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(ARRAY(i5700)))
f19361_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(ARRAY(i5700))) → f19371_0_transfer_ConstantStackPush(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(ARRAY(i5700)), i5894)
f19371_0_transfer_ConstantStackPush(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(ARRAY(i5700)), i5894) → f19396_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(ARRAY(i5700)), i5894, NULL)
f19396_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(ARRAY(i5700)), i5894, NULL) → f19401_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(ARRAY(i5700)), i5894, NULL)
f19401_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(ARRAY(i5700)), i5894, NULL) → f19420_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub)) | <(i5894, i5700)
f19420_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub)) → f19429_0_transfer_FieldAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o11768sub), java.lang.Object(o11768sub))
f19429_0_transfer_FieldAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905))) → f19434_0_transfer_FieldAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)))
f19434_0_transfer_FieldAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905))) → f19444_0_transfer_Store(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803)
f19444_0_transfer_Store(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803) → f19468_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803)
f19468_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803) → f19506_0_transfer_FieldAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)))
f19506_0_transfer_FieldAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905))) → f19519_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905)
f19519_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905) → f19525_0_transfer_InvokeMethod(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613)
f19525_0_transfer_InvokeMethod(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613) → f19531_0_indexFor_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5905, i5613)
f19531_0_indexFor_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5905, i5613) → f19549_0_indexFor_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5613, i5905)
f19549_0_indexFor_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5613, i5905) → f19557_0_indexFor_ConstantStackPush(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5905, i5613)
f19557_0_indexFor_ConstantStackPush(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5905, i5613) → f19572_0_indexFor_IntArithmetic(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5905, i5613, 1)
f19572_0_indexFor_IntArithmetic(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5905, i5613, matching1) → f19577_0_indexFor_IntArithmetic(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5905, -(i5613, 1)) | &&(>=(i5613, 0), =(matching1, 1))
f19577_0_indexFor_IntArithmetic(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5905, i5963) → f19583_0_indexFor_Return(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5964)
f19583_0_indexFor_Return(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5905, i5613, i5964) → f19596_0_transfer_Store(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964)
f19596_0_transfer_Store(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964) → f19610_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964)
f19610_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964) → f19625_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)))
f19625_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905))) → f19639_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), java.lang.Object(ARRAY(i5613)))
f19639_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), java.lang.Object(ARRAY(i5613))) → f19658_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), java.lang.Object(ARRAY(i5613)), i5964)
f19658_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), java.lang.Object(ARRAY(i5613)), i5964) → f19669_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), java.lang.Object(ARRAY(i5613)), i5964)
f19669_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), java.lang.Object(ARRAY(i5613)), i5964) → f19693_0_transfer_FieldAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11976) | <(i5964, i5613)
f19693_0_transfer_FieldAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11803, i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11803, i5905)), o11976) → f19713_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11976, i5905)), o11803, i5964)
f19713_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11976, i5905)), o11803, i5964) → f19747_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11976, i5905)), o11803, i5964, java.lang.Object(ARRAY(i5613)))
f19747_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11976, i5905)), o11803, i5964, java.lang.Object(ARRAY(i5613))) → f19803_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11976, i5905)), o11803, java.lang.Object(ARRAY(i5613)), i5964)
f19803_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11976, i5905)), o11803, java.lang.Object(ARRAY(i5613)), i5964) → f19861_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803, java.lang.Object(ARRAY(i5613)), i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11976, i5905)))
f19861_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803, java.lang.Object(ARRAY(i5613)), i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11976, i5905))) → f19873_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803, java.lang.Object(ARRAY(i5613)), i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11976, i5905)))
f19873_0_transfer_ArrayAccess(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803, java.lang.Object(ARRAY(i5613)), i5964, java.lang.Object(javaUtilEx.HashMap$Entry(o11800sub, o11976, i5905))) → f19893_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803) | <(i5964, i5613)
f19893_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803) → f19915_0_transfer_Store(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803)
f19915_0_transfer_Store(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803) → f19919_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803)
f19919_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803) → f19948_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, o11803, o11803)
f19948_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o12135sub), java.lang.Object(o12135sub)) → f19956_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o12135sub), java.lang.Object(o12135sub))
f19948_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, NULL, NULL) → f19957_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, NULL, NULL)
f19956_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o12135sub), java.lang.Object(o12135sub)) → f19983_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o12135sub))
f19983_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o12135sub)) → f19420_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, java.lang.Object(o12135sub))
f19957_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, NULL, NULL) → f20006_0_transfer_Inc(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894)
f20006_0_transfer_Inc(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894) → f20021_0_transfer_JMP(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, +(i5894, 1)) | >=(i5894, 0)
f20021_0_transfer_JMP(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i6097) → f20039_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i6097)
f20039_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i6097) → f19293_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i6097)
f19293_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894) → f19300_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, i5894)
f19350_0_transfer_NULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894, NULL, NULL) → f19357_0_transfer_Inc(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894)
f19357_0_transfer_Inc(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894) → f20006_0_transfer_Inc(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5613, java.lang.Object(ARRAY(i5613)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5613)), java.lang.Object(ARRAY(i5700)), i5613, i5894)
Combined rules. Obtained 4 IRules
P rules:
f19300_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(ARRAY(x0)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x0, x2, x2) → f19948_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(ARRAY(x0)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x0, x2, x3, x3) | &&(&&(<(x2, x1), >(+(x0, 1), 0)), >(+(x1, 1), 0))
f19948_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(ARRAY(x0)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x0, x2, java.lang.Object(javaUtilEx.HashMap$Entry(x3, x4, x5)), java.lang.Object(javaUtilEx.HashMap$Entry(x3, x4, x5))) → f19948_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(ARRAY(x0)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x0, x2, x4, x4) | >(+(x0, 1), 0)
f19948_0_transfer_NONNULL(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(ARRAY(x0)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x0, x2, NULL, NULL) → f19300_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(ARRAY(x0)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x0, +(x2, 1), +(x2, 1)) | >(+(x2, 1), 0)
f19300_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(ARRAY(x0)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x0, x2, x2) → f19300_0_transfer_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0, java.lang.Object(ARRAY(x0)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x0, +(x2, 1), +(x2, 1)) | &&(&&(>(+(x2, 1), 0), <(x2, x1)), >(+(x1, 1), 0))
Filtered ground terms:
f19300_0_transfer_Load(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) → f19300_0_transfer_Load(x5, x7, x8, x10, x11, x12, x13, x14, x15)
Cond_f19300_0_transfer_Load(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) → Cond_f19300_0_transfer_Load(x1, x6, x8, x9, x11, x12, x13, x14, x15, x16, x17)
f19948_0_transfer_NONNULL(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) → f19948_0_transfer_NONNULL(x5, x7, x8, x10, x11, x12, x13, x14, x15, x16)
Cond_f19948_0_transfer_NONNULL(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) → Cond_f19948_0_transfer_NONNULL(x1, x6, x8, x9, x11, x12, x13, x14, x15, x16, x17)
Cond_f19948_0_transfer_NONNULL1(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) → Cond_f19948_0_transfer_NONNULL1(x1, x6, x8, x9, x11, x12, x13, x14, x15)
Cond_f19300_0_transfer_Load1(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) → Cond_f19300_0_transfer_Load1(x1, x6, x8, x9, x11, x12, x13, x14, x15, x16)
javaUtilEx.AbstractMap(x1) → javaUtilEx.AbstractMap
javaUtilEx.HashMap(x1) → javaUtilEx.HashMap
Filtered duplicate terms:
f19300_0_transfer_Load(x1, x2, x3, x4, x5, x6, x7, x8, x9) → f19300_0_transfer_Load(x5, x6, x9)
Cond_f19300_0_transfer_Load(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) → Cond_f19300_0_transfer_Load(x1, x6, x7, x10, x11)
f19948_0_transfer_NONNULL(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) → f19948_0_transfer_NONNULL(x5, x6, x8, x10)
Cond_f19948_0_transfer_NONNULL(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) → Cond_f19948_0_transfer_NONNULL(x1, x6, x7, x9, x11)
Cond_f19948_0_transfer_NONNULL1(x1, x2, x3, x4, x5, x6, x7, x8, x9) → Cond_f19948_0_transfer_NONNULL1(x1, x6, x7, x9)
Cond_f19300_0_transfer_Load1(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) → Cond_f19300_0_transfer_Load1(x1, x6, x7, x10)
Filtered unneeded terms:
javaUtilEx.HashMap$Entry(x1, x2, x3) → javaUtilEx.HashMap$Entry(x2)
Prepared 4 rules for path length conversion:
P rules:
f19300_0_transfer_Load(java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x2, x0, x1) → f19948_0_transfer_NONNULL(java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x2, x3, x0, x1) | &&(&&(<(x2, x1), >(+(x0, 1), 0)), >(+(x1, 1), 0))
f19948_0_transfer_NONNULL(java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x2, java.lang.Object(javaUtilEx.HashMap$Entry(x4)), x0, x1) → f19948_0_transfer_NONNULL(java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x2, x4, x0, x1) | >(+(x0, 1), 0)
f19948_0_transfer_NONNULL(java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x2, NULL, x0, x1) → f19300_0_transfer_Load(java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), +(x2, 1), x0, x1) | >(+(x2, 1), 0)
f19300_0_transfer_Load(java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), x2, x0, x1) → f19300_0_transfer_Load(java.lang.Object(ARRAY(x0)), java.lang.Object(ARRAY(x1)), +(x2, 1), x0, x1) | &&(&&(>(+(x2, 1), 0), <(x2, x1)), >(+(x1, 1), 0))
Finished conversion. Obtained 4 rules.
P rules:
f19300_0_transfer_Load(v25, v26, x2, x0, x1) → f19948_0_transfer_NONNULL(v27, v28, x2, v29, x0, x1) | &&(&&(&&(&&(&&(&&(&&(&&(&&(&&(&&(<(x2, x1), >(x1, -1)), >(x0, -1)), >(+(v29, 1), 0)), >(+(v28, 1), 1)), <=(v28, v26)), <=(v28, v25)), >(+(v27, 1), 1)), <=(v27, v26)), <=(v27, v25)), >(+(v26, 1), 1)), >(+(v25, 1), 1))
f19948_0_transfer_NONNULL(v30, v31, x6, v32, x4, x5) → f19948_0_transfer_NONNULL(v33, v34, x6, v35, x4, x5) | &&(&&(&&(&&(&&(&&(&&(&&(&&(&&(&&(&&(&&(>(x4, -1), >(+(v35, 1), 0)), <=(+(v35, 1), v32)), >(+(v34, 1), 1)), <=(v34, v32)), <=(v34, v31)), <=(v34, v30)), >(+(v33, 1), 1)), <=(v33, v32)), <=(v33, v31)), <=(v33, v30)), >(+(v32, 1), 1)), >(+(v31, 1), 1)), >(+(v30, 1), 1))
f19948_0_transfer_NONNULL(v36, v37, x10, v38, x8, x9) → f19300_0_transfer_Load(v39, v40, +(x10, 1), x8, x9) | &&(&&(&&(&&(&&(&&(&&(&&(&&(&&(&&(>(x10, -1), >(+(v40, 1), 1)), <=(v40, v37)), <=(v40, v36)), <=(-(v40, 1), v38)), >(+(v39, 1), 1)), <=(v39, v37)), <=(v39, v36)), <=(-(v39, 1), v38)), >(+(v38, 1), 0)), >(+(v37, 1), 1)), >(+(v36, 1), 1))
f19300_0_transfer_Load(v41, v42, x13, x11, x12) → f19300_0_transfer_Load(v43, v44, +(x13, 1), x11, x12) | &&(&&(&&(&&(&&(&&(&&(&&(&&(&&(>(x13, -1), <(x13, x12)), >(x12, -1)), >(+(v44, 1), 1)), <=(v44, v42)), <=(v44, v41)), >(+(v43, 1), 1)), <=(v43, v42)), <=(v43, v41)), >(+(v42, 1), 1)), >(+(v41, 1), 1))
Found the following polynomial interpretation:
Therefore the following rule(s) have been dropped:
Constructed the termination graph and obtained one non-trivial SCC.
Found the following polynomial interpretation:
Therefore the following rule(s) have been dropped:
Generated rules. Obtained 46 IRules
P rules:
f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(o10553sub), java.lang.Object(o10553sub)) → f16868_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(o10553sub), java.lang.Object(o10553sub))
f16868_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(o10553sub), java.lang.Object(o10553sub)) → f16873_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(o10553sub))
f16873_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(o10553sub)) → f16877_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(o10553sub), java.lang.Object(o10553sub))
f16877_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)), java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559))) → f16882_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)), java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)))
f16882_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)), java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559))) → f16887_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)), i5289)
f16887_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)), i5289) → f16890_0_put_NE(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)), i5289, i5284)
f16890_0_put_NE(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)), i5289, i5284) → f16896_0_put_NE(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)), i5289, i5284)
f16890_0_put_NE(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), i5284, i5284) → f16897_0_put_NE(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), i5284, i5284)
f16896_0_put_NE(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)), i5289, i5284) → f16902_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559))) | !(=(i5289, i5284))
f16902_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559))) → f16908_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559)))
f16908_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5289, o10561, o10559))) → f16915_0_put_Store(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10561)
f16915_0_put_Store(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10561) → f17133_0_put_Store(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10561)
f17133_0_put_Store(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10621) → f17161_0_put_Store(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10621)
f17161_0_put_Store(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10635) → f17191_0_put_JMP(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10635)
f17191_0_put_JMP(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10635) → f17246_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10635)
f17246_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10635) → f16863_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10635)
f16863_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10550) → f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10550, o10550)
f16897_0_put_NE(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), i5284, i5284) → f16903_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)))
f16903_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559))) → f16909_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)))
f16909_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559))) → f16916_0_put_Duplicate(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559)
f16916_0_put_Duplicate(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559) → f16923_0_put_Store(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559, o10559)
f16923_0_put_Store(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559, o10559) → f16932_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559, o10559)
f16932_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559, o10559) → f16936_0_put_EQ(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559, o10559, java.lang.Object(javaUtilEx.Content(EOC)))
f16936_0_put_EQ(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559, o10559, java.lang.Object(javaUtilEx.Content(EOC))) → f16939_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559)
f16939_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559) → f16942_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559, java.lang.Object(javaUtilEx.Content(EOC)))
f16942_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), o10559, java.lang.Object(javaUtilEx.Content(EOC))) → f16945_0_put_InvokeMethod(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), java.lang.Object(javaUtilEx.Content(EOC)), o10559)
f16945_0_put_InvokeMethod(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), java.lang.Object(javaUtilEx.Content(EOC)), o10559) → f16953_0_equals_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), o10559, java.lang.Object(javaUtilEx.Content(EOC)), o10559)
f16945_0_put_InvokeMethod(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), java.lang.Object(javaUtilEx.Content(EOC)), o10559) → f16953_1_equals_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, o10559)), java.lang.Object(javaUtilEx.Content(EOC)), o10559, java.lang.Object(javaUtilEx.Content(EOC)), o10559)
f16953_0_equals_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), o10559, java.lang.Object(javaUtilEx.Content(EOC)), o10559) → f16959_0_equals_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), o10559, java.lang.Object(javaUtilEx.Content(EOC)), o10559)
f17045_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, NULL)), java.lang.Object(javaUtilEx.Content(EOC)), NULL, matching1) → f17059_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, NULL)), java.lang.Object(javaUtilEx.Content(EOC)), NULL, 0) | =(matching1, 0)
f17059_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10619sub, i5284, o10621, o10620)), java.lang.Object(javaUtilEx.Content(EOC)), o10620, matching1) → f17076_0_put_EQ(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10619sub, i5284, o10621, o10620)), 0) | =(matching1, 0)
f17076_0_put_EQ(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10619sub, i5284, o10621, o10620)), matching1) → f17101_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10619sub, i5284, o10621, o10620))) | =(matching1, 0)
f17101_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10619sub, i5284, o10621, o10620))) → f17114_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10619sub, i5284, o10621, o10620)))
f17114_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10619sub, i5284, o10621, o10620))) → f17133_0_put_Store(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10621)
f17058_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(o10588sub))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10588sub), matching1) → f17059_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(o10588sub))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10588sub), 0) | =(matching1, 0)
f17060_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(javaUtilEx.Content(EOC)))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), matching1) → f17070_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(javaUtilEx.Content(EOC)))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), 0) | =(matching1, 0)
f17070_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10633sub, i5284, o10635, java.lang.Object(javaUtilEx.Content(EOC)))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5341) → f17089_0_put_EQ(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10633sub, i5284, o10635, java.lang.Object(javaUtilEx.Content(EOC)))), i5341)
f17089_0_put_EQ(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10633sub, i5284, o10635, java.lang.Object(javaUtilEx.Content(EOC)))), matching1) → f17104_0_put_EQ(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10633sub, i5284, o10635, java.lang.Object(javaUtilEx.Content(EOC)))), 0) | =(matching1, 0)
f17104_0_put_EQ(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10633sub, i5284, o10635, java.lang.Object(javaUtilEx.Content(EOC)))), matching1) → f17123_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10633sub, i5284, o10635, java.lang.Object(javaUtilEx.Content(EOC))))) | =(matching1, 0)
f17123_0_put_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10633sub, i5284, o10635, java.lang.Object(javaUtilEx.Content(EOC))))) → f17143_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10633sub, i5284, o10635, java.lang.Object(javaUtilEx.Content(EOC)))))
f17143_0_put_FieldAccess(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10633sub, i5284, o10635, java.lang.Object(javaUtilEx.Content(EOC))))) → f17161_0_put_Store(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, o10635)
f17069_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(javaUtilEx.Content(EOC)))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), matching1) → f17070_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(javaUtilEx.Content(EOC)))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), 1) | =(matching1, 1)
f16953_1_equals_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, NULL)), java.lang.Object(javaUtilEx.Content(EOC)), NULL, java.lang.Object(javaUtilEx.Content(EOC)), NULL) → f17045_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, NULL)), java.lang.Object(javaUtilEx.Content(EOC)), NULL, 0)
f16953_1_equals_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(o10588sub))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10588sub), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10588sub)) → f17058_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(o10588sub))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10588sub), 0)
f16953_1_equals_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(javaUtilEx.Content(EOC)))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f17060_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(javaUtilEx.Content(EOC)))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), 0)
f16953_1_equals_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(javaUtilEx.Content(EOC)))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f17069_0_equals_Return(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5284, java.lang.Object(javaUtilEx.HashMap$Entry(o10558sub, i5284, o10561, java.lang.Object(javaUtilEx.Content(EOC)))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), 1)
Combined rules. Obtained 5 IRules
P rules:
f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), x0, java.lang.Object(javaUtilEx.HashMap$Entry(x1, x2, x3, x4)), java.lang.Object(javaUtilEx.HashMap$Entry(x1, x2, x3, x4))) → f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), x0, x3, x3) | !(=(x2, x0))
f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), x0, java.lang.Object(javaUtilEx.HashMap$Entry(x1, x0, x2, x3)), java.lang.Object(javaUtilEx.HashMap$Entry(x1, x0, x2, x3))) → f16959_0_equals_Load(EOS, java.lang.Object(javaUtilEx.Content(EOC)), x3, java.lang.Object(javaUtilEx.Content(EOC)), x3)
f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), x0, java.lang.Object(javaUtilEx.HashMap$Entry(x1, x0, x2, NULL)), java.lang.Object(javaUtilEx.HashMap$Entry(x1, x0, x2, NULL))) → f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), x0, x2, x2)
f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), x0, java.lang.Object(javaUtilEx.HashMap$Entry(x1, x0, x2, java.lang.Object(x3))), java.lang.Object(javaUtilEx.HashMap$Entry(x1, x0, x2, java.lang.Object(x3)))) → f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), x0, x2, x2)
f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), x0, java.lang.Object(javaUtilEx.HashMap$Entry(x1, x0, x2, java.lang.Object(javaUtilEx.Content(EOC)))), java.lang.Object(javaUtilEx.HashMap$Entry(x1, x0, x2, java.lang.Object(javaUtilEx.Content(EOC))))) → f16865_0_put_NULL(EOS, java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), x0, x2, x2)
Filtered ground terms:
f16865_0_put_NULL(x1, x2, x3, x4, x5, x6) → f16865_0_put_NULL(x4, x5, x6)
Cond_f16865_0_put_NULL(x1, x2, x3, x4, x5, x6, x7) → Cond_f16865_0_put_NULL(x1, x5, x6, x7)
f16959_0_equals_Load(x1, x2, x3, x4, x5) → f16959_0_equals_Load(x3, x5)
javaUtilEx.Content(x1) → javaUtilEx.Content
Filtered duplicate terms:
f16865_0_put_NULL(x1, x2, x3) → f16865_0_put_NULL(x1, x3)
Cond_f16865_0_put_NULL(x1, x2, x3, x4) → Cond_f16865_0_put_NULL(x1, x2, x4)
f16959_0_equals_Load(x1, x2) → f16959_0_equals_Load(x2)
Filtered unneeded terms:
javaUtilEx.HashMap$Entry(x1, x2, x3, x4) → javaUtilEx.HashMap$Entry(x2, x3, x4)
Prepared 5 rules for path length conversion:
P rules:
f16865_0_put_NULL(x0, java.lang.Object(javaUtilEx.HashMap$Entry(x2, x3, x4))) → f16865_0_put_NULL(x0, x3) | !(=(x2, x0))
f16865_0_put_NULL(x0, java.lang.Object(javaUtilEx.HashMap$Entry(x0, x2, x3))) → f16959_0_equals_Load(x3)
f16865_0_put_NULL(x0, java.lang.Object(javaUtilEx.HashMap$Entry(x0, x2, NULL))) → f16865_0_put_NULL(x0, x2)
f16865_0_put_NULL(x0, java.lang.Object(javaUtilEx.HashMap$Entry(x0, x2, java.lang.Object(x3)))) → f16865_0_put_NULL(x0, x2)
f16865_0_put_NULL(x0, java.lang.Object(javaUtilEx.HashMap$Entry(x0, x2, java.lang.Object(javaUtilEx.Content)))) → f16865_0_put_NULL(x0, x2)
Finished conversion. Obtained 5 rules.
P rules:
f16865_0_put_NULL(x0, v16) → f16865_0_put_NULL(x0, v17) | &&(&&(&&(<(x1, x0), >(+(v17, 1), 0)), <=(+(v17, 1), v16)), >(+(v16, 1), 1))
f16865_0_put_NULL(x0, v16) → f16865_0_put_NULL(x0, v17) | &&(&&(&&(>(x1, x0), >(+(v17, 1), 0)), <=(+(v17, 1), v16)), >(+(v16, 1), 1))
f16865_0_put_NULL(x7, v18) → f16865_0_put_NULL(x7, v19) | &&(&&(&&(<=(+(x7, 2), v18), >(+(v19, 1), 0)), <=(+(v19, 2), v18)), >(+(v18, 1), 2))
f16865_0_put_NULL(x9, v20) → f16865_0_put_NULL(x9, v21) | &&(&&(&&(<=(+(x9, 2), v20), >(+(v21, 1), 0)), <=(+(v21, 2), v20)), >(+(v20, 1), 3))
f16865_0_put_NULL(x12, v22) → f16865_0_put_NULL(x12, v23) | &&(&&(&&(<=(+(x12, 2), v22), >(+(v23, 1), 0)), <=(+(v23, 2), v22)), >(+(v22, 1), 3))
Found the following polynomial interpretation:
Therefore the following rule(s) have been dropped:
Generated rules. Obtained 79 IRules
P rules:
f15507_0_createMap_LE(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5036) → f15512_0_createMap_LE(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5036)
f15512_0_createMap_LE(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5036) → f15518_0_createMap_New(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) | >(i5036, 0)
f15518_0_createMap_New(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) → f15532_0_createMap_Duplicate(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)))
f15532_0_createMap_Duplicate(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC))) → f15541_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f15541_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f15559_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f15559_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f15581_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015)))
f15581_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015))) → f15587_0_random_ArrayAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015)), i5016)
f15587_0_random_ArrayAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015)), i5016) → f15595_0_random_ArrayAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015)), i5016)
f15595_0_random_ArrayAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015)), i5016) → f15603_0_random_Store(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949) | <(i5016, i5015)
f15603_0_random_Store(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949) → f15612_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949)
f15612_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949) → f15625_0_random_ConstantStackPush(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949, i5016)
f15625_0_random_ConstantStackPush(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949, i5016) → f15639_0_random_IntArithmetic(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949, i5016, 1)
f15639_0_random_IntArithmetic(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949, i5016, matching1) → f15657_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949, +(i5016, 1)) | &&(>(i5016, 0), =(matching1, 1))
f15657_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949, i5072) → f15668_0_random_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949)
f15668_0_random_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949) → f15681_0_random_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o9949)
f15681_0_random_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o9999sub)) → f15697_0_random_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o9999sub))
f15697_0_random_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o9999sub)) → f15712_0_length_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o9999sub), java.lang.Object(o9999sub))
f15712_0_length_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o9999sub), java.lang.Object(o9999sub)) → f15742_0_length_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o9999sub), java.lang.Object(o9999sub))
f15742_0_length_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(java.lang.String(o10028sub, i5085)), java.lang.Object(java.lang.String(o10028sub, i5085))) → f15767_0_length_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(java.lang.String(o10028sub, i5085)), java.lang.Object(java.lang.String(o10028sub, i5085))) | >=(i5085, 0)
f15767_0_length_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(java.lang.String(o10028sub, i5085)), java.lang.Object(java.lang.String(o10028sub, i5085))) → f15785_0_length_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(java.lang.String(o10028sub, i5085)), i5085)
f15785_0_length_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(java.lang.String(o10028sub, i5085)), i5085) → f15798_0_random_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085)
f15798_0_random_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085) → f15814_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085)
f15814_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085) → f15830_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085, java.lang.Object(javaUtilEx.Content(EOC)), i5085)
f15830_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085, java.lang.Object(javaUtilEx.Content(EOC)), i5085) → f15857_0__init__InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085, java.lang.Object(javaUtilEx.Content(EOC)), i5085, java.lang.Object(javaUtilEx.Content(EOC)))
f15857_0__init__InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085, java.lang.Object(javaUtilEx.Content(EOC)), i5085, java.lang.Object(javaUtilEx.Content(EOC))) → f15887_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085, java.lang.Object(javaUtilEx.Content(EOC)), i5085)
f15887_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085, java.lang.Object(javaUtilEx.Content(EOC)), i5085) → f15897_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085, i5085, java.lang.Object(javaUtilEx.Content(EOC)))
f15897_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085, i5085, java.lang.Object(javaUtilEx.Content(EOC))) → f15910_0__init__FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085, java.lang.Object(javaUtilEx.Content(EOC)), i5085)
f15910_0__init__FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085, java.lang.Object(javaUtilEx.Content(EOC)), i5085) → f15937_0__init__Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085)
f15937_0__init__Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5085) → f15950_0_createMap_Store(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)))
f15950_0_createMap_Store(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC))) → f15960_0_createMap_New(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)))
f15960_0_createMap_New(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC))) → f16016_0_createMap_Duplicate(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f16016_0_createMap_Duplicate(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f16029_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f16029_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f16041_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f16041_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f16067_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015)))
f16067_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015))) → f16083_0_random_ArrayAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015)), i5072)
f16083_0_random_ArrayAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015)), i5072) → f16105_0_random_ArrayAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015)), i5072)
f16105_0_random_ArrayAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(ARRAY(i5015)), i5072) → f16146_0_random_Store(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208) | <(i5072, i5015)
f16146_0_random_Store(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208) → f16164_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208)
f16164_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208) → f16181_0_random_ConstantStackPush(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208, i5072)
f16181_0_random_ConstantStackPush(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208, i5072) → f16202_0_random_IntArithmetic(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208, i5072, 1)
f16202_0_random_IntArithmetic(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208, i5072, matching1) → f16234_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208, +(i5072, 1)) | &&(>(i5072, 0), =(matching1, 1))
f16234_0_random_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208, i5159) → f16256_0_random_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208)
f16256_0_random_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208) → f16270_0_random_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), o10208)
f16270_0_random_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10273sub)) → f16276_0_random_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10273sub))
f16276_0_random_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10273sub)) → f16281_0_length_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10273sub), java.lang.Object(o10273sub))
f16281_0_length_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10273sub), java.lang.Object(o10273sub)) → f16322_0_length_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(o10273sub), java.lang.Object(o10273sub))
f16322_0_length_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(java.lang.String(o10324sub, i5180)), java.lang.Object(java.lang.String(o10324sub, i5180))) → f16363_0_length_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(java.lang.String(o10324sub, i5180)), java.lang.Object(java.lang.String(o10324sub, i5180))) | >=(i5180, 0)
f16363_0_length_FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(java.lang.String(o10324sub, i5180)), java.lang.Object(java.lang.String(o10324sub, i5180))) → f16372_0_length_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(java.lang.String(o10324sub, i5180)), i5180)
f16372_0_length_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(java.lang.String(o10324sub, i5180)), i5180) → f16388_0_random_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180)
f16388_0_random_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180) → f16398_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180)
f16398_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180) → f16409_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180, java.lang.Object(javaUtilEx.Content(EOC)), i5180)
f16409_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180, java.lang.Object(javaUtilEx.Content(EOC)), i5180) → f16440_0__init__InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180, java.lang.Object(javaUtilEx.Content(EOC)), i5180, java.lang.Object(javaUtilEx.Content(EOC)))
f16440_0__init__InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180, java.lang.Object(javaUtilEx.Content(EOC)), i5180, java.lang.Object(javaUtilEx.Content(EOC))) → f16458_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180, java.lang.Object(javaUtilEx.Content(EOC)), i5180)
f16458_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180, java.lang.Object(javaUtilEx.Content(EOC)), i5180) → f16477_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180, i5180, java.lang.Object(javaUtilEx.Content(EOC)))
f16477_0__init__Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180, i5180, java.lang.Object(javaUtilEx.Content(EOC))) → f16492_0__init__FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180, java.lang.Object(javaUtilEx.Content(EOC)), i5180)
f16492_0__init__FieldAccess(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180, java.lang.Object(javaUtilEx.Content(EOC)), i5180) → f16514_0__init__Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180)
f16514_0__init__Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5180) → f16526_0_createMap_Store(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f16526_0_createMap_Store(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f16550_0_createMap_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f16550_0_createMap_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f16562_0_createMap_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))))
f16562_0_createMap_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) → f16573_0_createMap_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)))
f16573_0_createMap_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC))) → f16599_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f16599_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f16621_0_put_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f16599_0_createMap_InvokeMethod(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f16621_1_put_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f16621_0_put_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f16642_0_put_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)))
f17324_0_put_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5447, i5448, java.lang.Object(javaUtilEx.HashMap$Entry(o10762sub))) → f17331_0_createMap_StackPop(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))))
f17331_0_createMap_StackPop(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) → f17335_0_createMap_Inc(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))))
f17335_0_createMap_Inc(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) → f17536_0_createMap_Inc(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))))
f17536_0_createMap_Inc(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) → f19501_0_createMap_Inc(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))))
f19501_0_createMap_Inc(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) → f19507_0_createMap_JMP(EOS, +(i5036, -1), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) | >(i5036, 0)
f19507_0_createMap_JMP(EOS, i5954, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) → f19514_0_createMap_Load(EOS, i5954, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))))
f19514_0_createMap_Load(EOS, i5954, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) → f15489_0_createMap_Load(EOS, i5954, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))))
f15489_0_createMap_Load(EOS, i5017, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC)))) → f15507_0_createMap_LE(EOS, i5017, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), i5017)
f17521_0_put_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), NULL) → f19491_0_put_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), NULL)
f19491_0_put_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), NULL) → f19496_0_createMap_StackPop(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), NULL)
f19496_0_createMap_StackPop(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), NULL) → f19501_0_createMap_Inc(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))))
f19490_0_put_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), NULL) → f19491_0_put_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), NULL)
f16621_1_put_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f17324_0_put_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), i5447, i5448, java.lang.Object(javaUtilEx.HashMap$Entry(o10762sub)))
f16621_1_put_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f17521_0_put_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), NULL)
f16621_1_put_Load(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) → f19490_0_put_Return(EOS, i5036, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), NULL)
Combined rules. Obtained 2 IRules
P rules:
f15507_0_createMap_LE(EOS, x0, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0) → f16642_0_put_Load(EOS, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), java.lang.Object(javaUtilEx.Content(EOC)), java.lang.Object(javaUtilEx.Content(EOC))) | >(x0, 0)
f15507_0_createMap_LE(EOS, x0, java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), x0) → f15507_0_createMap_LE(EOS, -(x0, 1), java.lang.Object(javaUtilEx.AbstractMap(javaUtilEx.HashMap(EOC))), -(x0, 1)) | >(x0, 0)
Filtered ground terms:
f15507_0_createMap_LE(x1, x2, x3, x4) → f15507_0_createMap_LE(x2, x4)
Cond_f15507_0_createMap_LE(x1, x2, x3, x4, x5) → Cond_f15507_0_createMap_LE(x1, x3, x5)
f16642_0_put_Load(x1, x2, x3, x4, x5, x6, x7) → f16642_0_put_Load
Cond_f15507_0_createMap_LE1(x1, x2, x3, x4, x5) → Cond_f15507_0_createMap_LE1(x1, x3, x5)
javaUtilEx.AbstractMap(x1) → javaUtilEx.AbstractMap
javaUtilEx.HashMap(x1) → javaUtilEx.HashMap
javaUtilEx.Content(x1) → javaUtilEx.Content
Filtered duplicate terms:
f15507_0_createMap_LE(x1, x2) → f15507_0_createMap_LE(x2)
Cond_f15507_0_createMap_LE(x1, x2, x3) → Cond_f15507_0_createMap_LE(x1, x3)
Cond_f15507_0_createMap_LE1(x1, x2, x3) → Cond_f15507_0_createMap_LE1(x1, x3)
Filtered unneeded terms:
Cond_f15507_0_createMap_LE(x1, x2) → Cond_f15507_0_createMap_LE(x1)
Prepared 2 rules for path length conversion:
P rules:
f15507_0_createMap_LE(x0) → f16642_0_put_Load | >(x0, 0)
f15507_0_createMap_LE(x0) → f15507_0_createMap_LE(-(x0, 1)) | >(x0, 0)
Finished conversion. Obtained 1 rules.
P rules:
f15507_0_createMap_LE(x1) → f15507_0_createMap_LE(-(x1, 1)) | >(x1, 0)
Found the following polynomial interpretation:
Therefore the following rule(s) have been dropped: