diff --git a/experimental/README.md b/experimental/README.md
index 4ed03678b2..f58401d525 100644
--- a/experimental/README.md
+++ b/experimental/README.md
@@ -1,8 +1,8 @@
 # Experimental module
 
-The purpose of this module is to hold contracts/cordapps that aren't yet ready for code review, but which still want
+The purpose of this module is to hold code that isn't yet ready for code review, but which still wants
 to be refactored and kept compiling as the underlying platform changes. Code placed into experimental *must* eventually
-either be moved into the main modules and go through code review, or deleted.
+either be moved into the main modules and go through code review, or be deleted.
 
 Code placed here can be committed to directly onto master at any time as long as it doesn't break the build
 (no compile failures or unit test failures). Any commits here that break the build will simply be rolled back.
diff --git a/experimental/sandbox/README.md b/experimental/sandbox/README.md
new file mode 100644
index 0000000000..30f3f74298
--- /dev/null
+++ b/experimental/sandbox/README.md
@@ -0,0 +1,22 @@
+# JVM sandbox
+
+The code in this submodule is not presently integrated with the rest of the platform and stands alone. It will
+eventually become a part of the node software and enforce deterministic and secure execution on smart contract
+code, which is mobile and may propagate around the network without human intervention. Note that this sandbox
+is not designed as a anti-DoS mitigation.
+
+To learn more about the sandbox design please consult the Corda technical white paper.
+
+This code was written by Ben Evans. 
+
+The sandbox has been briefly reviewed but not yet tested or thoroughly reviewed. It should NOT be used or relied upon in any production setting until this warning is removed.
+
+# Roadmap
+
+* Thorough testing, code and security review.
+* Possibly, a conversion to Kotlin.
+* Make the instrumentation ahead of time only.
+* Finalise the chosen subset of the Java platform to expose to contract code.
+* Create the pre-instrumented sandboxed class files and check them in.
+* Integrate with the AttachmentsClassLoader
+* Add OpenJDK/Avian patches for deterministic Object.hashCode() implementation.
\ No newline at end of file
diff --git a/experimental/sandbox/build.gradle b/experimental/sandbox/build.gradle
new file mode 100644
index 0000000000..5f2bcd6ffc
--- /dev/null
+++ b/experimental/sandbox/build.gradle
@@ -0,0 +1,31 @@
+group 'net.corda'
+version '0.6-SNAPSHOT'
+
+apply plugin: 'java'
+apply plugin: 'kotlin'
+
+sourceCompatibility = 1.8
+
+buildscript {
+    ext.asm_version = '5.1'
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    // Asm: bytecode manipulation library.
+    compile "org.ow2.asm:asm:$asm_version"
+    compile "org.ow2.asm:asm-tree:$asm_version"
+    compile "org.ow2.asm:asm-util:$asm_version"
+    compile "org.ow2.asm:asm-commons:$asm_version"
+
+    // JOptSimple: command line option parsing
+    compile "net.sf.jopt-simple:jopt-simple:5.0.1"
+
+    // Simple Logging Facade: makes the code independent of the chosen logging framework.
+    compile "org.slf4j:slf4j-api:1.7.21"
+
+    testCompile group: 'junit', name: 'junit', version: '4.11'
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/CandidacyStatus.java b/experimental/sandbox/src/main/java/net/corda/sandbox/CandidacyStatus.java
new file mode 100644
index 0000000000..9684dc2f08
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/CandidacyStatus.java
@@ -0,0 +1,221 @@
+package net.corda.sandbox;
+
+import java.util.*;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import static net.corda.sandbox.CandidateMethod.State.*;
+
+/**
+ * Represents the status of the candidacy of a particular set of candidate methods, i.e. Their progress from
+ * being {@link CandidateMethod.State#UNDETERMINED} to {@link CandidateMethod.State#DETERMINISTIC}
+ * or {@link CandidateMethod.State#DISALLOWED} states.
+ * A method is identified by a string that is encoded as a standard JVM representation
+ * as per the constant pool. E.g.: java/lang/Byte.compareTo:(Ljava/lang/Byte;)I
+ */
+public class CandidacyStatus {
+
+    private static final int MAX_CLASSLOADING_RECURSIVE_DEPTH = 500;
+
+    private static final String DETERMINISTIC_METHODS = "java8.scan.java.lang_and_util"; //"java8.scan.java.lang
+
+    private final SortedMap<String, CandidateMethod> candidateMethods = new TreeMap<>();
+
+    // Backlog of methodSignatures that may have come in from other loaded classes
+    private final Set<String> backlog = new LinkedHashSet<>();
+
+    private WhitelistClassLoader contextLoader;
+
+    // Loadable is true by default as it's easier to prove falsehood than truth
+    private boolean loadable = true;
+
+    // If at all possible, we want to be able to provide a precise reason why this
+    // class is not loadable. As some methods are determined to be showstoppers only
+    // at the ClassVisitor it makes sense to store it here (for final reporting)
+    // as well as in the CandidateMethod
+    private WhitelistClassloadingException reason;
+
+    private int recursiveDepth = 0;
+
+    private CandidacyStatus() {
+    }
+
+    /**
+     *
+     * @param signature
+     * @return true if the input was absent from the underlying map
+     */
+    boolean putIfAbsent(final String signature, final CandidateMethod candidate) {
+        return null == candidateMethods.putIfAbsent(signature, candidate);
+    }
+
+    /**
+     * 
+     * @param methodSignature
+     * @return true if the input was absent from the underlying map
+     */
+    public boolean putIfAbsent(final String methodSignature) {
+        return null == candidateMethods.putIfAbsent(methodSignature, CandidateMethod.of(methodSignature));
+    }
+
+    /**
+     * Static factory method
+     * 
+     * @param startingSet
+     * @return a candidacy status based on the starting set
+     */
+    public static CandidacyStatus of(final String startingSet) {
+        final CandidacyStatus baseCandidacyStatus = new CandidacyStatus();
+        try {
+            for (String s : baseCandidacyStatus.readLinesFromFile(startingSet)) {
+                baseCandidacyStatus.putIfAbsent(s, CandidateMethod.proven(s));
+            }
+        } catch (IOException | URISyntaxException ex) {
+            throw new RuntimeException(ex);
+        }
+
+        return baseCandidacyStatus;
+    }
+
+    /**
+     * Static factory method
+     * 
+     * @return a candidacy status based on the starting set
+     */
+    public static CandidacyStatus of() {
+        return CandidacyStatus.of(DETERMINISTIC_METHODS);
+    }
+
+    /**
+     * Add additional methods that are known to be deterministic
+     * 
+     * @param methodNames 
+     */
+    public void addKnownDeterministicMethods(final Set<String> methodNames) {
+        for (String known : methodNames) {
+            candidateMethods.putIfAbsent(known, CandidateMethod.proven(known));
+        }
+    }
+
+    /**
+     * Getter method for candidate methods
+     * 
+     * @param methodSignature
+     * @return the candidate method corresponding to a method signature
+     */
+    public CandidateMethod getCandidateMethod(final String methodSignature) {
+        return candidateMethods.get(methodSignature);
+    }
+
+    public Map<String, CandidateMethod> getCandidateMethods() {
+        return candidateMethods;
+    }
+
+    public void addToBacklog(final String discoveredMethod) {
+        if (!backlog.contains(discoveredMethod)) {
+            backlog.add(discoveredMethod);
+        }
+    }
+
+    public List<String> readLinesFromFile(final String fName) throws IOException, URISyntaxException {
+        final Path p = Paths.get(getClass().getClassLoader().getResource(fName).toURI());
+        return Files.readAllLines(p);
+    }
+
+    public boolean isLoadable() {
+        return loadable;
+    }
+
+    public void setLoadable(final boolean loadable) {
+        this.loadable = loadable;
+    }
+
+    public WhitelistClassloadingException getReason() {
+        return reason;
+    }
+
+    public void setReason(final String because) {
+        reason = new WhitelistClassloadingException(because);
+    }
+
+    public WhitelistClassLoader getContextLoader() {
+        return contextLoader;
+    }
+
+    public void setContextLoader(final WhitelistClassLoader contextLoader) {
+        this.contextLoader = contextLoader;
+    }
+
+    /**
+     * Increases the recursive depth of this classloading process, throwing a 
+     * ClassNotFoundException if it becomes too high
+     * 
+     * @throws ClassNotFoundException 
+     */
+    public void incRecursiveCount() throws ClassNotFoundException {
+        if (recursiveDepth >= MAX_CLASSLOADING_RECURSIVE_DEPTH - 1) {
+            reason = new WhitelistClassloadingException("Recursive depth of classloading exceeded");
+            throw new ClassNotFoundException("Class cannot be loaded due to deep recursion", reason);
+        }
+        recursiveDepth++;
+    }
+
+    public void decRecursiveCount() {
+        recursiveDepth--;
+    }
+
+    public Set<String> getDisallowedMethods() {
+        final Set<String> out = new HashSet<>();
+        for (final String candidateName : candidateMethods.keySet()) {
+            final CandidateMethod candidate = candidateMethods.get(candidateName);
+            if (candidate.getCurrentState() == CandidateMethod.State.DISALLOWED) {
+                out.add(candidateName);
+            }
+        }
+        
+        return out;
+    }
+
+    @Override
+    public String toString() {
+        return "CandidacyStatus{" + "candidateMethods=" + candidateMethods + ", backlog=" + backlog + ", contextLoader=" + contextLoader + ", loadable=" + loadable + ", reason=" + reason + ", recursiveDepth=" + recursiveDepth + '}';
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 5;
+        hash = 53 * hash + Objects.hashCode(this.candidateMethods);
+        hash = 53 * hash + Objects.hashCode(this.backlog);
+        hash = 53 * hash + Objects.hashCode(this.contextLoader);
+        hash = 53 * hash + (this.loadable ? 1 : 0);
+        hash = 53 * hash + Objects.hashCode(this.reason);
+        hash = 53 * hash + this.recursiveDepth;
+        return hash;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        final CandidacyStatus other = (CandidacyStatus) obj;
+        if (!Objects.equals(this.candidateMethods, other.candidateMethods))
+            return false;
+        if (!Objects.equals(this.backlog, other.backlog))
+            return false;
+        if (!Objects.equals(this.contextLoader, other.contextLoader))
+            return false;
+        if (this.loadable != other.loadable)
+            return false;
+        if (!Objects.equals(this.reason, other.reason))
+            return false;
+        if (this.recursiveDepth != other.recursiveDepth)
+            return false;
+        return true;
+    }
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/CandidateMethod.java b/experimental/sandbox/src/main/java/net/corda/sandbox/CandidateMethod.java
new file mode 100644
index 0000000000..49e5091fbe
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/CandidateMethod.java
@@ -0,0 +1,110 @@
+package net.corda.sandbox;
+
+import java.lang.invoke.MethodType;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * A candidate method that is under evaluation. Candidate methods have one of the following states:
+ *
+ * <ul>
+ *     <li>{@link CandidateMethod.State#DETERMINISTIC} - It's deterministic and therefore is allowed to be loaded.</li>
+ *     <li>{@link CandidateMethod.State#DISALLOWED} - It's not deterministic and won't be allowed to be loaded.</li>
+ *     <li>{@link CandidateMethod.State#SCANNED} - We're not sure if it's deterministic or not.</li>
+ * </ul>
+ *
+ * CandidateMethods themselves reference other CandidateMethods which are be checked for their deterministic state
+ *
+ */
+public final class CandidateMethod {
+
+    // The state model must reflect the difference between "mentioned in an API" and
+    // "scanned by classloader"
+    public enum State {
+        DETERMINISTIC,
+        MENTIONED,
+        SCANNED,
+        DISALLOWED
+    }
+
+    private State currentState = State.MENTIONED;
+
+    private String reason;
+
+    private CandidateMethod(String methodSignature) {
+        internalMethodName = methodSignature;
+    }
+
+    // TODO We'll likely use the formal MethodType for deeper analysis
+    private MethodType methodType;
+
+    // Internal method name as it appears in the constant pool
+    private final String internalMethodName;
+
+    private final Set<CandidateMethod> referencedCandidateMethods = new HashSet<>();
+
+    
+    public State getCurrentState() {
+        return currentState;
+    }
+
+    public void setCurrentState(final State currentState) {
+        this.currentState = currentState;
+    }
+
+    public void disallowed(final String because) {
+        reason = because;
+        currentState = State.DISALLOWED;
+    }
+
+    public void deterministic() {
+        if (currentState == State.DISALLOWED) {
+            throw new IllegalArgumentException("Method "+ internalMethodName +" attempted to transition from DISALLOWED to DETERMINISTIC");
+        }
+        currentState = State.DETERMINISTIC;
+    }
+
+    public void scanned() {
+        currentState = State.SCANNED;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+
+    public void setReason(String reason) {
+        this.reason = reason;
+    }
+
+    public String getInternalMethodName() {
+        return internalMethodName;
+    }
+    
+    public void addReferencedCandidateMethod(final CandidateMethod referenceCandidateMethod) {
+        referencedCandidateMethods.add(referenceCandidateMethod);
+    }
+
+    public Set<CandidateMethod> getReferencedCandidateMethods() {
+        return referencedCandidateMethods;
+    }
+
+    public static CandidateMethod of(String methodSignature) {
+        return new CandidateMethod(methodSignature);
+    }
+
+    /**
+     * This factory constructor is only called for methods that are known to be deterministic in advance
+     * @param methodSignature
+     * @return 
+     */
+    public static CandidateMethod proven(String methodSignature) {
+        final CandidateMethod provenCandidateMethod = new CandidateMethod(methodSignature);
+        provenCandidateMethod.deterministic();
+        return provenCandidateMethod;
+    }
+
+    @Override
+    public String toString() {
+        return "CandidateMethod{" + "currentState=" + currentState + ", reason=" + reason + ", methodType=" + methodType + ", internalMethodName=" + internalMethodName + ", referencedCandidateMethods=" + referencedCandidateMethods + '}';
+    }
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxAwareClassWriter.java b/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxAwareClassWriter.java
new file mode 100644
index 0000000000..03e3cf9d56
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxAwareClassWriter.java
@@ -0,0 +1,83 @@
+package net.corda.sandbox;
+
+import static net.corda.sandbox.Utils.*;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+
+/**
+ *
+ * @author ben
+ */
+public final class SandboxAwareClassWriter extends ClassWriter {
+
+    private final ClassLoader loader;
+
+    public SandboxAwareClassWriter(final ClassLoader save, final ClassReader classReader, final int flags) {
+        super(classReader, flags);
+        loader = save;
+    }
+
+    /**
+     * Returns the common super type of the two given types. The default
+     * implementation of this method <i>loads</i> the two given classes and uses
+     * the java.lang.Class methods to find the common super class. It can be
+     * overridden to compute this common super type in other ways, in particular
+     * without actually loading any class, or to take into account the class
+     * that is currently being generated by this ClassWriter, which can of
+     * course not be loaded since it is under construction.
+     * 
+     * @param type1
+     *            the internal name of a class.
+     * @param type2
+     *            the internal name of another class.
+     * @return the internal name of the common super class of the two given
+     *         classes.
+     */
+    @Override
+    public String getCommonSuperClass(final String type1, final String type2) {
+        if (OBJECT.equals(type1) || OBJECT.equals(type2) 
+                || OBJECT.equals(unsandboxNameIfNeedBe(type1)) || OBJECT.equals(unsandboxNameIfNeedBe(type2))) {
+            return OBJECT;
+        }
+//        System.out.println(type1 + " ; " + type2);
+        String out = super.getCommonSuperClass(unsandboxNameIfNeedBe(type1), unsandboxNameIfNeedBe(type2));
+//        try {
+//           out = getCommonSuperClassBorrowed(type1, type2);        
+//        } catch (final ClassNotFoundException cnfe) {
+//            throw new RuntimeException(cnfe);
+//        }
+        if (SANDBOX_PATTERN_INTERNAL.asPredicate().test(type1) || SANDBOX_PATTERN_INTERNAL.asPredicate().test(type2)) {
+            return SANDBOX_PREFIX_INTERNAL + out;
+        }
+        return out;
+    }
+
+    public String getCommonSuperClassBorrowed(final String type1, final String type2) throws ClassNotFoundException {
+        Class<?> c, d;
+        try {
+            c = Class.forName(type1.replace('/', '.'), false, loader);
+            d = Class.forName(type2.replace('/', '.'), false, loader);
+        } catch (Exception e) {
+            
+            c = Class.forName(unsandboxNameIfNeedBe(type1).replace('/', '.'), false, loader);
+            d = Class.forName(unsandboxNameIfNeedBe(type2).replace('/', '.'), false, loader);
+
+//            throw new RuntimeException(e.toString());
+        }
+        if (c.isAssignableFrom(d)) {
+            return type1;
+        }
+        if (d.isAssignableFrom(c)) {
+            return type2;
+        }
+        if (c.isInterface() || d.isInterface()) {
+            return "java/lang/Object";
+        } else {
+            do {
+                c = c.getSuperclass();
+            } while (!c.isAssignableFrom(d));
+            return c.getName().replace('.', '/');
+        }
+    }
+
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxRemapper.java b/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxRemapper.java
new file mode 100644
index 0000000000..2f55c4edb6
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxRemapper.java
@@ -0,0 +1,20 @@
+package net.corda.sandbox;
+
+import org.objectweb.asm.commons.Remapper;
+
+/**
+ *
+ * @author ben
+ */
+public final class SandboxRemapper extends Remapper {
+
+    @Override
+    public String mapDesc(final String desc) {
+        return super.mapDesc(Utils.rewriteDescInternal(desc));
+    }
+
+    @Override
+    public String map(final String typename) {
+        return super.map(Utils.sandboxInternalTypeName(typename));
+    }
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/Utils.java b/experimental/sandbox/src/main/java/net/corda/sandbox/Utils.java
new file mode 100644
index 0000000000..c185ba2500
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/Utils.java
@@ -0,0 +1,211 @@
+package net.corda.sandbox;
+
+import net.corda.sandbox.visitors.CostInstrumentingMethodVisitor;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.objectweb.asm.*;
+import org.objectweb.asm.commons.ClassRemapper;
+
+/**
+ *
+ * @author ben
+ */
+public final class Utils {
+
+    public final static String SANDBOX_PREFIX_INTERNAL = "sandbox/";
+
+    public final static String CLASSFILE_NAME_SUFFIX = "^(.*)\\.class$";
+    
+    public static final Pattern JAVA_LANG_PATTERN_INTERNAL = Pattern.compile("^java/lang/(.*)");
+
+    public static final Pattern SANDBOX_PATTERN_INTERNAL = Pattern.compile("^" + SANDBOX_PREFIX_INTERNAL + "(.*)");
+
+    public static final Pattern SIGNATURE_PATTERN_INTERNAL = Pattern.compile("\\((.*)\\)(.+)");
+
+    public static final Pattern REFTYPE_PATTERN_INTERNAL = Pattern.compile("(L[^;]+;)");
+
+    public static final Pattern ARRAY_REFTYPE_PATTERN_INTERNAL = Pattern.compile("((\\[+)L[^;]+;)");
+
+    public static final Pattern JAVA_PATTERN_QUALIFIED = Pattern.compile("^java\\.(.+)");
+
+    public static final Pattern CLASSNAME_PATTERN_QUALIFIED = Pattern.compile("([^\\.]+)\\.");
+
+    public static final String OBJECT = "java/lang/Object";
+    
+    public static final String THROWABLE = "java/lang/Throwable";
+    
+    public static final String ERROR = "java/lang/Error";
+    
+    public static final String THREAD_DEATH = "java/lang/ThreadDeath";
+    
+    // Hide constructor
+    private Utils() {
+    }
+
+    /**
+     * Helper method that converts from the internal class name format (as used in the
+     * Constant Pool) to a fully-qualified class name. No obvious library method to do this
+     * appears to exist, hence this code. If one exists, rip this out.
+     * @param classInternalName
+     * @return
+     */
+    public static String convertInternalFormToQualifiedClassName(final String classInternalName) {
+        String out = classInternalName.replaceAll("/", "\\.");
+        return out;
+    }
+
+    /**
+     * This method takes in an internal method name but needs to return a qualified 
+     * classname (suitable for loading)
+     * 
+     * 
+     * @param internalMethodName
+     * @return 
+     */
+    public static String convertInternalMethodNameToQualifiedClassName(final String internalMethodName) {
+        final Matcher classMatch = CLASSNAME_PATTERN_QUALIFIED.matcher(internalMethodName);
+        if (classMatch.find()) {
+            return convertInternalFormToQualifiedClassName(classMatch.group(1));
+        } else {
+            throw new IllegalArgumentException(internalMethodName + " is not a legal method name");
+        }
+    }
+
+    /**
+     * Helper method that converts from a fully-qualified class name to the internal class
+     * name format (as used in the Constant Pool). No obvious library method to do this
+     * appears to exist, hence this code. If one exists, rip this out.
+     * @param qualifiedClassName
+     * @return
+     */
+    public static String convertQualifiedClassNameToInternalForm(final String qualifiedClassName) {
+        String out = qualifiedClassName.replaceAll("\\.", "/");
+        return out;
+    }
+
+    /**
+     * This method potentially rewrites the classname. 
+     *
+     * @param internalClassname - specified in internal form
+     * @return
+     */
+    public static String sandboxInternalTypeName(final String internalClassname) {
+        if (classShouldBeSandboxedInternal(internalClassname)) {
+            final Matcher arrayMatch = ARRAY_REFTYPE_PATTERN_INTERNAL.matcher(internalClassname);
+            if (arrayMatch.find()) {
+                final String indirection = arrayMatch.group(2);
+                return indirection + SANDBOX_PREFIX_INTERNAL + internalClassname.substring(indirection.length());
+            } else {
+                // Regular, non-array reftype
+                return SANDBOX_PREFIX_INTERNAL + internalClassname;
+            }
+        }
+
+        return internalClassname;
+    }
+
+    /**
+     * 
+     * @param qualifiedTypeName
+     * @return 
+     */
+    public static String sandboxQualifiedTypeName(final String qualifiedTypeName) {
+        final String internal = convertQualifiedClassNameToInternalForm(qualifiedTypeName);
+        final String sandboxedInternal = sandboxInternalTypeName(internal);
+        if (internal.equals(sandboxedInternal)) {
+            return qualifiedTypeName;
+        }
+        return convertInternalFormToQualifiedClassName(sandboxedInternal);
+    }
+
+    /**
+     * This method removes the sandboxing prefix from a method or type name, if it has
+     * one, otherwise it returns the input string.
+     * 
+     * @param internalClassname
+     * @return the internal classname, unsandboxed if that was required
+     */
+    public static String unsandboxNameIfNeedBe(final String internalClassname) {
+        final Matcher m = SANDBOX_PATTERN_INTERNAL.matcher(internalClassname);
+        if (m.find()) {
+            return m.group(1);
+        }
+        return internalClassname;
+    }
+
+    /**
+     * 
+     * @param desc - internal
+     * @return the rewritten desc string
+     */
+    public static String rewriteDescInternal(final String desc) {
+        String remaining = desc;
+        final Matcher formatCheck = SIGNATURE_PATTERN_INTERNAL.matcher(desc);
+        // Check it's a valid signature string
+        if (!formatCheck.find())
+            return remaining;
+
+        final StringBuilder out = new StringBuilder();
+        while (remaining.length() > 0) {
+            final Matcher refTypeFound = REFTYPE_PATTERN_INTERNAL.matcher(remaining);
+            if (refTypeFound.find()) {
+                final int startOfType = refTypeFound.start();
+                final int endOfType = refTypeFound.end();
+                final String before = remaining.substring(0, startOfType);
+
+                final String found = refTypeFound.group(1);
+                final String rewritten = "L" + sandboxInternalTypeName(found.substring(1));
+                out.append(before);
+                out.append(rewritten);
+                remaining = remaining.substring(endOfType);
+            } else {
+                out.append(remaining);
+                remaining = "";
+            }
+        }
+
+        return out.toString();
+    }
+
+    /**
+     * Determines whether a classname in qualified form is a candidate for transitive
+     * loading. This should not attempt to load a classname that starts with java. as
+     * the only permissable classes have already been transformed into sandboxed
+     * methods
+     * 
+     * @param qualifiedClassName
+     * @return 
+     */
+    public static boolean shouldAttemptToTransitivelyLoad(final String qualifiedClassName) {
+        if (JAVA_PATTERN_QUALIFIED.asPredicate().test(qualifiedClassName)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Helper method that determines whether this class requires sandboxing
+     * 
+     * @param clazzName - specified in internal form
+     * @return true if the class should be sandboxed
+     */
+    public static boolean classShouldBeSandboxedInternal(final String clazzName) {
+        if (ARRAY_REFTYPE_PATTERN_INTERNAL.asPredicate().test(clazzName)) {
+            return classShouldBeSandboxedInternal(clazzName.substring(2, clazzName.length() - 1));
+        }
+
+        if (JAVA_LANG_PATTERN_INTERNAL.asPredicate().test(clazzName)) {
+            return false;
+        }
+
+        if (SANDBOX_PATTERN_INTERNAL.asPredicate().test(clazzName)) {
+            return false;
+        }
+
+        return true;
+    }
+
+
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassLoader.java b/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassLoader.java
new file mode 100644
index 0000000000..9f363e3187
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassLoader.java
@@ -0,0 +1,357 @@
+package net.corda.sandbox;
+
+import net.corda.sandbox.visitors.CostInstrumentingMethodVisitor;
+import net.corda.sandbox.visitors.WhitelistCheckingClassVisitor;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.*;
+import java.util.*;
+import org.objectweb.asm.*;
+import org.objectweb.asm.commons.ClassRemapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ *
+ * @author ben
+ */
+public final class WhitelistClassLoader extends ClassLoader {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(WhitelistClassLoader.class);
+
+    private final Map<String, Class<?>> loadedClasses;
+
+    private final Map<String, byte[]> transformedClasses;
+
+    private final List<Path> primaryClasspathSearchPath = new ArrayList<>();
+
+    private final List<Path> fileSystemSearchPath = new ArrayList<>();
+
+    private final CandidacyStatus candidacyStatus;
+
+    private final boolean removeNonDeterministicMethods;
+
+    private Path classDir;
+
+    private String classInternalName;
+
+    private Path outputJarPath;
+
+    private WhitelistClassLoader(final boolean stripNonDeterministicMethods) {
+        candidacyStatus = CandidacyStatus.of();
+        loadedClasses = new HashMap<>();
+        transformedClasses = new HashMap<>();
+        removeNonDeterministicMethods = stripNonDeterministicMethods;
+    }
+
+    /* 
+     * Copy constructor for use in recursive calls
+     * @param other 
+     */
+    private WhitelistClassLoader(WhitelistClassLoader other) {
+        candidacyStatus = other.candidacyStatus;
+        loadedClasses = other.loadedClasses;
+        transformedClasses = other.transformedClasses;
+        fileSystemSearchPath.addAll(other.fileSystemSearchPath);
+        primaryClasspathSearchPath.addAll(other.primaryClasspathSearchPath);
+        removeNonDeterministicMethods = other.removeNonDeterministicMethods;
+    }
+
+    /**
+     * Static factory method. Throws URISyntaxException currently, as this method is 
+     * called with user data, so a checked exception is not unreasonable. Could use a 
+     * runtime exception instead.
+     *
+     * @param auxiliaryClassPath
+     * @param stripNonDeterministic if set to true, then rather than requiring all
+     *                              methods to be deterministic, instead the classloader
+     *                              will remove all non-deterministic methods.
+     * @return a suitably constructed whitelisting classloader
+     * @throws URISyntaxException 
+     */
+    public static WhitelistClassLoader of(final String auxiliaryClassPath, final boolean stripNonDeterministic) throws URISyntaxException {
+        final WhitelistClassLoader out = new WhitelistClassLoader(stripNonDeterministic);
+        out.candidacyStatus.setContextLoader(out);
+        out.setupClasspath(auxiliaryClassPath);
+        return out;
+    }
+
+    public static WhitelistClassLoader of(final String auxiliaryClassPath) throws URISyntaxException {
+        return of(auxiliaryClassPath, false);
+    }
+
+    public static WhitelistClassLoader of(final Path auxiliaryJar, final boolean stripNonDeterministic) throws URISyntaxException {
+        final WhitelistClassLoader out = new WhitelistClassLoader(stripNonDeterministic);
+        out.candidacyStatus.setContextLoader(out);
+        out.fileSystemSearchPath.add(auxiliaryJar);
+        return out;
+    }
+
+    public static WhitelistClassLoader of(final Path auxiliaryJar) throws URISyntaxException {
+        return of(auxiliaryJar, false);
+    }
+
+    /**
+     * Static factory method. Used for recursive classloading
+     * 
+     * @param other
+     * @return a suitably constructed whitelisting classloader based on the state
+     *         of the passed classloader
+     */
+    public static WhitelistClassLoader of(final WhitelistClassLoader other) {
+        final WhitelistClassLoader out = new WhitelistClassLoader(other);
+//        out.candidacyStatus.setContextLoader(out);
+        return out;
+    }
+
+    /**
+     * Helper method that adds a jar to the path to be searched
+     *
+     * @param knownGoodJar 
+     */
+    void addJarToSandbox(final Path knownGoodJar) {
+        fileSystemSearchPath.add(knownGoodJar);
+    }
+
+    /**
+     * Setup the auxiliary classpath so that classes that are not on the original
+     * classpath can be scanned for.
+     * Note that this this method hardcodes Unix conventions, so won't work on e.g. Windows
+     * 
+     * @param auxiliaryClassPath
+     * @throws URISyntaxException 
+     */
+    void setupClasspath(final String auxiliaryClassPath) throws URISyntaxException {
+        for (String entry : auxiliaryClassPath.split(":")) {
+            if (entry.startsWith("/")) {
+                fileSystemSearchPath.add(Paths.get(entry));
+            } else {
+                final URL u = getClass().getClassLoader().getResource(entry);
+                primaryClasspathSearchPath.add(Paths.get(u.toURI()));
+            }
+        }
+    }
+
+    /**
+     * 
+     * @param qualifiedClassName
+     * @return a class object that has been whitelist checked and is known to be
+     *         deterministic
+     * @throws ClassNotFoundException 
+     */
+    @Override
+    public Class<?> findClass(final String qualifiedClassName) throws ClassNotFoundException {
+        // One problem is that the requested class may refer to untransformed (but
+        // deterministic) classes that will resolve & be loadable by the WLCL, but
+        // in doing so, the name of the referenced class is rewritten and the name
+        // by which it is now known does not have a mapping to a loaded class.
+        // To solve this, we use the loadedClasses cache - on both possible keys
+        // for the class (either of which will point to a transformed class object)
+        Class<?> cls = loadedClasses.get(qualifiedClassName);
+        if (cls != null) {
+            return cls;
+        }
+        final String sandboxed = Utils.sandboxQualifiedTypeName(qualifiedClassName);
+        cls = loadedClasses.get(sandboxed);
+        if (cls != null) {
+            return cls;
+        }
+        // Cache miss - so now try the superclass implementation
+        try {
+            cls = super.findClass(qualifiedClassName);
+        } catch (ClassNotFoundException ignored) {
+            // We actually need to load this ourselves, so find the path
+            // corresponding to the directory where the classfile lives.
+            // Note that for jar files this might be a "virtual" Path object
+            classInternalName = Utils.convertQualifiedClassNameToInternalForm(qualifiedClassName);
+            classDir = locateClassfileDir(classInternalName);
+            try {
+                final boolean isDeterministic = scan();
+                if (isDeterministic || removeNonDeterministicMethods) {
+                    final Path fullPathToClass = classDir.resolve(classInternalName + ".class");
+                    Set<String> methodsToRemove = new HashSet<>();
+                    if (removeNonDeterministicMethods && !isDeterministic) {
+                        methodsToRemove = candidacyStatus.getDisallowedMethods();
+                    }
+
+                    final byte[] classContents = Files.readAllBytes(fullPathToClass);
+                    final byte[] instrumentedBytes = instrumentWithCosts(classContents, methodsToRemove);
+                    if (!removeNonDeterministicMethods) {
+                        // If we're in stripping mode, then trying to define the class
+                        // will cause a transitive loading failure
+                        cls = defineClass(null, instrumentedBytes, 0, instrumentedBytes.length);
+                    }
+                    transformedClasses.put(sandboxed, instrumentedBytes);
+                } else {
+                    throw new ClassNotFoundException("Class " + qualifiedClassName + " could not be loaded.", reason());
+                }
+            } catch (final IOException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+
+        if (LOGGER.isDebugEnabled())
+            LOGGER.debug("Saving class " + cls + " as " + qualifiedClassName);
+
+        loadedClasses.put(qualifiedClassName, cls);
+
+        if (LOGGER.isDebugEnabled())
+            LOGGER.debug("Saving class " + cls + " as " + sandboxed);
+
+        loadedClasses.put(sandboxed, cls);
+
+        return cls;
+    }
+
+    /**
+     * Using the ASM library read in the currentClass's byte code and visit the call
+     * sites within it.  Whilst visiting, check to see if the classes/methods visited
+     * are deterministic and therefore safe to load.
+     *
+     * @return true if the current class is safe to be loaded
+     * @throws java.io.IOException
+     */
+    public boolean scan() throws IOException {
+        try (final InputStream in = Files.newInputStream(classDir.resolve(classInternalName + ".class"))) {
+            try {
+                final ClassReader classReader = new ClassReader(in);
+
+                // Useful for debug, you can pass in the traceClassVisitor as an extra parameter if needed
+                // PrintWriter printWriter = new PrintWriter(System.out);
+                // TraceClassVisitor traceClassVisitor = new TraceClassVisitor(printWriter);
+                final ClassVisitor whitelistCheckingClassVisitor
+                        = new WhitelistCheckingClassVisitor(classInternalName, candidacyStatus);
+
+                if (LOGGER.isDebugEnabled())
+                    LOGGER.debug("About to read class: " + classInternalName);
+
+                // If there's debug info in the class, don't look at that whilst visiting
+                classReader.accept(whitelistCheckingClassVisitor, ClassReader.SKIP_DEBUG);
+            } catch (Exception ex) {
+                LOGGER.error("Exception whilst reading class: " + classInternalName, ex);
+            }
+        }
+
+        return candidacyStatus.isLoadable();
+    }
+
+    /**
+     * Helper method that takes a class name (in internal format) and returns a Path
+     * corresponding to the dir where the classfile was found. We are essentially working
+     * around a limitation of the ASM library that does not integrate cleanly with Java 7
+     * NIO.2 Path APIs. This method also performs a couple of basic sanity check on the
+     * class file (e.g. that it exists, is a regular file and is readable).
+     * 
+     * @param internalClassName
+     * @return a path object that corresponds to a class that has been found
+     * @throws ClassNotFoundException 
+     */
+    Path locateClassfileDir(final String internalClassName) throws ClassNotFoundException {
+        // Check the primaryClasspathSearchPath
+        for (final Path p : primaryClasspathSearchPath) {
+            final Path check = Paths.get(p.toString(), internalClassName + ".class");
+
+            if (Files.isRegularFile(check)) {
+                if (!Files.isReadable(check)) {
+                    throw new IllegalArgumentException("File " + check + " found but is not readable");
+                }
+                return p;
+            }
+        }
+        for (final Path p : fileSystemSearchPath) {
+            final Path check = p.resolve(internalClassName + ".class");
+            if (Files.isRegularFile(check)) {
+                if (!Files.isReadable(check)) {
+                    throw new IllegalArgumentException("File " + check + " found but is not readable");
+                }
+                return p;
+            }
+        }
+
+        throw new ClassNotFoundException("Requested class "
+                + Utils.convertInternalFormToQualifiedClassName(internalClassName) + " could not be found");
+    }
+
+    /**
+     * Instruments a class with runtime cost accounting
+     *
+     * @param originalClassContents
+     * @param methodsToRemove
+     * @return the byte array that represents the transformed class
+     */
+    public byte[] instrumentWithCosts(final byte[] originalClassContents, final Set<String> methodsToRemove) {
+        final ClassReader reader = new ClassReader(originalClassContents);
+        final ClassWriter writer = new SandboxAwareClassWriter(this, reader, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
+        final ClassVisitor remapper = new ClassRemapper(writer, new SandboxRemapper());
+        final ClassVisitor coster = new ClassVisitor(Opcodes.ASM5, remapper) {
+            @Override
+            public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) {
+                final MethodVisitor baseMethodVisitor = super.visitMethod(access, name, desc, signature, exceptions);
+                return new CostInstrumentingMethodVisitor(baseMethodVisitor, access, name, desc);
+            }
+        };
+        reader.accept(coster, ClassReader.EXPAND_FRAMES);
+        return writer.toByteArray();
+    }
+
+    /**
+     * Creates a jar archive of all the transformed classes that this classloader
+     * has loaded.
+     * 
+     * @return true on success, false on failure
+     * @throws java.io.IOException
+     * @throws java.net.URISyntaxException
+     */
+    public boolean createJar() throws IOException, URISyntaxException {
+        final Map<String, String> env = new HashMap<>();
+        env.put("create", String.valueOf(!outputJarPath.toFile().exists()));
+
+        final URI fileUri = outputJarPath.toUri();
+        final URI zipUri = new URI("jar:" + fileUri.getScheme(), fileUri.getPath(), null);
+
+        try (final FileSystem zfs = FileSystems.newFileSystem(zipUri, env)) {
+            final Path jarRoot = zfs.getRootDirectories().iterator().next();
+
+            for (final String newName : transformedClasses.keySet()) {
+                final byte[] newClassDef = transformedClasses.get(newName);
+                final String relativePathName = Utils.convertQualifiedClassNameToInternalForm(newName) + ".class";
+                final Path outPath = jarRoot.resolve(relativePathName);
+
+                Files.createDirectories(outPath.getParent());
+                Files.write(outPath, newClassDef);
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Getter method for the reason for failure
+     * @return 
+     */
+    public WhitelistClassloadingException reason() {
+        return candidacyStatus.getReason();
+    }
+
+    /**
+     * Getter method for the method candidacy status
+     * @return 
+     */
+    public CandidacyStatus getCandidacyStatus() {
+        return candidacyStatus;
+    }
+
+    public Path getOutpurJarPath() {
+        return outputJarPath;
+    }
+
+    public void setOutpurJarPath(Path outpurJarPath) {
+        this.outputJarPath = outpurJarPath;
+    }
+
+    public Set<String> cachedClasses() {
+        return loadedClasses.keySet();
+    }
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassloadingException.java b/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassloadingException.java
new file mode 100644
index 0000000000..5f6c13ca9f
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassloadingException.java
@@ -0,0 +1,31 @@
+package net.corda.sandbox;
+
+/**
+ *
+ */
+public class WhitelistClassloadingException extends Exception {
+    
+    public WhitelistClassloadingException() {
+        super();
+    }
+
+    public WhitelistClassloadingException(String message) {
+        super(message);
+    }
+
+    public WhitelistClassloadingException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public WhitelistClassloadingException(Throwable cause) {
+        super(cause);
+    }
+
+    protected WhitelistClassloadingException(String message, Throwable cause,
+                        boolean enableSuppression,
+                        boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+
+    
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/Contract.java b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/Contract.java
new file mode 100644
index 0000000000..ec098ecfbd
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/Contract.java
@@ -0,0 +1,48 @@
+package net.corda.sandbox.costing;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class is the runtime representation of a running contract.
+ * 
+ * @author ben
+ */
+public class Contract {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(Contract.class);
+
+    private final RuntimeCostAccounter accountant = new RuntimeCostAccounter();
+    private final Thread contractThread;
+    private final Class<?> vettedCode;
+    private final ContractExecutor executionStrategy;
+
+    public Contract(final Class<?> newCode, final ContractExecutor strategy) {
+        vettedCode = newCode;
+        executionStrategy = strategy;
+        contractThread = new Thread(() -> executionStrategy.execute(this));
+        contractThread.setName("ContractThread-" + System.currentTimeMillis());
+        contractThread.setDaemon(true);
+    }
+
+    public boolean isViable() {
+        return executionStrategy.isSuitable(this);
+    }
+
+    public Thread getThread() {
+        return contractThread;
+    }
+
+    public Class<?> getCode() {
+        return vettedCode;
+    }
+
+    public void start() {
+        contractThread.start();
+    }
+
+    void suicide() {
+        LOGGER.info("Terminating contract " + this);
+        throw new ThreadDeath();
+    }
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/ContractExecutor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/ContractExecutor.java
new file mode 100644
index 0000000000..243a3ddf11
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/ContractExecutor.java
@@ -0,0 +1,24 @@
+package net.corda.sandbox.costing;
+
+/**
+ * This interface is to decouple the actual executable code from the entry point and
+ * how vetted deterministic code will be used inside the sandbox
+ * 
+ * @author ben
+ */
+public interface ContractExecutor {
+    /**
+     * Executes a smart contract
+     * 
+     * @param contract the contract to be executed
+     */
+    void execute(Contract contract);
+    
+    /**
+     * Checks to see if the supplied Contract is suitable
+     *
+     * @param contract
+     * @return true if the contract is suitable for execution
+     */
+    boolean isSuitable(Contract contract);
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/RuntimeCostAccounter.java b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/RuntimeCostAccounter.java
new file mode 100644
index 0000000000..f00c39defa
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/costing/RuntimeCostAccounter.java
@@ -0,0 +1,178 @@
+package net.corda.sandbox.costing;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ *
+ * @author ben
+ */
+public class RuntimeCostAccounter {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(RuntimeCostAccounter.class);
+
+    private static Thread primaryThread;
+
+    private static final ThreadLocal<Long> allocationCost = new ThreadLocal<Long>() {
+        @Override
+        protected Long initialValue() {
+            return 0L;
+        }
+    };
+
+    private static final ThreadLocal<Long> jumpCost = new ThreadLocal<Long>() {
+        @Override
+        protected Long initialValue() {
+            return 0L;
+        }
+    };
+
+    private static final ThreadLocal<Long> invokeCost = new ThreadLocal<Long>() {
+        @Override
+        protected Long initialValue() {
+            return 0L;
+        }
+    };
+
+    private static final ThreadLocal<Long> throwCost = new ThreadLocal<Long>() {
+        @Override
+        protected Long initialValue() {
+            return 0L;
+        }
+    };
+
+    private static final long BASELINE_ALLOC_KILL_THRESHOLD = 1024 * 1024;
+
+    private static final long BASELINE_JUMP_KILL_THRESHOLD = 100;
+
+    private static final long BASELINE_INVOKE_KILL_THRESHOLD = 100;
+
+    private static final long BASELINE_THROW_KILL_THRESHOLD = 50;
+
+    public static void recordJump() {
+        final Thread current = Thread.currentThread();
+        if (current == primaryThread)
+            return;
+
+        if (LOGGER.isDebugEnabled())
+            LOGGER.debug("In recordJump() at " + System.currentTimeMillis() + " on " + current.getName());
+        checkJumpCost(1);
+    }
+
+    public static void recordAllocation(final String typeName) {
+        final Thread current = Thread.currentThread();
+        if (current == primaryThread)
+            return;
+
+        if (LOGGER.isDebugEnabled())
+            LOGGER.debug("In recordAllocation() at " + System.currentTimeMillis()
+                    + ", got object type: " + typeName + " on " + current.getName());
+
+        // More sophistication is clearly possible, e.g. caching approximate sizes for types that we encounter
+        checkAllocationCost(1);
+    }
+
+    public static void recordArrayAllocation(final int length, final int multiplier) {
+        final Thread current = Thread.currentThread();
+        if (current == primaryThread)
+            return;
+
+        if (LOGGER.isDebugEnabled())
+            LOGGER.debug("In recordArrayAllocation() at " + System.currentTimeMillis()
+                    + ", got array element size: " + multiplier + " and size: " + length + " on " + current.getName());
+
+        checkAllocationCost(length * multiplier);
+    }
+
+    public static void recordMethodCall() {
+        final Thread current = Thread.currentThread();
+        if (current == primaryThread)
+            return;
+
+        if (LOGGER.isDebugEnabled())
+            LOGGER.debug("In recordMethodCall() at " + System.currentTimeMillis() + " on " + current.getName());
+
+        checkInvokeCost(1);
+    }
+
+    public static void recordThrow() {
+        final Thread current = Thread.currentThread();
+        if (current == primaryThread)
+            return;
+
+        if (LOGGER.isDebugEnabled())
+            LOGGER.debug("In recordThrow() at " + System.currentTimeMillis() + " on " + current.getName());
+        checkThrowCost(1);
+    }
+
+    public static void setPrimaryThread(final Thread toBeIgnored) {
+        primaryThread = toBeIgnored;
+    }
+
+    private static void checkAllocationCost(final long additional) {
+        final long newValue = additional + allocationCost.get();
+        allocationCost.set(newValue);
+        if (newValue > BASELINE_ALLOC_KILL_THRESHOLD) {
+            final Thread current = Thread.currentThread();
+            if (LOGGER.isDebugEnabled())
+                LOGGER.debug("Contract " + current + " terminated for overallocation");
+            throw new ThreadDeath();
+        }
+    }
+
+    private static void checkJumpCost(final long additional) {
+        final long newValue = additional + jumpCost.get();
+        jumpCost.set(newValue);
+        if (newValue > BASELINE_JUMP_KILL_THRESHOLD) {
+            final Thread current = Thread.currentThread();
+            if (LOGGER.isDebugEnabled())
+                LOGGER.debug("Contract " + current + " terminated for excessive use of looping");
+            throw new ThreadDeath();
+        }
+    }
+
+    private static void checkInvokeCost(final long additional) {
+        final long newValue = additional + invokeCost.get();
+        invokeCost.set(newValue);
+        if (newValue > BASELINE_INVOKE_KILL_THRESHOLD) {
+            final Thread current = Thread.currentThread();
+            if (LOGGER.isDebugEnabled())
+                LOGGER.debug("Contract " + current + " terminated for excessive method calling");
+            throw new ThreadDeath();
+        }
+    }
+
+    private static void checkThrowCost(final long additional) {
+        final long newValue = additional + throwCost.get();
+        throwCost.set(newValue);
+        if (newValue > BASELINE_THROW_KILL_THRESHOLD) {
+            final Thread current = Thread.currentThread();
+            if (LOGGER.isDebugEnabled())
+                LOGGER.debug("Contract " + current + " terminated for excessive exception throwing");
+            throw new ThreadDeath();
+        }
+    }
+
+    public static long getAllocationCost() {
+        return allocationCost.get();
+    }
+
+    public static long getJumpCost() {
+        return jumpCost.get();
+    }
+
+    public static long getInvokeCost() {
+        return invokeCost.get();
+    }
+
+    public static long getThrowCost() {
+        return throwCost.get();
+    }
+
+    public static void resetCounters() {
+        allocationCost.set(0L);
+        jumpCost.set(0L);
+        invokeCost.set(0L);
+        throwCost.set(0L);
+    }
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/tools/SandboxCreator.java b/experimental/sandbox/src/main/java/net/corda/sandbox/tools/SandboxCreator.java
new file mode 100644
index 0000000000..add163fd26
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/tools/SandboxCreator.java
@@ -0,0 +1,129 @@
+package net.corda.sandbox.tools;
+
+import net.corda.sandbox.WhitelistClassLoader;
+import net.corda.sandbox.visitors.SandboxPathVisitor;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.*;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import net.corda.sandbox.visitors.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import joptsimple.OptionParser;
+import joptsimple.OptionSet;
+
+/**
+ * This class takes in an exploded set of JRE classes, and a whitelist, and rewrites all
+ * classes (note: not methods) that have at least one whitelisted method to create a
+ * sandboxed version of the class.
+ *
+ */
+// java8.scan.java.lang_and_util java8.interfaces_for_compat java8 sandbox
+public final class SandboxCreator {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(SandboxCreator.class);
+    private static final String USAGE_STRING = "Usage: SandboxCreator <classes root dir> <output sandbox jar>";
+
+    private final String basePathName;
+    private final String outputJarName;
+    private final WhitelistClassLoader wlcl;
+    private final boolean hasInputJar;
+    
+    private final static OptionParser parser = new OptionParser();
+
+    private static void usage() {
+        System.err.println(USAGE_STRING);
+    }
+
+    private SandboxCreator(final OptionSet options) throws URISyntaxException {
+        basePathName = (String) (options.valueOf("dir"));
+        outputJarName = (String) (options.valueOf("out"));
+        wlcl = WhitelistClassLoader.of(basePathName, true);
+        hasInputJar = false;
+    }
+
+    private SandboxCreator(final String tmpDirName, final OptionSet options) throws URISyntaxException {
+        basePathName = tmpDirName;
+        outputJarName = (String) (options.valueOf("out"));
+        wlcl = WhitelistClassLoader.of(basePathName, true);
+        hasInputJar = true;
+    }
+
+    static String unpackJar(final String zipFilePath) throws IOException {
+        final Path tmpDir = Files.createTempDirectory(Paths.get("/tmp"), "wlcl-extract");
+        
+        try (final ZipInputStream zipIn = new ZipInputStream(new FileInputStream(zipFilePath))) {
+            ZipEntry entry = zipIn.getNextEntry();
+
+            while (entry != null) {
+                final Path newFile = tmpDir.resolve(entry.getName());
+                if (!entry.isDirectory()) {
+                    Files.copy(zipIn, newFile);
+                } else {
+                    Files.createDirectory(newFile);
+                }
+                zipIn.closeEntry();
+                entry = zipIn.getNextEntry();
+            }
+        }
+        
+        return tmpDir.toString();
+    }
+    
+    void cleanup() {
+        if (hasInputJar) {
+            
+        }
+    }
+
+    public static SandboxCreator of(final OptionSet options) throws URISyntaxException, IOException {
+        final String inputJarName = (String) (options.valueOf("jar"));
+        if (inputJarName != null) {
+            final String tmpDirName = unpackJar(inputJarName);
+            return new SandboxCreator(tmpDirName, options);
+        }
+        return new SandboxCreator(options);
+    }
+
+    public static void main(String[] args) throws IOException, URISyntaxException {
+        parser.accepts("help", "Displays this help screen").forHelp();
+        parser.accepts("dir", "The directory where classes to be sandboxed can be found").withRequiredArg().ofType(String.class);
+        parser.accepts("jar", "The jar file where classes to be sandboxed can be found").withRequiredArg().ofType(String.class);
+        parser.accepts("out", "The output jar file where rewritten classes will be found").withRequiredArg().ofType(String.class);
+
+        final OptionSet options = parser.parse(args);
+
+        if (options.has("help")) {
+            parser.printHelpOn(System.out);
+            System.exit(0);
+        }
+
+        final SandboxCreator sandboxer = SandboxCreator.of(options);
+        sandboxer.walk();
+        sandboxer.writeJar();
+        sandboxer.cleanup();
+    }
+
+    /**
+     * 
+     * @param basePath
+     * @param packageName
+     * @throws IOException 
+     */
+    void walk() throws IOException {
+        final Path scanDir = Paths.get(basePathName);
+        final SandboxPathVisitor visitor = new SandboxPathVisitor(wlcl, scanDir);
+        Files.walkFileTree(scanDir, visitor);
+    }
+
+    private void writeJar() throws IOException, URISyntaxException {
+        // When this method is called, wlcl should have loaded absolutely everything...
+        Path outJar = Paths.get(outputJarName);
+        wlcl.setOutpurJarPath(outJar);
+        wlcl.createJar();
+    }
+
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/CostInstrumentingMethodVisitor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/CostInstrumentingMethodVisitor.java
new file mode 100644
index 0000000000..5f7dc3fdea
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/CostInstrumentingMethodVisitor.java
@@ -0,0 +1,165 @@
+package net.corda.sandbox.visitors;
+
+import net.corda.sandbox.Utils;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.commons.GeneratorAdapter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ *
+ * @author ben
+ */
+public final class CostInstrumentingMethodVisitor extends GeneratorAdapter {
+
+    public static final int OP_BREAKPOINT = 0b1100_1010;
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(CostInstrumentingMethodVisitor.class);
+
+    // In future, we may want to have multiple different accounting types
+    // for e.g. benchmarking and to determine this at classloading time
+    // might be helpful. We may want additional flexibility, e.g. to determine
+    // the different accounting instrumenations separately, but this is a good
+    // stub
+    private final String runtimeAccounterTypeName;
+
+    public CostInstrumentingMethodVisitor(MethodVisitor methodVisitor, int access, String name, String desc) {
+        super(Opcodes.ASM5, methodVisitor, access, name, desc);
+
+        runtimeAccounterTypeName = "net/corda/sandbox/costing/RuntimeCostAccounter";
+        // save other calling parameters as well...?
+
+    }
+
+    /**
+     * This method replaces MONITORENTER / MONITOREXIT opcodes with POP - basically 
+     * stripping the synchronization out of any sandboxed code.
+     * @param opcode 
+     */
+    @Override
+    public void visitInsn(final int opcode) {
+        switch (opcode) {
+            case Opcodes.MONITORENTER:
+            case Opcodes.MONITOREXIT:
+                super.visitInsn(Opcodes.POP);
+                return;
+            case Opcodes.ATHROW:
+                super.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeAccounterTypeName, "recordThrow", "()V", false);
+                break;
+            case OP_BREAKPOINT:
+                throw new IllegalStateException("Illegal opcode BREAKPOINT seen");
+        }
+
+        super.visitInsn(opcode);
+    }
+
+    /**
+     * This method is called when visiting an opcode with a single int operand.
+     * For our purposes this is a NEWARRAY opcode.
+     *
+     * @param opcode
+     * @param operand 
+     */
+    @Override
+    public void visitIntInsn(final int opcode, final int operand) {
+        if (opcode != Opcodes.NEWARRAY) {
+            super.visitIntInsn(opcode, operand);
+            return;
+        }
+
+        // Opcode is NEWARRAY - recordArrayAllocation:(Ljava/lang/String;I)V
+        // operand value should be one of Opcodes.T_BOOLEAN, 
+        // Opcodes.T_CHAR, Opcodes.T_FLOAT, Opcodes.T_DOUBLE, Opcodes.T_BYTE, 
+        // Opcodes.T_SHORT, Opcodes.T_INT or Opcodes.T_LONG.
+        final int typeSize;
+        switch (operand) {
+            case Opcodes.T_BOOLEAN:
+            case Opcodes.T_BYTE:
+                typeSize = 1;
+                break;
+            case Opcodes.T_SHORT:
+            case Opcodes.T_CHAR:
+                typeSize = 2;
+                break;
+            case Opcodes.T_INT:
+            case Opcodes.T_FLOAT:
+                typeSize = 4;
+                break;
+            case Opcodes.T_LONG:
+            case Opcodes.T_DOUBLE:
+                typeSize = 8;
+                break;
+            default:
+                throw new IllegalStateException("Illegal operand to NEWARRAY seen: " + operand);
+        }
+        super.visitInsn(Opcodes.DUP);
+        super.visitLdcInsn(typeSize);
+        super.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeAccounterTypeName, "recordArrayAllocation", "(II)V", true);
+        super.visitIntInsn(opcode, operand);
+    }
+
+    /**
+     * This method is called when visiting an opcode with a single operand, that
+     * is a type (represented here as a String).
+     *
+     * For our purposes this is either a NEW opcode or a ANEWARRAY
+     *
+     * @param opcode 
+     * @param type 
+     */
+    @Override
+    public void visitTypeInsn(final int opcode, final String type) {
+        // opcode is either NEW - recordAllocation:(Ljava/lang/String;)V
+        // or ANEWARRAY - recordArrayAllocation:(Ljava/lang/String;I)V
+        switch (opcode) {
+            case Opcodes.NEW:
+                super.visitLdcInsn(type);
+                super.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeAccounterTypeName, "recordAllocation", "(Ljava/lang/String;)V", true);
+                break;
+            case Opcodes.ANEWARRAY:
+                super.visitInsn(Opcodes.DUP);
+                super.visitLdcInsn(8);
+                super.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeAccounterTypeName, "recordArrayAllocation", "(II)V", true);
+                break;
+        }
+
+        super.visitTypeInsn(opcode, type);
+    }
+
+    @Override
+    public void visitJumpInsn(final int opcode, final Label label) {
+        super.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeAccounterTypeName, "recordJump", "()V", true);
+        super.visitJumpInsn(opcode, label);
+    }
+
+    /**
+     * Visits a method instruction. We add accounting information to prevent runaway
+     * method calls. The case of INVOKEDYNAMIC is handled by the visitInvokeDynamicInsn
+     * method, but that opcode is disallowed by the whitelisting anyway.
+     *
+     * @param opcode
+     * @param owner
+     * @param name
+     * @param desc
+     * @param itf
+     */
+    @Override
+    public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+
+        switch (opcode) {
+            case Opcodes.INVOKEVIRTUAL:
+            case Opcodes.INVOKESTATIC:
+            case Opcodes.INVOKESPECIAL:
+            case Opcodes.INVOKEINTERFACE:
+                super.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeAccounterTypeName, "recordMethodCall", "()V", itf);
+                // If this is in the packages that are sandboxed, rewrite the link
+                final String sandboxedOwner = Utils.sandboxInternalTypeName(owner);
+                super.visitMethodInsn(opcode, sandboxedOwner, name, desc, itf);
+                break;
+            default:
+                throw new IllegalStateException("Unexpected opcode: " + opcode + " from ASM when expecting an INVOKE");
+        }
+    }
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/DefinitelyDisallowedMethodVisitor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/DefinitelyDisallowedMethodVisitor.java
new file mode 100644
index 0000000000..62b882f269
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/DefinitelyDisallowedMethodVisitor.java
@@ -0,0 +1,15 @@
+package net.corda.sandbox.visitors;
+
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * MethodVisitor that is a complete no-op. MethodVisitor is abstract, so we have to extend it
+ */
+class DefinitelyDisallowedMethodVisitor extends MethodVisitor {
+
+    DefinitelyDisallowedMethodVisitor(MethodVisitor baseMethodVisitor) {
+        super(Opcodes.ASM5, baseMethodVisitor);
+    }
+    
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/SandboxPathVisitor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/SandboxPathVisitor.java
new file mode 100644
index 0000000000..bdc81bf995
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/SandboxPathVisitor.java
@@ -0,0 +1,55 @@
+package net.corda.sandbox.visitors;
+
+import net.corda.sandbox.Utils;
+import net.corda.sandbox.WhitelistClassLoader;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This helper class visits each file (represented as a Path) in some directory
+ * tree containing classes to be sandboxed.
+ * 
+ * @author ben
+ */
+public final class SandboxPathVisitor extends SimpleFileVisitor<Path> {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(SandboxPathVisitor.class);
+
+    private final WhitelistClassLoader loader;
+
+    private final Path startFrom;
+
+    public SandboxPathVisitor(final WhitelistClassLoader wlcl, final Path baseDir) {
+        startFrom = baseDir;
+        loader = wlcl;
+    }
+
+    @Override
+    public FileVisitResult visitFile(final Path path, final BasicFileAttributes attr) {
+        // Check that this is a class file
+        if (!path.toString().matches(Utils.CLASSFILE_NAME_SUFFIX)) {
+            System.out.println("Skipping: "+ path);
+            return FileVisitResult.CONTINUE;
+        }
+        
+        // Check to see if this path corresponds to an allowedClass
+        final String classFileName = startFrom.relativize(path).toString().replace(".class", "");
+
+        if (!Utils.classShouldBeSandboxedInternal(classFileName)) {
+            return FileVisitResult.CONTINUE;
+        }
+
+        final String nameToLoad = Utils.convertInternalFormToQualifiedClassName(classFileName);
+
+        try {
+            loader.findClass(nameToLoad);
+        } catch (ClassNotFoundException ex) {
+            throw new RuntimeException(ex);
+        }
+
+        return FileVisitResult.CONTINUE;
+    }
+
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingClassVisitor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingClassVisitor.java
new file mode 100644
index 0000000000..1c5159dcff
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingClassVisitor.java
@@ -0,0 +1,191 @@
+package net.corda.sandbox.visitors;
+
+import net.corda.sandbox.WhitelistClassLoader;
+import net.corda.sandbox.CandidacyStatus;
+import java.util.Arrays;
+
+import net.corda.sandbox.CandidateMethod;
+import net.corda.sandbox.Utils;
+import java.util.HashSet;
+import java.util.Set;
+
+import net.corda.sandbox.*;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import static net.corda.sandbox.CandidateMethod.State.*;
+import static org.objectweb.asm.Opcodes.*;
+
+/**
+ * A ASM ClassVisitor which checks classes it visits against a whitelist
+ */
+public final class WhitelistCheckingClassVisitor extends ClassVisitor {
+
+    private final CandidacyStatus candidacyStatus;
+    private final String classname;
+    private final Set<String> internalMethodNames = new HashSet<>();
+    private String currentClassName;
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(WhitelistCheckingClassVisitor.class);
+
+    public WhitelistCheckingClassVisitor(final String currentClass, final CandidacyStatus initialCandidacyStatus) {
+        super(Opcodes.ASM5);
+        candidacyStatus = initialCandidacyStatus;
+        classname = currentClass;
+    }
+
+    @Override
+    public void visit(final int version, final int access, final String name, final String signature, final String superName, final String[] interfaces) {
+        super.visit(version, access, name, signature, superName, interfaces);
+        currentClassName = name;
+
+        if (resolveState(Utils.convertInternalFormToQualifiedClassName(superName)) == CandidateMethod.State.DISALLOWED) {
+            candidacyStatus.setLoadable(false);
+            candidacyStatus.setReason("Superclass " + superName + " could not be loaded");
+            return;
+        }
+
+        for (final String interfaceName : interfaces) {
+            if (resolveState(Utils.convertInternalFormToQualifiedClassName(interfaceName)) == CandidateMethod.State.DISALLOWED) {
+                candidacyStatus.setLoadable(false);
+                candidacyStatus.setReason("Interface " + interfaceName + " could not be loaded");
+                return;
+            }
+        }
+    }
+
+    /**
+     * We initially take the method passed in and store an internal representation of
+     * the method signature in the our CandidacyStatus working set.
+     *
+     * We then get an ASM MethodVisitor (which can read the byte code of the method) and pass that to our
+     * custom method visitor which perform additional checks.
+     *
+     * @param access
+     * @param name
+     * @param desc
+     * @param signature
+     * @param exceptions
+     * @return 
+     */
+    @Override
+    public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) {
+        if (LOGGER.isDebugEnabled())
+            LOGGER.debug("Visiting method with: access [" + access + "], name [" + currentClassName + "::" + name + "], signature [" + signature + "], desc ["
+                    + desc + "] and exceptions [" + Arrays.toString(exceptions) + "]");
+
+        // Force new access control flags - for now just strictfp for deterministic
+        // compliance to IEEE 754
+        final int maskedAccess = access | ACC_STRICT;
+        
+        final String internalName = classname + "." + name + ":" + desc;
+        internalMethodNames.add(internalName);
+        candidacyStatus.putIfAbsent(internalName);
+
+        final MethodVisitor baseMethodVisitor = super.visitMethod(maskedAccess, name, desc, signature, exceptions);
+
+        // If we're already not allowed to be loaded (a CandidateMethod was disallowed) 
+        // no other MethodVisitor can help
+        // so return a MethodVisitor that doesn't even try to do any more work
+        if (!candidacyStatus.isLoadable()) {
+            // This can mask problems with the class deeper down, so disabled for now for debugging
+//            return new DefinitelyDisallowedMethodVisitor(baseMethodVisitor);
+        }
+
+        // Disallow finalizers
+        if ("finalize".equals(name) && "()V".equals(desc)) {
+            return new DefinitelyDisallowedMethodVisitor(baseMethodVisitor);
+        }
+
+        // Native methods are completely disallowed
+        if ((access & Opcodes.ACC_NATIVE) > 0) {
+            candidacyStatus.setLoadable(false);
+            candidacyStatus.setReason("Method " + internalName + " is native");
+            return new DefinitelyDisallowedMethodVisitor(baseMethodVisitor);
+        }
+
+        return new WhitelistCheckingMethodVisitor(baseMethodVisitor, candidacyStatus, internalName);
+    }
+
+    /**
+     * Once we've finished visiting all of the methods, we check that they're all deterministic, if not we
+     * tell the candidacyStatus that this is not loadable and why.
+     */
+    @Override
+    public void visitEnd() {
+        if (!candidacyStatus.isLoadable())
+            return;
+        METHODS:
+        for (String internalMethodName : internalMethodNames) {
+            final CandidateMethod candidateMethod = candidacyStatus.getCandidateMethod(internalMethodName);
+            final CandidateMethod.State candidateState = candidateMethod.getCurrentState();
+
+            switch (candidateState) {
+                case DISALLOWED:
+                    candidacyStatus.setLoadable(false);
+                    candidacyStatus.setReason(candidateMethod.getReason());
+                    break METHODS;
+                case DETERMINISTIC:
+                    break;
+                case MENTIONED:
+                case SCANNED:
+                    // Try a recursive scan (to allow multiple classes to be loaded
+                    // as part of the same call). The scan needs to happen on the
+                    // methods we *refer* to, not the current method
+                    for (final CandidateMethod referred : candidateMethod.getReferencedCandidateMethods()) {
+                        final String internalName = referred.getInternalMethodName();
+
+                        final String toLoadQualified = Utils.convertInternalMethodNameToQualifiedClassName(internalName);
+                        if (!Utils.shouldAttemptToTransitivelyLoad(toLoadQualified)
+                                || resolveState(toLoadQualified) == CandidateMethod.State.DISALLOWED) {
+                            referred.disallowed(internalName + " is DISALLOWED");
+                            candidacyStatus.setLoadable(false);
+                            candidacyStatus.setReason(candidateMethod.getReason());
+                            break METHODS;
+                        }
+                    }
+                    candidateMethod.deterministic();
+                    break;
+            }
+        }
+
+        // If the initial scan has produced a DISALLOWED code path
+        if (!candidacyStatus.isLoadable()) {
+            return;
+        }
+    }
+
+    /**
+     * Take the name of a class and attempts to load it using a WLCL. 
+     * 
+     * @param qualifiedClassname
+     * @return 
+     */
+    CandidateMethod.State resolveState(final String qualifiedClassname) {
+        Class<?> clz = null;
+        try {
+            candidacyStatus.incRecursiveCount();
+            final ClassLoader loader = WhitelistClassLoader.of(candidacyStatus.getContextLoader());
+            clz = loader.loadClass(qualifiedClassname);
+            candidacyStatus.decRecursiveCount();
+        } catch (ClassNotFoundException ex) {
+            return CandidateMethod.State.DISALLOWED;
+        }
+        if (clz == null) {
+            LOGGER.error("Couldn't load: " + qualifiedClassname);
+            return CandidateMethod.State.DISALLOWED;
+        }
+
+        return CandidateMethod.State.DETERMINISTIC;
+    }
+
+    public CandidacyStatus getCandidacyStatus() {
+        return candidacyStatus;
+    }
+
+    public Set<String> getInternalMethodNames() {
+        return internalMethodNames;
+    }
+}
diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingMethodVisitor.java b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingMethodVisitor.java
new file mode 100644
index 0000000000..2fd52fa7e2
--- /dev/null
+++ b/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingMethodVisitor.java
@@ -0,0 +1,175 @@
+package net.corda.sandbox.visitors;
+
+import net.corda.sandbox.CandidacyStatus;
+import net.corda.sandbox.CandidateMethod;
+import net.corda.sandbox.*;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import static net.corda.sandbox.CandidateMethod.State.*;
+import net.corda.sandbox.Utils;
+import org.objectweb.asm.Label;
+
+/**
+ * A MethodVisitor which checks method instructions in order to determine if this
+ * method is deterministic or not
+ *
+ */
+final class WhitelistCheckingMethodVisitor extends MethodVisitor {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(WhitelistCheckingMethodVisitor.class);
+
+    private final CandidacyStatus candidacyStatus;
+    private final String currentMethodName;
+
+    public WhitelistCheckingMethodVisitor(final MethodVisitor methodVisitor, final CandidacyStatus initialCandidacyStatus, String methodName) {
+        super(Opcodes.ASM5, methodVisitor);
+        candidacyStatus = initialCandidacyStatus;
+        currentMethodName = methodName;
+    }
+
+    /**
+     * Visits a method instruction. A method instruction is an instruction that 
+     * invokes a method.
+     * <p>
+     * Some method instructions are by their nature un-deterministic, so we set those methods to have a
+     * {@link CandidateMethod.State#DISALLOWED} State
+     */
+    @Override
+    public void visitMethodInsn(final int opcode, final String owner, final String name, final String desc, final boolean itf) {
+
+        final CandidateMethod candidateMethod = candidacyStatus.getCandidateMethod(currentMethodName);
+        final String internalName = owner + "." + name + ":" + desc;
+        if (candidacyStatus.putIfAbsent(internalName)) {
+            candidacyStatus.addToBacklog(internalName);
+        }
+        final CandidateMethod referencedCandidateMethod = candidacyStatus.getCandidateMethod(internalName);
+        candidateMethod.addReferencedCandidateMethod(referencedCandidateMethod);
+
+        final String methodDetails = owner + " name [" + name + "], desc [" + desc + "]";
+
+        switch (opcode) {
+            case Opcodes.INVOKEVIRTUAL:
+                if (LOGGER.isDebugEnabled())
+                    LOGGER.debug("Visiting with INVOKEVIRTUAL: " + methodDetails);
+                break;
+            case Opcodes.INVOKESTATIC:
+                if (LOGGER.isDebugEnabled())
+                    LOGGER.debug("Visiting with INVOKESTATIC: " + methodDetails);
+                break;
+            case Opcodes.INVOKESPECIAL:
+                if (LOGGER.isDebugEnabled())
+                    LOGGER.debug("Visiting with INVOKESPECIAL: " + methodDetails);
+                break;
+            case Opcodes.INVOKEINTERFACE:
+                if (LOGGER.isDebugEnabled())
+                    LOGGER.debug("Visiting with INVOKEINTERFACE: " + methodDetails);
+                break;
+            // NOTE: case Opcodes.INVOKEDYNAMIC is handled by the visitInvokeDynamicInsn call
+            default:
+                throw new IllegalArgumentException("Got an unexpected opcode: " + opcode + " in " + currentMethodName);
+        }
+    }
+
+    @Override
+    public void visitTryCatchBlock(final Label start, final Label end, final Label handler, final String type) {
+        if (type == null)
+            throw new IllegalArgumentException("Exception type must not be null in try/catch block in " + currentMethodName);
+
+        // Forcible disallow attempts to catch ThreadDeath or any throwable superclass - preserve determinism
+        if (type.equals(Utils.THREAD_DEATH) || type.equals(Utils.ERROR) || type.equals(Utils.THROWABLE)) {
+            final CandidateMethod candidateMethod = candidacyStatus.getCandidateMethod(currentMethodName);
+            candidateMethod.disallowed("Method " + currentMethodName + " attempts to catch ThreadDeath, Error or Throwable");
+        }
+    }
+
+    /**
+     * Currently a no-op. 
+     *
+     * The JVMspec seems to permit the possibility of using a backwards branch in a
+     * tableswitch to try to create an infinite loop. However, it seems to be 
+     * impossible in practice - the specification of StackMapFrame seems to prevent
+     * it in modern classfile formats, and even by explicitly generating a version
+     * 49 (Java 5) classfile, the verifier seems to be specifically resistant to a
+     * backwards branch from a tableswitch. 
+     * 
+     * We could still add a belt-and-braces static instrumentation to protect
+     * against this but it currently seems unnecessary - at worse it is a branch that
+     * should count against the branch limit, or an explicit disallow of a backwards
+     * branch. Of course, if you find a way to exploit this, we'd welcome a pull
+     * request.
+     *
+     * @param min
+     * @param max
+     * @param dflt
+     * @param labels 
+     */
+    @Override
+    public void visitTableSwitchInsn(int min, int max, Label dflt, Label... labels) {
+        super.visitTableSwitchInsn(min, max, dflt, labels);
+    }
+
+    /**
+     * Visits an invokedynamic instruction - which is specifically disallowed for
+     * deterministic apps.
+     * 
+     * @param name
+     * @param desc
+     * @param bsm
+     * @param bsmArgs 
+     */
+    @Override
+    public void visitInvokeDynamicInsn(final String name, final String desc, final Handle bsm, final Object... bsmArgs) {
+        final String methodDetails = "name [" + name + "], desc [" + desc + "]";
+        final CandidateMethod candidateMethod = candidacyStatus.getCandidateMethod(currentMethodName);
+        if (LOGGER.isDebugEnabled())
+            LOGGER.debug("Visiting with INVOKEDYNAMIC:" + methodDetails);
+        candidateMethod.disallowed("InvokeDynamic in " + currentMethodName + " with " + methodDetails);
+    }
+
+    /**
+     * If all the call instructions are deterministic for the referenced candidate methods,
+     * then so is this one
+     */
+    @Override
+    public void visitEnd() {
+        // Start from the assumption that the method is deterministic, and try to disprove
+        CandidateMethod.State checkState = CandidateMethod.State.DETERMINISTIC;
+        final CandidateMethod candidateMethod = candidacyStatus.getCandidateMethod(currentMethodName);
+        if (candidateMethod == null) {
+            throw new IllegalArgumentException(currentMethodName + " not found in CandidacyStatus");
+        }
+        if (candidateMethod.getCurrentState() == CandidateMethod.State.DISALLOWED) {
+            return;
+        }
+
+        CHECK:
+        for (CandidateMethod referredMethod : candidateMethod.getReferencedCandidateMethods()) {
+            CandidateMethod.State childMethodState = referredMethod.getCurrentState();
+            switch (childMethodState) {
+                case DETERMINISTIC:
+                    break;
+                case MENTIONED:
+                    checkState = CandidateMethod.State.MENTIONED;
+                    break;
+                case DISALLOWED:
+                    checkState = CandidateMethod.State.DISALLOWED;
+                    break CHECK;
+                case SCANNED:
+                    checkState = CandidateMethod.State.MENTIONED;
+                    if (referredMethod != candidateMethod)
+                        throw new IllegalStateException("Illegal state of method " + referredMethod.getInternalMethodName() + " occurred when visiting method " + currentMethodName);
+                    break;
+                default:
+                    throw new IllegalStateException("Illegal state occurred when visiting method " + currentMethodName);
+            }
+        }
+        candidateMethod.setCurrentState(checkState);
+
+        // If this methods state hasn't already been determined, it should be set to SCANNED
+        if (candidateMethod.getCurrentState() == CandidateMethod.State.MENTIONED)
+            candidateMethod.scanned();
+    }
+}
diff --git a/experimental/sandbox/src/main/java/sandbox/net/corda/sandbox/costing/RuntimeCostAccounter.java b/experimental/sandbox/src/main/java/sandbox/net/corda/sandbox/costing/RuntimeCostAccounter.java
new file mode 100644
index 0000000000..7acc1f445d
--- /dev/null
+++ b/experimental/sandbox/src/main/java/sandbox/net/corda/sandbox/costing/RuntimeCostAccounter.java
@@ -0,0 +1,32 @@
+package sandbox.net.corda.sandbox.costing;
+
+/**
+ * A helper class that just forwards any static sandboxed calls to the real runtime
+ * cost accounting class. This removes the need to special case the accounting
+ * method calls during rewriting of method names
+ * 
+ * @author ben
+ */
+public class RuntimeCostAccounter {
+
+    public static void recordJump() {
+        net.corda.sandbox.costing.RuntimeCostAccounter.recordJump();
+    }
+
+    public static void recordAllocation(final String typeName) {
+        net.corda.sandbox.costing.RuntimeCostAccounter.recordAllocation(typeName);
+    }
+
+    public static void recordArrayAllocation(final int length, final int multiplier) {
+        net.corda.sandbox.costing.RuntimeCostAccounter.recordArrayAllocation(length, multiplier);
+    }
+
+    public static void recordMethodCall() {
+        net.corda.sandbox.costing.RuntimeCostAccounter.recordMethodCall();
+    }
+
+    public static void recordThrow() {
+        net.corda.sandbox.costing.RuntimeCostAccounter.recordThrow();
+    }
+
+}
diff --git a/experimental/sandbox/src/main/resources/java.base.deterministic b/experimental/sandbox/src/main/resources/java.base.deterministic
new file mode 100644
index 0000000000..20b889ce57
--- /dev/null
+++ b/experimental/sandbox/src/main/resources/java.base.deterministic
@@ -0,0 +1,3 @@
+java/lang/Object.equals:(Ljava/lang/Object;)Z
+java/lang/Object.getClass:()Ljava/lang/Class;
+java/lang/Object.<init>:()V
\ No newline at end of file
diff --git a/experimental/sandbox/src/main/resources/java.base.disallowed b/experimental/sandbox/src/main/resources/java.base.disallowed
new file mode 100644
index 0000000000..110b1a2125
--- /dev/null
+++ b/experimental/sandbox/src/main/resources/java.base.disallowed
@@ -0,0 +1 @@
+java.lang.invoke.*
\ No newline at end of file
diff --git a/experimental/sandbox/src/main/resources/java.base.hand-picked b/experimental/sandbox/src/main/resources/java.base.hand-picked
new file mode 100644
index 0000000000..592806e0ad
--- /dev/null
+++ b/experimental/sandbox/src/main/resources/java.base.hand-picked
@@ -0,0 +1,9 @@
+java/lang/Class.getComponentType:()Ljava/lang/Class;
+java/lang/Object.equals:(Ljava/lang/Object;)Z
+java/lang/Object.getClass:()Ljava/lang/Class;
+java/lang/Object.<init>:()V
+java/lang/Throwable.fillInStackTrace:(I)Ljava/lang/Throwable;
+java/lang/reflect/Array.newArray:(Ljava/lang/Class;I)Ljava/lang/Object;
+java/lang/System.arraycopy:(Ljava/lang/Object;ILjava/lang/Object;II)V
+java/lang/StringIndexOutOfBoundsException.<init>:(I)V
+java/util/Arrays.copyOfRange:([CII)[C
\ No newline at end of file
diff --git a/experimental/sandbox/src/main/resources/java8.interfaces_for_compat b/experimental/sandbox/src/main/resources/java8.interfaces_for_compat
new file mode 100644
index 0000000000..319cdd98fe
--- /dev/null
+++ b/experimental/sandbox/src/main/resources/java8.interfaces_for_compat
@@ -0,0 +1,2 @@
+java/util/RandomAccess
+java/io/Serializable
\ No newline at end of file
diff --git a/experimental/sandbox/src/main/resources/java8.scan.java.lang b/experimental/sandbox/src/main/resources/java8.scan.java.lang
new file mode 100644
index 0000000000..cbca492750
--- /dev/null
+++ b/experimental/sandbox/src/main/resources/java8.scan.java.lang
@@ -0,0 +1,1039 @@
+java/lang/AbstractMethodError.<init>:()V
+java/lang/AbstractMethodError.<init>:(Ljava/lang/String;)V
+java/lang/AbstractStringBuilder.<init>:()V
+java/lang/AbstractStringBuilder.<init>:(I)V
+java/lang/AbstractStringBuilder.capacity:()I
+java/lang/AbstractStringBuilder.charAt:(I)C
+java/lang/AbstractStringBuilder.codePointAt:(I)I
+java/lang/AbstractStringBuilder.codePointBefore:(I)I
+java/lang/AbstractStringBuilder.codePointCount:(II)I
+java/lang/AbstractStringBuilder.delete:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.deleteCharAt:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.getChars:(II[CI)V
+java/lang/AbstractStringBuilder.getValue:()[C
+java/lang/AbstractStringBuilder.indexOf:(Ljava/lang/String;)I
+java/lang/AbstractStringBuilder.indexOf:(Ljava/lang/String;I)I
+java/lang/AbstractStringBuilder.lastIndexOf:(Ljava/lang/String;)I
+java/lang/AbstractStringBuilder.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/AbstractStringBuilder.length:()I
+java/lang/AbstractStringBuilder.offsetByCodePoints:(II)I
+java/lang/AbstractStringBuilder.reverse:()Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.reverseAllValidSurrogatePairs:()V
+java/lang/AbstractStringBuilder.setCharAt:(IC)V
+java/lang/AbstractStringBuilder.toString:()Ljava/lang/String;
+java/lang/Appendable.append:(C)Ljava/lang/Appendable;
+java/lang/Appendable.append:(Ljava/lang/CharSequence;)Ljava/lang/Appendable;
+java/lang/Appendable.append:(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;
+java/lang/ApplicationShutdownHooks$1.<init>:()V
+java/lang/ApplicationShutdownHooks.<init>:()V
+java/lang/ArithmeticException.<init>:()V
+java/lang/ArithmeticException.<init>:(Ljava/lang/String;)V
+java/lang/ArrayIndexOutOfBoundsException.<init>:()V
+java/lang/ArrayIndexOutOfBoundsException.<init>:(Ljava/lang/String;)V
+java/lang/ArrayStoreException.<init>:()V
+java/lang/ArrayStoreException.<init>:(Ljava/lang/String;)V
+java/lang/AssertionError.<init>:()V
+java/lang/AssertionError.<init>:(C)V
+java/lang/AssertionError.<init>:(I)V
+java/lang/AssertionError.<init>:(J)V
+java/lang/AssertionError.<init>:(Ljava/lang/String;)V
+java/lang/AssertionError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/AssertionError.<init>:(Z)V
+java/lang/AssertionStatusDirectives.<init>:()V
+java/lang/AutoCloseable.close:()V
+java/lang/Boolean.<init>:(Ljava/lang/String;)V
+java/lang/Boolean.<init>:(Z)V
+java/lang/Boolean.booleanValue:()Z
+java/lang/Boolean.compare:(ZZ)I
+java/lang/Boolean.compareTo:(Ljava/lang/Boolean;)I
+java/lang/Boolean.compareTo:(Ljava/lang/Object;)I
+java/lang/Boolean.equals:(Ljava/lang/Object;)Z
+java/lang/Boolean.hashCode:()I
+java/lang/Boolean.hashCode:(Z)I
+java/lang/Boolean.logicalAnd:(ZZ)Z
+java/lang/Boolean.logicalOr:(ZZ)Z
+java/lang/Boolean.logicalXor:(ZZ)Z
+java/lang/Boolean.parseBoolean:(Ljava/lang/String;)Z
+java/lang/Boolean.toString:()Ljava/lang/String;
+java/lang/Boolean.toString:(Z)Ljava/lang/String;
+java/lang/Boolean.valueOf:(Ljava/lang/String;)Ljava/lang/Boolean;
+java/lang/Boolean.valueOf:(Z)Ljava/lang/Boolean;
+java/lang/BootstrapMethodError.<init>:()V
+java/lang/BootstrapMethodError.<init>:(Ljava/lang/String;)V
+java/lang/BootstrapMethodError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Byte$ByteCache.<clinit>:()V
+java/lang/Byte$ByteCache.<init>:()V
+java/lang/Byte.<init>:(B)V
+java/lang/Byte.byteValue:()B
+java/lang/Byte.compare:(BB)I
+java/lang/Byte.compareTo:(Ljava/lang/Byte;)I
+java/lang/Byte.compareTo:(Ljava/lang/Object;)I
+java/lang/Byte.doubleValue:()D
+java/lang/Byte.equals:(Ljava/lang/Object;)Z
+java/lang/Byte.floatValue:()F
+java/lang/Byte.hashCode:()I
+java/lang/Byte.hashCode:(B)I
+java/lang/Byte.intValue:()I
+java/lang/Byte.longValue:()J
+java/lang/Byte.shortValue:()S
+java/lang/Byte.toString:()Ljava/lang/String;
+java/lang/Byte.toUnsignedInt:(B)I
+java/lang/Byte.toUnsignedLong:(B)J
+java/lang/Byte.valueOf:(B)Ljava/lang/Byte;
+java/lang/CharSequence$1CharIterator.<init>:(Ljava/lang/CharSequence;)V
+java/lang/CharSequence$1CharIterator.hasNext:()Z
+java/lang/CharSequence$1CodePointIterator.<init>:(Ljava/lang/CharSequence;)V
+java/lang/CharSequence$1CodePointIterator.hasNext:()Z
+java/lang/CharSequence.charAt:(I)C
+java/lang/CharSequence.length:()I
+java/lang/CharSequence.subSequence:(II)Ljava/lang/CharSequence;
+java/lang/CharSequence.toString:()Ljava/lang/String;
+java/lang/Character$CharacterCache.<clinit>:()V
+java/lang/Character$CharacterCache.<init>:()V
+java/lang/Character$Subset.<init>:(Ljava/lang/String;)V
+java/lang/Character$Subset.equals:(Ljava/lang/Object;)Z
+java/lang/Character$Subset.toString:()Ljava/lang/String;
+java/lang/Character$UnicodeBlock.of:(C)Ljava/lang/Character$UnicodeBlock;
+java/lang/Character$UnicodeBlock.of:(I)Ljava/lang/Character$UnicodeBlock;
+java/lang/Character$UnicodeScript.<init>:(Ljava/lang/String;I)V
+java/lang/Character.<init>:(C)V
+java/lang/Character.charCount:(I)I
+java/lang/Character.charValue:()C
+java/lang/Character.codePointAt:(Ljava/lang/CharSequence;I)I
+java/lang/Character.codePointAt:([CI)I
+java/lang/Character.codePointAt:([CII)I
+java/lang/Character.codePointAtImpl:([CII)I
+java/lang/Character.codePointBefore:(Ljava/lang/CharSequence;I)I
+java/lang/Character.codePointBefore:([CI)I
+java/lang/Character.codePointBefore:([CII)I
+java/lang/Character.codePointBeforeImpl:([CII)I
+java/lang/Character.codePointCount:(Ljava/lang/CharSequence;II)I
+java/lang/Character.codePointCount:([CII)I
+java/lang/Character.codePointCountImpl:([CII)I
+java/lang/Character.compare:(CC)I
+java/lang/Character.compareTo:(Ljava/lang/Character;)I
+java/lang/Character.compareTo:(Ljava/lang/Object;)I
+java/lang/Character.digit:(CI)I
+java/lang/Character.digit:(II)I
+java/lang/Character.equals:(Ljava/lang/Object;)Z
+java/lang/Character.forDigit:(II)C
+java/lang/Character.getDirectionality:(C)B
+java/lang/Character.getDirectionality:(I)B
+java/lang/Character.getNumericValue:(C)I
+java/lang/Character.getNumericValue:(I)I
+java/lang/Character.getType:(C)I
+java/lang/Character.getType:(I)I
+java/lang/Character.hashCode:()I
+java/lang/Character.hashCode:(C)I
+java/lang/Character.highSurrogate:(I)C
+java/lang/Character.isAlphabetic:(I)Z
+java/lang/Character.isBmpCodePoint:(I)Z
+java/lang/Character.isDefined:(C)Z
+java/lang/Character.isDefined:(I)Z
+java/lang/Character.isDigit:(C)Z
+java/lang/Character.isDigit:(I)Z
+java/lang/Character.isHighSurrogate:(C)Z
+java/lang/Character.isISOControl:(C)Z
+java/lang/Character.isISOControl:(I)Z
+java/lang/Character.isIdentifierIgnorable:(C)Z
+java/lang/Character.isIdentifierIgnorable:(I)Z
+java/lang/Character.isIdeographic:(I)Z
+java/lang/Character.isJavaIdentifierPart:(C)Z
+java/lang/Character.isJavaIdentifierPart:(I)Z
+java/lang/Character.isJavaIdentifierStart:(C)Z
+java/lang/Character.isJavaIdentifierStart:(I)Z
+java/lang/Character.isJavaLetter:(C)Z
+java/lang/Character.isJavaLetterOrDigit:(C)Z
+java/lang/Character.isLetter:(C)Z
+java/lang/Character.isLetter:(I)Z
+java/lang/Character.isLetterOrDigit:(C)Z
+java/lang/Character.isLetterOrDigit:(I)Z
+java/lang/Character.isLowSurrogate:(C)Z
+java/lang/Character.isLowerCase:(C)Z
+java/lang/Character.isLowerCase:(I)Z
+java/lang/Character.isMirrored:(C)Z
+java/lang/Character.isMirrored:(I)Z
+java/lang/Character.isSpace:(C)Z
+java/lang/Character.isSpaceChar:(C)Z
+java/lang/Character.isSpaceChar:(I)Z
+java/lang/Character.isSupplementaryCodePoint:(I)Z
+java/lang/Character.isSurrogate:(C)Z
+java/lang/Character.isSurrogatePair:(CC)Z
+java/lang/Character.isTitleCase:(C)Z
+java/lang/Character.isTitleCase:(I)Z
+java/lang/Character.isUnicodeIdentifierPart:(C)Z
+java/lang/Character.isUnicodeIdentifierPart:(I)Z
+java/lang/Character.isUnicodeIdentifierStart:(C)Z
+java/lang/Character.isUnicodeIdentifierStart:(I)Z
+java/lang/Character.isUpperCase:(C)Z
+java/lang/Character.isUpperCase:(I)Z
+java/lang/Character.isValidCodePoint:(I)Z
+java/lang/Character.isWhitespace:(C)Z
+java/lang/Character.isWhitespace:(I)Z
+java/lang/Character.lowSurrogate:(I)C
+java/lang/Character.offsetByCodePoints:(Ljava/lang/CharSequence;II)I
+java/lang/Character.offsetByCodePoints:([CIIII)I
+java/lang/Character.offsetByCodePointsImpl:([CIIII)I
+java/lang/Character.reverseBytes:(C)C
+java/lang/Character.toChars:(I)[C
+java/lang/Character.toChars:(I[CI)I
+java/lang/Character.toCodePoint:(CC)I
+java/lang/Character.toLowerCase:(C)C
+java/lang/Character.toLowerCase:(I)I
+java/lang/Character.toString:(C)Ljava/lang/String;
+java/lang/Character.toSurrogates:(I[CI)V
+java/lang/Character.toTitleCase:(C)C
+java/lang/Character.toTitleCase:(I)I
+java/lang/Character.toUpperCase:(C)C
+java/lang/Character.toUpperCase:(I)I
+java/lang/Character.toUpperCaseCharArray:(I)[C
+java/lang/Character.toUpperCaseEx:(I)I
+java/lang/Character.valueOf:(C)Ljava/lang/Character;
+java/lang/CharacterData.<init>:()V
+java/lang/CharacterData.digit:(II)I
+java/lang/CharacterData.getDirectionality:(I)B
+java/lang/CharacterData.getNumericValue:(I)I
+java/lang/CharacterData.getProperties:(I)I
+java/lang/CharacterData.getType:(I)I
+java/lang/CharacterData.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData.isIdeographic:(I)Z
+java/lang/CharacterData.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData.isMirrored:(I)Z
+java/lang/CharacterData.isOtherAlphabetic:(I)Z
+java/lang/CharacterData.isOtherLowercase:(I)Z
+java/lang/CharacterData.isOtherUppercase:(I)Z
+java/lang/CharacterData.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData.isWhitespace:(I)Z
+java/lang/CharacterData.of:(I)Ljava/lang/CharacterData;
+java/lang/CharacterData.toLowerCase:(I)I
+java/lang/CharacterData.toTitleCase:(I)I
+java/lang/CharacterData.toUpperCase:(I)I
+java/lang/CharacterData.toUpperCaseCharArray:(I)[C
+java/lang/CharacterData.toUpperCaseEx:(I)I
+java/lang/CharacterData00.<init>:()V
+java/lang/CharacterData00.digit:(II)I
+java/lang/CharacterData00.findInCharMap:(I)I
+java/lang/CharacterData00.getDirectionality:(I)B
+java/lang/CharacterData00.getNumericValue:(I)I
+java/lang/CharacterData00.getProperties:(I)I
+java/lang/CharacterData00.getPropertiesEx:(I)I
+java/lang/CharacterData00.getType:(I)I
+java/lang/CharacterData00.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData00.isIdeographic:(I)Z
+java/lang/CharacterData00.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData00.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData00.isMirrored:(I)Z
+java/lang/CharacterData00.isOtherAlphabetic:(I)Z
+java/lang/CharacterData00.isOtherLowercase:(I)Z
+java/lang/CharacterData00.isOtherUppercase:(I)Z
+java/lang/CharacterData00.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData00.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData00.isWhitespace:(I)Z
+java/lang/CharacterData00.toLowerCase:(I)I
+java/lang/CharacterData00.toTitleCase:(I)I
+java/lang/CharacterData00.toUpperCase:(I)I
+java/lang/CharacterData00.toUpperCaseCharArray:(I)[C
+java/lang/CharacterData00.toUpperCaseEx:(I)I
+java/lang/CharacterData01.<init>:()V
+java/lang/CharacterData01.digit:(II)I
+java/lang/CharacterData01.getDirectionality:(I)B
+java/lang/CharacterData01.getNumericValue:(I)I
+java/lang/CharacterData01.getProperties:(I)I
+java/lang/CharacterData01.getPropertiesEx:(I)I
+java/lang/CharacterData01.getType:(I)I
+java/lang/CharacterData01.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData01.isIdeographic:(I)Z
+java/lang/CharacterData01.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData01.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData01.isMirrored:(I)Z
+java/lang/CharacterData01.isOtherAlphabetic:(I)Z
+java/lang/CharacterData01.isOtherLowercase:(I)Z
+java/lang/CharacterData01.isOtherUppercase:(I)Z
+java/lang/CharacterData01.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData01.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData01.isWhitespace:(I)Z
+java/lang/CharacterData01.toLowerCase:(I)I
+java/lang/CharacterData01.toTitleCase:(I)I
+java/lang/CharacterData01.toUpperCase:(I)I
+java/lang/CharacterData02.<init>:()V
+java/lang/CharacterData02.digit:(II)I
+java/lang/CharacterData02.getDirectionality:(I)B
+java/lang/CharacterData02.getNumericValue:(I)I
+java/lang/CharacterData02.getProperties:(I)I
+java/lang/CharacterData02.getPropertiesEx:(I)I
+java/lang/CharacterData02.getType:(I)I
+java/lang/CharacterData02.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData02.isIdeographic:(I)Z
+java/lang/CharacterData02.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData02.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData02.isMirrored:(I)Z
+java/lang/CharacterData02.isOtherAlphabetic:(I)Z
+java/lang/CharacterData02.isOtherLowercase:(I)Z
+java/lang/CharacterData02.isOtherUppercase:(I)Z
+java/lang/CharacterData02.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData02.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData02.isWhitespace:(I)Z
+java/lang/CharacterData02.toLowerCase:(I)I
+java/lang/CharacterData02.toTitleCase:(I)I
+java/lang/CharacterData02.toUpperCase:(I)I
+java/lang/CharacterData0E.<init>:()V
+java/lang/CharacterData0E.digit:(II)I
+java/lang/CharacterData0E.getDirectionality:(I)B
+java/lang/CharacterData0E.getNumericValue:(I)I
+java/lang/CharacterData0E.getProperties:(I)I
+java/lang/CharacterData0E.getPropertiesEx:(I)I
+java/lang/CharacterData0E.getType:(I)I
+java/lang/CharacterData0E.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData0E.isIdeographic:(I)Z
+java/lang/CharacterData0E.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData0E.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData0E.isMirrored:(I)Z
+java/lang/CharacterData0E.isOtherAlphabetic:(I)Z
+java/lang/CharacterData0E.isOtherLowercase:(I)Z
+java/lang/CharacterData0E.isOtherUppercase:(I)Z
+java/lang/CharacterData0E.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData0E.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData0E.isWhitespace:(I)Z
+java/lang/CharacterData0E.toLowerCase:(I)I
+java/lang/CharacterData0E.toTitleCase:(I)I
+java/lang/CharacterData0E.toUpperCase:(I)I
+java/lang/CharacterDataLatin1.<init>:()V
+java/lang/CharacterDataLatin1.digit:(II)I
+java/lang/CharacterDataLatin1.getDirectionality:(I)B
+java/lang/CharacterDataLatin1.getNumericValue:(I)I
+java/lang/CharacterDataLatin1.getProperties:(I)I
+java/lang/CharacterDataLatin1.getPropertiesEx:(I)I
+java/lang/CharacterDataLatin1.getType:(I)I
+java/lang/CharacterDataLatin1.isIdentifierIgnorable:(I)Z
+java/lang/CharacterDataLatin1.isIdeographic:(I)Z
+java/lang/CharacterDataLatin1.isJavaIdentifierPart:(I)Z
+java/lang/CharacterDataLatin1.isJavaIdentifierStart:(I)Z
+java/lang/CharacterDataLatin1.isMirrored:(I)Z
+java/lang/CharacterDataLatin1.isOtherAlphabetic:(I)Z
+java/lang/CharacterDataLatin1.isOtherLowercase:(I)Z
+java/lang/CharacterDataLatin1.isOtherUppercase:(I)Z
+java/lang/CharacterDataLatin1.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterDataLatin1.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterDataLatin1.isWhitespace:(I)Z
+java/lang/CharacterDataLatin1.toLowerCase:(I)I
+java/lang/CharacterDataLatin1.toTitleCase:(I)I
+java/lang/CharacterDataLatin1.toUpperCase:(I)I
+java/lang/CharacterDataLatin1.toUpperCaseCharArray:(I)[C
+java/lang/CharacterDataLatin1.toUpperCaseEx:(I)I
+java/lang/CharacterDataPrivateUse.<clinit>:()V
+java/lang/CharacterDataPrivateUse.<init>:()V
+java/lang/CharacterDataPrivateUse.digit:(II)I
+java/lang/CharacterDataPrivateUse.getDirectionality:(I)B
+java/lang/CharacterDataPrivateUse.getNumericValue:(I)I
+java/lang/CharacterDataPrivateUse.getProperties:(I)I
+java/lang/CharacterDataPrivateUse.getType:(I)I
+java/lang/CharacterDataPrivateUse.isIdentifierIgnorable:(I)Z
+java/lang/CharacterDataPrivateUse.isJavaIdentifierPart:(I)Z
+java/lang/CharacterDataPrivateUse.isJavaIdentifierStart:(I)Z
+java/lang/CharacterDataPrivateUse.isMirrored:(I)Z
+java/lang/CharacterDataPrivateUse.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterDataPrivateUse.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterDataPrivateUse.isWhitespace:(I)Z
+java/lang/CharacterDataPrivateUse.toLowerCase:(I)I
+java/lang/CharacterDataPrivateUse.toTitleCase:(I)I
+java/lang/CharacterDataPrivateUse.toUpperCase:(I)I
+java/lang/CharacterDataUndefined.<clinit>:()V
+java/lang/CharacterDataUndefined.<init>:()V
+java/lang/CharacterDataUndefined.digit:(II)I
+java/lang/CharacterDataUndefined.getDirectionality:(I)B
+java/lang/CharacterDataUndefined.getNumericValue:(I)I
+java/lang/CharacterDataUndefined.getProperties:(I)I
+java/lang/CharacterDataUndefined.getType:(I)I
+java/lang/CharacterDataUndefined.isIdentifierIgnorable:(I)Z
+java/lang/CharacterDataUndefined.isJavaIdentifierPart:(I)Z
+java/lang/CharacterDataUndefined.isJavaIdentifierStart:(I)Z
+java/lang/CharacterDataUndefined.isMirrored:(I)Z
+java/lang/CharacterDataUndefined.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterDataUndefined.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterDataUndefined.isWhitespace:(I)Z
+java/lang/CharacterDataUndefined.toLowerCase:(I)I
+java/lang/CharacterDataUndefined.toTitleCase:(I)I
+java/lang/CharacterDataUndefined.toUpperCase:(I)I
+java/lang/CharacterName$1.<init>:()V
+java/lang/CharacterName.<init>:()V
+java/lang/Class$1.<init>:(Ljava/lang/Class;Ljava/lang/reflect/Constructor;)V
+java/lang/Class$2.<init>:(Ljava/lang/Class;)V
+java/lang/Class$3.<init>:()V
+java/lang/Class$4.<init>:(Ljava/lang/Class;Ljava/lang/reflect/Method;)V
+java/lang/Class$AnnotationData.<init>:(Ljava/util/Map;Ljava/util/Map;I)V
+java/lang/Class$Atomic.<init>:()V
+java/lang/Class$EnclosingMethodInfo.<init>:([Ljava/lang/Object;)V
+java/lang/Class$EnclosingMethodInfo.<init>:([Ljava/lang/Object;Ljava/lang/Class$1;)V
+java/lang/Class$EnclosingMethodInfo.getDescriptor:()Ljava/lang/String;
+java/lang/Class$EnclosingMethodInfo.getEnclosingClass:()Ljava/lang/Class;
+java/lang/Class$EnclosingMethodInfo.getName:()Ljava/lang/String;
+java/lang/Class$EnclosingMethodInfo.isConstructor:()Z
+java/lang/Class$EnclosingMethodInfo.isMethod:()Z
+java/lang/Class$EnclosingMethodInfo.isPartial:()Z
+java/lang/Class$MethodArray.<init>:()V
+java/lang/Class$MethodArray.<init>:(I)V
+java/lang/Class$MethodArray.get:(I)Ljava/lang/reflect/Method;
+java/lang/Class$MethodArray.getArray:()[Ljava/lang/reflect/Method;
+java/lang/Class$MethodArray.getFirst:()Ljava/lang/reflect/Method;
+java/lang/Class$MethodArray.hasDefaults:()Z
+java/lang/Class$MethodArray.length:()I
+java/lang/Class$ReflectionData.<init>:(I)V
+java/lang/Class.<init>:()V
+java/lang/Class.access$300:([Ljava/lang/Object;[Ljava/lang/Object;)Z
+java/lang/Class.access$402:(Z)Z
+java/lang/Class.access$502:(Z)Z
+java/lang/Class.arrayContentsEq:([Ljava/lang/Object;[Ljava/lang/Object;)Z
+java/lang/Class.getAnnotationType:()Lsun/reflect/annotation/AnnotationType;
+java/lang/Class.getComponentType:()Ljava/lang/Class;
+java/lang/Class.isAsciiDigit:(C)Z
+java/lang/ClassCastException.<init>:()V
+java/lang/ClassCastException.<init>:(Ljava/lang/String;)V
+java/lang/ClassCircularityError.<init>:()V
+java/lang/ClassCircularityError.<init>:(Ljava/lang/String;)V
+java/lang/ClassFormatError.<init>:()V
+java/lang/ClassFormatError.<init>:(Ljava/lang/String;)V
+java/lang/ClassLoader$1.<init>:(Ljava/lang/ClassLoader;Ljava/lang/SecurityManager;Ljava/lang/String;I)V
+java/lang/ClassLoader$2.<init>:(Ljava/util/Enumeration;)V
+java/lang/ClassLoader$3.<init>:(Ljava/io/File;)V
+java/lang/ClassLoader$NativeLibrary.<init>:(Ljava/lang/Class;Ljava/lang/String;Z)V
+java/lang/ClassLoader$NativeLibrary.access$200:(Ljava/lang/ClassLoader$NativeLibrary;)Ljava/lang/Class;
+java/lang/ClassLoader$ParallelLoaders.<init>:()V
+java/lang/ClassLoader.access$000:()Ljava/util/Vector;
+java/lang/ClassLoader.access$100:()Ljava/util/Stack;
+java/lang/ClassLoader.findClass:(Ljava/lang/String;)Ljava/lang/Class;
+java/lang/ClassLoader.findLibrary:(Ljava/lang/String;)Ljava/lang/String;
+java/lang/ClassLoader.findResource:(Ljava/lang/String;)Ljava/net/URL;
+java/lang/ClassLoader.isAncestor:(Ljava/lang/ClassLoader;)Z
+java/lang/ClassLoader.needsClassLoaderPermissionCheck:(Ljava/lang/ClassLoader;Ljava/lang/ClassLoader;)Z
+java/lang/ClassLoaderHelper.<init>:()V
+java/lang/ClassNotFoundException.<init>:(Ljava/lang/String;)V
+java/lang/ClassNotFoundException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/ClassNotFoundException.getCause:()Ljava/lang/Throwable;
+java/lang/ClassNotFoundException.getException:()Ljava/lang/Throwable;
+java/lang/ClassValue$ClassValueMap.getCache:()[Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue$ClassValueMap.loadFromCache:([Ljava/lang/ClassValue$Entry;I)Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue$ClassValueMap.probeHomeLocation:([Ljava/lang/ClassValue$Entry;Ljava/lang/ClassValue;)Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue$ClassValueMap.sizeCache:(I)V
+java/lang/ClassValue$Entry.assertNotPromise:()V
+java/lang/ClassValue$Entry.isPromise:()Z
+java/lang/ClassValue$Entry.value:()Ljava/lang/Object;
+java/lang/ClassValue$Identity.<init>:()V
+java/lang/ClassValue$Version.classValue:()Ljava/lang/ClassValue;
+java/lang/ClassValue$Version.isLive:()Z
+java/lang/ClassValue$Version.promise:()Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue.castEntry:(Ljava/lang/ClassValue$Entry;)Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue.computeValue:(Ljava/lang/Class;)Ljava/lang/Object;
+java/lang/ClassValue.getCacheCarefully:(Ljava/lang/Class;)[Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue.version:()Ljava/lang/ClassValue$Version;
+java/lang/CloneNotSupportedException.<init>:()V
+java/lang/CloneNotSupportedException.<init>:(Ljava/lang/String;)V
+java/lang/Comparable.compareTo:(Ljava/lang/Object;)I
+java/lang/Compiler$1.<init>:()V
+java/lang/Compiler.<init>:()V
+java/lang/ConditionalSpecialCasing$Entry.<init>:(I[C[CLjava/lang/String;I)V
+java/lang/ConditionalSpecialCasing$Entry.getCodePoint:()I
+java/lang/ConditionalSpecialCasing$Entry.getCondition:()I
+java/lang/ConditionalSpecialCasing$Entry.getLanguage:()Ljava/lang/String;
+java/lang/ConditionalSpecialCasing$Entry.getLowerCase:()[C
+java/lang/ConditionalSpecialCasing$Entry.getUpperCase:()[C
+java/lang/ConditionalSpecialCasing.<init>:()V
+java/lang/ConditionalSpecialCasing.isCased:(I)Z
+java/lang/ConditionalSpecialCasing.isSoftDotted:(I)Z
+java/lang/Double.<init>:(D)V
+java/lang/Double.byteValue:()B
+java/lang/Double.doubleValue:()D
+java/lang/Double.floatValue:()F
+java/lang/Double.intValue:()I
+java/lang/Double.isFinite:(D)Z
+java/lang/Double.isInfinite:()Z
+java/lang/Double.isInfinite:(D)Z
+java/lang/Double.isNaN:()Z
+java/lang/Double.isNaN:(D)Z
+java/lang/Double.longValue:()J
+java/lang/Double.shortValue:()S
+java/lang/Double.sum:(DD)D
+java/lang/Double.valueOf:(D)Ljava/lang/Double;
+java/lang/Enum.<init>:(Ljava/lang/String;I)V
+java/lang/Enum.clone:()Ljava/lang/Object;
+java/lang/Enum.equals:(Ljava/lang/Object;)Z
+java/lang/Enum.name:()Ljava/lang/String;
+java/lang/Enum.ordinal:()I
+java/lang/Enum.toString:()Ljava/lang/String;
+java/lang/EnumConstantNotPresentException.constantName:()Ljava/lang/String;
+java/lang/EnumConstantNotPresentException.enumType:()Ljava/lang/Class;
+java/lang/Error.<init>:()V
+java/lang/Error.<init>:(Ljava/lang/String;)V
+java/lang/Error.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Error.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/Exception.<init>:()V
+java/lang/Exception.<init>:(Ljava/lang/String;)V
+java/lang/Exception.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Exception.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/ExceptionInInitializerError.getCause:()Ljava/lang/Throwable;
+java/lang/ExceptionInInitializerError.getException:()Ljava/lang/Throwable;
+java/lang/Float.<init>:(D)V
+java/lang/Float.<init>:(F)V
+java/lang/Float.byteValue:()B
+java/lang/Float.doubleValue:()D
+java/lang/Float.floatValue:()F
+java/lang/Float.intValue:()I
+java/lang/Float.isFinite:(F)Z
+java/lang/Float.isInfinite:()Z
+java/lang/Float.isInfinite:(F)Z
+java/lang/Float.isNaN:()Z
+java/lang/Float.isNaN:(F)Z
+java/lang/Float.longValue:()J
+java/lang/Float.shortValue:()S
+java/lang/Float.sum:(FF)F
+java/lang/Float.valueOf:(F)Ljava/lang/Float;
+java/lang/IllegalAccessError.<init>:()V
+java/lang/IllegalAccessError.<init>:(Ljava/lang/String;)V
+java/lang/IllegalAccessException.<init>:()V
+java/lang/IllegalAccessException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalArgumentException.<init>:()V
+java/lang/IllegalArgumentException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalArgumentException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/IllegalMonitorStateException.<init>:()V
+java/lang/IllegalMonitorStateException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalStateException.<init>:()V
+java/lang/IllegalStateException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalStateException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/IllegalThreadStateException.<init>:()V
+java/lang/IllegalThreadStateException.<init>:(Ljava/lang/String;)V
+java/lang/IncompatibleClassChangeError.<init>:()V
+java/lang/IncompatibleClassChangeError.<init>:(Ljava/lang/String;)V
+java/lang/IndexOutOfBoundsException.<init>:()V
+java/lang/IndexOutOfBoundsException.<init>:(Ljava/lang/String;)V
+java/lang/InheritableThreadLocal.childValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/InheritableThreadLocal.getMap:(Ljava/lang/Thread;)Ljava/lang/ThreadLocal$ThreadLocalMap;
+java/lang/InstantiationError.<init>:()V
+java/lang/InstantiationError.<init>:(Ljava/lang/String;)V
+java/lang/InstantiationException.<init>:()V
+java/lang/InstantiationException.<init>:(Ljava/lang/String;)V
+java/lang/Integer$IntegerCache.<init>:()V
+java/lang/Integer.<init>:(I)V
+java/lang/Integer.bitCount:(I)I
+java/lang/Integer.byteValue:()B
+java/lang/Integer.compare:(II)I
+java/lang/Integer.compareTo:(Ljava/lang/Integer;)I
+java/lang/Integer.compareTo:(Ljava/lang/Object;)I
+java/lang/Integer.compareUnsigned:(II)I
+java/lang/Integer.divideUnsigned:(II)I
+java/lang/Integer.doubleValue:()D
+java/lang/Integer.equals:(Ljava/lang/Object;)Z
+java/lang/Integer.floatValue:()F
+java/lang/Integer.formatUnsignedInt:(II[CII)I
+java/lang/Integer.getChars:(II[C)V
+java/lang/Integer.hashCode:()I
+java/lang/Integer.hashCode:(I)I
+java/lang/Integer.highestOneBit:(I)I
+java/lang/Integer.intValue:()I
+java/lang/Integer.longValue:()J
+java/lang/Integer.lowestOneBit:(I)I
+java/lang/Integer.max:(II)I
+java/lang/Integer.min:(II)I
+java/lang/Integer.numberOfLeadingZeros:(I)I
+java/lang/Integer.numberOfTrailingZeros:(I)I
+java/lang/Integer.remainderUnsigned:(II)I
+java/lang/Integer.reverse:(I)I
+java/lang/Integer.reverseBytes:(I)I
+java/lang/Integer.rotateLeft:(II)I
+java/lang/Integer.rotateRight:(II)I
+java/lang/Integer.shortValue:()S
+java/lang/Integer.signum:(I)I
+java/lang/Integer.stringSize:(I)I
+java/lang/Integer.sum:(II)I
+java/lang/Integer.toBinaryString:(I)Ljava/lang/String;
+java/lang/Integer.toHexString:(I)Ljava/lang/String;
+java/lang/Integer.toOctalString:(I)Ljava/lang/String;
+java/lang/Integer.toString:()Ljava/lang/String;
+java/lang/Integer.toString:(I)Ljava/lang/String;
+java/lang/Integer.toUnsignedLong:(I)J
+java/lang/Integer.toUnsignedString0:(II)Ljava/lang/String;
+java/lang/Integer.toUnsignedString:(I)Ljava/lang/String;
+java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
+java/lang/InternalError.<init>:()V
+java/lang/InternalError.<init>:(Ljava/lang/String;)V
+java/lang/InternalError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/InterruptedException.<init>:()V
+java/lang/InterruptedException.<init>:(Ljava/lang/String;)V
+java/lang/Iterable.iterator:()Ljava/util/Iterator;
+java/lang/LinkageError.<init>:()V
+java/lang/LinkageError.<init>:(Ljava/lang/String;)V
+java/lang/LinkageError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Long$LongCache.<clinit>:()V
+java/lang/Long$LongCache.<init>:()V
+java/lang/Long.<init>:(J)V
+java/lang/Long.bitCount:(J)I
+java/lang/Long.byteValue:()B
+java/lang/Long.compare:(JJ)I
+java/lang/Long.compareTo:(Ljava/lang/Long;)I
+java/lang/Long.compareTo:(Ljava/lang/Object;)I
+java/lang/Long.compareUnsigned:(JJ)I
+java/lang/Long.doubleValue:()D
+java/lang/Long.equals:(Ljava/lang/Object;)Z
+java/lang/Long.floatValue:()F
+java/lang/Long.formatUnsignedLong:(JI[CII)I
+java/lang/Long.getChars:(JI[C)V
+java/lang/Long.hashCode:()I
+java/lang/Long.hashCode:(J)I
+java/lang/Long.highestOneBit:(J)J
+java/lang/Long.intValue:()I
+java/lang/Long.longValue:()J
+java/lang/Long.lowestOneBit:(J)J
+java/lang/Long.max:(JJ)J
+java/lang/Long.min:(JJ)J
+java/lang/Long.numberOfLeadingZeros:(J)I
+java/lang/Long.numberOfTrailingZeros:(J)I
+java/lang/Long.reverse:(J)J
+java/lang/Long.reverseBytes:(J)J
+java/lang/Long.rotateLeft:(JI)J
+java/lang/Long.rotateRight:(JI)J
+java/lang/Long.shortValue:()S
+java/lang/Long.signum:(J)I
+java/lang/Long.stringSize:(J)I
+java/lang/Long.sum:(JJ)J
+java/lang/Long.toBinaryString:(J)Ljava/lang/String;
+java/lang/Long.toHexString:(J)Ljava/lang/String;
+java/lang/Long.toOctalString:(J)Ljava/lang/String;
+java/lang/Long.toString:()Ljava/lang/String;
+java/lang/Long.toString:(J)Ljava/lang/String;
+java/lang/Long.toUnsignedString0:(JI)Ljava/lang/String;
+java/lang/Long.valueOf:(J)Ljava/lang/Long;
+java/lang/Math$RandomNumberGeneratorHolder.<init>:()V
+java/lang/Math.<init>:()V
+java/lang/Math.abs:(D)D
+java/lang/Math.abs:(F)F
+java/lang/Math.abs:(I)I
+java/lang/Math.abs:(J)J
+java/lang/Math.addExact:(II)I
+java/lang/Math.addExact:(JJ)J
+java/lang/Math.decrementExact:(I)I
+java/lang/Math.decrementExact:(J)J
+java/lang/Math.floorDiv:(II)I
+java/lang/Math.floorDiv:(JJ)J
+java/lang/Math.floorMod:(II)I
+java/lang/Math.floorMod:(JJ)J
+java/lang/Math.incrementExact:(I)I
+java/lang/Math.incrementExact:(J)J
+java/lang/Math.max:(II)I
+java/lang/Math.max:(JJ)J
+java/lang/Math.min:(II)I
+java/lang/Math.min:(JJ)J
+java/lang/Math.multiplyExact:(II)I
+java/lang/Math.multiplyExact:(JJ)J
+java/lang/Math.negateExact:(I)I
+java/lang/Math.negateExact:(J)J
+java/lang/Math.subtractExact:(II)I
+java/lang/Math.subtractExact:(JJ)J
+java/lang/Math.toDegrees:(D)D
+java/lang/Math.toIntExact:(J)I
+java/lang/Math.toRadians:(D)D
+java/lang/NegativeArraySizeException.<init>:()V
+java/lang/NegativeArraySizeException.<init>:(Ljava/lang/String;)V
+java/lang/NoClassDefFoundError.<init>:()V
+java/lang/NoClassDefFoundError.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchFieldError.<init>:()V
+java/lang/NoSuchFieldError.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchFieldException.<init>:()V
+java/lang/NoSuchFieldException.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchMethodError.<init>:()V
+java/lang/NoSuchMethodError.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchMethodException.<init>:()V
+java/lang/NoSuchMethodException.<init>:(Ljava/lang/String;)V
+java/lang/NullPointerException.<init>:()V
+java/lang/NullPointerException.<init>:(Ljava/lang/String;)V
+java/lang/Number.<init>:()V
+java/lang/Number.byteValue:()B
+java/lang/Number.doubleValue:()D
+java/lang/Number.floatValue:()F
+java/lang/Number.intValue:()I
+java/lang/Number.longValue:()J
+java/lang/Number.shortValue:()S
+java/lang/NumberFormatException.<init>:()V
+java/lang/NumberFormatException.<init>:(Ljava/lang/String;)V
+java/lang/Object.<init>:()V
+java/lang/Object.equals:(Ljava/lang/Object;)Z
+java/lang/Object.getClass:()Ljava/lang/Class;
+java/lang/OutOfMemoryError.<init>:()V
+java/lang/OutOfMemoryError.<init>:(Ljava/lang/String;)V
+java/lang/Package$1.<init>:(Ljava/lang/String;Ljava/lang/String;)V
+java/lang/Package$1PackageInfoProxy.<init>:(Ljava/lang/Package;)V
+java/lang/Package.<init>:(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/net/URL;Ljava/lang/ClassLoader;)V
+java/lang/Package.access$000:()Ljava/util/Map;
+java/lang/Package.access$200:()Ljava/util/Map;
+java/lang/Package.access$400:()Ljava/util/Map;
+java/lang/Package.getImplementationTitle:()Ljava/lang/String;
+java/lang/Package.getImplementationVendor:()Ljava/lang/String;
+java/lang/Package.getImplementationVersion:()Ljava/lang/String;
+java/lang/Package.getName:()Ljava/lang/String;
+java/lang/Package.getSpecificationTitle:()Ljava/lang/String;
+java/lang/Package.getSpecificationVendor:()Ljava/lang/String;
+java/lang/Package.getSpecificationVersion:()Ljava/lang/String;
+java/lang/Package.hashCode:()I
+java/lang/Package.isSealed:()Z
+java/lang/Process.<init>:()V
+java/lang/Process.destroy:()V
+java/lang/Process.destroyForcibly:()Ljava/lang/Process;
+java/lang/Process.exitValue:()I
+java/lang/Process.getErrorStream:()Ljava/io/InputStream;
+java/lang/Process.getInputStream:()Ljava/io/InputStream;
+java/lang/Process.getOutputStream:()Ljava/io/OutputStream;
+java/lang/Process.isAlive:()Z
+java/lang/Process.waitFor:()I
+java/lang/ProcessBuilder$NullInputStream.available:()I
+java/lang/ProcessBuilder$NullInputStream.read:()I
+java/lang/ProcessBuilder$Redirect$1.<init>:()V
+java/lang/ProcessBuilder$Redirect$1.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$2.<init>:()V
+java/lang/ProcessBuilder$Redirect$2.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$3.<init>:(Ljava/io/File;)V
+java/lang/ProcessBuilder$Redirect$3.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect$3.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$4.<init>:(Ljava/io/File;)V
+java/lang/ProcessBuilder$Redirect$4.append:()Z
+java/lang/ProcessBuilder$Redirect$4.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect$4.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$5.<init>:(Ljava/io/File;)V
+java/lang/ProcessBuilder$Redirect$5.append:()Z
+java/lang/ProcessBuilder$Redirect$5.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect$5.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$Type.<clinit>:()V
+java/lang/ProcessBuilder$Redirect$Type.<init>:(Ljava/lang/String;I)V
+java/lang/ProcessBuilder$Redirect.<init>:()V
+java/lang/ProcessBuilder$Redirect.<init>:(Ljava/lang/ProcessBuilder$1;)V
+java/lang/ProcessBuilder$Redirect.append:()Z
+java/lang/ProcessBuilder$Redirect.appendTo:(Ljava/io/File;)Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder$Redirect.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect.from:(Ljava/io/File;)Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder$Redirect.to:(Ljava/io/File;)Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder$Redirect.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder.<init>:(Ljava/util/List;)V
+java/lang/ProcessBuilder.command:()Ljava/util/List;
+java/lang/ProcessBuilder.command:(Ljava/util/List;)Ljava/lang/ProcessBuilder;
+java/lang/ProcessBuilder.directory:()Ljava/io/File;
+java/lang/ProcessBuilder.directory:(Ljava/io/File;)Ljava/lang/ProcessBuilder;
+java/lang/ProcessBuilder.redirectError:()Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder.redirectErrorStream:()Z
+java/lang/ProcessBuilder.redirectErrorStream:(Z)Ljava/lang/ProcessBuilder;
+java/lang/ProcessBuilder.redirectInput:()Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder.redirectOutput:()Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder.redirects:()[Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessEnvironment$ExternalData.<init>:(Ljava/lang/String;[B)V
+java/lang/ProcessEnvironment$ExternalData.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$ExternalData.getBytes:()[B
+java/lang/ProcessEnvironment$ExternalData.hashCode:()I
+java/lang/ProcessEnvironment$ExternalData.toString:()Ljava/lang/String;
+java/lang/ProcessEnvironment$StringEntry.<init>:(Ljava/util/Map$Entry;)V
+java/lang/ProcessEnvironment$StringEntry.access$600:(Ljava/lang/ProcessEnvironment$StringEntry;)Ljava/util/Map$Entry;
+java/lang/ProcessEnvironment$StringEntrySet$2.<init>:(Ljava/lang/Object;)V
+java/lang/ProcessEnvironment$StringEntrySet$2.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/ProcessEnvironment$StringEntrySet$2.setValue:(Ljava/lang/ProcessEnvironment$Value;)Ljava/lang/ProcessEnvironment$Value;
+java/lang/ProcessEnvironment$StringEntrySet.access$500:(Ljava/lang/ProcessEnvironment$StringEntrySet;)Ljava/util/Set;
+java/lang/ProcessEnvironment$StringEntrySet.vvEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/lang/ProcessEnvironment$StringKeySet.access$800:(Ljava/lang/ProcessEnvironment$StringKeySet;)Ljava/util/Set;
+java/lang/ProcessEnvironment$StringValues.access$700:(Ljava/lang/ProcessEnvironment$StringValues;)Ljava/util/Collection;
+java/lang/ProcessEnvironment$Value.<init>:(Ljava/lang/String;[B)V
+java/lang/ProcessEnvironment$Value.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$Variable.<init>:(Ljava/lang/String;[B)V
+java/lang/ProcessEnvironment$Variable.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment.<init>:()V
+java/lang/ProcessEnvironment.access$000:([B[B)Z
+java/lang/ProcessEnvironment.access$100:([B)I
+java/lang/ProcessEnvironment.access$300:([B[B)I
+java/lang/ProcessEnvironment.arrayCompare:([B[B)I
+java/lang/ProcessEnvironment.arrayEquals:([B[B)Z
+java/lang/ProcessEnvironment.arrayHash:([B)I
+java/lang/ProcessEnvironment.getenv:()Ljava/util/Map;
+java/lang/ProcessImpl.<init>:()V
+java/lang/Readable.read:(Ljava/nio/CharBuffer;)I
+java/lang/ReflectiveOperationException.<init>:()V
+java/lang/ReflectiveOperationException.<init>:(Ljava/lang/String;)V
+java/lang/ReflectiveOperationException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Runnable.run:()V
+java/lang/Runtime.<clinit>:()V
+java/lang/Runtime.<init>:()V
+java/lang/Runtime.getLocalizedInputStream:(Ljava/io/InputStream;)Ljava/io/InputStream;
+java/lang/Runtime.getLocalizedOutputStream:(Ljava/io/OutputStream;)Ljava/io/OutputStream;
+java/lang/Runtime.getRuntime:()Ljava/lang/Runtime;
+java/lang/RuntimeException.<init>:()V
+java/lang/RuntimeException.<init>:(Ljava/lang/String;)V
+java/lang/RuntimeException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/RuntimeException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/SecurityException.<init>:()V
+java/lang/SecurityException.<init>:(Ljava/lang/String;)V
+java/lang/SecurityException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/SecurityManager$1.<init>:(Ljava/lang/SecurityManager;)V
+java/lang/SecurityManager$2.<init>:(Ljava/lang/SecurityManager;)V
+java/lang/SecurityManager.getInCheck:()Z
+java/lang/Short$ShortCache.<clinit>:()V
+java/lang/Short$ShortCache.<init>:()V
+java/lang/Short.<init>:(S)V
+java/lang/Short.byteValue:()B
+java/lang/Short.compare:(SS)I
+java/lang/Short.compareTo:(Ljava/lang/Object;)I
+java/lang/Short.compareTo:(Ljava/lang/Short;)I
+java/lang/Short.doubleValue:()D
+java/lang/Short.equals:(Ljava/lang/Object;)Z
+java/lang/Short.floatValue:()F
+java/lang/Short.hashCode:()I
+java/lang/Short.hashCode:(S)I
+java/lang/Short.intValue:()I
+java/lang/Short.longValue:()J
+java/lang/Short.reverseBytes:(S)S
+java/lang/Short.shortValue:()S
+java/lang/Short.toString:()Ljava/lang/String;
+java/lang/Short.toUnsignedInt:(S)I
+java/lang/Short.toUnsignedLong:(S)J
+java/lang/Short.valueOf:(S)Ljava/lang/Short;
+java/lang/Shutdown$Lock.<init>:()V
+java/lang/Shutdown$Lock.<init>:(Ljava/lang/Shutdown$1;)V
+java/lang/Shutdown.<clinit>:()V
+java/lang/Shutdown.<init>:()V
+java/lang/Shutdown.runHooks:()V
+java/lang/Shutdown.setRunFinalizersOnExit:(Z)V
+java/lang/StackOverflowError.<init>:()V
+java/lang/StackOverflowError.<init>:(Ljava/lang/String;)V
+java/lang/StackTraceElement.getClassName:()Ljava/lang/String;
+java/lang/StackTraceElement.getFileName:()Ljava/lang/String;
+java/lang/StackTraceElement.getLineNumber:()I
+java/lang/StackTraceElement.getMethodName:()Ljava/lang/String;
+java/lang/StackTraceElement.isNativeMethod:()Z
+java/lang/StrictMath$RandomNumberGeneratorHolder.<init>:()V
+java/lang/StrictMath.<init>:()V
+java/lang/StrictMath.abs:(D)D
+java/lang/StrictMath.abs:(F)F
+java/lang/StrictMath.abs:(I)I
+java/lang/StrictMath.abs:(J)J
+java/lang/StrictMath.addExact:(II)I
+java/lang/StrictMath.addExact:(JJ)J
+java/lang/StrictMath.floorDiv:(II)I
+java/lang/StrictMath.floorDiv:(JJ)J
+java/lang/StrictMath.floorMod:(II)I
+java/lang/StrictMath.floorMod:(JJ)J
+java/lang/StrictMath.max:(II)I
+java/lang/StrictMath.max:(JJ)J
+java/lang/StrictMath.min:(II)I
+java/lang/StrictMath.min:(JJ)J
+java/lang/StrictMath.multiplyExact:(II)I
+java/lang/StrictMath.multiplyExact:(JJ)J
+java/lang/StrictMath.subtractExact:(II)I
+java/lang/StrictMath.subtractExact:(JJ)J
+java/lang/StrictMath.toDegrees:(D)D
+java/lang/StrictMath.toIntExact:(J)I
+java/lang/StrictMath.toRadians:(D)D
+java/lang/String$CaseInsensitiveComparator.<init>:()V
+java/lang/String$CaseInsensitiveComparator.<init>:(Ljava/lang/String$1;)V
+java/lang/String$CaseInsensitiveComparator.compare:(Ljava/lang/Object;Ljava/lang/Object;)I
+java/lang/String$CaseInsensitiveComparator.compare:(Ljava/lang/String;Ljava/lang/String;)I
+java/lang/String$CaseInsensitiveComparator.readResolve:()Ljava/lang/Object;
+java/lang/String.<clinit>:()V
+java/lang/String.<init>:()V
+java/lang/String.<init>:(Ljava/lang/String;)V
+java/lang/String.<init>:([BI)V
+java/lang/String.<init>:([BIII)V
+java/lang/String.<init>:([CZ)V
+java/lang/String.<init>:([III)V
+java/lang/String.charAt:(I)C
+java/lang/String.checkBounds:([BII)V
+java/lang/String.codePointAt:(I)I
+java/lang/String.codePointBefore:(I)I
+java/lang/String.codePointCount:(II)I
+java/lang/String.compareTo:(Ljava/lang/Object;)I
+java/lang/String.compareTo:(Ljava/lang/String;)I
+java/lang/String.contains:(Ljava/lang/CharSequence;)Z
+java/lang/String.contentEquals:(Ljava/lang/CharSequence;)Z
+java/lang/String.contentEquals:(Ljava/lang/StringBuffer;)Z
+java/lang/String.endsWith:(Ljava/lang/String;)Z
+java/lang/String.equals:(Ljava/lang/Object;)Z
+java/lang/String.equalsIgnoreCase:(Ljava/lang/String;)Z
+java/lang/String.getChars:(II[CI)V
+java/lang/String.getChars:([CI)V
+java/lang/String.hashCode:()I
+java/lang/String.indexOf:(I)I
+java/lang/String.indexOf:(II)I
+java/lang/String.indexOf:(Ljava/lang/String;)I
+java/lang/String.indexOf:(Ljava/lang/String;I)I
+java/lang/String.indexOf:([CIILjava/lang/String;I)I
+java/lang/String.indexOf:([CII[CIII)I
+java/lang/String.indexOfSupplementary:(II)I
+java/lang/String.isEmpty:()Z
+java/lang/String.lastIndexOf:(I)I
+java/lang/String.lastIndexOf:(II)I
+java/lang/String.lastIndexOf:(Ljava/lang/String;)I
+java/lang/String.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/String.lastIndexOf:([CIILjava/lang/String;I)I
+java/lang/String.lastIndexOf:([CII[CIII)I
+java/lang/String.lastIndexOfSupplementary:(II)I
+java/lang/String.length:()I
+java/lang/String.nonSyncContentEquals:(Ljava/lang/AbstractStringBuilder;)Z
+java/lang/String.offsetByCodePoints:(II)I
+java/lang/String.regionMatches:(ILjava/lang/String;II)Z
+java/lang/String.regionMatches:(ZILjava/lang/String;II)Z
+java/lang/String.replace:(CC)Ljava/lang/String;
+java/lang/String.startsWith:(Ljava/lang/String;)Z
+java/lang/String.startsWith:(Ljava/lang/String;I)Z
+java/lang/String.toCharArray:()[C
+java/lang/String.toString:()Ljava/lang/String;
+java/lang/String.valueOf:(C)Ljava/lang/String;
+java/lang/String.valueOf:(I)Ljava/lang/String;
+java/lang/String.valueOf:(J)Ljava/lang/String;
+java/lang/String.valueOf:(Z)Ljava/lang/String;
+java/lang/StringBuffer.<init>:()V
+java/lang/StringBuffer.<init>:(I)V
+java/lang/StringBuffer.capacity:()I
+java/lang/StringBuffer.charAt:(I)C
+java/lang/StringBuffer.codePointAt:(I)I
+java/lang/StringBuffer.codePointBefore:(I)I
+java/lang/StringBuffer.codePointCount:(II)I
+java/lang/StringBuffer.delete:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.delete:(II)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.deleteCharAt:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.deleteCharAt:(I)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.getChars:(II[CI)V
+java/lang/StringBuffer.indexOf:(Ljava/lang/String;)I
+java/lang/StringBuffer.indexOf:(Ljava/lang/String;I)I
+java/lang/StringBuffer.lastIndexOf:(Ljava/lang/String;)I
+java/lang/StringBuffer.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/StringBuffer.length:()I
+java/lang/StringBuffer.offsetByCodePoints:(II)I
+java/lang/StringBuffer.reverse:()Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.reverse:()Ljava/lang/StringBuffer;
+java/lang/StringBuffer.setCharAt:(IC)V
+java/lang/StringBuilder.<init>:()V
+java/lang/StringBuilder.<init>:(I)V
+java/lang/StringBuilder.capacity:()I
+java/lang/StringBuilder.charAt:(I)C
+java/lang/StringBuilder.codePointAt:(I)I
+java/lang/StringBuilder.codePointBefore:(I)I
+java/lang/StringBuilder.codePointCount:(II)I
+java/lang/StringBuilder.delete:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.delete:(II)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.deleteCharAt:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.deleteCharAt:(I)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.getChars:(II[CI)V
+java/lang/StringBuilder.indexOf:(Ljava/lang/String;)I
+java/lang/StringBuilder.indexOf:(Ljava/lang/String;I)I
+java/lang/StringBuilder.lastIndexOf:(Ljava/lang/String;)I
+java/lang/StringBuilder.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/StringBuilder.length:()I
+java/lang/StringBuilder.offsetByCodePoints:(II)I
+java/lang/StringBuilder.reverse:()Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.reverse:()Ljava/lang/StringBuilder;
+java/lang/StringBuilder.setCharAt:(IC)V
+java/lang/StringCoding$StringDecoder.requestedCharsetName:()Ljava/lang/String;
+java/lang/StringCoding$StringEncoder.requestedCharsetName:()Ljava/lang/String;
+java/lang/StringCoding.<init>:()V
+java/lang/StringCoding.access$000:(IF)I
+java/lang/StringCoding.scale:(IF)I
+java/lang/StringIndexOutOfBoundsException.<init>:()V
+java/lang/StringIndexOutOfBoundsException.<init>:(I)V
+java/lang/StringIndexOutOfBoundsException.<init>:(Ljava/lang/String;)V
+java/lang/SuppressWarnings.value:()[Ljava/lang/String;
+java/lang/System$1.<init>:(Ljava/lang/SecurityManager;)V
+java/lang/System$2.<init>:()V
+java/lang/System$2.blockedOn:(Ljava/lang/Thread;Lsun/nio/ch/Interruptible;)V
+java/lang/System$2.getAnnotationType:(Ljava/lang/Class;)Lsun/reflect/annotation/AnnotationType;
+java/lang/System$2.newStringUnsafe:([C)Ljava/lang/String;
+java/lang/System.<init>:()V
+java/lang/System.arraycopy:(Ljava/lang/Object;ILjava/lang/Object;II)V
+java/lang/System.checkKey:(Ljava/lang/String;)V
+java/lang/System.getSecurityManager:()Ljava/lang/SecurityManager;
+java/lang/System.lineSeparator:()Ljava/lang/String;
+java/lang/SystemClassLoaderAction.<init>:(Ljava/lang/ClassLoader;)V
+java/lang/Terminator$1.<init>:()V
+java/lang/Terminator.<clinit>:()V
+java/lang/Terminator.<init>:()V
+java/lang/Terminator.teardown:()V
+java/lang/Thread$1.<init>:(Ljava/lang/Class;)V
+java/lang/Thread$Caches.<init>:()V
+java/lang/Thread$State.<clinit>:()V
+java/lang/Thread$State.<init>:(Ljava/lang/String;I)V
+java/lang/Thread$UncaughtExceptionHandler.uncaughtException:(Ljava/lang/Thread;Ljava/lang/Throwable;)V
+java/lang/Thread$WeakClassKey.hashCode:()I
+java/lang/Thread.blockedOn:(Lsun/nio/ch/Interruptible;)V
+java/lang/Thread.clone:()Ljava/lang/Object;
+java/lang/Thread.destroy:()V
+java/lang/Thread.dispatchUncaughtException:(Ljava/lang/Throwable;)V
+java/lang/Thread.getDefaultUncaughtExceptionHandler:()Ljava/lang/Thread$UncaughtExceptionHandler;
+java/lang/Thread.getId:()J
+java/lang/Thread.getName:()Ljava/lang/String;
+java/lang/Thread.getPriority:()I
+java/lang/Thread.getThreadGroup:()Ljava/lang/ThreadGroup;
+java/lang/Thread.getUncaughtExceptionHandler:()Ljava/lang/Thread$UncaughtExceptionHandler;
+java/lang/Thread.isDaemon:()Z
+java/lang/Thread.nextThreadID:()J
+java/lang/Thread.nextThreadNum:()I
+java/lang/Thread.run:()V
+java/lang/Thread.stop:(Ljava/lang/Throwable;)V
+java/lang/ThreadDeath.<init>:()V
+java/lang/ThreadGroup.<init>:()V
+java/lang/ThreadGroup.addUnstarted:()V
+java/lang/ThreadGroup.getMaxPriority:()I
+java/lang/ThreadGroup.getName:()Ljava/lang/String;
+java/lang/ThreadGroup.isDaemon:()Z
+java/lang/ThreadGroup.isDestroyed:()Z
+java/lang/ThreadGroup.parentOf:(Ljava/lang/ThreadGroup;)Z
+java/lang/ThreadGroup.remove:(Ljava/lang/Thread;)V
+java/lang/ThreadGroup.threadStartFailed:(Ljava/lang/Thread;)V
+java/lang/ThreadLocal$ThreadLocalMap.nextIndex:(II)I
+java/lang/ThreadLocal$ThreadLocalMap.prevIndex:(II)I
+java/lang/ThreadLocal$ThreadLocalMap.setThreshold:(I)V
+java/lang/ThreadLocal.access$400:(Ljava/lang/ThreadLocal;)I
+java/lang/ThreadLocal.childValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/ThreadLocal.getMap:(Ljava/lang/Thread;)Ljava/lang/ThreadLocal$ThreadLocalMap;
+java/lang/ThreadLocal.initialValue:()Ljava/lang/Object;
+java/lang/Throwable$PrintStreamOrWriter.<init>:()V
+java/lang/Throwable$PrintStreamOrWriter.<init>:(Ljava/lang/Throwable$1;)V
+java/lang/Throwable$PrintStreamOrWriter.lock:()Ljava/lang/Object;
+java/lang/Throwable$PrintStreamOrWriter.println:(Ljava/lang/Object;)V
+java/lang/Throwable$SentinelHolder.<init>:()V
+java/lang/Throwable$WrappedPrintStream.<init>:(Ljava/io/PrintStream;)V
+java/lang/Throwable$WrappedPrintStream.lock:()Ljava/lang/Object;
+java/lang/Throwable$WrappedPrintWriter.<init>:(Ljava/io/PrintWriter;)V
+java/lang/Throwable$WrappedPrintWriter.lock:()Ljava/lang/Object;
+java/lang/Throwable.<init>:()V
+java/lang/Throwable.<init>:(Ljava/lang/String;)V
+java/lang/Throwable.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Throwable.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/Throwable.fillInStackTrace:()Ljava/lang/Throwable;
+java/lang/Throwable.fillInStackTrace:(I)Ljava/lang/Throwable;
+java/lang/Throwable.getCause:()Ljava/lang/Throwable;
+java/lang/Throwable.getLocalizedMessage:()Ljava/lang/String;
+java/lang/Throwable.getMessage:()Ljava/lang/String;
+java/lang/TypeNotPresentException.typeName:()Ljava/lang/String;
+java/lang/UNIXProcess$1.<init>:()V
+java/lang/UNIXProcess$2.<init>:()V
+java/lang/UNIXProcess$3.<init>:(Ljava/lang/UNIXProcess;[I)V
+java/lang/UNIXProcess$4.<init>:(Ljava/lang/UNIXProcess;)V
+java/lang/UNIXProcess$LaunchMechanism.<clinit>:()V
+java/lang/UNIXProcess$LaunchMechanism.<init>:(Ljava/lang/String;II)V
+java/lang/UNIXProcess$LaunchMechanism.access$300:(Ljava/lang/UNIXProcess$LaunchMechanism;)I
+java/lang/UNIXProcess$ProcessReaperThreadFactory$1.<init>:()V
+java/lang/UNIXProcess$ProcessReaperThreadFactory.<init>:()V
+java/lang/UNIXProcess$ProcessReaperThreadFactory.<init>:(Ljava/lang/UNIXProcess$1;)V
+java/lang/UNIXProcess.access$002:([B)[B
+java/lang/UNIXProcess.access$400:(Ljava/lang/UNIXProcess;)I
+java/lang/UNIXProcess.exitValue:()I
+java/lang/UNIXProcess.getErrorStream:()Ljava/io/InputStream;
+java/lang/UNIXProcess.getInputStream:()Ljava/io/InputStream;
+java/lang/UNIXProcess.getOutputStream:()Ljava/io/OutputStream;
+java/lang/UNIXProcess.isAlive:()Z
+java/lang/UnknownError.<init>:()V
+java/lang/UnknownError.<init>:(Ljava/lang/String;)V
+java/lang/UnsatisfiedLinkError.<init>:()V
+java/lang/UnsatisfiedLinkError.<init>:(Ljava/lang/String;)V
+java/lang/UnsupportedClassVersionError.<init>:()V
+java/lang/UnsupportedClassVersionError.<init>:(Ljava/lang/String;)V
+java/lang/UnsupportedOperationException.<init>:()V
+java/lang/UnsupportedOperationException.<init>:(Ljava/lang/String;)V
+java/lang/UnsupportedOperationException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/VerifyError.<init>:()V
+java/lang/VerifyError.<init>:(Ljava/lang/String;)V
+java/lang/VirtualMachineError.<init>:()V
+java/lang/VirtualMachineError.<init>:(Ljava/lang/String;)V
+java/lang/VirtualMachineError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Void.<init>:()V
+java/lang/reflect/Array.newArray:(Ljava/lang/Class;I)Ljava/lang/Object;
\ No newline at end of file
diff --git a/experimental/sandbox/src/main/resources/java8.scan.java.lang_and_reflect b/experimental/sandbox/src/main/resources/java8.scan.java.lang_and_reflect
new file mode 100644
index 0000000000..ad2d2afcea
--- /dev/null
+++ b/experimental/sandbox/src/main/resources/java8.scan.java.lang_and_reflect
@@ -0,0 +1,1210 @@
+java/lang/AbstractMethodError.<init>:()V
+java/lang/AbstractMethodError.<init>:(Ljava/lang/String;)V
+java/lang/AbstractStringBuilder.<init>:()V
+java/lang/AbstractStringBuilder.<init>:(I)V
+java/lang/AbstractStringBuilder.capacity:()I
+java/lang/AbstractStringBuilder.charAt:(I)C
+java/lang/AbstractStringBuilder.codePointAt:(I)I
+java/lang/AbstractStringBuilder.codePointBefore:(I)I
+java/lang/AbstractStringBuilder.codePointCount:(II)I
+java/lang/AbstractStringBuilder.delete:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.deleteCharAt:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.getChars:(II[CI)V
+java/lang/AbstractStringBuilder.getValue:()[C
+java/lang/AbstractStringBuilder.indexOf:(Ljava/lang/String;)I
+java/lang/AbstractStringBuilder.indexOf:(Ljava/lang/String;I)I
+java/lang/AbstractStringBuilder.lastIndexOf:(Ljava/lang/String;)I
+java/lang/AbstractStringBuilder.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/AbstractStringBuilder.length:()I
+java/lang/AbstractStringBuilder.offsetByCodePoints:(II)I
+java/lang/AbstractStringBuilder.reverse:()Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.reverseAllValidSurrogatePairs:()V
+java/lang/AbstractStringBuilder.setCharAt:(IC)V
+java/lang/AbstractStringBuilder.toString:()Ljava/lang/String;
+java/lang/Appendable.append:(C)Ljava/lang/Appendable;
+java/lang/Appendable.append:(Ljava/lang/CharSequence;)Ljava/lang/Appendable;
+java/lang/Appendable.append:(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;
+java/lang/ApplicationShutdownHooks$1.<init>:()V
+java/lang/ApplicationShutdownHooks.<init>:()V
+java/lang/ArithmeticException.<init>:()V
+java/lang/ArithmeticException.<init>:(Ljava/lang/String;)V
+java/lang/ArrayIndexOutOfBoundsException.<init>:()V
+java/lang/ArrayIndexOutOfBoundsException.<init>:(Ljava/lang/String;)V
+java/lang/ArrayStoreException.<init>:()V
+java/lang/ArrayStoreException.<init>:(Ljava/lang/String;)V
+java/lang/AssertionError.<init>:()V
+java/lang/AssertionError.<init>:(C)V
+java/lang/AssertionError.<init>:(I)V
+java/lang/AssertionError.<init>:(J)V
+java/lang/AssertionError.<init>:(Ljava/lang/String;)V
+java/lang/AssertionError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/AssertionError.<init>:(Z)V
+java/lang/AssertionStatusDirectives.<init>:()V
+java/lang/AutoCloseable.close:()V
+java/lang/Boolean.<init>:(Ljava/lang/String;)V
+java/lang/Boolean.<init>:(Z)V
+java/lang/Boolean.booleanValue:()Z
+java/lang/Boolean.compare:(ZZ)I
+java/lang/Boolean.compareTo:(Ljava/lang/Boolean;)I
+java/lang/Boolean.compareTo:(Ljava/lang/Object;)I
+java/lang/Boolean.equals:(Ljava/lang/Object;)Z
+java/lang/Boolean.hashCode:()I
+java/lang/Boolean.hashCode:(Z)I
+java/lang/Boolean.logicalAnd:(ZZ)Z
+java/lang/Boolean.logicalOr:(ZZ)Z
+java/lang/Boolean.logicalXor:(ZZ)Z
+java/lang/Boolean.parseBoolean:(Ljava/lang/String;)Z
+java/lang/Boolean.toString:()Ljava/lang/String;
+java/lang/Boolean.toString:(Z)Ljava/lang/String;
+java/lang/Boolean.valueOf:(Ljava/lang/String;)Ljava/lang/Boolean;
+java/lang/Boolean.valueOf:(Z)Ljava/lang/Boolean;
+java/lang/BootstrapMethodError.<init>:()V
+java/lang/BootstrapMethodError.<init>:(Ljava/lang/String;)V
+java/lang/BootstrapMethodError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Byte$ByteCache.<clinit>:()V
+java/lang/Byte$ByteCache.<init>:()V
+java/lang/Byte.<init>:(B)V
+java/lang/Byte.byteValue:()B
+java/lang/Byte.compare:(BB)I
+java/lang/Byte.compareTo:(Ljava/lang/Byte;)I
+java/lang/Byte.compareTo:(Ljava/lang/Object;)I
+java/lang/Byte.doubleValue:()D
+java/lang/Byte.equals:(Ljava/lang/Object;)Z
+java/lang/Byte.floatValue:()F
+java/lang/Byte.hashCode:()I
+java/lang/Byte.hashCode:(B)I
+java/lang/Byte.intValue:()I
+java/lang/Byte.longValue:()J
+java/lang/Byte.shortValue:()S
+java/lang/Byte.toString:()Ljava/lang/String;
+java/lang/Byte.toUnsignedInt:(B)I
+java/lang/Byte.toUnsignedLong:(B)J
+java/lang/Byte.valueOf:(B)Ljava/lang/Byte;
+java/lang/CharSequence$1CharIterator.<init>:(Ljava/lang/CharSequence;)V
+java/lang/CharSequence$1CharIterator.hasNext:()Z
+java/lang/CharSequence$1CodePointIterator.<init>:(Ljava/lang/CharSequence;)V
+java/lang/CharSequence$1CodePointIterator.hasNext:()Z
+java/lang/CharSequence.charAt:(I)C
+java/lang/CharSequence.length:()I
+java/lang/CharSequence.subSequence:(II)Ljava/lang/CharSequence;
+java/lang/CharSequence.toString:()Ljava/lang/String;
+java/lang/Character$CharacterCache.<clinit>:()V
+java/lang/Character$CharacterCache.<init>:()V
+java/lang/Character$Subset.<init>:(Ljava/lang/String;)V
+java/lang/Character$Subset.equals:(Ljava/lang/Object;)Z
+java/lang/Character$Subset.toString:()Ljava/lang/String;
+java/lang/Character$UnicodeBlock.of:(C)Ljava/lang/Character$UnicodeBlock;
+java/lang/Character$UnicodeBlock.of:(I)Ljava/lang/Character$UnicodeBlock;
+java/lang/Character$UnicodeScript.<init>:(Ljava/lang/String;I)V
+java/lang/Character.<init>:(C)V
+java/lang/Character.charCount:(I)I
+java/lang/Character.charValue:()C
+java/lang/Character.codePointAt:(Ljava/lang/CharSequence;I)I
+java/lang/Character.codePointAt:([CI)I
+java/lang/Character.codePointAt:([CII)I
+java/lang/Character.codePointAtImpl:([CII)I
+java/lang/Character.codePointBefore:(Ljava/lang/CharSequence;I)I
+java/lang/Character.codePointBefore:([CI)I
+java/lang/Character.codePointBefore:([CII)I
+java/lang/Character.codePointBeforeImpl:([CII)I
+java/lang/Character.codePointCount:(Ljava/lang/CharSequence;II)I
+java/lang/Character.codePointCount:([CII)I
+java/lang/Character.codePointCountImpl:([CII)I
+java/lang/Character.compare:(CC)I
+java/lang/Character.compareTo:(Ljava/lang/Character;)I
+java/lang/Character.compareTo:(Ljava/lang/Object;)I
+java/lang/Character.digit:(CI)I
+java/lang/Character.digit:(II)I
+java/lang/Character.equals:(Ljava/lang/Object;)Z
+java/lang/Character.forDigit:(II)C
+java/lang/Character.getDirectionality:(C)B
+java/lang/Character.getDirectionality:(I)B
+java/lang/Character.getNumericValue:(C)I
+java/lang/Character.getNumericValue:(I)I
+java/lang/Character.getType:(C)I
+java/lang/Character.getType:(I)I
+java/lang/Character.hashCode:()I
+java/lang/Character.hashCode:(C)I
+java/lang/Character.highSurrogate:(I)C
+java/lang/Character.isAlphabetic:(I)Z
+java/lang/Character.isBmpCodePoint:(I)Z
+java/lang/Character.isDefined:(C)Z
+java/lang/Character.isDefined:(I)Z
+java/lang/Character.isDigit:(C)Z
+java/lang/Character.isDigit:(I)Z
+java/lang/Character.isHighSurrogate:(C)Z
+java/lang/Character.isISOControl:(C)Z
+java/lang/Character.isISOControl:(I)Z
+java/lang/Character.isIdentifierIgnorable:(C)Z
+java/lang/Character.isIdentifierIgnorable:(I)Z
+java/lang/Character.isIdeographic:(I)Z
+java/lang/Character.isJavaIdentifierPart:(C)Z
+java/lang/Character.isJavaIdentifierPart:(I)Z
+java/lang/Character.isJavaIdentifierStart:(C)Z
+java/lang/Character.isJavaIdentifierStart:(I)Z
+java/lang/Character.isJavaLetter:(C)Z
+java/lang/Character.isJavaLetterOrDigit:(C)Z
+java/lang/Character.isLetter:(C)Z
+java/lang/Character.isLetter:(I)Z
+java/lang/Character.isLetterOrDigit:(C)Z
+java/lang/Character.isLetterOrDigit:(I)Z
+java/lang/Character.isLowSurrogate:(C)Z
+java/lang/Character.isLowerCase:(C)Z
+java/lang/Character.isLowerCase:(I)Z
+java/lang/Character.isMirrored:(C)Z
+java/lang/Character.isMirrored:(I)Z
+java/lang/Character.isSpace:(C)Z
+java/lang/Character.isSpaceChar:(C)Z
+java/lang/Character.isSpaceChar:(I)Z
+java/lang/Character.isSupplementaryCodePoint:(I)Z
+java/lang/Character.isSurrogate:(C)Z
+java/lang/Character.isSurrogatePair:(CC)Z
+java/lang/Character.isTitleCase:(C)Z
+java/lang/Character.isTitleCase:(I)Z
+java/lang/Character.isUnicodeIdentifierPart:(C)Z
+java/lang/Character.isUnicodeIdentifierPart:(I)Z
+java/lang/Character.isUnicodeIdentifierStart:(C)Z
+java/lang/Character.isUnicodeIdentifierStart:(I)Z
+java/lang/Character.isUpperCase:(C)Z
+java/lang/Character.isUpperCase:(I)Z
+java/lang/Character.isValidCodePoint:(I)Z
+java/lang/Character.isWhitespace:(C)Z
+java/lang/Character.isWhitespace:(I)Z
+java/lang/Character.lowSurrogate:(I)C
+java/lang/Character.offsetByCodePoints:(Ljava/lang/CharSequence;II)I
+java/lang/Character.offsetByCodePoints:([CIIII)I
+java/lang/Character.offsetByCodePointsImpl:([CIIII)I
+java/lang/Character.reverseBytes:(C)C
+java/lang/Character.toChars:(I)[C
+java/lang/Character.toChars:(I[CI)I
+java/lang/Character.toCodePoint:(CC)I
+java/lang/Character.toLowerCase:(C)C
+java/lang/Character.toLowerCase:(I)I
+java/lang/Character.toString:(C)Ljava/lang/String;
+java/lang/Character.toSurrogates:(I[CI)V
+java/lang/Character.toTitleCase:(C)C
+java/lang/Character.toTitleCase:(I)I
+java/lang/Character.toUpperCase:(C)C
+java/lang/Character.toUpperCase:(I)I
+java/lang/Character.toUpperCaseCharArray:(I)[C
+java/lang/Character.toUpperCaseEx:(I)I
+java/lang/Character.valueOf:(C)Ljava/lang/Character;
+java/lang/CharacterData.<init>:()V
+java/lang/CharacterData.digit:(II)I
+java/lang/CharacterData.getDirectionality:(I)B
+java/lang/CharacterData.getNumericValue:(I)I
+java/lang/CharacterData.getProperties:(I)I
+java/lang/CharacterData.getType:(I)I
+java/lang/CharacterData.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData.isIdeographic:(I)Z
+java/lang/CharacterData.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData.isMirrored:(I)Z
+java/lang/CharacterData.isOtherAlphabetic:(I)Z
+java/lang/CharacterData.isOtherLowercase:(I)Z
+java/lang/CharacterData.isOtherUppercase:(I)Z
+java/lang/CharacterData.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData.isWhitespace:(I)Z
+java/lang/CharacterData.of:(I)Ljava/lang/CharacterData;
+java/lang/CharacterData.toLowerCase:(I)I
+java/lang/CharacterData.toTitleCase:(I)I
+java/lang/CharacterData.toUpperCase:(I)I
+java/lang/CharacterData.toUpperCaseCharArray:(I)[C
+java/lang/CharacterData.toUpperCaseEx:(I)I
+java/lang/CharacterData00.<init>:()V
+java/lang/CharacterData00.digit:(II)I
+java/lang/CharacterData00.findInCharMap:(I)I
+java/lang/CharacterData00.getDirectionality:(I)B
+java/lang/CharacterData00.getNumericValue:(I)I
+java/lang/CharacterData00.getProperties:(I)I
+java/lang/CharacterData00.getPropertiesEx:(I)I
+java/lang/CharacterData00.getType:(I)I
+java/lang/CharacterData00.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData00.isIdeographic:(I)Z
+java/lang/CharacterData00.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData00.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData00.isMirrored:(I)Z
+java/lang/CharacterData00.isOtherAlphabetic:(I)Z
+java/lang/CharacterData00.isOtherLowercase:(I)Z
+java/lang/CharacterData00.isOtherUppercase:(I)Z
+java/lang/CharacterData00.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData00.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData00.isWhitespace:(I)Z
+java/lang/CharacterData00.toLowerCase:(I)I
+java/lang/CharacterData00.toTitleCase:(I)I
+java/lang/CharacterData00.toUpperCase:(I)I
+java/lang/CharacterData00.toUpperCaseCharArray:(I)[C
+java/lang/CharacterData00.toUpperCaseEx:(I)I
+java/lang/CharacterData01.<init>:()V
+java/lang/CharacterData01.digit:(II)I
+java/lang/CharacterData01.getDirectionality:(I)B
+java/lang/CharacterData01.getNumericValue:(I)I
+java/lang/CharacterData01.getProperties:(I)I
+java/lang/CharacterData01.getPropertiesEx:(I)I
+java/lang/CharacterData01.getType:(I)I
+java/lang/CharacterData01.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData01.isIdeographic:(I)Z
+java/lang/CharacterData01.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData01.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData01.isMirrored:(I)Z
+java/lang/CharacterData01.isOtherAlphabetic:(I)Z
+java/lang/CharacterData01.isOtherLowercase:(I)Z
+java/lang/CharacterData01.isOtherUppercase:(I)Z
+java/lang/CharacterData01.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData01.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData01.isWhitespace:(I)Z
+java/lang/CharacterData01.toLowerCase:(I)I
+java/lang/CharacterData01.toTitleCase:(I)I
+java/lang/CharacterData01.toUpperCase:(I)I
+java/lang/CharacterData02.<init>:()V
+java/lang/CharacterData02.digit:(II)I
+java/lang/CharacterData02.getDirectionality:(I)B
+java/lang/CharacterData02.getNumericValue:(I)I
+java/lang/CharacterData02.getProperties:(I)I
+java/lang/CharacterData02.getPropertiesEx:(I)I
+java/lang/CharacterData02.getType:(I)I
+java/lang/CharacterData02.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData02.isIdeographic:(I)Z
+java/lang/CharacterData02.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData02.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData02.isMirrored:(I)Z
+java/lang/CharacterData02.isOtherAlphabetic:(I)Z
+java/lang/CharacterData02.isOtherLowercase:(I)Z
+java/lang/CharacterData02.isOtherUppercase:(I)Z
+java/lang/CharacterData02.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData02.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData02.isWhitespace:(I)Z
+java/lang/CharacterData02.toLowerCase:(I)I
+java/lang/CharacterData02.toTitleCase:(I)I
+java/lang/CharacterData02.toUpperCase:(I)I
+java/lang/CharacterData0E.<init>:()V
+java/lang/CharacterData0E.digit:(II)I
+java/lang/CharacterData0E.getDirectionality:(I)B
+java/lang/CharacterData0E.getNumericValue:(I)I
+java/lang/CharacterData0E.getProperties:(I)I
+java/lang/CharacterData0E.getPropertiesEx:(I)I
+java/lang/CharacterData0E.getType:(I)I
+java/lang/CharacterData0E.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData0E.isIdeographic:(I)Z
+java/lang/CharacterData0E.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData0E.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData0E.isMirrored:(I)Z
+java/lang/CharacterData0E.isOtherAlphabetic:(I)Z
+java/lang/CharacterData0E.isOtherLowercase:(I)Z
+java/lang/CharacterData0E.isOtherUppercase:(I)Z
+java/lang/CharacterData0E.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData0E.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData0E.isWhitespace:(I)Z
+java/lang/CharacterData0E.toLowerCase:(I)I
+java/lang/CharacterData0E.toTitleCase:(I)I
+java/lang/CharacterData0E.toUpperCase:(I)I
+java/lang/CharacterDataLatin1.<init>:()V
+java/lang/CharacterDataLatin1.digit:(II)I
+java/lang/CharacterDataLatin1.getDirectionality:(I)B
+java/lang/CharacterDataLatin1.getNumericValue:(I)I
+java/lang/CharacterDataLatin1.getProperties:(I)I
+java/lang/CharacterDataLatin1.getPropertiesEx:(I)I
+java/lang/CharacterDataLatin1.getType:(I)I
+java/lang/CharacterDataLatin1.isIdentifierIgnorable:(I)Z
+java/lang/CharacterDataLatin1.isIdeographic:(I)Z
+java/lang/CharacterDataLatin1.isJavaIdentifierPart:(I)Z
+java/lang/CharacterDataLatin1.isJavaIdentifierStart:(I)Z
+java/lang/CharacterDataLatin1.isMirrored:(I)Z
+java/lang/CharacterDataLatin1.isOtherAlphabetic:(I)Z
+java/lang/CharacterDataLatin1.isOtherLowercase:(I)Z
+java/lang/CharacterDataLatin1.isOtherUppercase:(I)Z
+java/lang/CharacterDataLatin1.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterDataLatin1.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterDataLatin1.isWhitespace:(I)Z
+java/lang/CharacterDataLatin1.toLowerCase:(I)I
+java/lang/CharacterDataLatin1.toTitleCase:(I)I
+java/lang/CharacterDataLatin1.toUpperCase:(I)I
+java/lang/CharacterDataLatin1.toUpperCaseCharArray:(I)[C
+java/lang/CharacterDataLatin1.toUpperCaseEx:(I)I
+java/lang/CharacterDataPrivateUse.<clinit>:()V
+java/lang/CharacterDataPrivateUse.<init>:()V
+java/lang/CharacterDataPrivateUse.digit:(II)I
+java/lang/CharacterDataPrivateUse.getDirectionality:(I)B
+java/lang/CharacterDataPrivateUse.getNumericValue:(I)I
+java/lang/CharacterDataPrivateUse.getProperties:(I)I
+java/lang/CharacterDataPrivateUse.getType:(I)I
+java/lang/CharacterDataPrivateUse.isIdentifierIgnorable:(I)Z
+java/lang/CharacterDataPrivateUse.isJavaIdentifierPart:(I)Z
+java/lang/CharacterDataPrivateUse.isJavaIdentifierStart:(I)Z
+java/lang/CharacterDataPrivateUse.isMirrored:(I)Z
+java/lang/CharacterDataPrivateUse.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterDataPrivateUse.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterDataPrivateUse.isWhitespace:(I)Z
+java/lang/CharacterDataPrivateUse.toLowerCase:(I)I
+java/lang/CharacterDataPrivateUse.toTitleCase:(I)I
+java/lang/CharacterDataPrivateUse.toUpperCase:(I)I
+java/lang/CharacterDataUndefined.<clinit>:()V
+java/lang/CharacterDataUndefined.<init>:()V
+java/lang/CharacterDataUndefined.digit:(II)I
+java/lang/CharacterDataUndefined.getDirectionality:(I)B
+java/lang/CharacterDataUndefined.getNumericValue:(I)I
+java/lang/CharacterDataUndefined.getProperties:(I)I
+java/lang/CharacterDataUndefined.getType:(I)I
+java/lang/CharacterDataUndefined.isIdentifierIgnorable:(I)Z
+java/lang/CharacterDataUndefined.isJavaIdentifierPart:(I)Z
+java/lang/CharacterDataUndefined.isJavaIdentifierStart:(I)Z
+java/lang/CharacterDataUndefined.isMirrored:(I)Z
+java/lang/CharacterDataUndefined.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterDataUndefined.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterDataUndefined.isWhitespace:(I)Z
+java/lang/CharacterDataUndefined.toLowerCase:(I)I
+java/lang/CharacterDataUndefined.toTitleCase:(I)I
+java/lang/CharacterDataUndefined.toUpperCase:(I)I
+java/lang/CharacterName$1.<init>:()V
+java/lang/CharacterName.<init>:()V
+java/lang/Class$1.<init>:(Ljava/lang/Class;Ljava/lang/reflect/Constructor;)V
+java/lang/Class$2.<init>:(Ljava/lang/Class;)V
+java/lang/Class$3.<init>:()V
+java/lang/Class$4.<init>:(Ljava/lang/Class;Ljava/lang/reflect/Method;)V
+java/lang/Class$AnnotationData.<init>:(Ljava/util/Map;Ljava/util/Map;I)V
+java/lang/Class$Atomic.<init>:()V
+java/lang/Class$EnclosingMethodInfo.<init>:([Ljava/lang/Object;)V
+java/lang/Class$EnclosingMethodInfo.<init>:([Ljava/lang/Object;Ljava/lang/Class$1;)V
+java/lang/Class$EnclosingMethodInfo.getDescriptor:()Ljava/lang/String;
+java/lang/Class$EnclosingMethodInfo.getEnclosingClass:()Ljava/lang/Class;
+java/lang/Class$EnclosingMethodInfo.getName:()Ljava/lang/String;
+java/lang/Class$EnclosingMethodInfo.isConstructor:()Z
+java/lang/Class$EnclosingMethodInfo.isMethod:()Z
+java/lang/Class$EnclosingMethodInfo.isPartial:()Z
+java/lang/Class$MethodArray.<init>:()V
+java/lang/Class$MethodArray.<init>:(I)V
+java/lang/Class$MethodArray.get:(I)Ljava/lang/reflect/Method;
+java/lang/Class$MethodArray.getArray:()[Ljava/lang/reflect/Method;
+java/lang/Class$MethodArray.getFirst:()Ljava/lang/reflect/Method;
+java/lang/Class$MethodArray.hasDefaults:()Z
+java/lang/Class$MethodArray.length:()I
+java/lang/Class$ReflectionData.<init>:(I)V
+java/lang/Class.<init>:()V
+java/lang/Class.access$300:([Ljava/lang/Object;[Ljava/lang/Object;)Z
+java/lang/Class.access$402:(Z)Z
+java/lang/Class.access$502:(Z)Z
+java/lang/Class.arrayContentsEq:([Ljava/lang/Object;[Ljava/lang/Object;)Z
+java/lang/Class.getAnnotationType:()Lsun/reflect/annotation/AnnotationType;
+java/lang/Class.getComponentType:()Ljava/lang/Class;
+java/lang/Class.isAsciiDigit:(C)Z
+java/lang/ClassCastException.<init>:()V
+java/lang/ClassCastException.<init>:(Ljava/lang/String;)V
+java/lang/ClassCircularityError.<init>:()V
+java/lang/ClassCircularityError.<init>:(Ljava/lang/String;)V
+java/lang/ClassFormatError.<init>:()V
+java/lang/ClassFormatError.<init>:(Ljava/lang/String;)V
+java/lang/ClassLoader$1.<init>:(Ljava/lang/ClassLoader;Ljava/lang/SecurityManager;Ljava/lang/String;I)V
+java/lang/ClassLoader$2.<init>:(Ljava/util/Enumeration;)V
+java/lang/ClassLoader$3.<init>:(Ljava/io/File;)V
+java/lang/ClassLoader$NativeLibrary.<init>:(Ljava/lang/Class;Ljava/lang/String;Z)V
+java/lang/ClassLoader$NativeLibrary.access$200:(Ljava/lang/ClassLoader$NativeLibrary;)Ljava/lang/Class;
+java/lang/ClassLoader$ParallelLoaders.<init>:()V
+java/lang/ClassLoader.access$000:()Ljava/util/Vector;
+java/lang/ClassLoader.access$100:()Ljava/util/Stack;
+java/lang/ClassLoader.findClass:(Ljava/lang/String;)Ljava/lang/Class;
+java/lang/ClassLoader.findLibrary:(Ljava/lang/String;)Ljava/lang/String;
+java/lang/ClassLoader.findResource:(Ljava/lang/String;)Ljava/net/URL;
+java/lang/ClassLoader.isAncestor:(Ljava/lang/ClassLoader;)Z
+java/lang/ClassLoader.needsClassLoaderPermissionCheck:(Ljava/lang/ClassLoader;Ljava/lang/ClassLoader;)Z
+java/lang/ClassLoaderHelper.<init>:()V
+java/lang/ClassNotFoundException.<init>:(Ljava/lang/String;)V
+java/lang/ClassNotFoundException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/ClassNotFoundException.getCause:()Ljava/lang/Throwable;
+java/lang/ClassNotFoundException.getException:()Ljava/lang/Throwable;
+java/lang/ClassValue$ClassValueMap.getCache:()[Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue$ClassValueMap.loadFromCache:([Ljava/lang/ClassValue$Entry;I)Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue$ClassValueMap.probeHomeLocation:([Ljava/lang/ClassValue$Entry;Ljava/lang/ClassValue;)Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue$ClassValueMap.sizeCache:(I)V
+java/lang/ClassValue$Entry.assertNotPromise:()V
+java/lang/ClassValue$Entry.isPromise:()Z
+java/lang/ClassValue$Entry.value:()Ljava/lang/Object;
+java/lang/ClassValue$Identity.<init>:()V
+java/lang/ClassValue$Version.classValue:()Ljava/lang/ClassValue;
+java/lang/ClassValue$Version.isLive:()Z
+java/lang/ClassValue$Version.promise:()Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue.castEntry:(Ljava/lang/ClassValue$Entry;)Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue.computeValue:(Ljava/lang/Class;)Ljava/lang/Object;
+java/lang/ClassValue.getCacheCarefully:(Ljava/lang/Class;)[Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue.version:()Ljava/lang/ClassValue$Version;
+java/lang/CloneNotSupportedException.<init>:()V
+java/lang/CloneNotSupportedException.<init>:(Ljava/lang/String;)V
+java/lang/Comparable.compareTo:(Ljava/lang/Object;)I
+java/lang/Compiler$1.<init>:()V
+java/lang/Compiler.<init>:()V
+java/lang/ConditionalSpecialCasing$Entry.<init>:(I[C[CLjava/lang/String;I)V
+java/lang/ConditionalSpecialCasing$Entry.getCodePoint:()I
+java/lang/ConditionalSpecialCasing$Entry.getCondition:()I
+java/lang/ConditionalSpecialCasing$Entry.getLanguage:()Ljava/lang/String;
+java/lang/ConditionalSpecialCasing$Entry.getLowerCase:()[C
+java/lang/ConditionalSpecialCasing$Entry.getUpperCase:()[C
+java/lang/ConditionalSpecialCasing.<init>:()V
+java/lang/ConditionalSpecialCasing.isCased:(I)Z
+java/lang/ConditionalSpecialCasing.isSoftDotted:(I)Z
+java/lang/Double.<init>:(D)V
+java/lang/Double.byteValue:()B
+java/lang/Double.doubleValue:()D
+java/lang/Double.floatValue:()F
+java/lang/Double.intValue:()I
+java/lang/Double.isFinite:(D)Z
+java/lang/Double.isInfinite:()Z
+java/lang/Double.isInfinite:(D)Z
+java/lang/Double.isNaN:()Z
+java/lang/Double.isNaN:(D)Z
+java/lang/Double.longValue:()J
+java/lang/Double.shortValue:()S
+java/lang/Double.sum:(DD)D
+java/lang/Double.valueOf:(D)Ljava/lang/Double;
+java/lang/Enum.<init>:(Ljava/lang/String;I)V
+java/lang/Enum.clone:()Ljava/lang/Object;
+java/lang/Enum.equals:(Ljava/lang/Object;)Z
+java/lang/Enum.name:()Ljava/lang/String;
+java/lang/Enum.ordinal:()I
+java/lang/Enum.toString:()Ljava/lang/String;
+java/lang/EnumConstantNotPresentException.constantName:()Ljava/lang/String;
+java/lang/EnumConstantNotPresentException.enumType:()Ljava/lang/Class;
+java/lang/Error.<init>:()V
+java/lang/Error.<init>:(Ljava/lang/String;)V
+java/lang/Error.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Error.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/Exception.<init>:()V
+java/lang/Exception.<init>:(Ljava/lang/String;)V
+java/lang/Exception.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Exception.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/ExceptionInInitializerError.getCause:()Ljava/lang/Throwable;
+java/lang/ExceptionInInitializerError.getException:()Ljava/lang/Throwable;
+java/lang/Float.<init>:(D)V
+java/lang/Float.<init>:(F)V
+java/lang/Float.byteValue:()B
+java/lang/Float.doubleValue:()D
+java/lang/Float.floatValue:()F
+java/lang/Float.intValue:()I
+java/lang/Float.isFinite:(F)Z
+java/lang/Float.isInfinite:()Z
+java/lang/Float.isInfinite:(F)Z
+java/lang/Float.isNaN:()Z
+java/lang/Float.isNaN:(F)Z
+java/lang/Float.longValue:()J
+java/lang/Float.shortValue:()S
+java/lang/Float.sum:(FF)F
+java/lang/Float.valueOf:(F)Ljava/lang/Float;
+java/lang/IllegalAccessError.<init>:()V
+java/lang/IllegalAccessError.<init>:(Ljava/lang/String;)V
+java/lang/IllegalAccessException.<init>:()V
+java/lang/IllegalAccessException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalArgumentException.<init>:()V
+java/lang/IllegalArgumentException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalArgumentException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/IllegalMonitorStateException.<init>:()V
+java/lang/IllegalMonitorStateException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalStateException.<init>:()V
+java/lang/IllegalStateException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalStateException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/IllegalThreadStateException.<init>:()V
+java/lang/IllegalThreadStateException.<init>:(Ljava/lang/String;)V
+java/lang/IncompatibleClassChangeError.<init>:()V
+java/lang/IncompatibleClassChangeError.<init>:(Ljava/lang/String;)V
+java/lang/IndexOutOfBoundsException.<init>:()V
+java/lang/IndexOutOfBoundsException.<init>:(Ljava/lang/String;)V
+java/lang/InheritableThreadLocal.childValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/InheritableThreadLocal.getMap:(Ljava/lang/Thread;)Ljava/lang/ThreadLocal$ThreadLocalMap;
+java/lang/InstantiationError.<init>:()V
+java/lang/InstantiationError.<init>:(Ljava/lang/String;)V
+java/lang/InstantiationException.<init>:()V
+java/lang/InstantiationException.<init>:(Ljava/lang/String;)V
+java/lang/Integer$IntegerCache.<init>:()V
+java/lang/Integer.<init>:(I)V
+java/lang/Integer.bitCount:(I)I
+java/lang/Integer.byteValue:()B
+java/lang/Integer.compare:(II)I
+java/lang/Integer.compareTo:(Ljava/lang/Integer;)I
+java/lang/Integer.compareTo:(Ljava/lang/Object;)I
+java/lang/Integer.compareUnsigned:(II)I
+java/lang/Integer.divideUnsigned:(II)I
+java/lang/Integer.doubleValue:()D
+java/lang/Integer.equals:(Ljava/lang/Object;)Z
+java/lang/Integer.floatValue:()F
+java/lang/Integer.formatUnsignedInt:(II[CII)I
+java/lang/Integer.getChars:(II[C)V
+java/lang/Integer.hashCode:()I
+java/lang/Integer.hashCode:(I)I
+java/lang/Integer.highestOneBit:(I)I
+java/lang/Integer.intValue:()I
+java/lang/Integer.longValue:()J
+java/lang/Integer.lowestOneBit:(I)I
+java/lang/Integer.max:(II)I
+java/lang/Integer.min:(II)I
+java/lang/Integer.numberOfLeadingZeros:(I)I
+java/lang/Integer.numberOfTrailingZeros:(I)I
+java/lang/Integer.remainderUnsigned:(II)I
+java/lang/Integer.reverse:(I)I
+java/lang/Integer.reverseBytes:(I)I
+java/lang/Integer.rotateLeft:(II)I
+java/lang/Integer.rotateRight:(II)I
+java/lang/Integer.shortValue:()S
+java/lang/Integer.signum:(I)I
+java/lang/Integer.stringSize:(I)I
+java/lang/Integer.sum:(II)I
+java/lang/Integer.toBinaryString:(I)Ljava/lang/String;
+java/lang/Integer.toHexString:(I)Ljava/lang/String;
+java/lang/Integer.toOctalString:(I)Ljava/lang/String;
+java/lang/Integer.toString:()Ljava/lang/String;
+java/lang/Integer.toString:(I)Ljava/lang/String;
+java/lang/Integer.toUnsignedLong:(I)J
+java/lang/Integer.toUnsignedString0:(II)Ljava/lang/String;
+java/lang/Integer.toUnsignedString:(I)Ljava/lang/String;
+java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
+java/lang/InternalError.<init>:()V
+java/lang/InternalError.<init>:(Ljava/lang/String;)V
+java/lang/InternalError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/InterruptedException.<init>:()V
+java/lang/InterruptedException.<init>:(Ljava/lang/String;)V
+java/lang/Iterable.iterator:()Ljava/util/Iterator;
+java/lang/LinkageError.<init>:()V
+java/lang/LinkageError.<init>:(Ljava/lang/String;)V
+java/lang/LinkageError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Long$LongCache.<clinit>:()V
+java/lang/Long$LongCache.<init>:()V
+java/lang/Long.<init>:(J)V
+java/lang/Long.bitCount:(J)I
+java/lang/Long.byteValue:()B
+java/lang/Long.compare:(JJ)I
+java/lang/Long.compareTo:(Ljava/lang/Long;)I
+java/lang/Long.compareTo:(Ljava/lang/Object;)I
+java/lang/Long.compareUnsigned:(JJ)I
+java/lang/Long.doubleValue:()D
+java/lang/Long.equals:(Ljava/lang/Object;)Z
+java/lang/Long.floatValue:()F
+java/lang/Long.formatUnsignedLong:(JI[CII)I
+java/lang/Long.getChars:(JI[C)V
+java/lang/Long.hashCode:()I
+java/lang/Long.hashCode:(J)I
+java/lang/Long.highestOneBit:(J)J
+java/lang/Long.intValue:()I
+java/lang/Long.longValue:()J
+java/lang/Long.lowestOneBit:(J)J
+java/lang/Long.max:(JJ)J
+java/lang/Long.min:(JJ)J
+java/lang/Long.numberOfLeadingZeros:(J)I
+java/lang/Long.numberOfTrailingZeros:(J)I
+java/lang/Long.reverse:(J)J
+java/lang/Long.reverseBytes:(J)J
+java/lang/Long.rotateLeft:(JI)J
+java/lang/Long.rotateRight:(JI)J
+java/lang/Long.shortValue:()S
+java/lang/Long.signum:(J)I
+java/lang/Long.stringSize:(J)I
+java/lang/Long.sum:(JJ)J
+java/lang/Long.toBinaryString:(J)Ljava/lang/String;
+java/lang/Long.toHexString:(J)Ljava/lang/String;
+java/lang/Long.toOctalString:(J)Ljava/lang/String;
+java/lang/Long.toString:()Ljava/lang/String;
+java/lang/Long.toString:(J)Ljava/lang/String;
+java/lang/Long.toUnsignedString0:(JI)Ljava/lang/String;
+java/lang/Long.valueOf:(J)Ljava/lang/Long;
+java/lang/Math$RandomNumberGeneratorHolder.<init>:()V
+java/lang/Math.<init>:()V
+java/lang/Math.abs:(D)D
+java/lang/Math.abs:(F)F
+java/lang/Math.abs:(I)I
+java/lang/Math.abs:(J)J
+java/lang/Math.addExact:(II)I
+java/lang/Math.addExact:(JJ)J
+java/lang/Math.decrementExact:(I)I
+java/lang/Math.decrementExact:(J)J
+java/lang/Math.floorDiv:(II)I
+java/lang/Math.floorDiv:(JJ)J
+java/lang/Math.floorMod:(II)I
+java/lang/Math.floorMod:(JJ)J
+java/lang/Math.incrementExact:(I)I
+java/lang/Math.incrementExact:(J)J
+java/lang/Math.max:(II)I
+java/lang/Math.max:(JJ)J
+java/lang/Math.min:(II)I
+java/lang/Math.min:(JJ)J
+java/lang/Math.multiplyExact:(II)I
+java/lang/Math.multiplyExact:(JJ)J
+java/lang/Math.negateExact:(I)I
+java/lang/Math.negateExact:(J)J
+java/lang/Math.subtractExact:(II)I
+java/lang/Math.subtractExact:(JJ)J
+java/lang/Math.toDegrees:(D)D
+java/lang/Math.toIntExact:(J)I
+java/lang/Math.toRadians:(D)D
+java/lang/NegativeArraySizeException.<init>:()V
+java/lang/NegativeArraySizeException.<init>:(Ljava/lang/String;)V
+java/lang/NoClassDefFoundError.<init>:()V
+java/lang/NoClassDefFoundError.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchFieldError.<init>:()V
+java/lang/NoSuchFieldError.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchFieldException.<init>:()V
+java/lang/NoSuchFieldException.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchMethodError.<init>:()V
+java/lang/NoSuchMethodError.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchMethodException.<init>:()V
+java/lang/NoSuchMethodException.<init>:(Ljava/lang/String;)V
+java/lang/NullPointerException.<init>:()V
+java/lang/NullPointerException.<init>:(Ljava/lang/String;)V
+java/lang/Number.<init>:()V
+java/lang/Number.byteValue:()B
+java/lang/Number.doubleValue:()D
+java/lang/Number.floatValue:()F
+java/lang/Number.intValue:()I
+java/lang/Number.longValue:()J
+java/lang/Number.shortValue:()S
+java/lang/NumberFormatException.<init>:()V
+java/lang/NumberFormatException.<init>:(Ljava/lang/String;)V
+java/lang/Object.<init>:()V
+java/lang/Object.equals:(Ljava/lang/Object;)Z
+java/lang/Object.getClass:()Ljava/lang/Class;
+java/lang/OutOfMemoryError.<init>:()V
+java/lang/OutOfMemoryError.<init>:(Ljava/lang/String;)V
+java/lang/Package$1.<init>:(Ljava/lang/String;Ljava/lang/String;)V
+java/lang/Package$1PackageInfoProxy.<init>:(Ljava/lang/Package;)V
+java/lang/Package.<init>:(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/net/URL;Ljava/lang/ClassLoader;)V
+java/lang/Package.access$000:()Ljava/util/Map;
+java/lang/Package.access$200:()Ljava/util/Map;
+java/lang/Package.access$400:()Ljava/util/Map;
+java/lang/Package.getImplementationTitle:()Ljava/lang/String;
+java/lang/Package.getImplementationVendor:()Ljava/lang/String;
+java/lang/Package.getImplementationVersion:()Ljava/lang/String;
+java/lang/Package.getName:()Ljava/lang/String;
+java/lang/Package.getSpecificationTitle:()Ljava/lang/String;
+java/lang/Package.getSpecificationVendor:()Ljava/lang/String;
+java/lang/Package.getSpecificationVersion:()Ljava/lang/String;
+java/lang/Package.hashCode:()I
+java/lang/Package.isSealed:()Z
+java/lang/Process.<init>:()V
+java/lang/Process.destroy:()V
+java/lang/Process.destroyForcibly:()Ljava/lang/Process;
+java/lang/Process.exitValue:()I
+java/lang/Process.getErrorStream:()Ljava/io/InputStream;
+java/lang/Process.getInputStream:()Ljava/io/InputStream;
+java/lang/Process.getOutputStream:()Ljava/io/OutputStream;
+java/lang/Process.isAlive:()Z
+java/lang/Process.waitFor:()I
+java/lang/ProcessBuilder$NullInputStream.available:()I
+java/lang/ProcessBuilder$NullInputStream.read:()I
+java/lang/ProcessBuilder$Redirect$1.<init>:()V
+java/lang/ProcessBuilder$Redirect$1.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$2.<init>:()V
+java/lang/ProcessBuilder$Redirect$2.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$3.<init>:(Ljava/io/File;)V
+java/lang/ProcessBuilder$Redirect$3.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect$3.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$4.<init>:(Ljava/io/File;)V
+java/lang/ProcessBuilder$Redirect$4.append:()Z
+java/lang/ProcessBuilder$Redirect$4.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect$4.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$5.<init>:(Ljava/io/File;)V
+java/lang/ProcessBuilder$Redirect$5.append:()Z
+java/lang/ProcessBuilder$Redirect$5.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect$5.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$Type.<clinit>:()V
+java/lang/ProcessBuilder$Redirect$Type.<init>:(Ljava/lang/String;I)V
+java/lang/ProcessBuilder$Redirect.<init>:()V
+java/lang/ProcessBuilder$Redirect.<init>:(Ljava/lang/ProcessBuilder$1;)V
+java/lang/ProcessBuilder$Redirect.append:()Z
+java/lang/ProcessBuilder$Redirect.appendTo:(Ljava/io/File;)Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder$Redirect.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect.from:(Ljava/io/File;)Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder$Redirect.to:(Ljava/io/File;)Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder$Redirect.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder.<init>:(Ljava/util/List;)V
+java/lang/ProcessBuilder.command:()Ljava/util/List;
+java/lang/ProcessBuilder.command:(Ljava/util/List;)Ljava/lang/ProcessBuilder;
+java/lang/ProcessBuilder.directory:()Ljava/io/File;
+java/lang/ProcessBuilder.directory:(Ljava/io/File;)Ljava/lang/ProcessBuilder;
+java/lang/ProcessBuilder.redirectError:()Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder.redirectErrorStream:()Z
+java/lang/ProcessBuilder.redirectErrorStream:(Z)Ljava/lang/ProcessBuilder;
+java/lang/ProcessBuilder.redirectInput:()Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder.redirectOutput:()Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder.redirects:()[Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessEnvironment$ExternalData.<init>:(Ljava/lang/String;[B)V
+java/lang/ProcessEnvironment$ExternalData.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$ExternalData.getBytes:()[B
+java/lang/ProcessEnvironment$ExternalData.hashCode:()I
+java/lang/ProcessEnvironment$ExternalData.toString:()Ljava/lang/String;
+java/lang/ProcessEnvironment$StringEntry.<init>:(Ljava/util/Map$Entry;)V
+java/lang/ProcessEnvironment$StringEntry.access$600:(Ljava/lang/ProcessEnvironment$StringEntry;)Ljava/util/Map$Entry;
+java/lang/ProcessEnvironment$StringEntrySet$2.<init>:(Ljava/lang/Object;)V
+java/lang/ProcessEnvironment$StringEntrySet$2.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/ProcessEnvironment$StringEntrySet$2.setValue:(Ljava/lang/ProcessEnvironment$Value;)Ljava/lang/ProcessEnvironment$Value;
+java/lang/ProcessEnvironment$StringEntrySet.access$500:(Ljava/lang/ProcessEnvironment$StringEntrySet;)Ljava/util/Set;
+java/lang/ProcessEnvironment$StringEntrySet.vvEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/lang/ProcessEnvironment$StringKeySet.access$800:(Ljava/lang/ProcessEnvironment$StringKeySet;)Ljava/util/Set;
+java/lang/ProcessEnvironment$StringValues.access$700:(Ljava/lang/ProcessEnvironment$StringValues;)Ljava/util/Collection;
+java/lang/ProcessEnvironment$Value.<init>:(Ljava/lang/String;[B)V
+java/lang/ProcessEnvironment$Value.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$Variable.<init>:(Ljava/lang/String;[B)V
+java/lang/ProcessEnvironment$Variable.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment.<init>:()V
+java/lang/ProcessEnvironment.access$000:([B[B)Z
+java/lang/ProcessEnvironment.access$100:([B)I
+java/lang/ProcessEnvironment.access$300:([B[B)I
+java/lang/ProcessEnvironment.arrayCompare:([B[B)I
+java/lang/ProcessEnvironment.arrayEquals:([B[B)Z
+java/lang/ProcessEnvironment.arrayHash:([B)I
+java/lang/ProcessEnvironment.getenv:()Ljava/util/Map;
+java/lang/ProcessImpl.<init>:()V
+java/lang/Readable.read:(Ljava/nio/CharBuffer;)I
+java/lang/ReflectiveOperationException.<init>:()V
+java/lang/ReflectiveOperationException.<init>:(Ljava/lang/String;)V
+java/lang/ReflectiveOperationException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Runnable.run:()V
+java/lang/Runtime.<clinit>:()V
+java/lang/Runtime.<init>:()V
+java/lang/Runtime.getLocalizedInputStream:(Ljava/io/InputStream;)Ljava/io/InputStream;
+java/lang/Runtime.getLocalizedOutputStream:(Ljava/io/OutputStream;)Ljava/io/OutputStream;
+java/lang/Runtime.getRuntime:()Ljava/lang/Runtime;
+java/lang/RuntimeException.<init>:()V
+java/lang/RuntimeException.<init>:(Ljava/lang/String;)V
+java/lang/RuntimeException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/RuntimeException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/SecurityException.<init>:()V
+java/lang/SecurityException.<init>:(Ljava/lang/String;)V
+java/lang/SecurityException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/SecurityManager$1.<init>:(Ljava/lang/SecurityManager;)V
+java/lang/SecurityManager$2.<init>:(Ljava/lang/SecurityManager;)V
+java/lang/SecurityManager.getInCheck:()Z
+java/lang/Short$ShortCache.<clinit>:()V
+java/lang/Short$ShortCache.<init>:()V
+java/lang/Short.<init>:(S)V
+java/lang/Short.byteValue:()B
+java/lang/Short.compare:(SS)I
+java/lang/Short.compareTo:(Ljava/lang/Object;)I
+java/lang/Short.compareTo:(Ljava/lang/Short;)I
+java/lang/Short.doubleValue:()D
+java/lang/Short.equals:(Ljava/lang/Object;)Z
+java/lang/Short.floatValue:()F
+java/lang/Short.hashCode:()I
+java/lang/Short.hashCode:(S)I
+java/lang/Short.intValue:()I
+java/lang/Short.longValue:()J
+java/lang/Short.reverseBytes:(S)S
+java/lang/Short.shortValue:()S
+java/lang/Short.toString:()Ljava/lang/String;
+java/lang/Short.toUnsignedInt:(S)I
+java/lang/Short.toUnsignedLong:(S)J
+java/lang/Short.valueOf:(S)Ljava/lang/Short;
+java/lang/Shutdown$Lock.<init>:()V
+java/lang/Shutdown$Lock.<init>:(Ljava/lang/Shutdown$1;)V
+java/lang/Shutdown.<clinit>:()V
+java/lang/Shutdown.<init>:()V
+java/lang/Shutdown.runHooks:()V
+java/lang/Shutdown.setRunFinalizersOnExit:(Z)V
+java/lang/StackOverflowError.<init>:()V
+java/lang/StackOverflowError.<init>:(Ljava/lang/String;)V
+java/lang/StackTraceElement.getClassName:()Ljava/lang/String;
+java/lang/StackTraceElement.getFileName:()Ljava/lang/String;
+java/lang/StackTraceElement.getLineNumber:()I
+java/lang/StackTraceElement.getMethodName:()Ljava/lang/String;
+java/lang/StackTraceElement.isNativeMethod:()Z
+java/lang/StrictMath$RandomNumberGeneratorHolder.<init>:()V
+java/lang/StrictMath.<init>:()V
+java/lang/StrictMath.abs:(D)D
+java/lang/StrictMath.abs:(F)F
+java/lang/StrictMath.abs:(I)I
+java/lang/StrictMath.abs:(J)J
+java/lang/StrictMath.addExact:(II)I
+java/lang/StrictMath.addExact:(JJ)J
+java/lang/StrictMath.floorDiv:(II)I
+java/lang/StrictMath.floorDiv:(JJ)J
+java/lang/StrictMath.floorMod:(II)I
+java/lang/StrictMath.floorMod:(JJ)J
+java/lang/StrictMath.max:(II)I
+java/lang/StrictMath.max:(JJ)J
+java/lang/StrictMath.min:(II)I
+java/lang/StrictMath.min:(JJ)J
+java/lang/StrictMath.multiplyExact:(II)I
+java/lang/StrictMath.multiplyExact:(JJ)J
+java/lang/StrictMath.subtractExact:(II)I
+java/lang/StrictMath.subtractExact:(JJ)J
+java/lang/StrictMath.toDegrees:(D)D
+java/lang/StrictMath.toIntExact:(J)I
+java/lang/StrictMath.toRadians:(D)D
+java/lang/String$CaseInsensitiveComparator.<init>:()V
+java/lang/String$CaseInsensitiveComparator.<init>:(Ljava/lang/String$1;)V
+java/lang/String$CaseInsensitiveComparator.compare:(Ljava/lang/Object;Ljava/lang/Object;)I
+java/lang/String$CaseInsensitiveComparator.compare:(Ljava/lang/String;Ljava/lang/String;)I
+java/lang/String$CaseInsensitiveComparator.readResolve:()Ljava/lang/Object;
+java/lang/String.<clinit>:()V
+java/lang/String.<init>:()V
+java/lang/String.<init>:(Ljava/lang/String;)V
+java/lang/String.<init>:([BI)V
+java/lang/String.<init>:([BIII)V
+java/lang/String.<init>:([CZ)V
+java/lang/String.<init>:([III)V
+java/lang/String.charAt:(I)C
+java/lang/String.checkBounds:([BII)V
+java/lang/String.codePointAt:(I)I
+java/lang/String.codePointBefore:(I)I
+java/lang/String.codePointCount:(II)I
+java/lang/String.compareTo:(Ljava/lang/Object;)I
+java/lang/String.compareTo:(Ljava/lang/String;)I
+java/lang/String.contains:(Ljava/lang/CharSequence;)Z
+java/lang/String.contentEquals:(Ljava/lang/CharSequence;)Z
+java/lang/String.contentEquals:(Ljava/lang/StringBuffer;)Z
+java/lang/String.endsWith:(Ljava/lang/String;)Z
+java/lang/String.equals:(Ljava/lang/Object;)Z
+java/lang/String.equalsIgnoreCase:(Ljava/lang/String;)Z
+java/lang/String.getChars:(II[CI)V
+java/lang/String.getChars:([CI)V
+java/lang/String.hashCode:()I
+java/lang/String.indexOf:(I)I
+java/lang/String.indexOf:(II)I
+java/lang/String.indexOf:(Ljava/lang/String;)I
+java/lang/String.indexOf:(Ljava/lang/String;I)I
+java/lang/String.indexOf:([CIILjava/lang/String;I)I
+java/lang/String.indexOf:([CII[CIII)I
+java/lang/String.indexOfSupplementary:(II)I
+java/lang/String.isEmpty:()Z
+java/lang/String.lastIndexOf:(I)I
+java/lang/String.lastIndexOf:(II)I
+java/lang/String.lastIndexOf:(Ljava/lang/String;)I
+java/lang/String.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/String.lastIndexOf:([CIILjava/lang/String;I)I
+java/lang/String.lastIndexOf:([CII[CIII)I
+java/lang/String.lastIndexOfSupplementary:(II)I
+java/lang/String.length:()I
+java/lang/String.nonSyncContentEquals:(Ljava/lang/AbstractStringBuilder;)Z
+java/lang/String.offsetByCodePoints:(II)I
+java/lang/String.regionMatches:(ILjava/lang/String;II)Z
+java/lang/String.regionMatches:(ZILjava/lang/String;II)Z
+java/lang/String.replace:(CC)Ljava/lang/String;
+java/lang/String.startsWith:(Ljava/lang/String;)Z
+java/lang/String.startsWith:(Ljava/lang/String;I)Z
+java/lang/String.toCharArray:()[C
+java/lang/String.toString:()Ljava/lang/String;
+java/lang/String.valueOf:(C)Ljava/lang/String;
+java/lang/String.valueOf:(I)Ljava/lang/String;
+java/lang/String.valueOf:(J)Ljava/lang/String;
+java/lang/String.valueOf:(Z)Ljava/lang/String;
+java/lang/StringBuffer.<init>:()V
+java/lang/StringBuffer.<init>:(I)V
+java/lang/StringBuffer.capacity:()I
+java/lang/StringBuffer.charAt:(I)C
+java/lang/StringBuffer.codePointAt:(I)I
+java/lang/StringBuffer.codePointBefore:(I)I
+java/lang/StringBuffer.codePointCount:(II)I
+java/lang/StringBuffer.delete:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.delete:(II)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.deleteCharAt:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.deleteCharAt:(I)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.getChars:(II[CI)V
+java/lang/StringBuffer.indexOf:(Ljava/lang/String;)I
+java/lang/StringBuffer.indexOf:(Ljava/lang/String;I)I
+java/lang/StringBuffer.lastIndexOf:(Ljava/lang/String;)I
+java/lang/StringBuffer.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/StringBuffer.length:()I
+java/lang/StringBuffer.offsetByCodePoints:(II)I
+java/lang/StringBuffer.reverse:()Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.reverse:()Ljava/lang/StringBuffer;
+java/lang/StringBuffer.setCharAt:(IC)V
+java/lang/StringBuilder.<init>:()V
+java/lang/StringBuilder.<init>:(I)V
+java/lang/StringBuilder.capacity:()I
+java/lang/StringBuilder.charAt:(I)C
+java/lang/StringBuilder.codePointAt:(I)I
+java/lang/StringBuilder.codePointBefore:(I)I
+java/lang/StringBuilder.codePointCount:(II)I
+java/lang/StringBuilder.delete:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.delete:(II)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.deleteCharAt:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.deleteCharAt:(I)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.getChars:(II[CI)V
+java/lang/StringBuilder.indexOf:(Ljava/lang/String;)I
+java/lang/StringBuilder.indexOf:(Ljava/lang/String;I)I
+java/lang/StringBuilder.lastIndexOf:(Ljava/lang/String;)I
+java/lang/StringBuilder.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/StringBuilder.length:()I
+java/lang/StringBuilder.offsetByCodePoints:(II)I
+java/lang/StringBuilder.reverse:()Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.reverse:()Ljava/lang/StringBuilder;
+java/lang/StringBuilder.setCharAt:(IC)V
+java/lang/StringCoding$StringDecoder.requestedCharsetName:()Ljava/lang/String;
+java/lang/StringCoding$StringEncoder.requestedCharsetName:()Ljava/lang/String;
+java/lang/StringCoding.<init>:()V
+java/lang/StringCoding.access$000:(IF)I
+java/lang/StringCoding.scale:(IF)I
+java/lang/StringIndexOutOfBoundsException.<init>:()V
+java/lang/StringIndexOutOfBoundsException.<init>:(I)V
+java/lang/StringIndexOutOfBoundsException.<init>:(Ljava/lang/String;)V
+java/lang/SuppressWarnings.value:()[Ljava/lang/String;
+java/lang/System$1.<init>:(Ljava/lang/SecurityManager;)V
+java/lang/System$2.<init>:()V
+java/lang/System$2.blockedOn:(Ljava/lang/Thread;Lsun/nio/ch/Interruptible;)V
+java/lang/System$2.getAnnotationType:(Ljava/lang/Class;)Lsun/reflect/annotation/AnnotationType;
+java/lang/System$2.newStringUnsafe:([C)Ljava/lang/String;
+java/lang/System.<init>:()V
+java/lang/System.arraycopy:(Ljava/lang/Object;ILjava/lang/Object;II)V
+java/lang/System.checkKey:(Ljava/lang/String;)V
+java/lang/System.getSecurityManager:()Ljava/lang/SecurityManager;
+java/lang/System.lineSeparator:()Ljava/lang/String;
+java/lang/SystemClassLoaderAction.<init>:(Ljava/lang/ClassLoader;)V
+java/lang/Terminator$1.<init>:()V
+java/lang/Terminator.<clinit>:()V
+java/lang/Terminator.<init>:()V
+java/lang/Terminator.teardown:()V
+java/lang/Thread$1.<init>:(Ljava/lang/Class;)V
+java/lang/Thread$Caches.<init>:()V
+java/lang/Thread$State.<clinit>:()V
+java/lang/Thread$State.<init>:(Ljava/lang/String;I)V
+java/lang/Thread$UncaughtExceptionHandler.uncaughtException:(Ljava/lang/Thread;Ljava/lang/Throwable;)V
+java/lang/Thread$WeakClassKey.hashCode:()I
+java/lang/Thread.blockedOn:(Lsun/nio/ch/Interruptible;)V
+java/lang/Thread.clone:()Ljava/lang/Object;
+java/lang/Thread.destroy:()V
+java/lang/Thread.dispatchUncaughtException:(Ljava/lang/Throwable;)V
+java/lang/Thread.getDefaultUncaughtExceptionHandler:()Ljava/lang/Thread$UncaughtExceptionHandler;
+java/lang/Thread.getId:()J
+java/lang/Thread.getName:()Ljava/lang/String;
+java/lang/Thread.getPriority:()I
+java/lang/Thread.getThreadGroup:()Ljava/lang/ThreadGroup;
+java/lang/Thread.getUncaughtExceptionHandler:()Ljava/lang/Thread$UncaughtExceptionHandler;
+java/lang/Thread.isDaemon:()Z
+java/lang/Thread.nextThreadID:()J
+java/lang/Thread.nextThreadNum:()I
+java/lang/Thread.run:()V
+java/lang/Thread.stop:(Ljava/lang/Throwable;)V
+java/lang/ThreadDeath.<init>:()V
+java/lang/ThreadGroup.<init>:()V
+java/lang/ThreadGroup.addUnstarted:()V
+java/lang/ThreadGroup.getMaxPriority:()I
+java/lang/ThreadGroup.getName:()Ljava/lang/String;
+java/lang/ThreadGroup.isDaemon:()Z
+java/lang/ThreadGroup.isDestroyed:()Z
+java/lang/ThreadGroup.parentOf:(Ljava/lang/ThreadGroup;)Z
+java/lang/ThreadGroup.remove:(Ljava/lang/Thread;)V
+java/lang/ThreadGroup.threadStartFailed:(Ljava/lang/Thread;)V
+java/lang/ThreadLocal$ThreadLocalMap.nextIndex:(II)I
+java/lang/ThreadLocal$ThreadLocalMap.prevIndex:(II)I
+java/lang/ThreadLocal$ThreadLocalMap.setThreshold:(I)V
+java/lang/ThreadLocal.access$400:(Ljava/lang/ThreadLocal;)I
+java/lang/ThreadLocal.childValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/ThreadLocal.getMap:(Ljava/lang/Thread;)Ljava/lang/ThreadLocal$ThreadLocalMap;
+java/lang/ThreadLocal.initialValue:()Ljava/lang/Object;
+java/lang/Throwable$PrintStreamOrWriter.<init>:()V
+java/lang/Throwable$PrintStreamOrWriter.<init>:(Ljava/lang/Throwable$1;)V
+java/lang/Throwable$PrintStreamOrWriter.lock:()Ljava/lang/Object;
+java/lang/Throwable$PrintStreamOrWriter.println:(Ljava/lang/Object;)V
+java/lang/Throwable$SentinelHolder.<init>:()V
+java/lang/Throwable$WrappedPrintStream.<init>:(Ljava/io/PrintStream;)V
+java/lang/Throwable$WrappedPrintStream.lock:()Ljava/lang/Object;
+java/lang/Throwable$WrappedPrintWriter.<init>:(Ljava/io/PrintWriter;)V
+java/lang/Throwable$WrappedPrintWriter.lock:()Ljava/lang/Object;
+java/lang/Throwable.<init>:()V
+java/lang/Throwable.<init>:(Ljava/lang/String;)V
+java/lang/Throwable.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Throwable.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/Throwable.fillInStackTrace:()Ljava/lang/Throwable;
+java/lang/Throwable.fillInStackTrace:(I)Ljava/lang/Throwable;
+java/lang/Throwable.getCause:()Ljava/lang/Throwable;
+java/lang/Throwable.getLocalizedMessage:()Ljava/lang/String;
+java/lang/Throwable.getMessage:()Ljava/lang/String;
+java/lang/TypeNotPresentException.typeName:()Ljava/lang/String;
+java/lang/UNIXProcess$1.<init>:()V
+java/lang/UNIXProcess$2.<init>:()V
+java/lang/UNIXProcess$3.<init>:(Ljava/lang/UNIXProcess;[I)V
+java/lang/UNIXProcess$4.<init>:(Ljava/lang/UNIXProcess;)V
+java/lang/UNIXProcess$LaunchMechanism.<clinit>:()V
+java/lang/UNIXProcess$LaunchMechanism.<init>:(Ljava/lang/String;II)V
+java/lang/UNIXProcess$LaunchMechanism.access$300:(Ljava/lang/UNIXProcess$LaunchMechanism;)I
+java/lang/UNIXProcess$ProcessReaperThreadFactory$1.<init>:()V
+java/lang/UNIXProcess$ProcessReaperThreadFactory.<init>:()V
+java/lang/UNIXProcess$ProcessReaperThreadFactory.<init>:(Ljava/lang/UNIXProcess$1;)V
+java/lang/UNIXProcess.access$002:([B)[B
+java/lang/UNIXProcess.access$400:(Ljava/lang/UNIXProcess;)I
+java/lang/UNIXProcess.exitValue:()I
+java/lang/UNIXProcess.getErrorStream:()Ljava/io/InputStream;
+java/lang/UNIXProcess.getInputStream:()Ljava/io/InputStream;
+java/lang/UNIXProcess.getOutputStream:()Ljava/io/OutputStream;
+java/lang/UNIXProcess.isAlive:()Z
+java/lang/UnknownError.<init>:()V
+java/lang/UnknownError.<init>:(Ljava/lang/String;)V
+java/lang/UnsatisfiedLinkError.<init>:()V
+java/lang/UnsatisfiedLinkError.<init>:(Ljava/lang/String;)V
+java/lang/UnsupportedClassVersionError.<init>:()V
+java/lang/UnsupportedClassVersionError.<init>:(Ljava/lang/String;)V
+java/lang/UnsupportedOperationException.<init>:()V
+java/lang/UnsupportedOperationException.<init>:(Ljava/lang/String;)V
+java/lang/UnsupportedOperationException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/VerifyError.<init>:()V
+java/lang/VerifyError.<init>:(Ljava/lang/String;)V
+java/lang/VirtualMachineError.<init>:()V
+java/lang/VirtualMachineError.<init>:(Ljava/lang/String;)V
+java/lang/VirtualMachineError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Void.<init>:()V
+java/lang/reflect/AccessibleObject.<init>:()V
+java/lang/reflect/AccessibleObject.isAccessible:()Z
+java/lang/reflect/AccessibleObject.isAnnotationPresent:(Ljava/lang/Class;)Z
+java/lang/reflect/AccessibleObject.setAccessible0:(Ljava/lang/reflect/AccessibleObject;Z)V
+java/lang/reflect/AnnotatedArrayType.getAnnotatedGenericComponentType:()Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/AnnotatedElement.getAnnotation:(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;
+java/lang/reflect/AnnotatedElement.getAnnotations:()[Ljava/lang/annotation/Annotation;
+java/lang/reflect/AnnotatedElement.getDeclaredAnnotations:()[Ljava/lang/annotation/Annotation;
+java/lang/reflect/AnnotatedElement.isAnnotationPresent:(Ljava/lang/Class;)Z
+java/lang/reflect/AnnotatedElement.lambda$getDeclaredAnnotationsByType$0:(Ljava/lang/annotation/Annotation;Ljava/lang/annotation/Annotation;)Ljava/lang/annotation/Annotation;
+java/lang/reflect/AnnotatedParameterizedType.getAnnotatedActualTypeArguments:()[Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/AnnotatedType.getType:()Ljava/lang/reflect/Type;
+java/lang/reflect/AnnotatedTypeVariable.getAnnotatedBounds:()[Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/AnnotatedWildcardType.getAnnotatedLowerBounds:()[Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/AnnotatedWildcardType.getAnnotatedUpperBounds:()[Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/Array.<init>:()V
+java/lang/reflect/Array.newArray:(Ljava/lang/Class;I)Ljava/lang/Object;
+java/lang/reflect/Array.newInstance:(Ljava/lang/Class;I)Ljava/lang/Object;
+java/lang/reflect/Constructor.<init>:(Ljava/lang/Class;[Ljava/lang/Class;[Ljava/lang/Class;IILjava/lang/String;[B[B)V
+java/lang/reflect/Constructor.copy:()Ljava/lang/reflect/Constructor;
+java/lang/reflect/Constructor.getAnnotationBytes:()[B
+java/lang/reflect/Constructor.getConstructorAccessor:()Lsun/reflect/ConstructorAccessor;
+java/lang/reflect/Constructor.getDeclaringClass:()Ljava/lang/Class;
+java/lang/reflect/Constructor.getModifiers:()I
+java/lang/reflect/Constructor.getParameterCount:()I
+java/lang/reflect/Constructor.getRawAnnotations:()[B
+java/lang/reflect/Constructor.getRawParameterAnnotations:()[B
+java/lang/reflect/Constructor.getSignature:()Ljava/lang/String;
+java/lang/reflect/Constructor.getSlot:()I
+java/lang/reflect/Constructor.hasGenericInformation:()Z
+java/lang/reflect/Constructor.isSynthetic:()Z
+java/lang/reflect/Constructor.isVarArgs:()Z
+java/lang/reflect/Constructor.setConstructorAccessor:(Lsun/reflect/ConstructorAccessor;)V
+java/lang/reflect/Executable.<init>:()V
+java/lang/reflect/Executable.equalParamTypes:([Ljava/lang/Class;[Ljava/lang/Class;)Z
+java/lang/reflect/Executable.getAnnotatedReturnType:()Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/Executable.getAnnotationBytes:()[B
+java/lang/reflect/Executable.getDeclaringClass:()Ljava/lang/Class;
+java/lang/reflect/Executable.getExceptionTypes:()[Ljava/lang/Class;
+java/lang/reflect/Executable.getGenericInfo:()Lsun/reflect/generics/repository/ConstructorRepository;
+java/lang/reflect/Executable.getModifiers:()I
+java/lang/reflect/Executable.getName:()Ljava/lang/String;
+java/lang/reflect/Executable.getParameterAnnotations:()[[Ljava/lang/annotation/Annotation;
+java/lang/reflect/Executable.getParameterCount:()I
+java/lang/reflect/Executable.getParameterTypes:()[Ljava/lang/Class;
+java/lang/reflect/Executable.getTypeParameters:()[Ljava/lang/reflect/TypeVariable;
+java/lang/reflect/Executable.handleParameterNumberMismatch:(II)V
+java/lang/reflect/Executable.hasGenericInformation:()Z
+java/lang/reflect/Executable.isSynthetic:()Z
+java/lang/reflect/Executable.isVarArgs:()Z
+java/lang/reflect/Executable.specificToGenericStringHeader:(Ljava/lang/StringBuilder;)V
+java/lang/reflect/Executable.specificToStringHeader:(Ljava/lang/StringBuilder;)V
+java/lang/reflect/Executable.toGenericString:()Ljava/lang/String;
+java/lang/reflect/Field.<init>:(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/Class;IILjava/lang/String;[B)V
+java/lang/reflect/Field.copy:()Ljava/lang/reflect/Field;
+java/lang/reflect/Field.equals:(Ljava/lang/Object;)Z
+java/lang/reflect/Field.getDeclaringClass:()Ljava/lang/Class;
+java/lang/reflect/Field.getFieldAccessor:(Z)Lsun/reflect/FieldAccessor;
+java/lang/reflect/Field.getGenericSignature:()Ljava/lang/String;
+java/lang/reflect/Field.getModifiers:()I
+java/lang/reflect/Field.getName:()Ljava/lang/String;
+java/lang/reflect/Field.getType:()Ljava/lang/Class;
+java/lang/reflect/Field.isEnumConstant:()Z
+java/lang/reflect/Field.isSynthetic:()Z
+java/lang/reflect/Field.setFieldAccessor:(Lsun/reflect/FieldAccessor;Z)V
+java/lang/reflect/GenericArrayType.getGenericComponentType:()Ljava/lang/reflect/Type;
+java/lang/reflect/GenericDeclaration.getTypeParameters:()[Ljava/lang/reflect/TypeVariable;
+java/lang/reflect/GenericSignatureFormatError.<init>:()V
+java/lang/reflect/GenericSignatureFormatError.<init>:(Ljava/lang/String;)V
+java/lang/reflect/InvocationHandler.invoke:(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/reflect/InvocationTargetException.<init>:(Ljava/lang/Throwable;Ljava/lang/String;)V
+java/lang/reflect/InvocationTargetException.getCause:()Ljava/lang/Throwable;
+java/lang/reflect/InvocationTargetException.getTargetException:()Ljava/lang/Throwable;
+java/lang/reflect/MalformedParameterizedTypeException.<init>:()V
+java/lang/reflect/MalformedParametersException.<init>:()V
+java/lang/reflect/MalformedParametersException.<init>:(Ljava/lang/String;)V
+java/lang/reflect/Member.getDeclaringClass:()Ljava/lang/Class;
+java/lang/reflect/Member.getModifiers:()I
+java/lang/reflect/Member.getName:()Ljava/lang/String;
+java/lang/reflect/Member.isSynthetic:()Z
+java/lang/reflect/Method.<init>:(Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/Class;Ljava/lang/Class;[Ljava/lang/Class;IILjava/lang/String;[B[B[B)V
+java/lang/reflect/Method.copy:()Ljava/lang/reflect/Method;
+java/lang/reflect/Method.getAnnotationBytes:()[B
+java/lang/reflect/Method.getDeclaringClass:()Ljava/lang/Class;
+java/lang/reflect/Method.getGenericSignature:()Ljava/lang/String;
+java/lang/reflect/Method.getMethodAccessor:()Lsun/reflect/MethodAccessor;
+java/lang/reflect/Method.getModifiers:()I
+java/lang/reflect/Method.getName:()Ljava/lang/String;
+java/lang/reflect/Method.getParameterCount:()I
+java/lang/reflect/Method.getReturnType:()Ljava/lang/Class;
+java/lang/reflect/Method.hasGenericInformation:()Z
+java/lang/reflect/Method.isBridge:()Z
+java/lang/reflect/Method.isSynthetic:()Z
+java/lang/reflect/Method.isVarArgs:()Z
+java/lang/reflect/Method.setMethodAccessor:(Lsun/reflect/MethodAccessor;)V
+java/lang/reflect/Modifier.<init>:()V
+java/lang/reflect/Modifier.classModifiers:()I
+java/lang/reflect/Modifier.constructorModifiers:()I
+java/lang/reflect/Modifier.fieldModifiers:()I
+java/lang/reflect/Modifier.interfaceModifiers:()I
+java/lang/reflect/Modifier.isAbstract:(I)Z
+java/lang/reflect/Modifier.isFinal:(I)Z
+java/lang/reflect/Modifier.isInterface:(I)Z
+java/lang/reflect/Modifier.isMandated:(I)Z
+java/lang/reflect/Modifier.isNative:(I)Z
+java/lang/reflect/Modifier.isPrivate:(I)Z
+java/lang/reflect/Modifier.isProtected:(I)Z
+java/lang/reflect/Modifier.isPublic:(I)Z
+java/lang/reflect/Modifier.isStatic:(I)Z
+java/lang/reflect/Modifier.isStrict:(I)Z
+java/lang/reflect/Modifier.isSynchronized:(I)Z
+java/lang/reflect/Modifier.isSynthetic:(I)Z
+java/lang/reflect/Modifier.isTransient:(I)Z
+java/lang/reflect/Modifier.isVolatile:(I)Z
+java/lang/reflect/Modifier.methodModifiers:()I
+java/lang/reflect/Modifier.parameterModifiers:()I
+java/lang/reflect/Parameter.<init>:(Ljava/lang/String;ILjava/lang/reflect/Executable;I)V
+java/lang/reflect/Parameter.equals:(Ljava/lang/Object;)Z
+java/lang/reflect/Parameter.getAnnotations:()[Ljava/lang/annotation/Annotation;
+java/lang/reflect/Parameter.getDeclaredAnnotations:()[Ljava/lang/annotation/Annotation;
+java/lang/reflect/Parameter.getDeclaringExecutable:()Ljava/lang/reflect/Executable;
+java/lang/reflect/Parameter.getModifiers:()I
+java/lang/reflect/Parameter.getRealName:()Ljava/lang/String;
+java/lang/reflect/Parameter.getType:()Ljava/lang/Class;
+java/lang/reflect/Parameter.isImplicit:()Z
+java/lang/reflect/Parameter.isSynthetic:()Z
+java/lang/reflect/Parameter.isVarArgs:()Z
+java/lang/reflect/ParameterizedType.getActualTypeArguments:()[Ljava/lang/reflect/Type;
+java/lang/reflect/ParameterizedType.getOwnerType:()Ljava/lang/reflect/Type;
+java/lang/reflect/ParameterizedType.getRawType:()Ljava/lang/reflect/Type;
+java/lang/reflect/Proxy$1.<init>:(Ljava/lang/reflect/Constructor;)V
+java/lang/reflect/Proxy$Key1.hashCode:()I
+java/lang/reflect/Proxy$Key2.hashCode:()I
+java/lang/reflect/Proxy$KeyFactory.<init>:()V
+java/lang/reflect/Proxy$KeyFactory.<init>:(Ljava/lang/reflect/Proxy$1;)V
+java/lang/reflect/Proxy$KeyX.hashCode:()I
+java/lang/reflect/Proxy$ProxyClassFactory.<init>:()V
+java/lang/reflect/Proxy$ProxyClassFactory.<init>:(Ljava/lang/reflect/Proxy$1;)V
+java/lang/reflect/Proxy.<init>:()V
+java/lang/reflect/Proxy.access$200:()Ljava/lang/Object;
+java/lang/reflect/ReflectAccess.<init>:()V
+java/lang/reflect/ReflectAccess.copyConstructor:(Ljava/lang/reflect/Constructor;)Ljava/lang/reflect/Constructor;
+java/lang/reflect/ReflectAccess.copyField:(Ljava/lang/reflect/Field;)Ljava/lang/reflect/Field;
+java/lang/reflect/ReflectAccess.copyMethod:(Ljava/lang/reflect/Method;)Ljava/lang/reflect/Method;
+java/lang/reflect/ReflectAccess.getConstructorAccessor:(Ljava/lang/reflect/Constructor;)Lsun/reflect/ConstructorAccessor;
+java/lang/reflect/ReflectAccess.getConstructorAnnotations:(Ljava/lang/reflect/Constructor;)[B
+java/lang/reflect/ReflectAccess.getConstructorParameterAnnotations:(Ljava/lang/reflect/Constructor;)[B
+java/lang/reflect/ReflectAccess.getConstructorSignature:(Ljava/lang/reflect/Constructor;)Ljava/lang/String;
+java/lang/reflect/ReflectAccess.getConstructorSlot:(Ljava/lang/reflect/Constructor;)I
+java/lang/reflect/ReflectAccess.getMethodAccessor:(Ljava/lang/reflect/Method;)Lsun/reflect/MethodAccessor;
+java/lang/reflect/ReflectAccess.newConstructor:(Ljava/lang/Class;[Ljava/lang/Class;[Ljava/lang/Class;IILjava/lang/String;[B[B)Ljava/lang/reflect/Constructor;
+java/lang/reflect/ReflectAccess.newField:(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/Class;IILjava/lang/String;[B)Ljava/lang/reflect/Field;
+java/lang/reflect/ReflectAccess.newMethod:(Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/Class;Ljava/lang/Class;[Ljava/lang/Class;IILjava/lang/String;[B[B[B)Ljava/lang/reflect/Method;
+java/lang/reflect/ReflectAccess.setConstructorAccessor:(Ljava/lang/reflect/Constructor;Lsun/reflect/ConstructorAccessor;)V
+java/lang/reflect/ReflectAccess.setMethodAccessor:(Ljava/lang/reflect/Method;Lsun/reflect/MethodAccessor;)V
+java/lang/reflect/TypeVariable.getAnnotatedBounds:()[Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/TypeVariable.getBounds:()[Ljava/lang/reflect/Type;
+java/lang/reflect/TypeVariable.getGenericDeclaration:()Ljava/lang/reflect/GenericDeclaration;
+java/lang/reflect/TypeVariable.getName:()Ljava/lang/String;
+java/lang/reflect/UndeclaredThrowableException.<init>:(Ljava/lang/Throwable;Ljava/lang/String;)V
+java/lang/reflect/UndeclaredThrowableException.getCause:()Ljava/lang/Throwable;
+java/lang/reflect/UndeclaredThrowableException.getUndeclaredThrowable:()Ljava/lang/Throwable;
+java/lang/reflect/WeakCache$CacheKey.<clinit>:()V
+java/lang/reflect/WeakCache$CacheKey.hashCode:()I
+java/lang/reflect/WeakCache$CacheValue.hashCode:()I
+java/lang/reflect/WeakCache$Factory.<init>:(Ljava/lang/reflect/WeakCache;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/util/concurrent/ConcurrentMap;)V
+java/lang/reflect/WeakCache$LookupValue.<init>:(Ljava/lang/Object;)V
+java/lang/reflect/WeakCache$LookupValue.get:()Ljava/lang/Object;
+java/lang/reflect/WeakCache.access$000:(Ljava/lang/reflect/WeakCache;)Ljava/util/function/BiFunction;
+java/lang/reflect/WeakCache.access$100:(Ljava/lang/reflect/WeakCache;)Ljava/util/concurrent/ConcurrentMap;
+java/lang/reflect/WildcardType.getLowerBounds:()[Ljava/lang/reflect/Type;
+java/lang/reflect/WildcardType.getUpperBounds:()[Ljava/lang/reflect/Type;
\ No newline at end of file
diff --git a/experimental/sandbox/src/main/resources/java8.scan.java.lang_and_util b/experimental/sandbox/src/main/resources/java8.scan.java.lang_and_util
new file mode 100644
index 0000000000..fa79a124b3
--- /dev/null
+++ b/experimental/sandbox/src/main/resources/java8.scan.java.lang_and_util
@@ -0,0 +1,4429 @@
+java/lang/AbstractMethodError.<init>:()V
+java/lang/AbstractMethodError.<init>:(Ljava/lang/String;)V
+java/lang/AbstractStringBuilder.<init>:()V
+java/lang/AbstractStringBuilder.<init>:(I)V
+java/lang/AbstractStringBuilder.append:(C)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.append:(C)Ljava/lang/Appendable;
+java/lang/AbstractStringBuilder.append:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.append:(J)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.append:(Ljava/lang/AbstractStringBuilder;)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.append:(Ljava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.append:(Ljava/lang/CharSequence;)Ljava/lang/Appendable;
+java/lang/AbstractStringBuilder.append:(Ljava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.append:(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;
+java/lang/AbstractStringBuilder.append:(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.append:(Ljava/lang/StringBuffer;)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.append:(Z)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.append:([C)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.append:([CII)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.appendCodePoint:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.appendNull:()Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.capacity:()I
+java/lang/AbstractStringBuilder.charAt:(I)C
+java/lang/AbstractStringBuilder.codePointAt:(I)I
+java/lang/AbstractStringBuilder.codePointBefore:(I)I
+java/lang/AbstractStringBuilder.codePointCount:(II)I
+java/lang/AbstractStringBuilder.delete:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.deleteCharAt:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.ensureCapacity:(I)V
+java/lang/AbstractStringBuilder.ensureCapacityInternal:(I)V
+java/lang/AbstractStringBuilder.expandCapacity:(I)V
+java/lang/AbstractStringBuilder.getChars:(II[CI)V
+java/lang/AbstractStringBuilder.getValue:()[C
+java/lang/AbstractStringBuilder.indexOf:(Ljava/lang/String;)I
+java/lang/AbstractStringBuilder.indexOf:(Ljava/lang/String;I)I
+java/lang/AbstractStringBuilder.insert:(IC)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.insert:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.insert:(IJ)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.insert:(ILjava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.insert:(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.insert:(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.insert:(IZ)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.insert:(I[C)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.insert:(I[CII)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.lastIndexOf:(Ljava/lang/String;)I
+java/lang/AbstractStringBuilder.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/AbstractStringBuilder.length:()I
+java/lang/AbstractStringBuilder.offsetByCodePoints:(II)I
+java/lang/AbstractStringBuilder.replace:(IILjava/lang/String;)Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.reverse:()Ljava/lang/AbstractStringBuilder;
+java/lang/AbstractStringBuilder.reverseAllValidSurrogatePairs:()V
+java/lang/AbstractStringBuilder.setCharAt:(IC)V
+java/lang/AbstractStringBuilder.subSequence:(II)Ljava/lang/CharSequence;
+java/lang/AbstractStringBuilder.substring:(I)Ljava/lang/String;
+java/lang/AbstractStringBuilder.substring:(II)Ljava/lang/String;
+java/lang/AbstractStringBuilder.toString:()Ljava/lang/String;
+java/lang/AbstractStringBuilder.trimToSize:()V
+java/lang/Appendable.append:(C)Ljava/lang/Appendable;
+java/lang/Appendable.append:(Ljava/lang/CharSequence;)Ljava/lang/Appendable;
+java/lang/Appendable.append:(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;
+java/lang/ApplicationShutdownHooks$1.<init>:()V
+java/lang/ApplicationShutdownHooks.<clinit>:()V
+java/lang/ApplicationShutdownHooks.<init>:()V
+java/lang/ArithmeticException.<init>:()V
+java/lang/ArithmeticException.<init>:(Ljava/lang/String;)V
+java/lang/ArrayIndexOutOfBoundsException.<init>:()V
+java/lang/ArrayIndexOutOfBoundsException.<init>:(I)V
+java/lang/ArrayIndexOutOfBoundsException.<init>:(Ljava/lang/String;)V
+java/lang/ArrayStoreException.<init>:()V
+java/lang/ArrayStoreException.<init>:(Ljava/lang/String;)V
+java/lang/AssertionError.<init>:()V
+java/lang/AssertionError.<init>:(C)V
+java/lang/AssertionError.<init>:(I)V
+java/lang/AssertionError.<init>:(J)V
+java/lang/AssertionError.<init>:(Ljava/lang/String;)V
+java/lang/AssertionError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/AssertionError.<init>:(Z)V
+java/lang/AssertionStatusDirectives.<init>:()V
+java/lang/AutoCloseable.close:()V
+java/lang/Boolean.<init>:(Ljava/lang/String;)V
+java/lang/Boolean.<init>:(Z)V
+java/lang/Boolean.booleanValue:()Z
+java/lang/Boolean.compare:(ZZ)I
+java/lang/Boolean.compareTo:(Ljava/lang/Boolean;)I
+java/lang/Boolean.compareTo:(Ljava/lang/Object;)I
+java/lang/Boolean.equals:(Ljava/lang/Object;)Z
+java/lang/Boolean.hashCode:()I
+java/lang/Boolean.hashCode:(Z)I
+java/lang/Boolean.logicalAnd:(ZZ)Z
+java/lang/Boolean.logicalOr:(ZZ)Z
+java/lang/Boolean.logicalXor:(ZZ)Z
+java/lang/Boolean.parseBoolean:(Ljava/lang/String;)Z
+java/lang/Boolean.toString:()Ljava/lang/String;
+java/lang/Boolean.toString:(Z)Ljava/lang/String;
+java/lang/Boolean.valueOf:(Ljava/lang/String;)Ljava/lang/Boolean;
+java/lang/Boolean.valueOf:(Z)Ljava/lang/Boolean;
+java/lang/BootstrapMethodError.<init>:()V
+java/lang/BootstrapMethodError.<init>:(Ljava/lang/String;)V
+java/lang/BootstrapMethodError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Byte$ByteCache.<clinit>:()V
+java/lang/Byte$ByteCache.<init>:()V
+java/lang/Byte.<init>:(B)V
+java/lang/Byte.<init>:(Ljava/lang/String;)V
+java/lang/Byte.byteValue:()B
+java/lang/Byte.compare:(BB)I
+java/lang/Byte.compareTo:(Ljava/lang/Byte;)I
+java/lang/Byte.compareTo:(Ljava/lang/Object;)I
+java/lang/Byte.decode:(Ljava/lang/String;)Ljava/lang/Byte;
+java/lang/Byte.doubleValue:()D
+java/lang/Byte.equals:(Ljava/lang/Object;)Z
+java/lang/Byte.floatValue:()F
+java/lang/Byte.hashCode:()I
+java/lang/Byte.hashCode:(B)I
+java/lang/Byte.intValue:()I
+java/lang/Byte.longValue:()J
+java/lang/Byte.parseByte:(Ljava/lang/String;)B
+java/lang/Byte.parseByte:(Ljava/lang/String;I)B
+java/lang/Byte.shortValue:()S
+java/lang/Byte.toString:()Ljava/lang/String;
+java/lang/Byte.toString:(B)Ljava/lang/String;
+java/lang/Byte.toUnsignedInt:(B)I
+java/lang/Byte.toUnsignedLong:(B)J
+java/lang/Byte.valueOf:(B)Ljava/lang/Byte;
+java/lang/Byte.valueOf:(Ljava/lang/String;)Ljava/lang/Byte;
+java/lang/Byte.valueOf:(Ljava/lang/String;I)Ljava/lang/Byte;
+java/lang/CharSequence$1CharIterator.<init>:(Ljava/lang/CharSequence;)V
+java/lang/CharSequence$1CharIterator.hasNext:()Z
+java/lang/CharSequence$1CharIterator.nextInt:()I
+java/lang/CharSequence$1CodePointIterator.<init>:(Ljava/lang/CharSequence;)V
+java/lang/CharSequence$1CodePointIterator.hasNext:()Z
+java/lang/CharSequence$1CodePointIterator.nextInt:()I
+java/lang/CharSequence.charAt:(I)C
+java/lang/CharSequence.lambda$chars$1:()Ljava/util/Spliterator$OfInt;
+java/lang/CharSequence.lambda$codePoints$2:()Ljava/util/Spliterator$OfInt;
+java/lang/CharSequence.length:()I
+java/lang/CharSequence.subSequence:(II)Ljava/lang/CharSequence;
+java/lang/CharSequence.toString:()Ljava/lang/String;
+java/lang/Character$CharacterCache.<clinit>:()V
+java/lang/Character$CharacterCache.<init>:()V
+java/lang/Character$Subset.<init>:(Ljava/lang/String;)V
+java/lang/Character$Subset.equals:(Ljava/lang/Object;)Z
+java/lang/Character$Subset.toString:()Ljava/lang/String;
+java/lang/Character$UnicodeBlock.<init>:(Ljava/lang/String;)V
+java/lang/Character$UnicodeBlock.<init>:(Ljava/lang/String;Ljava/lang/String;)V
+java/lang/Character$UnicodeBlock.<init>:(Ljava/lang/String;[Ljava/lang/String;)V
+java/lang/Character$UnicodeBlock.of:(C)Ljava/lang/Character$UnicodeBlock;
+java/lang/Character$UnicodeBlock.of:(I)Ljava/lang/Character$UnicodeBlock;
+java/lang/Character$UnicodeScript.<init>:(Ljava/lang/String;I)V
+java/lang/Character$UnicodeScript.of:(I)Ljava/lang/Character$UnicodeScript;
+java/lang/Character.<init>:(C)V
+java/lang/Character.charCount:(I)I
+java/lang/Character.charValue:()C
+java/lang/Character.codePointAt:(Ljava/lang/CharSequence;I)I
+java/lang/Character.codePointAt:([CI)I
+java/lang/Character.codePointAt:([CII)I
+java/lang/Character.codePointAtImpl:([CII)I
+java/lang/Character.codePointBefore:(Ljava/lang/CharSequence;I)I
+java/lang/Character.codePointBefore:([CI)I
+java/lang/Character.codePointBefore:([CII)I
+java/lang/Character.codePointBeforeImpl:([CII)I
+java/lang/Character.codePointCount:(Ljava/lang/CharSequence;II)I
+java/lang/Character.codePointCount:([CII)I
+java/lang/Character.codePointCountImpl:([CII)I
+java/lang/Character.compare:(CC)I
+java/lang/Character.compareTo:(Ljava/lang/Character;)I
+java/lang/Character.compareTo:(Ljava/lang/Object;)I
+java/lang/Character.digit:(CI)I
+java/lang/Character.digit:(II)I
+java/lang/Character.equals:(Ljava/lang/Object;)Z
+java/lang/Character.forDigit:(II)C
+java/lang/Character.getDirectionality:(C)B
+java/lang/Character.getDirectionality:(I)B
+java/lang/Character.getNumericValue:(C)I
+java/lang/Character.getNumericValue:(I)I
+java/lang/Character.getType:(C)I
+java/lang/Character.getType:(I)I
+java/lang/Character.hashCode:()I
+java/lang/Character.hashCode:(C)I
+java/lang/Character.highSurrogate:(I)C
+java/lang/Character.isAlphabetic:(I)Z
+java/lang/Character.isBmpCodePoint:(I)Z
+java/lang/Character.isDefined:(C)Z
+java/lang/Character.isDefined:(I)Z
+java/lang/Character.isDigit:(C)Z
+java/lang/Character.isDigit:(I)Z
+java/lang/Character.isHighSurrogate:(C)Z
+java/lang/Character.isISOControl:(C)Z
+java/lang/Character.isISOControl:(I)Z
+java/lang/Character.isIdentifierIgnorable:(C)Z
+java/lang/Character.isIdentifierIgnorable:(I)Z
+java/lang/Character.isIdeographic:(I)Z
+java/lang/Character.isJavaIdentifierPart:(C)Z
+java/lang/Character.isJavaIdentifierPart:(I)Z
+java/lang/Character.isJavaIdentifierStart:(C)Z
+java/lang/Character.isJavaIdentifierStart:(I)Z
+java/lang/Character.isJavaLetter:(C)Z
+java/lang/Character.isJavaLetterOrDigit:(C)Z
+java/lang/Character.isLetter:(C)Z
+java/lang/Character.isLetter:(I)Z
+java/lang/Character.isLetterOrDigit:(C)Z
+java/lang/Character.isLetterOrDigit:(I)Z
+java/lang/Character.isLowSurrogate:(C)Z
+java/lang/Character.isLowerCase:(C)Z
+java/lang/Character.isLowerCase:(I)Z
+java/lang/Character.isMirrored:(C)Z
+java/lang/Character.isMirrored:(I)Z
+java/lang/Character.isSpace:(C)Z
+java/lang/Character.isSpaceChar:(C)Z
+java/lang/Character.isSpaceChar:(I)Z
+java/lang/Character.isSupplementaryCodePoint:(I)Z
+java/lang/Character.isSurrogate:(C)Z
+java/lang/Character.isSurrogatePair:(CC)Z
+java/lang/Character.isTitleCase:(C)Z
+java/lang/Character.isTitleCase:(I)Z
+java/lang/Character.isUnicodeIdentifierPart:(C)Z
+java/lang/Character.isUnicodeIdentifierPart:(I)Z
+java/lang/Character.isUnicodeIdentifierStart:(C)Z
+java/lang/Character.isUnicodeIdentifierStart:(I)Z
+java/lang/Character.isUpperCase:(C)Z
+java/lang/Character.isUpperCase:(I)Z
+java/lang/Character.isValidCodePoint:(I)Z
+java/lang/Character.isWhitespace:(C)Z
+java/lang/Character.isWhitespace:(I)Z
+java/lang/Character.lowSurrogate:(I)C
+java/lang/Character.offsetByCodePoints:(Ljava/lang/CharSequence;II)I
+java/lang/Character.offsetByCodePoints:([CIIII)I
+java/lang/Character.offsetByCodePointsImpl:([CIIII)I
+java/lang/Character.reverseBytes:(C)C
+java/lang/Character.toChars:(I)[C
+java/lang/Character.toChars:(I[CI)I
+java/lang/Character.toCodePoint:(CC)I
+java/lang/Character.toLowerCase:(C)C
+java/lang/Character.toLowerCase:(I)I
+java/lang/Character.toString:()Ljava/lang/String;
+java/lang/Character.toString:(C)Ljava/lang/String;
+java/lang/Character.toSurrogates:(I[CI)V
+java/lang/Character.toTitleCase:(C)C
+java/lang/Character.toTitleCase:(I)I
+java/lang/Character.toUpperCase:(C)C
+java/lang/Character.toUpperCase:(I)I
+java/lang/Character.toUpperCaseCharArray:(I)[C
+java/lang/Character.toUpperCaseEx:(I)I
+java/lang/Character.valueOf:(C)Ljava/lang/Character;
+java/lang/CharacterData.<init>:()V
+java/lang/CharacterData.digit:(II)I
+java/lang/CharacterData.getDirectionality:(I)B
+java/lang/CharacterData.getNumericValue:(I)I
+java/lang/CharacterData.getProperties:(I)I
+java/lang/CharacterData.getType:(I)I
+java/lang/CharacterData.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData.isIdeographic:(I)Z
+java/lang/CharacterData.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData.isMirrored:(I)Z
+java/lang/CharacterData.isOtherAlphabetic:(I)Z
+java/lang/CharacterData.isOtherLowercase:(I)Z
+java/lang/CharacterData.isOtherUppercase:(I)Z
+java/lang/CharacterData.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData.isWhitespace:(I)Z
+java/lang/CharacterData.of:(I)Ljava/lang/CharacterData;
+java/lang/CharacterData.toLowerCase:(I)I
+java/lang/CharacterData.toTitleCase:(I)I
+java/lang/CharacterData.toUpperCase:(I)I
+java/lang/CharacterData.toUpperCaseCharArray:(I)[C
+java/lang/CharacterData.toUpperCaseEx:(I)I
+java/lang/CharacterData00.<init>:()V
+java/lang/CharacterData00.digit:(II)I
+java/lang/CharacterData00.findInCharMap:(I)I
+java/lang/CharacterData00.getDirectionality:(I)B
+java/lang/CharacterData00.getNumericValue:(I)I
+java/lang/CharacterData00.getProperties:(I)I
+java/lang/CharacterData00.getPropertiesEx:(I)I
+java/lang/CharacterData00.getType:(I)I
+java/lang/CharacterData00.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData00.isIdeographic:(I)Z
+java/lang/CharacterData00.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData00.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData00.isMirrored:(I)Z
+java/lang/CharacterData00.isOtherAlphabetic:(I)Z
+java/lang/CharacterData00.isOtherLowercase:(I)Z
+java/lang/CharacterData00.isOtherUppercase:(I)Z
+java/lang/CharacterData00.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData00.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData00.isWhitespace:(I)Z
+java/lang/CharacterData00.toLowerCase:(I)I
+java/lang/CharacterData00.toTitleCase:(I)I
+java/lang/CharacterData00.toUpperCase:(I)I
+java/lang/CharacterData00.toUpperCaseCharArray:(I)[C
+java/lang/CharacterData00.toUpperCaseEx:(I)I
+java/lang/CharacterData01.<init>:()V
+java/lang/CharacterData01.digit:(II)I
+java/lang/CharacterData01.getDirectionality:(I)B
+java/lang/CharacterData01.getNumericValue:(I)I
+java/lang/CharacterData01.getProperties:(I)I
+java/lang/CharacterData01.getPropertiesEx:(I)I
+java/lang/CharacterData01.getType:(I)I
+java/lang/CharacterData01.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData01.isIdeographic:(I)Z
+java/lang/CharacterData01.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData01.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData01.isMirrored:(I)Z
+java/lang/CharacterData01.isOtherAlphabetic:(I)Z
+java/lang/CharacterData01.isOtherLowercase:(I)Z
+java/lang/CharacterData01.isOtherUppercase:(I)Z
+java/lang/CharacterData01.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData01.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData01.isWhitespace:(I)Z
+java/lang/CharacterData01.toLowerCase:(I)I
+java/lang/CharacterData01.toTitleCase:(I)I
+java/lang/CharacterData01.toUpperCase:(I)I
+java/lang/CharacterData02.<init>:()V
+java/lang/CharacterData02.digit:(II)I
+java/lang/CharacterData02.getDirectionality:(I)B
+java/lang/CharacterData02.getNumericValue:(I)I
+java/lang/CharacterData02.getProperties:(I)I
+java/lang/CharacterData02.getPropertiesEx:(I)I
+java/lang/CharacterData02.getType:(I)I
+java/lang/CharacterData02.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData02.isIdeographic:(I)Z
+java/lang/CharacterData02.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData02.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData02.isMirrored:(I)Z
+java/lang/CharacterData02.isOtherAlphabetic:(I)Z
+java/lang/CharacterData02.isOtherLowercase:(I)Z
+java/lang/CharacterData02.isOtherUppercase:(I)Z
+java/lang/CharacterData02.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData02.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData02.isWhitespace:(I)Z
+java/lang/CharacterData02.toLowerCase:(I)I
+java/lang/CharacterData02.toTitleCase:(I)I
+java/lang/CharacterData02.toUpperCase:(I)I
+java/lang/CharacterData0E.<init>:()V
+java/lang/CharacterData0E.digit:(II)I
+java/lang/CharacterData0E.getDirectionality:(I)B
+java/lang/CharacterData0E.getNumericValue:(I)I
+java/lang/CharacterData0E.getProperties:(I)I
+java/lang/CharacterData0E.getPropertiesEx:(I)I
+java/lang/CharacterData0E.getType:(I)I
+java/lang/CharacterData0E.isIdentifierIgnorable:(I)Z
+java/lang/CharacterData0E.isIdeographic:(I)Z
+java/lang/CharacterData0E.isJavaIdentifierPart:(I)Z
+java/lang/CharacterData0E.isJavaIdentifierStart:(I)Z
+java/lang/CharacterData0E.isMirrored:(I)Z
+java/lang/CharacterData0E.isOtherAlphabetic:(I)Z
+java/lang/CharacterData0E.isOtherLowercase:(I)Z
+java/lang/CharacterData0E.isOtherUppercase:(I)Z
+java/lang/CharacterData0E.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterData0E.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterData0E.isWhitespace:(I)Z
+java/lang/CharacterData0E.toLowerCase:(I)I
+java/lang/CharacterData0E.toTitleCase:(I)I
+java/lang/CharacterData0E.toUpperCase:(I)I
+java/lang/CharacterDataLatin1.<init>:()V
+java/lang/CharacterDataLatin1.digit:(II)I
+java/lang/CharacterDataLatin1.getDirectionality:(I)B
+java/lang/CharacterDataLatin1.getNumericValue:(I)I
+java/lang/CharacterDataLatin1.getProperties:(I)I
+java/lang/CharacterDataLatin1.getPropertiesEx:(I)I
+java/lang/CharacterDataLatin1.getType:(I)I
+java/lang/CharacterDataLatin1.isIdentifierIgnorable:(I)Z
+java/lang/CharacterDataLatin1.isIdeographic:(I)Z
+java/lang/CharacterDataLatin1.isJavaIdentifierPart:(I)Z
+java/lang/CharacterDataLatin1.isJavaIdentifierStart:(I)Z
+java/lang/CharacterDataLatin1.isMirrored:(I)Z
+java/lang/CharacterDataLatin1.isOtherAlphabetic:(I)Z
+java/lang/CharacterDataLatin1.isOtherLowercase:(I)Z
+java/lang/CharacterDataLatin1.isOtherUppercase:(I)Z
+java/lang/CharacterDataLatin1.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterDataLatin1.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterDataLatin1.isWhitespace:(I)Z
+java/lang/CharacterDataLatin1.toLowerCase:(I)I
+java/lang/CharacterDataLatin1.toTitleCase:(I)I
+java/lang/CharacterDataLatin1.toUpperCase:(I)I
+java/lang/CharacterDataLatin1.toUpperCaseCharArray:(I)[C
+java/lang/CharacterDataLatin1.toUpperCaseEx:(I)I
+java/lang/CharacterDataPrivateUse.<clinit>:()V
+java/lang/CharacterDataPrivateUse.<init>:()V
+java/lang/CharacterDataPrivateUse.digit:(II)I
+java/lang/CharacterDataPrivateUse.getDirectionality:(I)B
+java/lang/CharacterDataPrivateUse.getNumericValue:(I)I
+java/lang/CharacterDataPrivateUse.getProperties:(I)I
+java/lang/CharacterDataPrivateUse.getType:(I)I
+java/lang/CharacterDataPrivateUse.isIdentifierIgnorable:(I)Z
+java/lang/CharacterDataPrivateUse.isJavaIdentifierPart:(I)Z
+java/lang/CharacterDataPrivateUse.isJavaIdentifierStart:(I)Z
+java/lang/CharacterDataPrivateUse.isMirrored:(I)Z
+java/lang/CharacterDataPrivateUse.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterDataPrivateUse.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterDataPrivateUse.isWhitespace:(I)Z
+java/lang/CharacterDataPrivateUse.toLowerCase:(I)I
+java/lang/CharacterDataPrivateUse.toTitleCase:(I)I
+java/lang/CharacterDataPrivateUse.toUpperCase:(I)I
+java/lang/CharacterDataUndefined.<clinit>:()V
+java/lang/CharacterDataUndefined.<init>:()V
+java/lang/CharacterDataUndefined.digit:(II)I
+java/lang/CharacterDataUndefined.getDirectionality:(I)B
+java/lang/CharacterDataUndefined.getNumericValue:(I)I
+java/lang/CharacterDataUndefined.getProperties:(I)I
+java/lang/CharacterDataUndefined.getType:(I)I
+java/lang/CharacterDataUndefined.isIdentifierIgnorable:(I)Z
+java/lang/CharacterDataUndefined.isJavaIdentifierPart:(I)Z
+java/lang/CharacterDataUndefined.isJavaIdentifierStart:(I)Z
+java/lang/CharacterDataUndefined.isMirrored:(I)Z
+java/lang/CharacterDataUndefined.isUnicodeIdentifierPart:(I)Z
+java/lang/CharacterDataUndefined.isUnicodeIdentifierStart:(I)Z
+java/lang/CharacterDataUndefined.isWhitespace:(I)Z
+java/lang/CharacterDataUndefined.toLowerCase:(I)I
+java/lang/CharacterDataUndefined.toTitleCase:(I)I
+java/lang/CharacterDataUndefined.toUpperCase:(I)I
+java/lang/CharacterName$1.<init>:()V
+java/lang/CharacterName.<init>:()V
+java/lang/Class$1.<init>:(Ljava/lang/Class;Ljava/lang/reflect/Constructor;)V
+java/lang/Class$2.<init>:(Ljava/lang/Class;)V
+java/lang/Class$3.<init>:()V
+java/lang/Class$4.<init>:(Ljava/lang/Class;Ljava/lang/reflect/Method;)V
+java/lang/Class$AnnotationData.<init>:(Ljava/util/Map;Ljava/util/Map;I)V
+java/lang/Class$Atomic.<init>:()V
+java/lang/Class$EnclosingMethodInfo.<init>:([Ljava/lang/Object;)V
+java/lang/Class$EnclosingMethodInfo.<init>:([Ljava/lang/Object;Ljava/lang/Class$1;)V
+java/lang/Class$EnclosingMethodInfo.getDescriptor:()Ljava/lang/String;
+java/lang/Class$EnclosingMethodInfo.getEnclosingClass:()Ljava/lang/Class;
+java/lang/Class$EnclosingMethodInfo.getName:()Ljava/lang/String;
+java/lang/Class$EnclosingMethodInfo.isConstructor:()Z
+java/lang/Class$EnclosingMethodInfo.isMethod:()Z
+java/lang/Class$EnclosingMethodInfo.isPartial:()Z
+java/lang/Class$MethodArray.<init>:()V
+java/lang/Class$MethodArray.<init>:(I)V
+java/lang/Class$MethodArray.compactAndTrim:()V
+java/lang/Class$MethodArray.get:(I)Ljava/lang/reflect/Method;
+java/lang/Class$MethodArray.getArray:()[Ljava/lang/reflect/Method;
+java/lang/Class$MethodArray.getFirst:()Ljava/lang/reflect/Method;
+java/lang/Class$MethodArray.hasDefaults:()Z
+java/lang/Class$MethodArray.length:()I
+java/lang/Class$ReflectionData.<init>:(I)V
+java/lang/Class.<init>:()V
+java/lang/Class.access$300:([Ljava/lang/Object;[Ljava/lang/Object;)Z
+java/lang/Class.access$402:(Z)Z
+java/lang/Class.access$502:(Z)Z
+java/lang/Class.addAll:(Ljava/util/Collection;[Ljava/lang/reflect/Field;)V
+java/lang/Class.arrayContentsEq:([Ljava/lang/Object;[Ljava/lang/Object;)Z
+java/lang/Class.getAnnotationType:()Lsun/reflect/annotation/AnnotationType;
+java/lang/Class.getComponentType:()Ljava/lang/Class;
+java/lang/Class.isAsciiDigit:(C)Z
+java/lang/Class.toClass:(Ljava/lang/reflect/Type;)Ljava/lang/Class;
+java/lang/ClassCastException.<init>:()V
+java/lang/ClassCastException.<init>:(Ljava/lang/String;)V
+java/lang/ClassCircularityError.<init>:()V
+java/lang/ClassCircularityError.<init>:(Ljava/lang/String;)V
+java/lang/ClassFormatError.<init>:()V
+java/lang/ClassFormatError.<init>:(Ljava/lang/String;)V
+java/lang/ClassLoader$1.<init>:(Ljava/lang/ClassLoader;Ljava/lang/SecurityManager;Ljava/lang/String;I)V
+java/lang/ClassLoader$2.<init>:(Ljava/util/Enumeration;)V
+java/lang/ClassLoader$2.hasMoreElements:()Z
+java/lang/ClassLoader$3.<init>:(Ljava/io/File;)V
+java/lang/ClassLoader$NativeLibrary.<init>:(Ljava/lang/Class;Ljava/lang/String;Z)V
+java/lang/ClassLoader$NativeLibrary.access$200:(Ljava/lang/ClassLoader$NativeLibrary;)Ljava/lang/Class;
+java/lang/ClassLoader$ParallelLoaders.<init>:()V
+java/lang/ClassLoader$ParallelLoaders.isRegistered:(Ljava/lang/Class;)Z
+java/lang/ClassLoader.access$000:()Ljava/util/Vector;
+java/lang/ClassLoader.access$100:()Ljava/util/Stack;
+java/lang/ClassLoader.addClass:(Ljava/lang/Class;)V
+java/lang/ClassLoader.clearAssertionStatus:()V
+java/lang/ClassLoader.desiredAssertionStatus:(Ljava/lang/String;)Z
+java/lang/ClassLoader.findClass:(Ljava/lang/String;)Ljava/lang/Class;
+java/lang/ClassLoader.findLibrary:(Ljava/lang/String;)Ljava/lang/String;
+java/lang/ClassLoader.findResource:(Ljava/lang/String;)Ljava/net/URL;
+java/lang/ClassLoader.findResources:(Ljava/lang/String;)Ljava/util/Enumeration;
+java/lang/ClassLoader.isAncestor:(Ljava/lang/ClassLoader;)Z
+java/lang/ClassLoader.needsClassLoaderPermissionCheck:(Ljava/lang/ClassLoader;Ljava/lang/ClassLoader;)Z
+java/lang/ClassLoaderHelper.<init>:()V
+java/lang/ClassNotFoundException.<init>:(Ljava/lang/String;)V
+java/lang/ClassNotFoundException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/ClassNotFoundException.getCause:()Ljava/lang/Throwable;
+java/lang/ClassNotFoundException.getException:()Ljava/lang/Throwable;
+java/lang/ClassValue$ClassValueMap.getCache:()[Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue$ClassValueMap.loadFromCache:([Ljava/lang/ClassValue$Entry;I)Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue$ClassValueMap.probeHomeLocation:([Ljava/lang/ClassValue$Entry;Ljava/lang/ClassValue;)Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue$ClassValueMap.sizeCache:(I)V
+java/lang/ClassValue$Entry.assertNotPromise:()V
+java/lang/ClassValue$Entry.isPromise:()Z
+java/lang/ClassValue$Entry.value:()Ljava/lang/Object;
+java/lang/ClassValue$Identity.<init>:()V
+java/lang/ClassValue$Version.classValue:()Ljava/lang/ClassValue;
+java/lang/ClassValue$Version.isLive:()Z
+java/lang/ClassValue$Version.promise:()Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue.castEntry:(Ljava/lang/ClassValue$Entry;)Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue.computeValue:(Ljava/lang/Class;)Ljava/lang/Object;
+java/lang/ClassValue.getCacheCarefully:(Ljava/lang/Class;)[Ljava/lang/ClassValue$Entry;
+java/lang/ClassValue.version:()Ljava/lang/ClassValue$Version;
+java/lang/CloneNotSupportedException.<init>:()V
+java/lang/CloneNotSupportedException.<init>:(Ljava/lang/String;)V
+java/lang/Comparable.compareTo:(Ljava/lang/Object;)I
+java/lang/Compiler$1.<init>:()V
+java/lang/Compiler.<init>:()V
+java/lang/ConditionalSpecialCasing$Entry.<init>:(I[C[CLjava/lang/String;I)V
+java/lang/ConditionalSpecialCasing$Entry.getCodePoint:()I
+java/lang/ConditionalSpecialCasing$Entry.getCondition:()I
+java/lang/ConditionalSpecialCasing$Entry.getLanguage:()Ljava/lang/String;
+java/lang/ConditionalSpecialCasing$Entry.getLowerCase:()[C
+java/lang/ConditionalSpecialCasing$Entry.getUpperCase:()[C
+java/lang/ConditionalSpecialCasing.<init>:()V
+java/lang/ConditionalSpecialCasing.isCased:(I)Z
+java/lang/ConditionalSpecialCasing.isSoftDotted:(I)Z
+java/lang/Double.<init>:(D)V
+java/lang/Double.byteValue:()B
+java/lang/Double.doubleValue:()D
+java/lang/Double.floatValue:()F
+java/lang/Double.intValue:()I
+java/lang/Double.isFinite:(D)Z
+java/lang/Double.isInfinite:()Z
+java/lang/Double.isInfinite:(D)Z
+java/lang/Double.isNaN:()Z
+java/lang/Double.isNaN:(D)Z
+java/lang/Double.longValue:()J
+java/lang/Double.shortValue:()S
+java/lang/Double.sum:(DD)D
+java/lang/Double.valueOf:(D)Ljava/lang/Double;
+java/lang/Enum.<init>:(Ljava/lang/String;I)V
+java/lang/Enum.clone:()Ljava/lang/Object;
+java/lang/Enum.equals:(Ljava/lang/Object;)Z
+java/lang/Enum.name:()Ljava/lang/String;
+java/lang/Enum.ordinal:()I
+java/lang/Enum.toString:()Ljava/lang/String;
+java/lang/EnumConstantNotPresentException.constantName:()Ljava/lang/String;
+java/lang/EnumConstantNotPresentException.enumType:()Ljava/lang/Class;
+java/lang/Error.<init>:()V
+java/lang/Error.<init>:(Ljava/lang/String;)V
+java/lang/Error.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Error.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/Exception.<init>:()V
+java/lang/Exception.<init>:(Ljava/lang/String;)V
+java/lang/Exception.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Exception.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/ExceptionInInitializerError.getCause:()Ljava/lang/Throwable;
+java/lang/ExceptionInInitializerError.getException:()Ljava/lang/Throwable;
+java/lang/Float.<init>:(D)V
+java/lang/Float.<init>:(F)V
+java/lang/Float.byteValue:()B
+java/lang/Float.doubleValue:()D
+java/lang/Float.floatValue:()F
+java/lang/Float.intValue:()I
+java/lang/Float.isFinite:(F)Z
+java/lang/Float.isInfinite:()Z
+java/lang/Float.isInfinite:(F)Z
+java/lang/Float.isNaN:()Z
+java/lang/Float.isNaN:(F)Z
+java/lang/Float.longValue:()J
+java/lang/Float.shortValue:()S
+java/lang/Float.sum:(FF)F
+java/lang/Float.valueOf:(F)Ljava/lang/Float;
+java/lang/IllegalAccessError.<init>:()V
+java/lang/IllegalAccessError.<init>:(Ljava/lang/String;)V
+java/lang/IllegalAccessException.<init>:()V
+java/lang/IllegalAccessException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalArgumentException.<init>:()V
+java/lang/IllegalArgumentException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalArgumentException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/IllegalMonitorStateException.<init>:()V
+java/lang/IllegalMonitorStateException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalStateException.<init>:()V
+java/lang/IllegalStateException.<init>:(Ljava/lang/String;)V
+java/lang/IllegalStateException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/IllegalThreadStateException.<init>:()V
+java/lang/IllegalThreadStateException.<init>:(Ljava/lang/String;)V
+java/lang/IncompatibleClassChangeError.<init>:()V
+java/lang/IncompatibleClassChangeError.<init>:(Ljava/lang/String;)V
+java/lang/IndexOutOfBoundsException.<init>:()V
+java/lang/IndexOutOfBoundsException.<init>:(Ljava/lang/String;)V
+java/lang/InheritableThreadLocal.childValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/InheritableThreadLocal.getMap:(Ljava/lang/Thread;)Ljava/lang/ThreadLocal$ThreadLocalMap;
+java/lang/InstantiationError.<init>:()V
+java/lang/InstantiationError.<init>:(Ljava/lang/String;)V
+java/lang/InstantiationException.<init>:()V
+java/lang/InstantiationException.<init>:(Ljava/lang/String;)V
+java/lang/Integer$IntegerCache.<init>:()V
+java/lang/Integer.<init>:(I)V
+java/lang/Integer.<init>:(Ljava/lang/String;)V
+java/lang/Integer.bitCount:(I)I
+java/lang/Integer.byteValue:()B
+java/lang/Integer.compare:(II)I
+java/lang/Integer.compareTo:(Ljava/lang/Integer;)I
+java/lang/Integer.compareTo:(Ljava/lang/Object;)I
+java/lang/Integer.compareUnsigned:(II)I
+java/lang/Integer.decode:(Ljava/lang/String;)Ljava/lang/Integer;
+java/lang/Integer.divideUnsigned:(II)I
+java/lang/Integer.doubleValue:()D
+java/lang/Integer.equals:(Ljava/lang/Object;)Z
+java/lang/Integer.floatValue:()F
+java/lang/Integer.formatUnsignedInt:(II[CII)I
+java/lang/Integer.getChars:(II[C)V
+java/lang/Integer.hashCode:()I
+java/lang/Integer.hashCode:(I)I
+java/lang/Integer.highestOneBit:(I)I
+java/lang/Integer.intValue:()I
+java/lang/Integer.longValue:()J
+java/lang/Integer.lowestOneBit:(I)I
+java/lang/Integer.max:(II)I
+java/lang/Integer.min:(II)I
+java/lang/Integer.numberOfLeadingZeros:(I)I
+java/lang/Integer.numberOfTrailingZeros:(I)I
+java/lang/Integer.parseInt:(Ljava/lang/String;)I
+java/lang/Integer.parseInt:(Ljava/lang/String;I)I
+java/lang/Integer.remainderUnsigned:(II)I
+java/lang/Integer.reverse:(I)I
+java/lang/Integer.reverseBytes:(I)I
+java/lang/Integer.rotateLeft:(II)I
+java/lang/Integer.rotateRight:(II)I
+java/lang/Integer.shortValue:()S
+java/lang/Integer.signum:(I)I
+java/lang/Integer.stringSize:(I)I
+java/lang/Integer.sum:(II)I
+java/lang/Integer.toBinaryString:(I)Ljava/lang/String;
+java/lang/Integer.toHexString:(I)Ljava/lang/String;
+java/lang/Integer.toOctalString:(I)Ljava/lang/String;
+java/lang/Integer.toString:()Ljava/lang/String;
+java/lang/Integer.toString:(I)Ljava/lang/String;
+java/lang/Integer.toString:(II)Ljava/lang/String;
+java/lang/Integer.toUnsignedLong:(I)J
+java/lang/Integer.toUnsignedString0:(II)Ljava/lang/String;
+java/lang/Integer.toUnsignedString:(I)Ljava/lang/String;
+java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
+java/lang/Integer.valueOf:(Ljava/lang/String;)Ljava/lang/Integer;
+java/lang/Integer.valueOf:(Ljava/lang/String;I)Ljava/lang/Integer;
+java/lang/InternalError.<init>:()V
+java/lang/InternalError.<init>:(Ljava/lang/String;)V
+java/lang/InternalError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/InterruptedException.<init>:()V
+java/lang/InterruptedException.<init>:(Ljava/lang/String;)V
+java/lang/Iterable.iterator:()Ljava/util/Iterator;
+java/lang/Iterable.spliterator:()Ljava/util/Spliterator;
+java/lang/LinkageError.<init>:()V
+java/lang/LinkageError.<init>:(Ljava/lang/String;)V
+java/lang/LinkageError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Long$LongCache.<clinit>:()V
+java/lang/Long$LongCache.<init>:()V
+java/lang/Long.<init>:(J)V
+java/lang/Long.<init>:(Ljava/lang/String;)V
+java/lang/Long.bitCount:(J)I
+java/lang/Long.byteValue:()B
+java/lang/Long.compare:(JJ)I
+java/lang/Long.compareTo:(Ljava/lang/Long;)I
+java/lang/Long.compareTo:(Ljava/lang/Object;)I
+java/lang/Long.compareUnsigned:(JJ)I
+java/lang/Long.decode:(Ljava/lang/String;)Ljava/lang/Long;
+java/lang/Long.doubleValue:()D
+java/lang/Long.equals:(Ljava/lang/Object;)Z
+java/lang/Long.floatValue:()F
+java/lang/Long.formatUnsignedLong:(JI[CII)I
+java/lang/Long.getChars:(JI[C)V
+java/lang/Long.hashCode:()I
+java/lang/Long.hashCode:(J)I
+java/lang/Long.highestOneBit:(J)J
+java/lang/Long.intValue:()I
+java/lang/Long.longValue:()J
+java/lang/Long.lowestOneBit:(J)J
+java/lang/Long.max:(JJ)J
+java/lang/Long.min:(JJ)J
+java/lang/Long.numberOfLeadingZeros:(J)I
+java/lang/Long.numberOfTrailingZeros:(J)I
+java/lang/Long.parseLong:(Ljava/lang/String;)J
+java/lang/Long.parseLong:(Ljava/lang/String;I)J
+java/lang/Long.reverse:(J)J
+java/lang/Long.reverseBytes:(J)J
+java/lang/Long.rotateLeft:(JI)J
+java/lang/Long.rotateRight:(JI)J
+java/lang/Long.shortValue:()S
+java/lang/Long.signum:(J)I
+java/lang/Long.stringSize:(J)I
+java/lang/Long.sum:(JJ)J
+java/lang/Long.toBinaryString:(J)Ljava/lang/String;
+java/lang/Long.toHexString:(J)Ljava/lang/String;
+java/lang/Long.toOctalString:(J)Ljava/lang/String;
+java/lang/Long.toString:()Ljava/lang/String;
+java/lang/Long.toString:(J)Ljava/lang/String;
+java/lang/Long.toString:(JI)Ljava/lang/String;
+java/lang/Long.toUnsignedString0:(JI)Ljava/lang/String;
+java/lang/Long.valueOf:(J)Ljava/lang/Long;
+java/lang/Long.valueOf:(Ljava/lang/String;)Ljava/lang/Long;
+java/lang/Long.valueOf:(Ljava/lang/String;I)Ljava/lang/Long;
+java/lang/Math$RandomNumberGeneratorHolder.<init>:()V
+java/lang/Math.<init>:()V
+java/lang/Math.abs:(D)D
+java/lang/Math.abs:(F)F
+java/lang/Math.abs:(I)I
+java/lang/Math.abs:(J)J
+java/lang/Math.addExact:(II)I
+java/lang/Math.addExact:(JJ)J
+java/lang/Math.decrementExact:(I)I
+java/lang/Math.decrementExact:(J)J
+java/lang/Math.floorDiv:(II)I
+java/lang/Math.floorDiv:(JJ)J
+java/lang/Math.floorMod:(II)I
+java/lang/Math.floorMod:(JJ)J
+java/lang/Math.incrementExact:(I)I
+java/lang/Math.incrementExact:(J)J
+java/lang/Math.max:(II)I
+java/lang/Math.max:(JJ)J
+java/lang/Math.min:(II)I
+java/lang/Math.min:(JJ)J
+java/lang/Math.multiplyExact:(II)I
+java/lang/Math.multiplyExact:(JJ)J
+java/lang/Math.negateExact:(I)I
+java/lang/Math.negateExact:(J)J
+java/lang/Math.subtractExact:(II)I
+java/lang/Math.subtractExact:(JJ)J
+java/lang/Math.toDegrees:(D)D
+java/lang/Math.toIntExact:(J)I
+java/lang/Math.toRadians:(D)D
+java/lang/NegativeArraySizeException.<init>:()V
+java/lang/NegativeArraySizeException.<init>:(Ljava/lang/String;)V
+java/lang/NoClassDefFoundError.<init>:()V
+java/lang/NoClassDefFoundError.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchFieldError.<init>:()V
+java/lang/NoSuchFieldError.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchFieldException.<init>:()V
+java/lang/NoSuchFieldException.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchMethodError.<init>:()V
+java/lang/NoSuchMethodError.<init>:(Ljava/lang/String;)V
+java/lang/NoSuchMethodException.<init>:()V
+java/lang/NoSuchMethodException.<init>:(Ljava/lang/String;)V
+java/lang/NullPointerException.<init>:()V
+java/lang/NullPointerException.<init>:(Ljava/lang/String;)V
+java/lang/Number.<init>:()V
+java/lang/Number.byteValue:()B
+java/lang/Number.doubleValue:()D
+java/lang/Number.floatValue:()F
+java/lang/Number.intValue:()I
+java/lang/Number.longValue:()J
+java/lang/Number.shortValue:()S
+java/lang/NumberFormatException.<init>:()V
+java/lang/NumberFormatException.<init>:(Ljava/lang/String;)V
+java/lang/NumberFormatException.forInputString:(Ljava/lang/String;)Ljava/lang/NumberFormatException;
+java/lang/Object.<init>:()V
+java/lang/Object.equals:(Ljava/lang/Object;)Z
+java/lang/Object.getClass:()Ljava/lang/Class;
+java/lang/OutOfMemoryError.<init>:()V
+java/lang/OutOfMemoryError.<init>:(Ljava/lang/String;)V
+java/lang/Package$1.<init>:(Ljava/lang/String;Ljava/lang/String;)V
+java/lang/Package$1PackageInfoProxy.<init>:(Ljava/lang/Package;)V
+java/lang/Package.<init>:(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/net/URL;Ljava/lang/ClassLoader;)V
+java/lang/Package.access$000:()Ljava/util/Map;
+java/lang/Package.access$200:()Ljava/util/Map;
+java/lang/Package.access$400:()Ljava/util/Map;
+java/lang/Package.getImplementationTitle:()Ljava/lang/String;
+java/lang/Package.getImplementationVendor:()Ljava/lang/String;
+java/lang/Package.getImplementationVersion:()Ljava/lang/String;
+java/lang/Package.getName:()Ljava/lang/String;
+java/lang/Package.getSpecificationTitle:()Ljava/lang/String;
+java/lang/Package.getSpecificationVendor:()Ljava/lang/String;
+java/lang/Package.getSpecificationVersion:()Ljava/lang/String;
+java/lang/Package.hashCode:()I
+java/lang/Package.isAnnotationPresent:(Ljava/lang/Class;)Z
+java/lang/Package.isSealed:()Z
+java/lang/Package.toString:()Ljava/lang/String;
+java/lang/Process.<init>:()V
+java/lang/Process.destroy:()V
+java/lang/Process.destroyForcibly:()Ljava/lang/Process;
+java/lang/Process.exitValue:()I
+java/lang/Process.getErrorStream:()Ljava/io/InputStream;
+java/lang/Process.getInputStream:()Ljava/io/InputStream;
+java/lang/Process.getOutputStream:()Ljava/io/OutputStream;
+java/lang/Process.isAlive:()Z
+java/lang/Process.waitFor:()I
+java/lang/ProcessBuilder$NullInputStream.available:()I
+java/lang/ProcessBuilder$NullInputStream.read:()I
+java/lang/ProcessBuilder$Redirect$1.<init>:()V
+java/lang/ProcessBuilder$Redirect$1.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$2.<init>:()V
+java/lang/ProcessBuilder$Redirect$2.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$3.<init>:(Ljava/io/File;)V
+java/lang/ProcessBuilder$Redirect$3.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect$3.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$4.<init>:(Ljava/io/File;)V
+java/lang/ProcessBuilder$Redirect$4.append:()Z
+java/lang/ProcessBuilder$Redirect$4.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect$4.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$5.<init>:(Ljava/io/File;)V
+java/lang/ProcessBuilder$Redirect$5.append:()Z
+java/lang/ProcessBuilder$Redirect$5.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect$5.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder$Redirect$Type.<clinit>:()V
+java/lang/ProcessBuilder$Redirect$Type.<init>:(Ljava/lang/String;I)V
+java/lang/ProcessBuilder$Redirect.<init>:()V
+java/lang/ProcessBuilder$Redirect.<init>:(Ljava/lang/ProcessBuilder$1;)V
+java/lang/ProcessBuilder$Redirect.append:()Z
+java/lang/ProcessBuilder$Redirect.appendTo:(Ljava/io/File;)Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder$Redirect.file:()Ljava/io/File;
+java/lang/ProcessBuilder$Redirect.from:(Ljava/io/File;)Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder$Redirect.to:(Ljava/io/File;)Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder$Redirect.type:()Ljava/lang/ProcessBuilder$Redirect$Type;
+java/lang/ProcessBuilder.<init>:(Ljava/util/List;)V
+java/lang/ProcessBuilder.command:()Ljava/util/List;
+java/lang/ProcessBuilder.command:(Ljava/util/List;)Ljava/lang/ProcessBuilder;
+java/lang/ProcessBuilder.directory:()Ljava/io/File;
+java/lang/ProcessBuilder.directory:(Ljava/io/File;)Ljava/lang/ProcessBuilder;
+java/lang/ProcessBuilder.inheritIO:()Ljava/lang/ProcessBuilder;
+java/lang/ProcessBuilder.redirectError:()Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder.redirectErrorStream:()Z
+java/lang/ProcessBuilder.redirectErrorStream:(Z)Ljava/lang/ProcessBuilder;
+java/lang/ProcessBuilder.redirectInput:()Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder.redirectOutput:()Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessBuilder.redirects:()[Ljava/lang/ProcessBuilder$Redirect;
+java/lang/ProcessEnvironment$ExternalData.<init>:(Ljava/lang/String;[B)V
+java/lang/ProcessEnvironment$ExternalData.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$ExternalData.getBytes:()[B
+java/lang/ProcessEnvironment$ExternalData.hashCode:()I
+java/lang/ProcessEnvironment$ExternalData.toString:()Ljava/lang/String;
+java/lang/ProcessEnvironment$StringEntry.<init>:(Ljava/util/Map$Entry;)V
+java/lang/ProcessEnvironment$StringEntry.access$600:(Ljava/lang/ProcessEnvironment$StringEntry;)Ljava/util/Map$Entry;
+java/lang/ProcessEnvironment$StringEntry.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$StringEntry.hashCode:()I
+java/lang/ProcessEnvironment$StringEntrySet$1.<init>:(Ljava/lang/ProcessEnvironment$StringEntrySet;)V
+java/lang/ProcessEnvironment$StringEntrySet$1.hasNext:()Z
+java/lang/ProcessEnvironment$StringEntrySet$1.next:()Ljava/lang/Object;
+java/lang/ProcessEnvironment$StringEntrySet$1.next:()Ljava/util/Map$Entry;
+java/lang/ProcessEnvironment$StringEntrySet$1.remove:()V
+java/lang/ProcessEnvironment$StringEntrySet$2.<init>:(Ljava/lang/Object;)V
+java/lang/ProcessEnvironment$StringEntrySet$2.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/ProcessEnvironment$StringEntrySet$2.setValue:(Ljava/lang/ProcessEnvironment$Value;)Ljava/lang/ProcessEnvironment$Value;
+java/lang/ProcessEnvironment$StringEntrySet.<init>:(Ljava/util/Set;)V
+java/lang/ProcessEnvironment$StringEntrySet.access$500:(Ljava/lang/ProcessEnvironment$StringEntrySet;)Ljava/util/Set;
+java/lang/ProcessEnvironment$StringEntrySet.clear:()V
+java/lang/ProcessEnvironment$StringEntrySet.contains:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$StringEntrySet.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$StringEntrySet.hashCode:()I
+java/lang/ProcessEnvironment$StringEntrySet.isEmpty:()Z
+java/lang/ProcessEnvironment$StringEntrySet.iterator:()Ljava/util/Iterator;
+java/lang/ProcessEnvironment$StringEntrySet.remove:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$StringEntrySet.size:()I
+java/lang/ProcessEnvironment$StringEntrySet.vvEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/lang/ProcessEnvironment$StringEnvironment.<init>:(Ljava/util/Map;)V
+java/lang/ProcessEnvironment$StringEnvironment.clear:()V
+java/lang/ProcessEnvironment$StringEnvironment.entrySet:()Ljava/util/Set;
+java/lang/ProcessEnvironment$StringEnvironment.isEmpty:()Z
+java/lang/ProcessEnvironment$StringEnvironment.keySet:()Ljava/util/Set;
+java/lang/ProcessEnvironment$StringEnvironment.size:()I
+java/lang/ProcessEnvironment$StringEnvironment.values:()Ljava/util/Collection;
+java/lang/ProcessEnvironment$StringKeySet$1.<init>:(Ljava/lang/ProcessEnvironment$StringKeySet;)V
+java/lang/ProcessEnvironment$StringKeySet$1.hasNext:()Z
+java/lang/ProcessEnvironment$StringKeySet$1.remove:()V
+java/lang/ProcessEnvironment$StringKeySet.<init>:(Ljava/util/Set;)V
+java/lang/ProcessEnvironment$StringKeySet.access$800:(Ljava/lang/ProcessEnvironment$StringKeySet;)Ljava/util/Set;
+java/lang/ProcessEnvironment$StringKeySet.clear:()V
+java/lang/ProcessEnvironment$StringKeySet.isEmpty:()Z
+java/lang/ProcessEnvironment$StringKeySet.iterator:()Ljava/util/Iterator;
+java/lang/ProcessEnvironment$StringKeySet.size:()I
+java/lang/ProcessEnvironment$StringValues$1.<init>:(Ljava/lang/ProcessEnvironment$StringValues;)V
+java/lang/ProcessEnvironment$StringValues$1.hasNext:()Z
+java/lang/ProcessEnvironment$StringValues$1.remove:()V
+java/lang/ProcessEnvironment$StringValues.<init>:(Ljava/util/Collection;)V
+java/lang/ProcessEnvironment$StringValues.access$700:(Ljava/lang/ProcessEnvironment$StringValues;)Ljava/util/Collection;
+java/lang/ProcessEnvironment$StringValues.clear:()V
+java/lang/ProcessEnvironment$StringValues.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$StringValues.hashCode:()I
+java/lang/ProcessEnvironment$StringValues.isEmpty:()Z
+java/lang/ProcessEnvironment$StringValues.iterator:()Ljava/util/Iterator;
+java/lang/ProcessEnvironment$StringValues.size:()I
+java/lang/ProcessEnvironment$Value.<init>:(Ljava/lang/String;[B)V
+java/lang/ProcessEnvironment$Value.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment$Variable.<init>:(Ljava/lang/String;[B)V
+java/lang/ProcessEnvironment$Variable.equals:(Ljava/lang/Object;)Z
+java/lang/ProcessEnvironment.<init>:()V
+java/lang/ProcessEnvironment.access$000:([B[B)Z
+java/lang/ProcessEnvironment.access$100:([B)I
+java/lang/ProcessEnvironment.access$200:(Ljava/lang/String;)V
+java/lang/ProcessEnvironment.access$300:([B[B)I
+java/lang/ProcessEnvironment.access$400:(Ljava/lang/String;)V
+java/lang/ProcessEnvironment.arrayCompare:([B[B)I
+java/lang/ProcessEnvironment.arrayEquals:([B[B)Z
+java/lang/ProcessEnvironment.arrayHash:([B)I
+java/lang/ProcessEnvironment.getenv:()Ljava/util/Map;
+java/lang/ProcessEnvironment.getenv:(Ljava/lang/String;)Ljava/lang/String;
+java/lang/ProcessEnvironment.validateValue:(Ljava/lang/String;)V
+java/lang/ProcessEnvironment.validateVariable:(Ljava/lang/String;)V
+java/lang/ProcessImpl.<init>:()V
+java/lang/Readable.read:(Ljava/nio/CharBuffer;)I
+java/lang/ReflectiveOperationException.<init>:()V
+java/lang/ReflectiveOperationException.<init>:(Ljava/lang/String;)V
+java/lang/ReflectiveOperationException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Runnable.run:()V
+java/lang/Runtime.<clinit>:()V
+java/lang/Runtime.<init>:()V
+java/lang/Runtime.getLocalizedInputStream:(Ljava/io/InputStream;)Ljava/io/InputStream;
+java/lang/Runtime.getLocalizedOutputStream:(Ljava/io/OutputStream;)Ljava/io/OutputStream;
+java/lang/Runtime.getRuntime:()Ljava/lang/Runtime;
+java/lang/RuntimeException.<init>:()V
+java/lang/RuntimeException.<init>:(Ljava/lang/String;)V
+java/lang/RuntimeException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/RuntimeException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/SecurityException.<init>:()V
+java/lang/SecurityException.<init>:(Ljava/lang/String;)V
+java/lang/SecurityException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/SecurityManager$1.<init>:(Ljava/lang/SecurityManager;)V
+java/lang/SecurityManager$2.<init>:(Ljava/lang/SecurityManager;)V
+java/lang/SecurityManager.getInCheck:()Z
+java/lang/Short$ShortCache.<clinit>:()V
+java/lang/Short$ShortCache.<init>:()V
+java/lang/Short.<init>:(Ljava/lang/String;)V
+java/lang/Short.<init>:(S)V
+java/lang/Short.byteValue:()B
+java/lang/Short.compare:(SS)I
+java/lang/Short.compareTo:(Ljava/lang/Object;)I
+java/lang/Short.compareTo:(Ljava/lang/Short;)I
+java/lang/Short.decode:(Ljava/lang/String;)Ljava/lang/Short;
+java/lang/Short.doubleValue:()D
+java/lang/Short.equals:(Ljava/lang/Object;)Z
+java/lang/Short.floatValue:()F
+java/lang/Short.hashCode:()I
+java/lang/Short.hashCode:(S)I
+java/lang/Short.intValue:()I
+java/lang/Short.longValue:()J
+java/lang/Short.parseShort:(Ljava/lang/String;)S
+java/lang/Short.parseShort:(Ljava/lang/String;I)S
+java/lang/Short.reverseBytes:(S)S
+java/lang/Short.shortValue:()S
+java/lang/Short.toString:()Ljava/lang/String;
+java/lang/Short.toString:(S)Ljava/lang/String;
+java/lang/Short.toUnsignedInt:(S)I
+java/lang/Short.toUnsignedLong:(S)J
+java/lang/Short.valueOf:(Ljava/lang/String;)Ljava/lang/Short;
+java/lang/Short.valueOf:(Ljava/lang/String;I)Ljava/lang/Short;
+java/lang/Short.valueOf:(S)Ljava/lang/Short;
+java/lang/Shutdown$Lock.<init>:()V
+java/lang/Shutdown$Lock.<init>:(Ljava/lang/Shutdown$1;)V
+java/lang/Shutdown.<clinit>:()V
+java/lang/Shutdown.<init>:()V
+java/lang/Shutdown.add:(IZLjava/lang/Runnable;)V
+java/lang/Shutdown.runHooks:()V
+java/lang/Shutdown.setRunFinalizersOnExit:(Z)V
+java/lang/StackOverflowError.<init>:()V
+java/lang/StackOverflowError.<init>:(Ljava/lang/String;)V
+java/lang/StackTraceElement.<init>:(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)V
+java/lang/StackTraceElement.equals:(Ljava/lang/Object;)Z
+java/lang/StackTraceElement.getClassName:()Ljava/lang/String;
+java/lang/StackTraceElement.getFileName:()Ljava/lang/String;
+java/lang/StackTraceElement.getLineNumber:()I
+java/lang/StackTraceElement.getMethodName:()Ljava/lang/String;
+java/lang/StackTraceElement.isNativeMethod:()Z
+java/lang/StackTraceElement.toString:()Ljava/lang/String;
+java/lang/StrictMath$RandomNumberGeneratorHolder.<init>:()V
+java/lang/StrictMath.<init>:()V
+java/lang/StrictMath.abs:(D)D
+java/lang/StrictMath.abs:(F)F
+java/lang/StrictMath.abs:(I)I
+java/lang/StrictMath.abs:(J)J
+java/lang/StrictMath.addExact:(II)I
+java/lang/StrictMath.addExact:(JJ)J
+java/lang/StrictMath.floorDiv:(II)I
+java/lang/StrictMath.floorDiv:(JJ)J
+java/lang/StrictMath.floorMod:(II)I
+java/lang/StrictMath.floorMod:(JJ)J
+java/lang/StrictMath.max:(II)I
+java/lang/StrictMath.max:(JJ)J
+java/lang/StrictMath.min:(II)I
+java/lang/StrictMath.min:(JJ)J
+java/lang/StrictMath.multiplyExact:(II)I
+java/lang/StrictMath.multiplyExact:(JJ)J
+java/lang/StrictMath.subtractExact:(II)I
+java/lang/StrictMath.subtractExact:(JJ)J
+java/lang/StrictMath.toDegrees:(D)D
+java/lang/StrictMath.toIntExact:(J)I
+java/lang/StrictMath.toRadians:(D)D
+java/lang/String$CaseInsensitiveComparator.<init>:()V
+java/lang/String$CaseInsensitiveComparator.<init>:(Ljava/lang/String$1;)V
+java/lang/String$CaseInsensitiveComparator.compare:(Ljava/lang/Object;Ljava/lang/Object;)I
+java/lang/String$CaseInsensitiveComparator.compare:(Ljava/lang/String;Ljava/lang/String;)I
+java/lang/String$CaseInsensitiveComparator.readResolve:()Ljava/lang/Object;
+java/lang/String.<clinit>:()V
+java/lang/String.<init>:()V
+java/lang/String.<init>:(Ljava/lang/String;)V
+java/lang/String.<init>:([BI)V
+java/lang/String.<init>:([BIII)V
+java/lang/String.<init>:([C)V
+java/lang/String.<init>:([CII)V
+java/lang/String.<init>:([CZ)V
+java/lang/String.<init>:([III)V
+java/lang/String.charAt:(I)C
+java/lang/String.checkBounds:([BII)V
+java/lang/String.codePointAt:(I)I
+java/lang/String.codePointBefore:(I)I
+java/lang/String.codePointCount:(II)I
+java/lang/String.compareTo:(Ljava/lang/Object;)I
+java/lang/String.compareTo:(Ljava/lang/String;)I
+java/lang/String.compareToIgnoreCase:(Ljava/lang/String;)I
+java/lang/String.concat:(Ljava/lang/String;)Ljava/lang/String;
+java/lang/String.contains:(Ljava/lang/CharSequence;)Z
+java/lang/String.contentEquals:(Ljava/lang/CharSequence;)Z
+java/lang/String.contentEquals:(Ljava/lang/StringBuffer;)Z
+java/lang/String.copyValueOf:([C)Ljava/lang/String;
+java/lang/String.copyValueOf:([CII)Ljava/lang/String;
+java/lang/String.endsWith:(Ljava/lang/String;)Z
+java/lang/String.equals:(Ljava/lang/Object;)Z
+java/lang/String.equalsIgnoreCase:(Ljava/lang/String;)Z
+java/lang/String.getBytes:(II[BI)V
+java/lang/String.getChars:(II[CI)V
+java/lang/String.getChars:([CI)V
+java/lang/String.hashCode:()I
+java/lang/String.indexOf:(I)I
+java/lang/String.indexOf:(II)I
+java/lang/String.indexOf:(Ljava/lang/String;)I
+java/lang/String.indexOf:(Ljava/lang/String;I)I
+java/lang/String.indexOf:([CIILjava/lang/String;I)I
+java/lang/String.indexOf:([CII[CIII)I
+java/lang/String.indexOfSupplementary:(II)I
+java/lang/String.isEmpty:()Z
+java/lang/String.lastIndexOf:(I)I
+java/lang/String.lastIndexOf:(II)I
+java/lang/String.lastIndexOf:(Ljava/lang/String;)I
+java/lang/String.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/String.lastIndexOf:([CIILjava/lang/String;I)I
+java/lang/String.lastIndexOf:([CII[CIII)I
+java/lang/String.lastIndexOfSupplementary:(II)I
+java/lang/String.length:()I
+java/lang/String.nonSyncContentEquals:(Ljava/lang/AbstractStringBuilder;)Z
+java/lang/String.offsetByCodePoints:(II)I
+java/lang/String.regionMatches:(ILjava/lang/String;II)Z
+java/lang/String.regionMatches:(ZILjava/lang/String;II)Z
+java/lang/String.replace:(CC)Ljava/lang/String;
+java/lang/String.startsWith:(Ljava/lang/String;)Z
+java/lang/String.startsWith:(Ljava/lang/String;I)Z
+java/lang/String.subSequence:(II)Ljava/lang/CharSequence;
+java/lang/String.substring:(I)Ljava/lang/String;
+java/lang/String.substring:(II)Ljava/lang/String;
+java/lang/String.toCharArray:()[C
+java/lang/String.toString:()Ljava/lang/String;
+java/lang/String.trim:()Ljava/lang/String;
+java/lang/String.valueOf:(C)Ljava/lang/String;
+java/lang/String.valueOf:(I)Ljava/lang/String;
+java/lang/String.valueOf:(J)Ljava/lang/String;
+java/lang/String.valueOf:(Z)Ljava/lang/String;
+java/lang/String.valueOf:([C)Ljava/lang/String;
+java/lang/String.valueOf:([CII)Ljava/lang/String;
+java/lang/StringBuffer.<init>:()V
+java/lang/StringBuffer.<init>:(I)V
+java/lang/StringBuffer.<init>:(Ljava/lang/CharSequence;)V
+java/lang/StringBuffer.<init>:(Ljava/lang/String;)V
+java/lang/StringBuffer.append:(C)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:(C)Ljava/lang/Appendable;
+java/lang/StringBuffer.append:(C)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.append:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:(I)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.append:(J)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:(J)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.append:(Ljava/lang/AbstractStringBuilder;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:(Ljava/lang/AbstractStringBuilder;)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.append:(Ljava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:(Ljava/lang/CharSequence;)Ljava/lang/Appendable;
+java/lang/StringBuffer.append:(Ljava/lang/CharSequence;)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.append:(Ljava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;
+java/lang/StringBuffer.append:(Ljava/lang/CharSequence;II)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.append:(Ljava/lang/StringBuffer;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:(Ljava/lang/StringBuffer;)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.append:(Z)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:(Z)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.append:([C)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:([C)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.append:([CII)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.append:([CII)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.appendCodePoint:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.appendCodePoint:(I)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.capacity:()I
+java/lang/StringBuffer.charAt:(I)C
+java/lang/StringBuffer.codePointAt:(I)I
+java/lang/StringBuffer.codePointBefore:(I)I
+java/lang/StringBuffer.codePointCount:(II)I
+java/lang/StringBuffer.delete:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.delete:(II)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.deleteCharAt:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.deleteCharAt:(I)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.getChars:(II[CI)V
+java/lang/StringBuffer.indexOf:(Ljava/lang/String;)I
+java/lang/StringBuffer.indexOf:(Ljava/lang/String;I)I
+java/lang/StringBuffer.insert:(IC)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.insert:(IC)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.insert:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.insert:(II)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.insert:(IJ)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.insert:(IJ)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.insert:(ILjava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.insert:(ILjava/lang/CharSequence;)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.insert:(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.insert:(ILjava/lang/CharSequence;II)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.insert:(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.insert:(ILjava/lang/String;)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.insert:(IZ)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.insert:(IZ)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.insert:(I[C)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.insert:(I[C)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.insert:(I[CII)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.insert:(I[CII)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.lastIndexOf:(Ljava/lang/String;)I
+java/lang/StringBuffer.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/StringBuffer.length:()I
+java/lang/StringBuffer.offsetByCodePoints:(II)I
+java/lang/StringBuffer.replace:(IILjava/lang/String;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.replace:(IILjava/lang/String;)Ljava/lang/StringBuffer;
+java/lang/StringBuffer.reverse:()Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuffer.reverse:()Ljava/lang/StringBuffer;
+java/lang/StringBuffer.setCharAt:(IC)V
+java/lang/StringBuffer.subSequence:(II)Ljava/lang/CharSequence;
+java/lang/StringBuffer.substring:(I)Ljava/lang/String;
+java/lang/StringBuffer.substring:(II)Ljava/lang/String;
+java/lang/StringBuffer.toString:()Ljava/lang/String;
+java/lang/StringBuffer.trimToSize:()V
+java/lang/StringBuilder.<init>:()V
+java/lang/StringBuilder.<init>:(I)V
+java/lang/StringBuilder.<init>:(Ljava/lang/CharSequence;)V
+java/lang/StringBuilder.<init>:(Ljava/lang/String;)V
+java/lang/StringBuilder.append:(C)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.append:(C)Ljava/lang/Appendable;
+java/lang/StringBuilder.append:(C)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.append:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.append:(J)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.append:(J)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.append:(Ljava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.append:(Ljava/lang/CharSequence;)Ljava/lang/Appendable;
+java/lang/StringBuilder.append:(Ljava/lang/CharSequence;)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.append:(Ljava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.append:(Ljava/lang/CharSequence;II)Ljava/lang/Appendable;
+java/lang/StringBuilder.append:(Ljava/lang/CharSequence;II)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.append:(Ljava/lang/StringBuffer;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.append:(Ljava/lang/StringBuffer;)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.append:(Z)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.append:(Z)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.append:([C)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.append:([C)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.append:([CII)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.append:([CII)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.appendCodePoint:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.appendCodePoint:(I)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.capacity:()I
+java/lang/StringBuilder.charAt:(I)C
+java/lang/StringBuilder.codePointAt:(I)I
+java/lang/StringBuilder.codePointBefore:(I)I
+java/lang/StringBuilder.codePointCount:(II)I
+java/lang/StringBuilder.delete:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.delete:(II)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.deleteCharAt:(I)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.deleteCharAt:(I)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.ensureCapacity:(I)V
+java/lang/StringBuilder.getChars:(II[CI)V
+java/lang/StringBuilder.indexOf:(Ljava/lang/String;)I
+java/lang/StringBuilder.indexOf:(Ljava/lang/String;I)I
+java/lang/StringBuilder.insert:(IC)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.insert:(IC)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.insert:(II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.insert:(II)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.insert:(IJ)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.insert:(IJ)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.insert:(ILjava/lang/CharSequence;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.insert:(ILjava/lang/CharSequence;)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.insert:(ILjava/lang/CharSequence;II)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.insert:(ILjava/lang/CharSequence;II)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.insert:(ILjava/lang/String;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.insert:(ILjava/lang/String;)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.insert:(IZ)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.insert:(IZ)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.insert:(I[C)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.insert:(I[C)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.insert:(I[CII)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.insert:(I[CII)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.lastIndexOf:(Ljava/lang/String;)I
+java/lang/StringBuilder.lastIndexOf:(Ljava/lang/String;I)I
+java/lang/StringBuilder.length:()I
+java/lang/StringBuilder.offsetByCodePoints:(II)I
+java/lang/StringBuilder.replace:(IILjava/lang/String;)Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.replace:(IILjava/lang/String;)Ljava/lang/StringBuilder;
+java/lang/StringBuilder.reverse:()Ljava/lang/AbstractStringBuilder;
+java/lang/StringBuilder.reverse:()Ljava/lang/StringBuilder;
+java/lang/StringBuilder.setCharAt:(IC)V
+java/lang/StringBuilder.subSequence:(II)Ljava/lang/CharSequence;
+java/lang/StringBuilder.substring:(I)Ljava/lang/String;
+java/lang/StringBuilder.substring:(II)Ljava/lang/String;
+java/lang/StringBuilder.toString:()Ljava/lang/String;
+java/lang/StringBuilder.trimToSize:()V
+java/lang/StringCoding$StringDecoder.requestedCharsetName:()Ljava/lang/String;
+java/lang/StringCoding$StringEncoder.requestedCharsetName:()Ljava/lang/String;
+java/lang/StringCoding.<init>:()V
+java/lang/StringCoding.access$000:(IF)I
+java/lang/StringCoding.access$100:([CILjava/nio/charset/Charset;Z)[C
+java/lang/StringCoding.access$300:([BILjava/nio/charset/Charset;Z)[B
+java/lang/StringCoding.safeTrim:([BILjava/nio/charset/Charset;Z)[B
+java/lang/StringCoding.safeTrim:([CILjava/nio/charset/Charset;Z)[C
+java/lang/StringCoding.scale:(IF)I
+java/lang/StringIndexOutOfBoundsException.<init>:()V
+java/lang/StringIndexOutOfBoundsException.<init>:(I)V
+java/lang/StringIndexOutOfBoundsException.<init>:(Ljava/lang/String;)V
+java/lang/SuppressWarnings.value:()[Ljava/lang/String;
+java/lang/System$1.<init>:(Ljava/lang/SecurityManager;)V
+java/lang/System$2.<init>:()V
+java/lang/System$2.blockedOn:(Ljava/lang/Thread;Lsun/nio/ch/Interruptible;)V
+java/lang/System$2.getAnnotationType:(Ljava/lang/Class;)Lsun/reflect/annotation/AnnotationType;
+java/lang/System$2.newStringUnsafe:([C)Ljava/lang/String;
+java/lang/System$2.registerShutdownHook:(IZLjava/lang/Runnable;)V
+java/lang/System.<init>:()V
+java/lang/System.arraycopy:(Ljava/lang/Object;ILjava/lang/Object;II)V
+java/lang/System.checkKey:(Ljava/lang/String;)V
+java/lang/System.getSecurityManager:()Ljava/lang/SecurityManager;
+java/lang/System.lineSeparator:()Ljava/lang/String;
+java/lang/SystemClassLoaderAction.<init>:(Ljava/lang/ClassLoader;)V
+java/lang/Terminator$1.<init>:()V
+java/lang/Terminator.<clinit>:()V
+java/lang/Terminator.<init>:()V
+java/lang/Terminator.teardown:()V
+java/lang/Thread$1.<init>:(Ljava/lang/Class;)V
+java/lang/Thread$Caches.<init>:()V
+java/lang/Thread$State.<clinit>:()V
+java/lang/Thread$State.<init>:(Ljava/lang/String;I)V
+java/lang/Thread$UncaughtExceptionHandler.uncaughtException:(Ljava/lang/Thread;Ljava/lang/Throwable;)V
+java/lang/Thread$WeakClassKey.hashCode:()I
+java/lang/Thread.blockedOn:(Lsun/nio/ch/Interruptible;)V
+java/lang/Thread.clone:()Ljava/lang/Object;
+java/lang/Thread.destroy:()V
+java/lang/Thread.dispatchUncaughtException:(Ljava/lang/Throwable;)V
+java/lang/Thread.getDefaultUncaughtExceptionHandler:()Ljava/lang/Thread$UncaughtExceptionHandler;
+java/lang/Thread.getId:()J
+java/lang/Thread.getName:()Ljava/lang/String;
+java/lang/Thread.getPriority:()I
+java/lang/Thread.getThreadGroup:()Ljava/lang/ThreadGroup;
+java/lang/Thread.getUncaughtExceptionHandler:()Ljava/lang/Thread$UncaughtExceptionHandler;
+java/lang/Thread.isDaemon:()Z
+java/lang/Thread.nextThreadID:()J
+java/lang/Thread.nextThreadNum:()I
+java/lang/Thread.run:()V
+java/lang/Thread.stop:(Ljava/lang/Throwable;)V
+java/lang/Thread.toString:()Ljava/lang/String;
+java/lang/ThreadDeath.<init>:()V
+java/lang/ThreadGroup.<init>:()V
+java/lang/ThreadGroup.<init>:(Ljava/lang/Void;Ljava/lang/ThreadGroup;Ljava/lang/String;)V
+java/lang/ThreadGroup.activeCount:()I
+java/lang/ThreadGroup.activeGroupCount:()I
+java/lang/ThreadGroup.add:(Ljava/lang/Thread;)V
+java/lang/ThreadGroup.add:(Ljava/lang/ThreadGroup;)V
+java/lang/ThreadGroup.addUnstarted:()V
+java/lang/ThreadGroup.enumerate:([Ljava/lang/ThreadGroup;IZ)I
+java/lang/ThreadGroup.getMaxPriority:()I
+java/lang/ThreadGroup.getName:()Ljava/lang/String;
+java/lang/ThreadGroup.isDaemon:()Z
+java/lang/ThreadGroup.isDestroyed:()Z
+java/lang/ThreadGroup.parentOf:(Ljava/lang/ThreadGroup;)Z
+java/lang/ThreadGroup.remove:(Ljava/lang/Thread;)V
+java/lang/ThreadGroup.threadStartFailed:(Ljava/lang/Thread;)V
+java/lang/ThreadLocal$ThreadLocalMap.nextIndex:(II)I
+java/lang/ThreadLocal$ThreadLocalMap.prevIndex:(II)I
+java/lang/ThreadLocal$ThreadLocalMap.setThreshold:(I)V
+java/lang/ThreadLocal.access$400:(Ljava/lang/ThreadLocal;)I
+java/lang/ThreadLocal.childValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/ThreadLocal.getMap:(Ljava/lang/Thread;)Ljava/lang/ThreadLocal$ThreadLocalMap;
+java/lang/ThreadLocal.initialValue:()Ljava/lang/Object;
+java/lang/Throwable$PrintStreamOrWriter.<init>:()V
+java/lang/Throwable$PrintStreamOrWriter.<init>:(Ljava/lang/Throwable$1;)V
+java/lang/Throwable$PrintStreamOrWriter.lock:()Ljava/lang/Object;
+java/lang/Throwable$PrintStreamOrWriter.println:(Ljava/lang/Object;)V
+java/lang/Throwable$SentinelHolder.<clinit>:()V
+java/lang/Throwable$SentinelHolder.<init>:()V
+java/lang/Throwable$WrappedPrintStream.<init>:(Ljava/io/PrintStream;)V
+java/lang/Throwable$WrappedPrintStream.lock:()Ljava/lang/Object;
+java/lang/Throwable$WrappedPrintWriter.<init>:(Ljava/io/PrintWriter;)V
+java/lang/Throwable$WrappedPrintWriter.lock:()Ljava/lang/Object;
+java/lang/Throwable.<init>:()V
+java/lang/Throwable.<init>:(Ljava/lang/String;)V
+java/lang/Throwable.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Throwable.<init>:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V
+java/lang/Throwable.fillInStackTrace:()Ljava/lang/Throwable;
+java/lang/Throwable.fillInStackTrace:(I)Ljava/lang/Throwable;
+java/lang/Throwable.getCause:()Ljava/lang/Throwable;
+java/lang/Throwable.getLocalizedMessage:()Ljava/lang/String;
+java/lang/Throwable.getMessage:()Ljava/lang/String;
+java/lang/Throwable.getSuppressed:()[Ljava/lang/Throwable;
+java/lang/TypeNotPresentException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/TypeNotPresentException.typeName:()Ljava/lang/String;
+java/lang/UNIXProcess$1.<init>:()V
+java/lang/UNIXProcess$2.<init>:()V
+java/lang/UNIXProcess$3.<init>:(Ljava/lang/UNIXProcess;[I)V
+java/lang/UNIXProcess$4.<init>:(Ljava/lang/UNIXProcess;)V
+java/lang/UNIXProcess$LaunchMechanism.<clinit>:()V
+java/lang/UNIXProcess$LaunchMechanism.<init>:(Ljava/lang/String;II)V
+java/lang/UNIXProcess$LaunchMechanism.access$300:(Ljava/lang/UNIXProcess$LaunchMechanism;)I
+java/lang/UNIXProcess$ProcessReaperThreadFactory$1.<init>:()V
+java/lang/UNIXProcess$ProcessReaperThreadFactory.<init>:()V
+java/lang/UNIXProcess$ProcessReaperThreadFactory.<init>:(Ljava/lang/UNIXProcess$1;)V
+java/lang/UNIXProcess.access$002:([B)[B
+java/lang/UNIXProcess.access$400:(Ljava/lang/UNIXProcess;)I
+java/lang/UNIXProcess.exitValue:()I
+java/lang/UNIXProcess.getErrorStream:()Ljava/io/InputStream;
+java/lang/UNIXProcess.getInputStream:()Ljava/io/InputStream;
+java/lang/UNIXProcess.getOutputStream:()Ljava/io/OutputStream;
+java/lang/UNIXProcess.isAlive:()Z
+java/lang/UnknownError.<init>:()V
+java/lang/UnknownError.<init>:(Ljava/lang/String;)V
+java/lang/UnsatisfiedLinkError.<init>:()V
+java/lang/UnsatisfiedLinkError.<init>:(Ljava/lang/String;)V
+java/lang/UnsupportedClassVersionError.<init>:()V
+java/lang/UnsupportedClassVersionError.<init>:(Ljava/lang/String;)V
+java/lang/UnsupportedOperationException.<init>:()V
+java/lang/UnsupportedOperationException.<init>:(Ljava/lang/String;)V
+java/lang/UnsupportedOperationException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/VerifyError.<init>:()V
+java/lang/VerifyError.<init>:(Ljava/lang/String;)V
+java/lang/VirtualMachineError.<init>:()V
+java/lang/VirtualMachineError.<init>:(Ljava/lang/String;)V
+java/lang/VirtualMachineError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/lang/Void.<init>:()V
+java/lang/reflect/AccessibleObject.<init>:()V
+java/lang/reflect/AccessibleObject.isAccessible:()Z
+java/lang/reflect/AccessibleObject.isAnnotationPresent:(Ljava/lang/Class;)Z
+java/lang/reflect/AccessibleObject.setAccessible0:(Ljava/lang/reflect/AccessibleObject;Z)V
+java/lang/reflect/AnnotatedArrayType.getAnnotatedGenericComponentType:()Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/AnnotatedElement.getAnnotation:(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;
+java/lang/reflect/AnnotatedElement.getAnnotations:()[Ljava/lang/annotation/Annotation;
+java/lang/reflect/AnnotatedElement.getDeclaredAnnotations:()[Ljava/lang/annotation/Annotation;
+java/lang/reflect/AnnotatedElement.isAnnotationPresent:(Ljava/lang/Class;)Z
+java/lang/reflect/AnnotatedElement.lambda$getDeclaredAnnotationsByType$0:(Ljava/lang/annotation/Annotation;Ljava/lang/annotation/Annotation;)Ljava/lang/annotation/Annotation;
+java/lang/reflect/AnnotatedParameterizedType.getAnnotatedActualTypeArguments:()[Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/AnnotatedType.getType:()Ljava/lang/reflect/Type;
+java/lang/reflect/AnnotatedTypeVariable.getAnnotatedBounds:()[Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/AnnotatedWildcardType.getAnnotatedLowerBounds:()[Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/AnnotatedWildcardType.getAnnotatedUpperBounds:()[Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/Array.<init>:()V
+java/lang/reflect/Array.newArray:(Ljava/lang/Class;I)Ljava/lang/Object;
+java/lang/reflect/Array.newInstance:(Ljava/lang/Class;I)Ljava/lang/Object;
+java/lang/reflect/Constructor.<init>:(Ljava/lang/Class;[Ljava/lang/Class;[Ljava/lang/Class;IILjava/lang/String;[B[B)V
+java/lang/reflect/Constructor.copy:()Ljava/lang/reflect/Constructor;
+java/lang/reflect/Constructor.getAnnotationBytes:()[B
+java/lang/reflect/Constructor.getConstructorAccessor:()Lsun/reflect/ConstructorAccessor;
+java/lang/reflect/Constructor.getDeclaringClass:()Ljava/lang/Class;
+java/lang/reflect/Constructor.getModifiers:()I
+java/lang/reflect/Constructor.getParameterCount:()I
+java/lang/reflect/Constructor.getRawAnnotations:()[B
+java/lang/reflect/Constructor.getRawParameterAnnotations:()[B
+java/lang/reflect/Constructor.getSignature:()Ljava/lang/String;
+java/lang/reflect/Constructor.getSlot:()I
+java/lang/reflect/Constructor.hasGenericInformation:()Z
+java/lang/reflect/Constructor.isSynthetic:()Z
+java/lang/reflect/Constructor.isVarArgs:()Z
+java/lang/reflect/Constructor.setConstructorAccessor:(Lsun/reflect/ConstructorAccessor;)V
+java/lang/reflect/Executable.<init>:()V
+java/lang/reflect/Executable.equalParamTypes:([Ljava/lang/Class;[Ljava/lang/Class;)Z
+java/lang/reflect/Executable.getAnnotatedReturnType:()Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/Executable.getAnnotationBytes:()[B
+java/lang/reflect/Executable.getDeclaringClass:()Ljava/lang/Class;
+java/lang/reflect/Executable.getExceptionTypes:()[Ljava/lang/Class;
+java/lang/reflect/Executable.getGenericInfo:()Lsun/reflect/generics/repository/ConstructorRepository;
+java/lang/reflect/Executable.getModifiers:()I
+java/lang/reflect/Executable.getName:()Ljava/lang/String;
+java/lang/reflect/Executable.getParameterAnnotations:()[[Ljava/lang/annotation/Annotation;
+java/lang/reflect/Executable.getParameterCount:()I
+java/lang/reflect/Executable.getParameterTypes:()[Ljava/lang/Class;
+java/lang/reflect/Executable.getTypeParameters:()[Ljava/lang/reflect/TypeVariable;
+java/lang/reflect/Executable.handleParameterNumberMismatch:(II)V
+java/lang/reflect/Executable.hasGenericInformation:()Z
+java/lang/reflect/Executable.isSynthetic:()Z
+java/lang/reflect/Executable.isVarArgs:()Z
+java/lang/reflect/Executable.specificToGenericStringHeader:(Ljava/lang/StringBuilder;)V
+java/lang/reflect/Executable.specificToStringHeader:(Ljava/lang/StringBuilder;)V
+java/lang/reflect/Executable.toGenericString:()Ljava/lang/String;
+java/lang/reflect/Field.<init>:(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/Class;IILjava/lang/String;[B)V
+java/lang/reflect/Field.copy:()Ljava/lang/reflect/Field;
+java/lang/reflect/Field.equals:(Ljava/lang/Object;)Z
+java/lang/reflect/Field.getDeclaringClass:()Ljava/lang/Class;
+java/lang/reflect/Field.getFieldAccessor:(Z)Lsun/reflect/FieldAccessor;
+java/lang/reflect/Field.getGenericSignature:()Ljava/lang/String;
+java/lang/reflect/Field.getModifiers:()I
+java/lang/reflect/Field.getName:()Ljava/lang/String;
+java/lang/reflect/Field.getType:()Ljava/lang/Class;
+java/lang/reflect/Field.isEnumConstant:()Z
+java/lang/reflect/Field.isSynthetic:()Z
+java/lang/reflect/Field.setFieldAccessor:(Lsun/reflect/FieldAccessor;Z)V
+java/lang/reflect/GenericArrayType.getGenericComponentType:()Ljava/lang/reflect/Type;
+java/lang/reflect/GenericDeclaration.getTypeParameters:()[Ljava/lang/reflect/TypeVariable;
+java/lang/reflect/GenericSignatureFormatError.<init>:()V
+java/lang/reflect/GenericSignatureFormatError.<init>:(Ljava/lang/String;)V
+java/lang/reflect/InvocationHandler.invoke:(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;
+java/lang/reflect/InvocationTargetException.<init>:(Ljava/lang/Throwable;Ljava/lang/String;)V
+java/lang/reflect/InvocationTargetException.getCause:()Ljava/lang/Throwable;
+java/lang/reflect/InvocationTargetException.getTargetException:()Ljava/lang/Throwable;
+java/lang/reflect/MalformedParameterizedTypeException.<init>:()V
+java/lang/reflect/MalformedParametersException.<init>:()V
+java/lang/reflect/MalformedParametersException.<init>:(Ljava/lang/String;)V
+java/lang/reflect/Member.getDeclaringClass:()Ljava/lang/Class;
+java/lang/reflect/Member.getModifiers:()I
+java/lang/reflect/Member.getName:()Ljava/lang/String;
+java/lang/reflect/Member.isSynthetic:()Z
+java/lang/reflect/Method.<init>:(Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/Class;Ljava/lang/Class;[Ljava/lang/Class;IILjava/lang/String;[B[B[B)V
+java/lang/reflect/Method.copy:()Ljava/lang/reflect/Method;
+java/lang/reflect/Method.getAnnotationBytes:()[B
+java/lang/reflect/Method.getDeclaringClass:()Ljava/lang/Class;
+java/lang/reflect/Method.getGenericSignature:()Ljava/lang/String;
+java/lang/reflect/Method.getMethodAccessor:()Lsun/reflect/MethodAccessor;
+java/lang/reflect/Method.getModifiers:()I
+java/lang/reflect/Method.getName:()Ljava/lang/String;
+java/lang/reflect/Method.getParameterCount:()I
+java/lang/reflect/Method.getReturnType:()Ljava/lang/Class;
+java/lang/reflect/Method.hasGenericInformation:()Z
+java/lang/reflect/Method.isBridge:()Z
+java/lang/reflect/Method.isSynthetic:()Z
+java/lang/reflect/Method.isVarArgs:()Z
+java/lang/reflect/Method.setMethodAccessor:(Lsun/reflect/MethodAccessor;)V
+java/lang/reflect/Modifier.<init>:()V
+java/lang/reflect/Modifier.classModifiers:()I
+java/lang/reflect/Modifier.constructorModifiers:()I
+java/lang/reflect/Modifier.fieldModifiers:()I
+java/lang/reflect/Modifier.interfaceModifiers:()I
+java/lang/reflect/Modifier.isAbstract:(I)Z
+java/lang/reflect/Modifier.isFinal:(I)Z
+java/lang/reflect/Modifier.isInterface:(I)Z
+java/lang/reflect/Modifier.isMandated:(I)Z
+java/lang/reflect/Modifier.isNative:(I)Z
+java/lang/reflect/Modifier.isPrivate:(I)Z
+java/lang/reflect/Modifier.isProtected:(I)Z
+java/lang/reflect/Modifier.isPublic:(I)Z
+java/lang/reflect/Modifier.isStatic:(I)Z
+java/lang/reflect/Modifier.isStrict:(I)Z
+java/lang/reflect/Modifier.isSynchronized:(I)Z
+java/lang/reflect/Modifier.isSynthetic:(I)Z
+java/lang/reflect/Modifier.isTransient:(I)Z
+java/lang/reflect/Modifier.isVolatile:(I)Z
+java/lang/reflect/Modifier.methodModifiers:()I
+java/lang/reflect/Modifier.parameterModifiers:()I
+java/lang/reflect/Parameter.<init>:(Ljava/lang/String;ILjava/lang/reflect/Executable;I)V
+java/lang/reflect/Parameter.equals:(Ljava/lang/Object;)Z
+java/lang/reflect/Parameter.getAnnotations:()[Ljava/lang/annotation/Annotation;
+java/lang/reflect/Parameter.getDeclaredAnnotations:()[Ljava/lang/annotation/Annotation;
+java/lang/reflect/Parameter.getDeclaringExecutable:()Ljava/lang/reflect/Executable;
+java/lang/reflect/Parameter.getModifiers:()I
+java/lang/reflect/Parameter.getRealName:()Ljava/lang/String;
+java/lang/reflect/Parameter.getType:()Ljava/lang/Class;
+java/lang/reflect/Parameter.isImplicit:()Z
+java/lang/reflect/Parameter.isSynthetic:()Z
+java/lang/reflect/Parameter.isVarArgs:()Z
+java/lang/reflect/ParameterizedType.getActualTypeArguments:()[Ljava/lang/reflect/Type;
+java/lang/reflect/ParameterizedType.getOwnerType:()Ljava/lang/reflect/Type;
+java/lang/reflect/ParameterizedType.getRawType:()Ljava/lang/reflect/Type;
+java/lang/reflect/Proxy$1.<init>:(Ljava/lang/reflect/Constructor;)V
+java/lang/reflect/Proxy$Key1.hashCode:()I
+java/lang/reflect/Proxy$Key2.hashCode:()I
+java/lang/reflect/Proxy$KeyFactory.<init>:()V
+java/lang/reflect/Proxy$KeyFactory.<init>:(Ljava/lang/reflect/Proxy$1;)V
+java/lang/reflect/Proxy$KeyX.hashCode:()I
+java/lang/reflect/Proxy$ProxyClassFactory.<init>:()V
+java/lang/reflect/Proxy$ProxyClassFactory.<init>:(Ljava/lang/reflect/Proxy$1;)V
+java/lang/reflect/Proxy.<init>:()V
+java/lang/reflect/Proxy.access$200:()Ljava/lang/Object;
+java/lang/reflect/ReflectAccess.<init>:()V
+java/lang/reflect/ReflectAccess.copyConstructor:(Ljava/lang/reflect/Constructor;)Ljava/lang/reflect/Constructor;
+java/lang/reflect/ReflectAccess.copyField:(Ljava/lang/reflect/Field;)Ljava/lang/reflect/Field;
+java/lang/reflect/ReflectAccess.copyMethod:(Ljava/lang/reflect/Method;)Ljava/lang/reflect/Method;
+java/lang/reflect/ReflectAccess.getConstructorAccessor:(Ljava/lang/reflect/Constructor;)Lsun/reflect/ConstructorAccessor;
+java/lang/reflect/ReflectAccess.getConstructorAnnotations:(Ljava/lang/reflect/Constructor;)[B
+java/lang/reflect/ReflectAccess.getConstructorParameterAnnotations:(Ljava/lang/reflect/Constructor;)[B
+java/lang/reflect/ReflectAccess.getConstructorSignature:(Ljava/lang/reflect/Constructor;)Ljava/lang/String;
+java/lang/reflect/ReflectAccess.getConstructorSlot:(Ljava/lang/reflect/Constructor;)I
+java/lang/reflect/ReflectAccess.getMethodAccessor:(Ljava/lang/reflect/Method;)Lsun/reflect/MethodAccessor;
+java/lang/reflect/ReflectAccess.newConstructor:(Ljava/lang/Class;[Ljava/lang/Class;[Ljava/lang/Class;IILjava/lang/String;[B[B)Ljava/lang/reflect/Constructor;
+java/lang/reflect/ReflectAccess.newField:(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/Class;IILjava/lang/String;[B)Ljava/lang/reflect/Field;
+java/lang/reflect/ReflectAccess.newMethod:(Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/Class;Ljava/lang/Class;[Ljava/lang/Class;IILjava/lang/String;[B[B[B)Ljava/lang/reflect/Method;
+java/lang/reflect/ReflectAccess.setConstructorAccessor:(Ljava/lang/reflect/Constructor;Lsun/reflect/ConstructorAccessor;)V
+java/lang/reflect/ReflectAccess.setMethodAccessor:(Ljava/lang/reflect/Method;Lsun/reflect/MethodAccessor;)V
+java/lang/reflect/TypeVariable.getAnnotatedBounds:()[Ljava/lang/reflect/AnnotatedType;
+java/lang/reflect/TypeVariable.getBounds:()[Ljava/lang/reflect/Type;
+java/lang/reflect/TypeVariable.getGenericDeclaration:()Ljava/lang/reflect/GenericDeclaration;
+java/lang/reflect/TypeVariable.getName:()Ljava/lang/String;
+java/lang/reflect/UndeclaredThrowableException.<init>:(Ljava/lang/Throwable;Ljava/lang/String;)V
+java/lang/reflect/UndeclaredThrowableException.getCause:()Ljava/lang/Throwable;
+java/lang/reflect/UndeclaredThrowableException.getUndeclaredThrowable:()Ljava/lang/Throwable;
+java/lang/reflect/WeakCache$CacheKey.<clinit>:()V
+java/lang/reflect/WeakCache$CacheKey.hashCode:()I
+java/lang/reflect/WeakCache$CacheValue.hashCode:()I
+java/lang/reflect/WeakCache$Factory.<init>:(Ljava/lang/reflect/WeakCache;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/util/concurrent/ConcurrentMap;)V
+java/lang/reflect/WeakCache$LookupValue.<init>:(Ljava/lang/Object;)V
+java/lang/reflect/WeakCache$LookupValue.get:()Ljava/lang/Object;
+java/lang/reflect/WeakCache.access$000:(Ljava/lang/reflect/WeakCache;)Ljava/util/function/BiFunction;
+java/lang/reflect/WeakCache.access$100:(Ljava/lang/reflect/WeakCache;)Ljava/util/concurrent/ConcurrentMap;
+java/lang/reflect/WildcardType.getLowerBounds:()[Ljava/lang/reflect/Type;
+java/lang/reflect/WildcardType.getUpperBounds:()[Ljava/lang/reflect/Type;
+java/util/AbstractCollection.<init>:()V
+java/util/AbstractCollection.add:(Ljava/lang/Object;)Z
+java/util/AbstractCollection.addAll:(Ljava/util/Collection;)Z
+java/util/AbstractCollection.clear:()V
+java/util/AbstractCollection.contains:(Ljava/lang/Object;)Z
+java/util/AbstractCollection.containsAll:(Ljava/util/Collection;)Z
+java/util/AbstractCollection.finishToArray:([Ljava/lang/Object;Ljava/util/Iterator;)[Ljava/lang/Object;
+java/util/AbstractCollection.hugeCapacity:(I)I
+java/util/AbstractCollection.isEmpty:()Z
+java/util/AbstractCollection.iterator:()Ljava/util/Iterator;
+java/util/AbstractCollection.remove:(Ljava/lang/Object;)Z
+java/util/AbstractCollection.removeAll:(Ljava/util/Collection;)Z
+java/util/AbstractCollection.retainAll:(Ljava/util/Collection;)Z
+java/util/AbstractCollection.size:()I
+java/util/AbstractCollection.toArray:()[Ljava/lang/Object;
+java/util/AbstractCollection.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/AbstractList$Itr.<init>:(Ljava/util/AbstractList;)V
+java/util/AbstractList$Itr.<init>:(Ljava/util/AbstractList;Ljava/util/AbstractList$1;)V
+java/util/AbstractList$Itr.checkForComodification:()V
+java/util/AbstractList$Itr.next:()Ljava/lang/Object;
+java/util/AbstractList$Itr.remove:()V
+java/util/AbstractList$ListItr.<init>:(Ljava/util/AbstractList;I)V
+java/util/AbstractList$ListItr.hasPrevious:()Z
+java/util/AbstractList$ListItr.nextIndex:()I
+java/util/AbstractList$ListItr.previousIndex:()I
+java/util/AbstractList.<init>:()V
+java/util/AbstractList.add:(ILjava/lang/Object;)V
+java/util/AbstractList.get:(I)Ljava/lang/Object;
+java/util/AbstractList.iterator:()Ljava/util/Iterator;
+java/util/AbstractList.remove:(I)Ljava/lang/Object;
+java/util/AbstractList.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/AbstractMap$1$1.<init>:(Ljava/util/AbstractMap$1;)V
+java/util/AbstractMap$1$1.hasNext:()Z
+java/util/AbstractMap$1$1.next:()Ljava/lang/Object;
+java/util/AbstractMap$1$1.remove:()V
+java/util/AbstractMap$1.<init>:(Ljava/util/AbstractMap;)V
+java/util/AbstractMap$1.clear:()V
+java/util/AbstractMap$1.contains:(Ljava/lang/Object;)Z
+java/util/AbstractMap$1.isEmpty:()Z
+java/util/AbstractMap$1.iterator:()Ljava/util/Iterator;
+java/util/AbstractMap$1.size:()I
+java/util/AbstractMap$2$1.<init>:(Ljava/util/AbstractMap$2;)V
+java/util/AbstractMap$2$1.hasNext:()Z
+java/util/AbstractMap$2$1.next:()Ljava/lang/Object;
+java/util/AbstractMap$2$1.remove:()V
+java/util/AbstractMap$2.<init>:(Ljava/util/AbstractMap;)V
+java/util/AbstractMap$2.clear:()V
+java/util/AbstractMap$2.contains:(Ljava/lang/Object;)Z
+java/util/AbstractMap$2.isEmpty:()Z
+java/util/AbstractMap$2.iterator:()Ljava/util/Iterator;
+java/util/AbstractMap$2.size:()I
+java/util/AbstractMap$SimpleEntry.<init>:(Ljava/lang/Object;Ljava/lang/Object;)V
+java/util/AbstractMap$SimpleEntry.<init>:(Ljava/util/Map$Entry;)V
+java/util/AbstractMap$SimpleEntry.equals:(Ljava/lang/Object;)Z
+java/util/AbstractMap$SimpleEntry.getKey:()Ljava/lang/Object;
+java/util/AbstractMap$SimpleEntry.getValue:()Ljava/lang/Object;
+java/util/AbstractMap$SimpleEntry.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/AbstractMap$SimpleImmutableEntry.<init>:(Ljava/lang/Object;Ljava/lang/Object;)V
+java/util/AbstractMap$SimpleImmutableEntry.<init>:(Ljava/util/Map$Entry;)V
+java/util/AbstractMap$SimpleImmutableEntry.equals:(Ljava/lang/Object;)Z
+java/util/AbstractMap$SimpleImmutableEntry.getKey:()Ljava/lang/Object;
+java/util/AbstractMap$SimpleImmutableEntry.getValue:()Ljava/lang/Object;
+java/util/AbstractMap$SimpleImmutableEntry.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/AbstractMap.<init>:()V
+java/util/AbstractMap.access$000:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/AbstractMap.clear:()V
+java/util/AbstractMap.containsKey:(Ljava/lang/Object;)Z
+java/util/AbstractMap.containsValue:(Ljava/lang/Object;)Z
+java/util/AbstractMap.entrySet:()Ljava/util/Set;
+java/util/AbstractMap.eq:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/AbstractMap.equals:(Ljava/lang/Object;)Z
+java/util/AbstractMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/AbstractMap.hashCode:()I
+java/util/AbstractMap.isEmpty:()Z
+java/util/AbstractMap.keySet:()Ljava/util/Set;
+java/util/AbstractMap.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/AbstractMap.putAll:(Ljava/util/Map;)V
+java/util/AbstractMap.remove:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/AbstractMap.size:()I
+java/util/AbstractMap.values:()Ljava/util/Collection;
+java/util/AbstractQueue.<init>:()V
+java/util/AbstractSequentialList.<init>:()V
+java/util/AbstractSequentialList.add:(ILjava/lang/Object;)V
+java/util/AbstractSequentialList.addAll:(ILjava/util/Collection;)Z
+java/util/AbstractSequentialList.get:(I)Ljava/lang/Object;
+java/util/AbstractSequentialList.listIterator:(I)Ljava/util/ListIterator;
+java/util/AbstractSequentialList.remove:(I)Ljava/lang/Object;
+java/util/AbstractSequentialList.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/AbstractSet.<init>:()V
+java/util/ArrayDeque$DeqIterator.<init>:(Ljava/util/ArrayDeque;)V
+java/util/ArrayDeque$DeqIterator.<init>:(Ljava/util/ArrayDeque;Ljava/util/ArrayDeque$1;)V
+java/util/ArrayDeque$DeqIterator.hasNext:()Z
+java/util/ArrayDeque$DeqIterator.next:()Ljava/lang/Object;
+java/util/ArrayDeque$DeqIterator.remove:()V
+java/util/ArrayDeque$DeqSpliterator.<init>:(Ljava/util/ArrayDeque;II)V
+java/util/ArrayDeque$DeqSpliterator.characteristics:()I
+java/util/ArrayDeque$DeqSpliterator.estimateSize:()J
+java/util/ArrayDeque$DeqSpliterator.getFence:()I
+java/util/ArrayDeque$DeqSpliterator.trySplit:()Ljava/util/ArrayDeque$DeqSpliterator;
+java/util/ArrayDeque$DeqSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/ArrayDeque$DescendingIterator.<init>:(Ljava/util/ArrayDeque;)V
+java/util/ArrayDeque$DescendingIterator.<init>:(Ljava/util/ArrayDeque;Ljava/util/ArrayDeque$1;)V
+java/util/ArrayDeque$DescendingIterator.hasNext:()Z
+java/util/ArrayDeque$DescendingIterator.next:()Ljava/lang/Object;
+java/util/ArrayDeque$DescendingIterator.remove:()V
+java/util/ArrayDeque.<init>:()V
+java/util/ArrayDeque.<init>:(I)V
+java/util/ArrayDeque.access$200:(Ljava/util/ArrayDeque;I)Z
+java/util/ArrayDeque.add:(Ljava/lang/Object;)Z
+java/util/ArrayDeque.addFirst:(Ljava/lang/Object;)V
+java/util/ArrayDeque.addLast:(Ljava/lang/Object;)V
+java/util/ArrayDeque.allocateElements:(I)V
+java/util/ArrayDeque.checkInvariants:()V
+java/util/ArrayDeque.clear:()V
+java/util/ArrayDeque.contains:(Ljava/lang/Object;)Z
+java/util/ArrayDeque.copyElements:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/ArrayDeque.delete:(I)Z
+java/util/ArrayDeque.descendingIterator:()Ljava/util/Iterator;
+java/util/ArrayDeque.doubleCapacity:()V
+java/util/ArrayDeque.element:()Ljava/lang/Object;
+java/util/ArrayDeque.getFirst:()Ljava/lang/Object;
+java/util/ArrayDeque.getLast:()Ljava/lang/Object;
+java/util/ArrayDeque.isEmpty:()Z
+java/util/ArrayDeque.iterator:()Ljava/util/Iterator;
+java/util/ArrayDeque.offer:(Ljava/lang/Object;)Z
+java/util/ArrayDeque.offerFirst:(Ljava/lang/Object;)Z
+java/util/ArrayDeque.offerLast:(Ljava/lang/Object;)Z
+java/util/ArrayDeque.peek:()Ljava/lang/Object;
+java/util/ArrayDeque.peekFirst:()Ljava/lang/Object;
+java/util/ArrayDeque.peekLast:()Ljava/lang/Object;
+java/util/ArrayDeque.poll:()Ljava/lang/Object;
+java/util/ArrayDeque.pollFirst:()Ljava/lang/Object;
+java/util/ArrayDeque.pollLast:()Ljava/lang/Object;
+java/util/ArrayDeque.pop:()Ljava/lang/Object;
+java/util/ArrayDeque.push:(Ljava/lang/Object;)V
+java/util/ArrayDeque.remove:()Ljava/lang/Object;
+java/util/ArrayDeque.remove:(Ljava/lang/Object;)Z
+java/util/ArrayDeque.removeFirst:()Ljava/lang/Object;
+java/util/ArrayDeque.removeFirstOccurrence:(Ljava/lang/Object;)Z
+java/util/ArrayDeque.removeLast:()Ljava/lang/Object;
+java/util/ArrayDeque.removeLastOccurrence:(Ljava/lang/Object;)Z
+java/util/ArrayDeque.size:()I
+java/util/ArrayDeque.spliterator:()Ljava/util/Spliterator;
+java/util/ArrayDeque.toArray:()[Ljava/lang/Object;
+java/util/ArrayDeque.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/ArrayList$ArrayListSpliterator.<init>:(Ljava/util/ArrayList;III)V
+java/util/ArrayList$ArrayListSpliterator.characteristics:()I
+java/util/ArrayList$ArrayListSpliterator.estimateSize:()J
+java/util/ArrayList$ArrayListSpliterator.getFence:()I
+java/util/ArrayList$ArrayListSpliterator.trySplit:()Ljava/util/ArrayList$ArrayListSpliterator;
+java/util/ArrayList$ArrayListSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/ArrayList$Itr.<init>:(Ljava/util/ArrayList;)V
+java/util/ArrayList$Itr.<init>:(Ljava/util/ArrayList;Ljava/util/ArrayList$1;)V
+java/util/ArrayList$Itr.checkForComodification:()V
+java/util/ArrayList$Itr.hasNext:()Z
+java/util/ArrayList$Itr.next:()Ljava/lang/Object;
+java/util/ArrayList$Itr.remove:()V
+java/util/ArrayList$ListItr.<init>:(Ljava/util/ArrayList;I)V
+java/util/ArrayList$ListItr.hasPrevious:()Z
+java/util/ArrayList$ListItr.nextIndex:()I
+java/util/ArrayList$ListItr.previousIndex:()I
+java/util/ArrayList$SubList$1.<init>:(Ljava/util/ArrayList$SubList;II)V
+java/util/ArrayList$SubList$1.add:(Ljava/lang/Object;)V
+java/util/ArrayList$SubList$1.checkForComodification:()V
+java/util/ArrayList$SubList$1.hasNext:()Z
+java/util/ArrayList$SubList$1.hasPrevious:()Z
+java/util/ArrayList$SubList$1.next:()Ljava/lang/Object;
+java/util/ArrayList$SubList$1.nextIndex:()I
+java/util/ArrayList$SubList$1.previous:()Ljava/lang/Object;
+java/util/ArrayList$SubList$1.previousIndex:()I
+java/util/ArrayList$SubList$1.remove:()V
+java/util/ArrayList$SubList$1.set:(Ljava/lang/Object;)V
+java/util/ArrayList$SubList.<init>:(Ljava/util/ArrayList;Ljava/util/AbstractList;III)V
+java/util/ArrayList$SubList.add:(ILjava/lang/Object;)V
+java/util/ArrayList$SubList.checkForComodification:()V
+java/util/ArrayList$SubList.get:(I)Ljava/lang/Object;
+java/util/ArrayList$SubList.listIterator:(I)Ljava/util/ListIterator;
+java/util/ArrayList$SubList.outOfBoundsMsg:(I)Ljava/lang/String;
+java/util/ArrayList$SubList.rangeCheck:(I)V
+java/util/ArrayList$SubList.rangeCheckForAdd:(I)V
+java/util/ArrayList$SubList.remove:(I)Ljava/lang/Object;
+java/util/ArrayList$SubList.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/ArrayList$SubList.size:()I
+java/util/ArrayList$SubList.spliterator:()Ljava/util/Spliterator;
+java/util/ArrayList$SubList.subList:(II)Ljava/util/List;
+java/util/ArrayList.<clinit>:()V
+java/util/ArrayList.<init>:()V
+java/util/ArrayList.<init>:(I)V
+java/util/ArrayList.<init>:(Ljava/util/Collection;)V
+java/util/ArrayList.access$100:(Ljava/util/ArrayList;)I
+java/util/ArrayList.add:(ILjava/lang/Object;)V
+java/util/ArrayList.add:(Ljava/lang/Object;)Z
+java/util/ArrayList.addAll:(ILjava/util/Collection;)Z
+java/util/ArrayList.addAll:(Ljava/util/Collection;)Z
+java/util/ArrayList.batchRemove:(Ljava/util/Collection;Z)Z
+java/util/ArrayList.clear:()V
+java/util/ArrayList.contains:(Ljava/lang/Object;)Z
+java/util/ArrayList.elementData:(I)Ljava/lang/Object;
+java/util/ArrayList.ensureCapacity:(I)V
+java/util/ArrayList.ensureCapacityInternal:(I)V
+java/util/ArrayList.ensureExplicitCapacity:(I)V
+java/util/ArrayList.fastRemove:(I)V
+java/util/ArrayList.get:(I)Ljava/lang/Object;
+java/util/ArrayList.grow:(I)V
+java/util/ArrayList.hugeCapacity:(I)I
+java/util/ArrayList.indexOf:(Ljava/lang/Object;)I
+java/util/ArrayList.isEmpty:()Z
+java/util/ArrayList.iterator:()Ljava/util/Iterator;
+java/util/ArrayList.lastIndexOf:(Ljava/lang/Object;)I
+java/util/ArrayList.listIterator:()Ljava/util/ListIterator;
+java/util/ArrayList.listIterator:(I)Ljava/util/ListIterator;
+java/util/ArrayList.outOfBoundsMsg:(I)Ljava/lang/String;
+java/util/ArrayList.rangeCheck:(I)V
+java/util/ArrayList.rangeCheckForAdd:(I)V
+java/util/ArrayList.remove:(I)Ljava/lang/Object;
+java/util/ArrayList.remove:(Ljava/lang/Object;)Z
+java/util/ArrayList.removeAll:(Ljava/util/Collection;)Z
+java/util/ArrayList.removeRange:(II)V
+java/util/ArrayList.retainAll:(Ljava/util/Collection;)Z
+java/util/ArrayList.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/ArrayList.size:()I
+java/util/ArrayList.sort:(Ljava/util/Comparator;)V
+java/util/ArrayList.spliterator:()Ljava/util/Spliterator;
+java/util/ArrayList.subList:(II)Ljava/util/List;
+java/util/ArrayList.subListRangeCheck:(III)V
+java/util/ArrayList.toArray:()[Ljava/lang/Object;
+java/util/ArrayList.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/ArrayList.trimToSize:()V
+java/util/ArrayPrefixHelpers.<init>:()V
+java/util/Arrays$ArrayList.<init>:([Ljava/lang/Object;)V
+java/util/Arrays$ArrayList.contains:(Ljava/lang/Object;)Z
+java/util/Arrays$ArrayList.get:(I)Ljava/lang/Object;
+java/util/Arrays$ArrayList.indexOf:(Ljava/lang/Object;)I
+java/util/Arrays$ArrayList.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/Arrays$ArrayList.size:()I
+java/util/Arrays$ArrayList.spliterator:()Ljava/util/Spliterator;
+java/util/Arrays$ArrayList.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Arrays$LegacyMergeSort.<init>:()V
+java/util/Arrays$LegacyMergeSort.access$000:()Z
+java/util/Arrays$NaturalOrder.<clinit>:()V
+java/util/Arrays$NaturalOrder.<init>:()V
+java/util/Arrays$NaturalOrder.compare:(Ljava/lang/Object;Ljava/lang/Object;)I
+java/util/Arrays.<init>:()V
+java/util/Arrays.asList:([Ljava/lang/Object;)Ljava/util/List;
+java/util/Arrays.binarySearch0:([BIIB)I
+java/util/Arrays.binarySearch0:([CIIC)I
+java/util/Arrays.binarySearch0:([IIII)I
+java/util/Arrays.binarySearch0:([JIIJ)I
+java/util/Arrays.binarySearch0:([Ljava/lang/Object;IILjava/lang/Object;)I
+java/util/Arrays.binarySearch0:([Ljava/lang/Object;IILjava/lang/Object;Ljava/util/Comparator;)I
+java/util/Arrays.binarySearch0:([SIIS)I
+java/util/Arrays.binarySearch:([BB)I
+java/util/Arrays.binarySearch:([BIIB)I
+java/util/Arrays.binarySearch:([CC)I
+java/util/Arrays.binarySearch:([CIIC)I
+java/util/Arrays.binarySearch:([II)I
+java/util/Arrays.binarySearch:([IIII)I
+java/util/Arrays.binarySearch:([JIIJ)I
+java/util/Arrays.binarySearch:([JJ)I
+java/util/Arrays.binarySearch:([Ljava/lang/Object;IILjava/lang/Object;)I
+java/util/Arrays.binarySearch:([Ljava/lang/Object;IILjava/lang/Object;Ljava/util/Comparator;)I
+java/util/Arrays.binarySearch:([Ljava/lang/Object;Ljava/lang/Object;)I
+java/util/Arrays.binarySearch:([Ljava/lang/Object;Ljava/lang/Object;Ljava/util/Comparator;)I
+java/util/Arrays.binarySearch:([SIIS)I
+java/util/Arrays.binarySearch:([SS)I
+java/util/Arrays.copyOf:([BI)[B
+java/util/Arrays.copyOf:([CI)[C
+java/util/Arrays.copyOf:([DI)[D
+java/util/Arrays.copyOf:([FI)[F
+java/util/Arrays.copyOf:([II)[I
+java/util/Arrays.copyOf:([JI)[J
+java/util/Arrays.copyOf:([Ljava/lang/Object;I)[Ljava/lang/Object;
+java/util/Arrays.copyOf:([Ljava/lang/Object;ILjava/lang/Class;)[Ljava/lang/Object;
+java/util/Arrays.copyOf:([SI)[S
+java/util/Arrays.copyOf:([ZI)[Z
+java/util/Arrays.copyOfRange:([BII)[B
+java/util/Arrays.copyOfRange:([CII)[C
+java/util/Arrays.copyOfRange:([DII)[D
+java/util/Arrays.copyOfRange:([FII)[F
+java/util/Arrays.copyOfRange:([III)[I
+java/util/Arrays.copyOfRange:([JII)[J
+java/util/Arrays.copyOfRange:([Ljava/lang/Object;II)[Ljava/lang/Object;
+java/util/Arrays.copyOfRange:([Ljava/lang/Object;IILjava/lang/Class;)[Ljava/lang/Object;
+java/util/Arrays.copyOfRange:([SII)[S
+java/util/Arrays.copyOfRange:([ZII)[Z
+java/util/Arrays.equals:([B[B)Z
+java/util/Arrays.equals:([C[C)Z
+java/util/Arrays.equals:([I[I)Z
+java/util/Arrays.equals:([J[J)Z
+java/util/Arrays.equals:([Ljava/lang/Object;[Ljava/lang/Object;)Z
+java/util/Arrays.equals:([S[S)Z
+java/util/Arrays.equals:([Z[Z)Z
+java/util/Arrays.fill:([BB)V
+java/util/Arrays.fill:([BIIB)V
+java/util/Arrays.fill:([CC)V
+java/util/Arrays.fill:([CIIC)V
+java/util/Arrays.fill:([DD)V
+java/util/Arrays.fill:([DIID)V
+java/util/Arrays.fill:([FF)V
+java/util/Arrays.fill:([FIIF)V
+java/util/Arrays.fill:([II)V
+java/util/Arrays.fill:([IIII)V
+java/util/Arrays.fill:([JIIJ)V
+java/util/Arrays.fill:([JJ)V
+java/util/Arrays.fill:([Ljava/lang/Object;IILjava/lang/Object;)V
+java/util/Arrays.fill:([Ljava/lang/Object;Ljava/lang/Object;)V
+java/util/Arrays.fill:([SIIS)V
+java/util/Arrays.fill:([SS)V
+java/util/Arrays.fill:([ZIIZ)V
+java/util/Arrays.fill:([ZZ)V
+java/util/Arrays.hashCode:([B)I
+java/util/Arrays.hashCode:([C)I
+java/util/Arrays.hashCode:([I)I
+java/util/Arrays.hashCode:([J)I
+java/util/Arrays.hashCode:([S)I
+java/util/Arrays.hashCode:([Z)I
+java/util/Arrays.legacyMergeSort:([Ljava/lang/Object;II)V
+java/util/Arrays.legacyMergeSort:([Ljava/lang/Object;IILjava/util/Comparator;)V
+java/util/Arrays.mergeSort:([Ljava/lang/Object;[Ljava/lang/Object;III)V
+java/util/Arrays.mergeSort:([Ljava/lang/Object;[Ljava/lang/Object;IIILjava/util/Comparator;)V
+java/util/Arrays.rangeCheck:(III)V
+java/util/Arrays.sort:([B)V
+java/util/Arrays.sort:([BII)V
+java/util/Arrays.sort:([C)V
+java/util/Arrays.sort:([CII)V
+java/util/Arrays.sort:([I)V
+java/util/Arrays.sort:([III)V
+java/util/Arrays.sort:([J)V
+java/util/Arrays.sort:([JII)V
+java/util/Arrays.sort:([Ljava/lang/Object;II)V
+java/util/Arrays.sort:([Ljava/lang/Object;IILjava/util/Comparator;)V
+java/util/Arrays.sort:([S)V
+java/util/Arrays.sort:([SII)V
+java/util/Arrays.spliterator:([D)Ljava/util/Spliterator$OfDouble;
+java/util/Arrays.spliterator:([DII)Ljava/util/Spliterator$OfDouble;
+java/util/Arrays.spliterator:([I)Ljava/util/Spliterator$OfInt;
+java/util/Arrays.spliterator:([III)Ljava/util/Spliterator$OfInt;
+java/util/Arrays.spliterator:([J)Ljava/util/Spliterator$OfLong;
+java/util/Arrays.spliterator:([JII)Ljava/util/Spliterator$OfLong;
+java/util/Arrays.spliterator:([Ljava/lang/Object;)Ljava/util/Spliterator;
+java/util/Arrays.spliterator:([Ljava/lang/Object;II)Ljava/util/Spliterator;
+java/util/Arrays.swap:([Ljava/lang/Object;II)V
+java/util/Arrays.toString:([B)Ljava/lang/String;
+java/util/Arrays.toString:([C)Ljava/lang/String;
+java/util/Arrays.toString:([I)Ljava/lang/String;
+java/util/Arrays.toString:([J)Ljava/lang/String;
+java/util/Arrays.toString:([S)Ljava/lang/String;
+java/util/Arrays.toString:([Z)Ljava/lang/String;
+java/util/ArraysParallelSortHelpers$EmptyCompleter.compute:()V
+java/util/ArraysParallelSortHelpers$FJByte.<init>:()V
+java/util/ArraysParallelSortHelpers$FJChar.<init>:()V
+java/util/ArraysParallelSortHelpers$FJDouble.<init>:()V
+java/util/ArraysParallelSortHelpers$FJFloat.<init>:()V
+java/util/ArraysParallelSortHelpers$FJInt.<init>:()V
+java/util/ArraysParallelSortHelpers$FJLong.<init>:()V
+java/util/ArraysParallelSortHelpers$FJObject.<init>:()V
+java/util/ArraysParallelSortHelpers$FJShort.<init>:()V
+java/util/ArraysParallelSortHelpers$Relay.compute:()V
+java/util/ArraysParallelSortHelpers.<init>:()V
+java/util/Base64$Decoder.<clinit>:()V
+java/util/Base64$Decoder.<init>:(ZZ)V
+java/util/Base64$Decoder.access$000:()[I
+java/util/Base64$Decoder.decode0:([BII[B)I
+java/util/Base64$Decoder.decode:([B)[B
+java/util/Base64$Decoder.decode:([B[B)I
+java/util/Base64$Decoder.outLength:([BII)I
+java/util/Base64$Encoder.<clinit>:()V
+java/util/Base64$Encoder.<init>:(Z[BIZ)V
+java/util/Base64$Encoder.<init>:(Z[BIZLjava/util/Base64$1;)V
+java/util/Base64$Encoder.access$200:()[C
+java/util/Base64$Encoder.access$300:()[C
+java/util/Base64$Encoder.encode0:([BII[B)I
+java/util/Base64$Encoder.encode:([B)[B
+java/util/Base64$Encoder.encode:([B[B)I
+java/util/Base64$Encoder.encodeToString:([B)Ljava/lang/String;
+java/util/Base64$Encoder.outLength:(I)I
+java/util/Base64$Encoder.withoutPadding:()Ljava/util/Base64$Encoder;
+java/util/Base64.<init>:()V
+java/util/Base64.getDecoder:()Ljava/util/Base64$Decoder;
+java/util/Base64.getEncoder:()Ljava/util/Base64$Encoder;
+java/util/Base64.getMimeDecoder:()Ljava/util/Base64$Decoder;
+java/util/Base64.getMimeEncoder:()Ljava/util/Base64$Encoder;
+java/util/Base64.getMimeEncoder:(I[B)Ljava/util/Base64$Encoder;
+java/util/Base64.getUrlDecoder:()Ljava/util/Base64$Decoder;
+java/util/Base64.getUrlEncoder:()Ljava/util/Base64$Encoder;
+java/util/BitSet$1BitSetIterator.<init>:(Ljava/util/BitSet;)V
+java/util/BitSet$1BitSetIterator.hasNext:()Z
+java/util/BitSet$1BitSetIterator.nextInt:()I
+java/util/BitSet.<init>:()V
+java/util/BitSet.<init>:(I)V
+java/util/BitSet.<init>:([J)V
+java/util/BitSet.and:(Ljava/util/BitSet;)V
+java/util/BitSet.andNot:(Ljava/util/BitSet;)V
+java/util/BitSet.cardinality:()I
+java/util/BitSet.checkInvariants:()V
+java/util/BitSet.checkRange:(II)V
+java/util/BitSet.clear:()V
+java/util/BitSet.clear:(I)V
+java/util/BitSet.clear:(II)V
+java/util/BitSet.ensureCapacity:(I)V
+java/util/BitSet.equals:(Ljava/lang/Object;)Z
+java/util/BitSet.expandTo:(I)V
+java/util/BitSet.flip:(I)V
+java/util/BitSet.flip:(II)V
+java/util/BitSet.get:(I)Z
+java/util/BitSet.get:(II)Ljava/util/BitSet;
+java/util/BitSet.hashCode:()I
+java/util/BitSet.initWords:(I)V
+java/util/BitSet.intersects:(Ljava/util/BitSet;)Z
+java/util/BitSet.isEmpty:()Z
+java/util/BitSet.lambda$stream$70:()Ljava/util/Spliterator$OfInt;
+java/util/BitSet.length:()I
+java/util/BitSet.nextClearBit:(I)I
+java/util/BitSet.nextSetBit:(I)I
+java/util/BitSet.or:(Ljava/util/BitSet;)V
+java/util/BitSet.previousClearBit:(I)I
+java/util/BitSet.previousSetBit:(I)I
+java/util/BitSet.recalculateWordsInUse:()V
+java/util/BitSet.set:(I)V
+java/util/BitSet.set:(II)V
+java/util/BitSet.set:(IIZ)V
+java/util/BitSet.set:(IZ)V
+java/util/BitSet.size:()I
+java/util/BitSet.toLongArray:()[J
+java/util/BitSet.toString:()Ljava/lang/String;
+java/util/BitSet.trimToSize:()V
+java/util/BitSet.valueOf:([J)Ljava/util/BitSet;
+java/util/BitSet.wordIndex:(I)I
+java/util/BitSet.xor:(Ljava/util/BitSet;)V
+java/util/Calendar$1.<init>:(Ljava/util/Calendar;Ljava/io/ObjectInputStream;)V
+java/util/Calendar$AvailableCalendarTypes.<init>:()V
+java/util/Calendar$AvailableCalendarTypes.access$000:()Ljava/util/Set;
+java/util/Calendar$Builder.<init>:()V
+java/util/Calendar$Builder.allocateFields:()V
+java/util/Calendar$Builder.internalSet:(II)V
+java/util/Calendar$Builder.isInstantSet:()Z
+java/util/Calendar$Builder.isSet:(I)Z
+java/util/Calendar$Builder.isValidWeekParameter:(I)Z
+java/util/Calendar$Builder.set:(II)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setCalendarType:(Ljava/lang/String;)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setDate:(III)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setFields:([I)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setInstant:(J)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setLenient:(Z)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setLocale:(Ljava/util/Locale;)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setTimeOfDay:(III)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setTimeOfDay:(IIII)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setTimeZone:(Ljava/util/TimeZone;)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setWeekDate:(III)Ljava/util/Calendar$Builder;
+java/util/Calendar$Builder.setWeekDefinition:(II)Ljava/util/Calendar$Builder;
+java/util/Calendar$CalendarAccessControlContext.<init>:()V
+java/util/Calendar$CalendarAccessControlContext.access$100:()Ljava/security/AccessControlContext;
+java/util/Calendar.add:(II)V
+java/util/Calendar.adjustStamp:()V
+java/util/Calendar.aggregateStamp:(II)I
+java/util/Calendar.appendValue:(Ljava/lang/StringBuilder;Ljava/lang/String;ZJ)V
+java/util/Calendar.checkDisplayNameParams:(IIIILjava/util/Locale;I)Z
+java/util/Calendar.clear:()V
+java/util/Calendar.clear:(I)V
+java/util/Calendar.complete:()V
+java/util/Calendar.computeFields:()V
+java/util/Calendar.computeTime:()V
+java/util/Calendar.get:(I)I
+java/util/Calendar.getAvailableCalendarTypes:()Ljava/util/Set;
+java/util/Calendar.getBaseStyle:(I)I
+java/util/Calendar.getFieldName:(I)Ljava/lang/String;
+java/util/Calendar.getFirstDayOfWeek:()I
+java/util/Calendar.getGreatestMinimum:(I)I
+java/util/Calendar.getLeastMaximum:(I)I
+java/util/Calendar.getMaximum:(I)I
+java/util/Calendar.getMinimalDaysInFirstWeek:()I
+java/util/Calendar.getMinimum:(I)I
+java/util/Calendar.getSetStateFields:()I
+java/util/Calendar.getTime:()Ljava/util/Date;
+java/util/Calendar.getTimeInMillis:()J
+java/util/Calendar.getWeekYear:()I
+java/util/Calendar.getWeeksInWeekYear:()I
+java/util/Calendar.getZone:()Ljava/util/TimeZone;
+java/util/Calendar.internalGet:(I)I
+java/util/Calendar.internalSet:(II)V
+java/util/Calendar.isExternallySet:(I)Z
+java/util/Calendar.isFieldSet:(II)Z
+java/util/Calendar.isFullyNormalized:()Z
+java/util/Calendar.isLenient:()Z
+java/util/Calendar.isNarrowStyle:(I)Z
+java/util/Calendar.isPartiallyNormalized:()Z
+java/util/Calendar.isSet:(I)Z
+java/util/Calendar.isStandaloneStyle:(I)Z
+java/util/Calendar.isWeekDateSupported:()Z
+java/util/Calendar.roll:(II)V
+java/util/Calendar.roll:(IZ)V
+java/util/Calendar.selectFields:()I
+java/util/Calendar.set:(II)V
+java/util/Calendar.set:(III)V
+java/util/Calendar.set:(IIIII)V
+java/util/Calendar.set:(IIIIII)V
+java/util/Calendar.setFieldsComputed:(I)V
+java/util/Calendar.setFieldsNormalized:(I)V
+java/util/Calendar.setLenient:(Z)V
+java/util/Calendar.setTimeZone:(Ljava/util/TimeZone;)V
+java/util/Calendar.setUnnormalized:()V
+java/util/Calendar.setWeekDate:(III)V
+java/util/Calendar.setZoneShared:(Z)V
+java/util/Calendar.updateTime:()V
+java/util/Collection.add:(Ljava/lang/Object;)Z
+java/util/Collection.addAll:(Ljava/util/Collection;)Z
+java/util/Collection.clear:()V
+java/util/Collection.contains:(Ljava/lang/Object;)Z
+java/util/Collection.containsAll:(Ljava/util/Collection;)Z
+java/util/Collection.equals:(Ljava/lang/Object;)Z
+java/util/Collection.hashCode:()I
+java/util/Collection.isEmpty:()Z
+java/util/Collection.iterator:()Ljava/util/Iterator;
+java/util/Collection.remove:(Ljava/lang/Object;)Z
+java/util/Collection.removeAll:(Ljava/util/Collection;)Z
+java/util/Collection.retainAll:(Ljava/util/Collection;)Z
+java/util/Collection.size:()I
+java/util/Collection.spliterator:()Ljava/util/Spliterator;
+java/util/Collection.toArray:()[Ljava/lang/Object;
+java/util/Collection.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Collections$1.<init>:(Ljava/lang/Object;)V
+java/util/Collections$1.hasNext:()Z
+java/util/Collections$1.next:()Ljava/lang/Object;
+java/util/Collections$1.remove:()V
+java/util/Collections$2.<init>:(Ljava/lang/Object;)V
+java/util/Collections$2.characteristics:()I
+java/util/Collections$2.estimateSize:()J
+java/util/Collections$2.trySplit:()Ljava/util/Spliterator;
+java/util/Collections$3.<init>:(Ljava/util/Collection;)V
+java/util/Collections$3.hasMoreElements:()Z
+java/util/Collections$3.nextElement:()Ljava/lang/Object;
+java/util/Collections$AsLIFOQueue.<init>:(Ljava/util/Deque;)V
+java/util/Collections$AsLIFOQueue.add:(Ljava/lang/Object;)Z
+java/util/Collections$AsLIFOQueue.contains:(Ljava/lang/Object;)Z
+java/util/Collections$AsLIFOQueue.element:()Ljava/lang/Object;
+java/util/Collections$AsLIFOQueue.iterator:()Ljava/util/Iterator;
+java/util/Collections$AsLIFOQueue.offer:(Ljava/lang/Object;)Z
+java/util/Collections$AsLIFOQueue.peek:()Ljava/lang/Object;
+java/util/Collections$AsLIFOQueue.poll:()Ljava/lang/Object;
+java/util/Collections$AsLIFOQueue.remove:()Ljava/lang/Object;
+java/util/Collections$AsLIFOQueue.remove:(Ljava/lang/Object;)Z
+java/util/Collections$AsLIFOQueue.size:()I
+java/util/Collections$CheckedCollection$1.<init>:(Ljava/util/Collections$CheckedCollection;Ljava/util/Iterator;)V
+java/util/Collections$CheckedCollection$1.hasNext:()Z
+java/util/Collections$CheckedCollection$1.next:()Ljava/lang/Object;
+java/util/Collections$CheckedCollection$1.remove:()V
+java/util/Collections$CheckedCollection.<init>:(Ljava/util/Collection;Ljava/lang/Class;)V
+java/util/Collections$CheckedCollection.clear:()V
+java/util/Collections$CheckedCollection.contains:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedCollection.containsAll:(Ljava/util/Collection;)Z
+java/util/Collections$CheckedCollection.isEmpty:()Z
+java/util/Collections$CheckedCollection.iterator:()Ljava/util/Iterator;
+java/util/Collections$CheckedCollection.remove:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedCollection.removeAll:(Ljava/util/Collection;)Z
+java/util/Collections$CheckedCollection.retainAll:(Ljava/util/Collection;)Z
+java/util/Collections$CheckedCollection.size:()I
+java/util/Collections$CheckedCollection.spliterator:()Ljava/util/Spliterator;
+java/util/Collections$CheckedCollection.toArray:()[Ljava/lang/Object;
+java/util/Collections$CheckedCollection.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Collections$CheckedCollection.zeroLengthElementArray:()[Ljava/lang/Object;
+java/util/Collections$CheckedList$1.<init>:(Ljava/util/Collections$CheckedList;Ljava/util/ListIterator;)V
+java/util/Collections$CheckedList$1.hasNext:()Z
+java/util/Collections$CheckedList$1.hasPrevious:()Z
+java/util/Collections$CheckedList$1.next:()Ljava/lang/Object;
+java/util/Collections$CheckedList$1.nextIndex:()I
+java/util/Collections$CheckedList$1.previous:()Ljava/lang/Object;
+java/util/Collections$CheckedList$1.previousIndex:()I
+java/util/Collections$CheckedList$1.remove:()V
+java/util/Collections$CheckedList.<init>:(Ljava/util/List;Ljava/lang/Class;)V
+java/util/Collections$CheckedList.equals:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedList.get:(I)Ljava/lang/Object;
+java/util/Collections$CheckedList.hashCode:()I
+java/util/Collections$CheckedList.indexOf:(Ljava/lang/Object;)I
+java/util/Collections$CheckedList.lastIndexOf:(Ljava/lang/Object;)I
+java/util/Collections$CheckedList.listIterator:()Ljava/util/ListIterator;
+java/util/Collections$CheckedList.listIterator:(I)Ljava/util/ListIterator;
+java/util/Collections$CheckedList.remove:(I)Ljava/lang/Object;
+java/util/Collections$CheckedList.subList:(II)Ljava/util/List;
+java/util/Collections$CheckedMap$CheckedEntrySet$1.<init>:(Ljava/util/Collections$CheckedMap$CheckedEntrySet;Ljava/util/Iterator;Ljava/lang/Class;)V
+java/util/Collections$CheckedMap$CheckedEntrySet$1.hasNext:()Z
+java/util/Collections$CheckedMap$CheckedEntrySet$1.next:()Ljava/lang/Object;
+java/util/Collections$CheckedMap$CheckedEntrySet$1.next:()Ljava/util/Map$Entry;
+java/util/Collections$CheckedMap$CheckedEntrySet$1.remove:()V
+java/util/Collections$CheckedMap$CheckedEntrySet$CheckedEntry.<init>:(Ljava/util/Map$Entry;Ljava/lang/Class;)V
+java/util/Collections$CheckedMap$CheckedEntrySet$CheckedEntry.equals:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedMap$CheckedEntrySet$CheckedEntry.getKey:()Ljava/lang/Object;
+java/util/Collections$CheckedMap$CheckedEntrySet$CheckedEntry.getValue:()Ljava/lang/Object;
+java/util/Collections$CheckedMap$CheckedEntrySet$CheckedEntry.hashCode:()I
+java/util/Collections$CheckedMap$CheckedEntrySet.<init>:(Ljava/util/Set;Ljava/lang/Class;)V
+java/util/Collections$CheckedMap$CheckedEntrySet.add:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedMap$CheckedEntrySet.add:(Ljava/util/Map$Entry;)Z
+java/util/Collections$CheckedMap$CheckedEntrySet.addAll:(Ljava/util/Collection;)Z
+java/util/Collections$CheckedMap$CheckedEntrySet.batchRemove:(Ljava/util/Collection;Z)Z
+java/util/Collections$CheckedMap$CheckedEntrySet.checkedEntry:(Ljava/util/Map$Entry;Ljava/lang/Class;)Ljava/util/Collections$CheckedMap$CheckedEntrySet$CheckedEntry;
+java/util/Collections$CheckedMap$CheckedEntrySet.clear:()V
+java/util/Collections$CheckedMap$CheckedEntrySet.contains:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedMap$CheckedEntrySet.containsAll:(Ljava/util/Collection;)Z
+java/util/Collections$CheckedMap$CheckedEntrySet.equals:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedMap$CheckedEntrySet.hashCode:()I
+java/util/Collections$CheckedMap$CheckedEntrySet.isEmpty:()Z
+java/util/Collections$CheckedMap$CheckedEntrySet.iterator:()Ljava/util/Iterator;
+java/util/Collections$CheckedMap$CheckedEntrySet.remove:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedMap$CheckedEntrySet.removeAll:(Ljava/util/Collection;)Z
+java/util/Collections$CheckedMap$CheckedEntrySet.retainAll:(Ljava/util/Collection;)Z
+java/util/Collections$CheckedMap$CheckedEntrySet.size:()I
+java/util/Collections$CheckedMap$CheckedEntrySet.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Collections$CheckedMap.<init>:(Ljava/util/Map;Ljava/lang/Class;Ljava/lang/Class;)V
+java/util/Collections$CheckedMap.clear:()V
+java/util/Collections$CheckedMap.containsKey:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedMap.containsValue:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedMap.entrySet:()Ljava/util/Set;
+java/util/Collections$CheckedMap.equals:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$CheckedMap.hashCode:()I
+java/util/Collections$CheckedMap.isEmpty:()Z
+java/util/Collections$CheckedMap.keySet:()Ljava/util/Set;
+java/util/Collections$CheckedMap.remove:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$CheckedMap.remove:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections$CheckedMap.size:()I
+java/util/Collections$CheckedMap.typeCheck:(Ljava/util/function/BiFunction;)Ljava/util/function/BiFunction;
+java/util/Collections$CheckedMap.values:()Ljava/util/Collection;
+java/util/Collections$CheckedNavigableMap.<init>:(Ljava/util/NavigableMap;Ljava/lang/Class;Ljava/lang/Class;)V
+java/util/Collections$CheckedNavigableMap.ceilingEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$CheckedNavigableMap.ceilingKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$CheckedNavigableMap.descendingKeySet:()Ljava/util/NavigableSet;
+java/util/Collections$CheckedNavigableMap.descendingMap:()Ljava/util/NavigableMap;
+java/util/Collections$CheckedNavigableMap.firstEntry:()Ljava/util/Map$Entry;
+java/util/Collections$CheckedNavigableMap.floorEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$CheckedNavigableMap.floorKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$CheckedNavigableMap.headMap:(Ljava/lang/Object;)Ljava/util/NavigableMap;
+java/util/Collections$CheckedNavigableMap.headMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$CheckedNavigableMap.headMap:(Ljava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/Collections$CheckedNavigableMap.higherEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$CheckedNavigableMap.higherKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$CheckedNavigableMap.keySet:()Ljava/util/NavigableSet;
+java/util/Collections$CheckedNavigableMap.keySet:()Ljava/util/Set;
+java/util/Collections$CheckedNavigableMap.lastEntry:()Ljava/util/Map$Entry;
+java/util/Collections$CheckedNavigableMap.lowerEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$CheckedNavigableMap.lowerKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$CheckedNavigableMap.navigableKeySet:()Ljava/util/NavigableSet;
+java/util/Collections$CheckedNavigableMap.pollFirstEntry:()Ljava/util/Map$Entry;
+java/util/Collections$CheckedNavigableMap.pollLastEntry:()Ljava/util/Map$Entry;
+java/util/Collections$CheckedNavigableMap.subMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/NavigableMap;
+java/util/Collections$CheckedNavigableMap.subMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$CheckedNavigableMap.subMap:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/Collections$CheckedNavigableMap.tailMap:(Ljava/lang/Object;)Ljava/util/NavigableMap;
+java/util/Collections$CheckedNavigableMap.tailMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$CheckedNavigableMap.tailMap:(Ljava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/Collections$CheckedNavigableSet.<init>:(Ljava/util/NavigableSet;Ljava/lang/Class;)V
+java/util/Collections$CheckedNavigableSet.ceiling:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$CheckedNavigableSet.descendingIterator:()Ljava/util/Iterator;
+java/util/Collections$CheckedNavigableSet.descendingSet:()Ljava/util/NavigableSet;
+java/util/Collections$CheckedNavigableSet.floor:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$CheckedNavigableSet.headSet:(Ljava/lang/Object;)Ljava/util/NavigableSet;
+java/util/Collections$CheckedNavigableSet.headSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$CheckedNavigableSet.headSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/Collections$CheckedNavigableSet.higher:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$CheckedNavigableSet.lower:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$CheckedNavigableSet.pollFirst:()Ljava/lang/Object;
+java/util/Collections$CheckedNavigableSet.pollLast:()Ljava/lang/Object;
+java/util/Collections$CheckedNavigableSet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/NavigableSet;
+java/util/Collections$CheckedNavigableSet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$CheckedNavigableSet.subSet:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/Collections$CheckedNavigableSet.tailSet:(Ljava/lang/Object;)Ljava/util/NavigableSet;
+java/util/Collections$CheckedNavigableSet.tailSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$CheckedNavigableSet.tailSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/Collections$CheckedQueue.<init>:(Ljava/util/Queue;Ljava/lang/Class;)V
+java/util/Collections$CheckedQueue.element:()Ljava/lang/Object;
+java/util/Collections$CheckedQueue.equals:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedQueue.hashCode:()I
+java/util/Collections$CheckedQueue.peek:()Ljava/lang/Object;
+java/util/Collections$CheckedQueue.poll:()Ljava/lang/Object;
+java/util/Collections$CheckedQueue.remove:()Ljava/lang/Object;
+java/util/Collections$CheckedRandomAccessList.<init>:(Ljava/util/List;Ljava/lang/Class;)V
+java/util/Collections$CheckedRandomAccessList.subList:(II)Ljava/util/List;
+java/util/Collections$CheckedSet.<init>:(Ljava/util/Set;Ljava/lang/Class;)V
+java/util/Collections$CheckedSet.equals:(Ljava/lang/Object;)Z
+java/util/Collections$CheckedSet.hashCode:()I
+java/util/Collections$CheckedSortedMap.<init>:(Ljava/util/SortedMap;Ljava/lang/Class;Ljava/lang/Class;)V
+java/util/Collections$CheckedSortedMap.comparator:()Ljava/util/Comparator;
+java/util/Collections$CheckedSortedMap.firstKey:()Ljava/lang/Object;
+java/util/Collections$CheckedSortedMap.headMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$CheckedSortedMap.lastKey:()Ljava/lang/Object;
+java/util/Collections$CheckedSortedMap.subMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$CheckedSortedMap.tailMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$CheckedSortedSet.<init>:(Ljava/util/SortedSet;Ljava/lang/Class;)V
+java/util/Collections$CheckedSortedSet.comparator:()Ljava/util/Comparator;
+java/util/Collections$CheckedSortedSet.first:()Ljava/lang/Object;
+java/util/Collections$CheckedSortedSet.headSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$CheckedSortedSet.last:()Ljava/lang/Object;
+java/util/Collections$CheckedSortedSet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$CheckedSortedSet.tailSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$CopiesList.<init>:(ILjava/lang/Object;)V
+java/util/Collections$CopiesList.contains:(Ljava/lang/Object;)Z
+java/util/Collections$CopiesList.get:(I)Ljava/lang/Object;
+java/util/Collections$CopiesList.indexOf:(Ljava/lang/Object;)I
+java/util/Collections$CopiesList.lambda$parallelStream$97:(I)Ljava/lang/Object;
+java/util/Collections$CopiesList.lambda$stream$96:(I)Ljava/lang/Object;
+java/util/Collections$CopiesList.lastIndexOf:(Ljava/lang/Object;)I
+java/util/Collections$CopiesList.size:()I
+java/util/Collections$CopiesList.subList:(II)Ljava/util/List;
+java/util/Collections$CopiesList.toArray:()[Ljava/lang/Object;
+java/util/Collections$CopiesList.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Collections$EmptyEnumeration.<clinit>:()V
+java/util/Collections$EmptyEnumeration.<init>:()V
+java/util/Collections$EmptyEnumeration.hasMoreElements:()Z
+java/util/Collections$EmptyEnumeration.nextElement:()Ljava/lang/Object;
+java/util/Collections$EmptyIterator.<clinit>:()V
+java/util/Collections$EmptyIterator.<init>:()V
+java/util/Collections$EmptyIterator.<init>:(Ljava/util/Collections$1;)V
+java/util/Collections$EmptyIterator.forEachRemaining:(Ljava/util/function/Consumer;)V
+java/util/Collections$EmptyIterator.hasNext:()Z
+java/util/Collections$EmptyIterator.next:()Ljava/lang/Object;
+java/util/Collections$EmptyIterator.remove:()V
+java/util/Collections$EmptyList.<init>:()V
+java/util/Collections$EmptyList.<init>:(Ljava/util/Collections$1;)V
+java/util/Collections$EmptyList.contains:(Ljava/lang/Object;)Z
+java/util/Collections$EmptyList.containsAll:(Ljava/util/Collection;)Z
+java/util/Collections$EmptyList.equals:(Ljava/lang/Object;)Z
+java/util/Collections$EmptyList.forEach:(Ljava/util/function/Consumer;)V
+java/util/Collections$EmptyList.get:(I)Ljava/lang/Object;
+java/util/Collections$EmptyList.hashCode:()I
+java/util/Collections$EmptyList.isEmpty:()Z
+java/util/Collections$EmptyList.iterator:()Ljava/util/Iterator;
+java/util/Collections$EmptyList.listIterator:()Ljava/util/ListIterator;
+java/util/Collections$EmptyList.readResolve:()Ljava/lang/Object;
+java/util/Collections$EmptyList.removeIf:(Ljava/util/function/Predicate;)Z
+java/util/Collections$EmptyList.replaceAll:(Ljava/util/function/UnaryOperator;)V
+java/util/Collections$EmptyList.size:()I
+java/util/Collections$EmptyList.sort:(Ljava/util/Comparator;)V
+java/util/Collections$EmptyList.spliterator:()Ljava/util/Spliterator;
+java/util/Collections$EmptyList.toArray:()[Ljava/lang/Object;
+java/util/Collections$EmptyList.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Collections$EmptyListIterator.<clinit>:()V
+java/util/Collections$EmptyListIterator.<init>:()V
+java/util/Collections$EmptyListIterator.add:(Ljava/lang/Object;)V
+java/util/Collections$EmptyListIterator.hasPrevious:()Z
+java/util/Collections$EmptyListIterator.nextIndex:()I
+java/util/Collections$EmptyListIterator.previous:()Ljava/lang/Object;
+java/util/Collections$EmptyListIterator.previousIndex:()I
+java/util/Collections$EmptyListIterator.set:(Ljava/lang/Object;)V
+java/util/Collections$EmptyMap.<init>:()V
+java/util/Collections$EmptyMap.<init>:(Ljava/util/Collections$1;)V
+java/util/Collections$EmptyMap.compute:(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;
+java/util/Collections$EmptyMap.computeIfAbsent:(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;
+java/util/Collections$EmptyMap.computeIfPresent:(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;
+java/util/Collections$EmptyMap.containsKey:(Ljava/lang/Object;)Z
+java/util/Collections$EmptyMap.containsValue:(Ljava/lang/Object;)Z
+java/util/Collections$EmptyMap.entrySet:()Ljava/util/Set;
+java/util/Collections$EmptyMap.equals:(Ljava/lang/Object;)Z
+java/util/Collections$EmptyMap.forEach:(Ljava/util/function/BiConsumer;)V
+java/util/Collections$EmptyMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$EmptyMap.getOrDefault:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$EmptyMap.hashCode:()I
+java/util/Collections$EmptyMap.isEmpty:()Z
+java/util/Collections$EmptyMap.keySet:()Ljava/util/Set;
+java/util/Collections$EmptyMap.merge:(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;
+java/util/Collections$EmptyMap.putIfAbsent:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$EmptyMap.readResolve:()Ljava/lang/Object;
+java/util/Collections$EmptyMap.remove:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections$EmptyMap.replace:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$EmptyMap.replace:(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections$EmptyMap.replaceAll:(Ljava/util/function/BiFunction;)V
+java/util/Collections$EmptyMap.size:()I
+java/util/Collections$EmptyMap.values:()Ljava/util/Collection;
+java/util/Collections$EmptySet.<init>:()V
+java/util/Collections$EmptySet.<init>:(Ljava/util/Collections$1;)V
+java/util/Collections$EmptySet.contains:(Ljava/lang/Object;)Z
+java/util/Collections$EmptySet.containsAll:(Ljava/util/Collection;)Z
+java/util/Collections$EmptySet.forEach:(Ljava/util/function/Consumer;)V
+java/util/Collections$EmptySet.isEmpty:()Z
+java/util/Collections$EmptySet.iterator:()Ljava/util/Iterator;
+java/util/Collections$EmptySet.readResolve:()Ljava/lang/Object;
+java/util/Collections$EmptySet.removeIf:(Ljava/util/function/Predicate;)Z
+java/util/Collections$EmptySet.size:()I
+java/util/Collections$EmptySet.spliterator:()Ljava/util/Spliterator;
+java/util/Collections$EmptySet.toArray:()[Ljava/lang/Object;
+java/util/Collections$EmptySet.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Collections$ReverseComparator.<clinit>:()V
+java/util/Collections$ReverseComparator.<init>:()V
+java/util/Collections$ReverseComparator.compare:(Ljava/lang/Comparable;Ljava/lang/Comparable;)I
+java/util/Collections$ReverseComparator.compare:(Ljava/lang/Object;Ljava/lang/Object;)I
+java/util/Collections$ReverseComparator.readResolve:()Ljava/lang/Object;
+java/util/Collections$ReverseComparator.reversed:()Ljava/util/Comparator;
+java/util/Collections$ReverseComparator2.<init>:(Ljava/util/Comparator;)V
+java/util/Collections$ReverseComparator2.compare:(Ljava/lang/Object;Ljava/lang/Object;)I
+java/util/Collections$ReverseComparator2.equals:(Ljava/lang/Object;)Z
+java/util/Collections$ReverseComparator2.reversed:()Ljava/util/Comparator;
+java/util/Collections$SetFromMap.<init>:(Ljava/util/Map;)V
+java/util/Collections$SetFromMap.add:(Ljava/lang/Object;)Z
+java/util/Collections$SetFromMap.clear:()V
+java/util/Collections$SetFromMap.contains:(Ljava/lang/Object;)Z
+java/util/Collections$SetFromMap.containsAll:(Ljava/util/Collection;)Z
+java/util/Collections$SetFromMap.equals:(Ljava/lang/Object;)Z
+java/util/Collections$SetFromMap.hashCode:()I
+java/util/Collections$SetFromMap.isEmpty:()Z
+java/util/Collections$SetFromMap.iterator:()Ljava/util/Iterator;
+java/util/Collections$SetFromMap.remove:(Ljava/lang/Object;)Z
+java/util/Collections$SetFromMap.removeAll:(Ljava/util/Collection;)Z
+java/util/Collections$SetFromMap.retainAll:(Ljava/util/Collection;)Z
+java/util/Collections$SetFromMap.size:()I
+java/util/Collections$SetFromMap.spliterator:()Ljava/util/Spliterator;
+java/util/Collections$SetFromMap.toArray:()[Ljava/lang/Object;
+java/util/Collections$SetFromMap.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Collections$SingletonList.<init>:(Ljava/lang/Object;)V
+java/util/Collections$SingletonList.contains:(Ljava/lang/Object;)Z
+java/util/Collections$SingletonList.get:(I)Ljava/lang/Object;
+java/util/Collections$SingletonList.iterator:()Ljava/util/Iterator;
+java/util/Collections$SingletonList.removeIf:(Ljava/util/function/Predicate;)Z
+java/util/Collections$SingletonList.replaceAll:(Ljava/util/function/UnaryOperator;)V
+java/util/Collections$SingletonList.size:()I
+java/util/Collections$SingletonList.sort:(Ljava/util/Comparator;)V
+java/util/Collections$SingletonList.spliterator:()Ljava/util/Spliterator;
+java/util/Collections$SingletonMap.<init>:(Ljava/lang/Object;Ljava/lang/Object;)V
+java/util/Collections$SingletonMap.compute:(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;
+java/util/Collections$SingletonMap.computeIfAbsent:(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;
+java/util/Collections$SingletonMap.computeIfPresent:(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;
+java/util/Collections$SingletonMap.containsKey:(Ljava/lang/Object;)Z
+java/util/Collections$SingletonMap.containsValue:(Ljava/lang/Object;)Z
+java/util/Collections$SingletonMap.entrySet:()Ljava/util/Set;
+java/util/Collections$SingletonMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SingletonMap.getOrDefault:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SingletonMap.isEmpty:()Z
+java/util/Collections$SingletonMap.keySet:()Ljava/util/Set;
+java/util/Collections$SingletonMap.merge:(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;
+java/util/Collections$SingletonMap.putIfAbsent:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SingletonMap.remove:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections$SingletonMap.replace:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SingletonMap.replace:(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections$SingletonMap.replaceAll:(Ljava/util/function/BiFunction;)V
+java/util/Collections$SingletonMap.size:()I
+java/util/Collections$SingletonMap.values:()Ljava/util/Collection;
+java/util/Collections$SingletonSet.<init>:(Ljava/lang/Object;)V
+java/util/Collections$SingletonSet.contains:(Ljava/lang/Object;)Z
+java/util/Collections$SingletonSet.iterator:()Ljava/util/Iterator;
+java/util/Collections$SingletonSet.removeIf:(Ljava/util/function/Predicate;)Z
+java/util/Collections$SingletonSet.size:()I
+java/util/Collections$SingletonSet.spliterator:()Ljava/util/Spliterator;
+java/util/Collections$SynchronizedCollection.<init>:(Ljava/util/Collection;)V
+java/util/Collections$SynchronizedCollection.<init>:(Ljava/util/Collection;Ljava/lang/Object;)V
+java/util/Collections$SynchronizedCollection.add:(Ljava/lang/Object;)Z
+java/util/Collections$SynchronizedCollection.addAll:(Ljava/util/Collection;)Z
+java/util/Collections$SynchronizedCollection.clear:()V
+java/util/Collections$SynchronizedCollection.contains:(Ljava/lang/Object;)Z
+java/util/Collections$SynchronizedCollection.containsAll:(Ljava/util/Collection;)Z
+java/util/Collections$SynchronizedCollection.isEmpty:()Z
+java/util/Collections$SynchronizedCollection.iterator:()Ljava/util/Iterator;
+java/util/Collections$SynchronizedCollection.remove:(Ljava/lang/Object;)Z
+java/util/Collections$SynchronizedCollection.removeAll:(Ljava/util/Collection;)Z
+java/util/Collections$SynchronizedCollection.retainAll:(Ljava/util/Collection;)Z
+java/util/Collections$SynchronizedCollection.size:()I
+java/util/Collections$SynchronizedCollection.spliterator:()Ljava/util/Spliterator;
+java/util/Collections$SynchronizedCollection.toArray:()[Ljava/lang/Object;
+java/util/Collections$SynchronizedCollection.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Collections$SynchronizedList.<init>:(Ljava/util/List;)V
+java/util/Collections$SynchronizedList.<init>:(Ljava/util/List;Ljava/lang/Object;)V
+java/util/Collections$SynchronizedList.add:(ILjava/lang/Object;)V
+java/util/Collections$SynchronizedList.addAll:(ILjava/util/Collection;)Z
+java/util/Collections$SynchronizedList.equals:(Ljava/lang/Object;)Z
+java/util/Collections$SynchronizedList.get:(I)Ljava/lang/Object;
+java/util/Collections$SynchronizedList.hashCode:()I
+java/util/Collections$SynchronizedList.indexOf:(Ljava/lang/Object;)I
+java/util/Collections$SynchronizedList.lastIndexOf:(Ljava/lang/Object;)I
+java/util/Collections$SynchronizedList.listIterator:()Ljava/util/ListIterator;
+java/util/Collections$SynchronizedList.listIterator:(I)Ljava/util/ListIterator;
+java/util/Collections$SynchronizedList.readResolve:()Ljava/lang/Object;
+java/util/Collections$SynchronizedList.remove:(I)Ljava/lang/Object;
+java/util/Collections$SynchronizedList.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedList.subList:(II)Ljava/util/List;
+java/util/Collections$SynchronizedMap.<init>:(Ljava/util/Map;)V
+java/util/Collections$SynchronizedMap.<init>:(Ljava/util/Map;Ljava/lang/Object;)V
+java/util/Collections$SynchronizedMap.clear:()V
+java/util/Collections$SynchronizedMap.containsKey:(Ljava/lang/Object;)Z
+java/util/Collections$SynchronizedMap.containsValue:(Ljava/lang/Object;)Z
+java/util/Collections$SynchronizedMap.entrySet:()Ljava/util/Set;
+java/util/Collections$SynchronizedMap.equals:(Ljava/lang/Object;)Z
+java/util/Collections$SynchronizedMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedMap.getOrDefault:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedMap.hashCode:()I
+java/util/Collections$SynchronizedMap.isEmpty:()Z
+java/util/Collections$SynchronizedMap.keySet:()Ljava/util/Set;
+java/util/Collections$SynchronizedMap.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedMap.putAll:(Ljava/util/Map;)V
+java/util/Collections$SynchronizedMap.putIfAbsent:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedMap.remove:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedMap.remove:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections$SynchronizedMap.replace:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedMap.replace:(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections$SynchronizedMap.size:()I
+java/util/Collections$SynchronizedMap.values:()Ljava/util/Collection;
+java/util/Collections$SynchronizedNavigableMap.<init>:(Ljava/util/NavigableMap;)V
+java/util/Collections$SynchronizedNavigableMap.<init>:(Ljava/util/NavigableMap;Ljava/lang/Object;)V
+java/util/Collections$SynchronizedNavigableMap.ceilingEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$SynchronizedNavigableMap.ceilingKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedNavigableMap.descendingKeySet:()Ljava/util/NavigableSet;
+java/util/Collections$SynchronizedNavigableMap.descendingMap:()Ljava/util/NavigableMap;
+java/util/Collections$SynchronizedNavigableMap.firstEntry:()Ljava/util/Map$Entry;
+java/util/Collections$SynchronizedNavigableMap.floorEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$SynchronizedNavigableMap.floorKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedNavigableMap.headMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$SynchronizedNavigableMap.headMap:(Ljava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/Collections$SynchronizedNavigableMap.higherEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$SynchronizedNavigableMap.higherKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedNavigableMap.keySet:()Ljava/util/NavigableSet;
+java/util/Collections$SynchronizedNavigableMap.keySet:()Ljava/util/Set;
+java/util/Collections$SynchronizedNavigableMap.lastEntry:()Ljava/util/Map$Entry;
+java/util/Collections$SynchronizedNavigableMap.lowerEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$SynchronizedNavigableMap.lowerKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedNavigableMap.navigableKeySet:()Ljava/util/NavigableSet;
+java/util/Collections$SynchronizedNavigableMap.pollFirstEntry:()Ljava/util/Map$Entry;
+java/util/Collections$SynchronizedNavigableMap.pollLastEntry:()Ljava/util/Map$Entry;
+java/util/Collections$SynchronizedNavigableMap.subMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$SynchronizedNavigableMap.subMap:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/Collections$SynchronizedNavigableMap.tailMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$SynchronizedNavigableMap.tailMap:(Ljava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/Collections$SynchronizedNavigableSet.<init>:(Ljava/util/NavigableSet;)V
+java/util/Collections$SynchronizedNavigableSet.<init>:(Ljava/util/NavigableSet;Ljava/lang/Object;)V
+java/util/Collections$SynchronizedNavigableSet.ceiling:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedNavigableSet.descendingIterator:()Ljava/util/Iterator;
+java/util/Collections$SynchronizedNavigableSet.descendingSet:()Ljava/util/NavigableSet;
+java/util/Collections$SynchronizedNavigableSet.floor:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedNavigableSet.headSet:(Ljava/lang/Object;)Ljava/util/NavigableSet;
+java/util/Collections$SynchronizedNavigableSet.headSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$SynchronizedNavigableSet.headSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/Collections$SynchronizedNavigableSet.higher:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedNavigableSet.lower:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$SynchronizedNavigableSet.pollFirst:()Ljava/lang/Object;
+java/util/Collections$SynchronizedNavigableSet.pollLast:()Ljava/lang/Object;
+java/util/Collections$SynchronizedNavigableSet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/NavigableSet;
+java/util/Collections$SynchronizedNavigableSet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$SynchronizedNavigableSet.subSet:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/Collections$SynchronizedNavigableSet.tailSet:(Ljava/lang/Object;)Ljava/util/NavigableSet;
+java/util/Collections$SynchronizedNavigableSet.tailSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$SynchronizedNavigableSet.tailSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/Collections$SynchronizedRandomAccessList.<init>:(Ljava/util/List;)V
+java/util/Collections$SynchronizedRandomAccessList.<init>:(Ljava/util/List;Ljava/lang/Object;)V
+java/util/Collections$SynchronizedRandomAccessList.subList:(II)Ljava/util/List;
+java/util/Collections$SynchronizedRandomAccessList.writeReplace:()Ljava/lang/Object;
+java/util/Collections$SynchronizedSet.<init>:(Ljava/util/Set;)V
+java/util/Collections$SynchronizedSet.<init>:(Ljava/util/Set;Ljava/lang/Object;)V
+java/util/Collections$SynchronizedSet.equals:(Ljava/lang/Object;)Z
+java/util/Collections$SynchronizedSet.hashCode:()I
+java/util/Collections$SynchronizedSortedMap.<init>:(Ljava/util/SortedMap;)V
+java/util/Collections$SynchronizedSortedMap.<init>:(Ljava/util/SortedMap;Ljava/lang/Object;)V
+java/util/Collections$SynchronizedSortedMap.comparator:()Ljava/util/Comparator;
+java/util/Collections$SynchronizedSortedMap.firstKey:()Ljava/lang/Object;
+java/util/Collections$SynchronizedSortedMap.headMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$SynchronizedSortedMap.lastKey:()Ljava/lang/Object;
+java/util/Collections$SynchronizedSortedMap.subMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$SynchronizedSortedMap.tailMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$SynchronizedSortedSet.<init>:(Ljava/util/SortedSet;)V
+java/util/Collections$SynchronizedSortedSet.<init>:(Ljava/util/SortedSet;Ljava/lang/Object;)V
+java/util/Collections$SynchronizedSortedSet.comparator:()Ljava/util/Comparator;
+java/util/Collections$SynchronizedSortedSet.first:()Ljava/lang/Object;
+java/util/Collections$SynchronizedSortedSet.headSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$SynchronizedSortedSet.last:()Ljava/lang/Object;
+java/util/Collections$SynchronizedSortedSet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$SynchronizedSortedSet.tailSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$UnmodifiableCollection$1.<init>:(Ljava/util/Collections$UnmodifiableCollection;)V
+java/util/Collections$UnmodifiableCollection$1.hasNext:()Z
+java/util/Collections$UnmodifiableCollection$1.next:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableCollection$1.remove:()V
+java/util/Collections$UnmodifiableCollection.<init>:(Ljava/util/Collection;)V
+java/util/Collections$UnmodifiableCollection.add:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableCollection.addAll:(Ljava/util/Collection;)Z
+java/util/Collections$UnmodifiableCollection.clear:()V
+java/util/Collections$UnmodifiableCollection.contains:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableCollection.containsAll:(Ljava/util/Collection;)Z
+java/util/Collections$UnmodifiableCollection.isEmpty:()Z
+java/util/Collections$UnmodifiableCollection.iterator:()Ljava/util/Iterator;
+java/util/Collections$UnmodifiableCollection.remove:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableCollection.removeAll:(Ljava/util/Collection;)Z
+java/util/Collections$UnmodifiableCollection.removeIf:(Ljava/util/function/Predicate;)Z
+java/util/Collections$UnmodifiableCollection.retainAll:(Ljava/util/Collection;)Z
+java/util/Collections$UnmodifiableCollection.size:()I
+java/util/Collections$UnmodifiableCollection.spliterator:()Ljava/util/Spliterator;
+java/util/Collections$UnmodifiableCollection.toArray:()[Ljava/lang/Object;
+java/util/Collections$UnmodifiableCollection.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Collections$UnmodifiableList$1.<init>:(Ljava/util/Collections$UnmodifiableList;I)V
+java/util/Collections$UnmodifiableList$1.add:(Ljava/lang/Object;)V
+java/util/Collections$UnmodifiableList$1.hasNext:()Z
+java/util/Collections$UnmodifiableList$1.hasPrevious:()Z
+java/util/Collections$UnmodifiableList$1.next:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableList$1.nextIndex:()I
+java/util/Collections$UnmodifiableList$1.previous:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableList$1.previousIndex:()I
+java/util/Collections$UnmodifiableList$1.remove:()V
+java/util/Collections$UnmodifiableList$1.set:(Ljava/lang/Object;)V
+java/util/Collections$UnmodifiableList.<init>:(Ljava/util/List;)V
+java/util/Collections$UnmodifiableList.add:(ILjava/lang/Object;)V
+java/util/Collections$UnmodifiableList.addAll:(ILjava/util/Collection;)Z
+java/util/Collections$UnmodifiableList.equals:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableList.get:(I)Ljava/lang/Object;
+java/util/Collections$UnmodifiableList.hashCode:()I
+java/util/Collections$UnmodifiableList.indexOf:(Ljava/lang/Object;)I
+java/util/Collections$UnmodifiableList.lastIndexOf:(Ljava/lang/Object;)I
+java/util/Collections$UnmodifiableList.listIterator:()Ljava/util/ListIterator;
+java/util/Collections$UnmodifiableList.listIterator:(I)Ljava/util/ListIterator;
+java/util/Collections$UnmodifiableList.readResolve:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableList.remove:(I)Ljava/lang/Object;
+java/util/Collections$UnmodifiableList.replaceAll:(Ljava/util/function/UnaryOperator;)V
+java/util/Collections$UnmodifiableList.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableList.sort:(Ljava/util/Comparator;)V
+java/util/Collections$UnmodifiableList.subList:(II)Ljava/util/List;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$1.<init>:(Ljava/util/Collections$UnmodifiableMap$UnmodifiableEntrySet;)V
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$1.hasNext:()Z
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$1.next:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$1.next:()Ljava/util/Map$Entry;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$1.remove:()V
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry.<init>:(Ljava/util/Map$Entry;)V
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry.equals:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry.getKey:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry.getValue:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry.hashCode:()I
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntry.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntrySetSpliterator.<init>:(Ljava/util/Spliterator;)V
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntrySetSpliterator.characteristics:()I
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntrySetSpliterator.estimateSize:()J
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntrySetSpliterator.forEachRemaining:(Ljava/util/function/Consumer;)V
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntrySetSpliterator.getComparator:()Ljava/util/Comparator;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntrySetSpliterator.getExactSizeIfKnown:()J
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntrySetSpliterator.hasCharacteristics:(I)Z
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntrySetSpliterator.tryAdvance:(Ljava/util/function/Consumer;)Z
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet$UnmodifiableEntrySetSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet.<init>:(Ljava/util/Set;)V
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet.contains:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet.containsAll:(Ljava/util/Collection;)Z
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet.entryConsumer:(Ljava/util/function/Consumer;)Ljava/util/function/Consumer;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet.equals:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet.iterator:()Ljava/util/Iterator;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet.spliterator:()Ljava/util/Spliterator;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet.toArray:()[Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap$UnmodifiableEntrySet.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.<init>:(Ljava/util/Map;)V
+java/util/Collections$UnmodifiableMap.clear:()V
+java/util/Collections$UnmodifiableMap.compute:(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.computeIfAbsent:(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.computeIfPresent:(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.containsKey:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableMap.containsValue:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableMap.entrySet:()Ljava/util/Set;
+java/util/Collections$UnmodifiableMap.equals:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.getOrDefault:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.hashCode:()I
+java/util/Collections$UnmodifiableMap.isEmpty:()Z
+java/util/Collections$UnmodifiableMap.keySet:()Ljava/util/Set;
+java/util/Collections$UnmodifiableMap.merge:(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.putAll:(Ljava/util/Map;)V
+java/util/Collections$UnmodifiableMap.putIfAbsent:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.remove:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.remove:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableMap.replace:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableMap.replace:(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableMap.replaceAll:(Ljava/util/function/BiFunction;)V
+java/util/Collections$UnmodifiableMap.size:()I
+java/util/Collections$UnmodifiableMap.values:()Ljava/util/Collection;
+java/util/Collections$UnmodifiableNavigableMap$EmptyNavigableMap.<init>:()V
+java/util/Collections$UnmodifiableNavigableMap$EmptyNavigableMap.navigableKeySet:()Ljava/util/NavigableSet;
+java/util/Collections$UnmodifiableNavigableMap$EmptyNavigableMap.readResolve:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableMap.<clinit>:()V
+java/util/Collections$UnmodifiableNavigableMap.<init>:(Ljava/util/NavigableMap;)V
+java/util/Collections$UnmodifiableNavigableMap.access$100:()Ljava/util/Collections$UnmodifiableNavigableMap$EmptyNavigableMap;
+java/util/Collections$UnmodifiableNavigableMap.ceilingEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$UnmodifiableNavigableMap.ceilingKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableMap.descendingKeySet:()Ljava/util/NavigableSet;
+java/util/Collections$UnmodifiableNavigableMap.descendingMap:()Ljava/util/NavigableMap;
+java/util/Collections$UnmodifiableNavigableMap.firstEntry:()Ljava/util/Map$Entry;
+java/util/Collections$UnmodifiableNavigableMap.floorEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$UnmodifiableNavigableMap.floorKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableMap.headMap:(Ljava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/Collections$UnmodifiableNavigableMap.higherEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$UnmodifiableNavigableMap.higherKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableMap.lastEntry:()Ljava/util/Map$Entry;
+java/util/Collections$UnmodifiableNavigableMap.lowerEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/Collections$UnmodifiableNavigableMap.lowerKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableMap.navigableKeySet:()Ljava/util/NavigableSet;
+java/util/Collections$UnmodifiableNavigableMap.pollFirstEntry:()Ljava/util/Map$Entry;
+java/util/Collections$UnmodifiableNavigableMap.pollLastEntry:()Ljava/util/Map$Entry;
+java/util/Collections$UnmodifiableNavigableMap.subMap:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/Collections$UnmodifiableNavigableMap.tailMap:(Ljava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/Collections$UnmodifiableNavigableSet$EmptyNavigableSet.<init>:()V
+java/util/Collections$UnmodifiableNavigableSet$EmptyNavigableSet.readResolve:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableSet.<clinit>:()V
+java/util/Collections$UnmodifiableNavigableSet.<init>:(Ljava/util/NavigableSet;)V
+java/util/Collections$UnmodifiableNavigableSet.access$000:()Ljava/util/NavigableSet;
+java/util/Collections$UnmodifiableNavigableSet.ceiling:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableSet.descendingIterator:()Ljava/util/Iterator;
+java/util/Collections$UnmodifiableNavigableSet.descendingSet:()Ljava/util/NavigableSet;
+java/util/Collections$UnmodifiableNavigableSet.floor:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableSet.headSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/Collections$UnmodifiableNavigableSet.higher:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableSet.lower:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableSet.pollFirst:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableSet.pollLast:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableNavigableSet.subSet:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/Collections$UnmodifiableNavigableSet.tailSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/Collections$UnmodifiableRandomAccessList.<init>:(Ljava/util/List;)V
+java/util/Collections$UnmodifiableRandomAccessList.subList:(II)Ljava/util/List;
+java/util/Collections$UnmodifiableRandomAccessList.writeReplace:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableSet.<init>:(Ljava/util/Set;)V
+java/util/Collections$UnmodifiableSet.equals:(Ljava/lang/Object;)Z
+java/util/Collections$UnmodifiableSet.hashCode:()I
+java/util/Collections$UnmodifiableSortedMap.<init>:(Ljava/util/SortedMap;)V
+java/util/Collections$UnmodifiableSortedMap.comparator:()Ljava/util/Comparator;
+java/util/Collections$UnmodifiableSortedMap.firstKey:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableSortedMap.headMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$UnmodifiableSortedMap.lastKey:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableSortedMap.subMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$UnmodifiableSortedMap.tailMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/Collections$UnmodifiableSortedSet.<init>:(Ljava/util/SortedSet;)V
+java/util/Collections$UnmodifiableSortedSet.comparator:()Ljava/util/Comparator;
+java/util/Collections$UnmodifiableSortedSet.first:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableSortedSet.headSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$UnmodifiableSortedSet.last:()Ljava/lang/Object;
+java/util/Collections$UnmodifiableSortedSet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections$UnmodifiableSortedSet.tailSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Collections.<clinit>:()V
+java/util/Collections.<init>:()V
+java/util/Collections.addAll:(Ljava/util/Collection;[Ljava/lang/Object;)Z
+java/util/Collections.asLifoQueue:(Ljava/util/Deque;)Ljava/util/Queue;
+java/util/Collections.binarySearch:(Ljava/util/List;Ljava/lang/Object;)I
+java/util/Collections.binarySearch:(Ljava/util/List;Ljava/lang/Object;Ljava/util/Comparator;)I
+java/util/Collections.checkedCollection:(Ljava/util/Collection;Ljava/lang/Class;)Ljava/util/Collection;
+java/util/Collections.checkedList:(Ljava/util/List;Ljava/lang/Class;)Ljava/util/List;
+java/util/Collections.checkedMap:(Ljava/util/Map;Ljava/lang/Class;Ljava/lang/Class;)Ljava/util/Map;
+java/util/Collections.checkedNavigableMap:(Ljava/util/NavigableMap;Ljava/lang/Class;Ljava/lang/Class;)Ljava/util/NavigableMap;
+java/util/Collections.checkedNavigableSet:(Ljava/util/NavigableSet;Ljava/lang/Class;)Ljava/util/NavigableSet;
+java/util/Collections.checkedQueue:(Ljava/util/Queue;Ljava/lang/Class;)Ljava/util/Queue;
+java/util/Collections.checkedSet:(Ljava/util/Set;Ljava/lang/Class;)Ljava/util/Set;
+java/util/Collections.checkedSortedMap:(Ljava/util/SortedMap;Ljava/lang/Class;Ljava/lang/Class;)Ljava/util/SortedMap;
+java/util/Collections.checkedSortedSet:(Ljava/util/SortedSet;Ljava/lang/Class;)Ljava/util/SortedSet;
+java/util/Collections.copy:(Ljava/util/List;Ljava/util/List;)V
+java/util/Collections.disjoint:(Ljava/util/Collection;Ljava/util/Collection;)Z
+java/util/Collections.emptyEnumeration:()Ljava/util/Enumeration;
+java/util/Collections.emptyIterator:()Ljava/util/Iterator;
+java/util/Collections.emptyList:()Ljava/util/List;
+java/util/Collections.emptyListIterator:()Ljava/util/ListIterator;
+java/util/Collections.emptyMap:()Ljava/util/Map;
+java/util/Collections.emptyNavigableMap:()Ljava/util/NavigableMap;
+java/util/Collections.emptyNavigableSet:()Ljava/util/NavigableSet;
+java/util/Collections.emptySet:()Ljava/util/Set;
+java/util/Collections.emptySortedMap:()Ljava/util/SortedMap;
+java/util/Collections.emptySortedSet:()Ljava/util/SortedSet;
+java/util/Collections.enumeration:(Ljava/util/Collection;)Ljava/util/Enumeration;
+java/util/Collections.eq:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections.fill:(Ljava/util/List;Ljava/lang/Object;)V
+java/util/Collections.frequency:(Ljava/util/Collection;Ljava/lang/Object;)I
+java/util/Collections.get:(Ljava/util/ListIterator;I)Ljava/lang/Object;
+java/util/Collections.indexOfSubList:(Ljava/util/List;Ljava/util/List;)I
+java/util/Collections.indexedBinarySearch:(Ljava/util/List;Ljava/lang/Object;)I
+java/util/Collections.indexedBinarySearch:(Ljava/util/List;Ljava/lang/Object;Ljava/util/Comparator;)I
+java/util/Collections.iteratorBinarySearch:(Ljava/util/List;Ljava/lang/Object;)I
+java/util/Collections.iteratorBinarySearch:(Ljava/util/List;Ljava/lang/Object;Ljava/util/Comparator;)I
+java/util/Collections.lastIndexOfSubList:(Ljava/util/List;Ljava/util/List;)I
+java/util/Collections.list:(Ljava/util/Enumeration;)Ljava/util/ArrayList;
+java/util/Collections.max:(Ljava/util/Collection;)Ljava/lang/Object;
+java/util/Collections.max:(Ljava/util/Collection;Ljava/util/Comparator;)Ljava/lang/Object;
+java/util/Collections.min:(Ljava/util/Collection;)Ljava/lang/Object;
+java/util/Collections.min:(Ljava/util/Collection;Ljava/util/Comparator;)Ljava/lang/Object;
+java/util/Collections.nCopies:(ILjava/lang/Object;)Ljava/util/List;
+java/util/Collections.newSetFromMap:(Ljava/util/Map;)Ljava/util/Set;
+java/util/Collections.replaceAll:(Ljava/util/List;Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Collections.reverse:(Ljava/util/List;)V
+java/util/Collections.reverseOrder:()Ljava/util/Comparator;
+java/util/Collections.reverseOrder:(Ljava/util/Comparator;)Ljava/util/Comparator;
+java/util/Collections.rotate1:(Ljava/util/List;I)V
+java/util/Collections.rotate2:(Ljava/util/List;I)V
+java/util/Collections.rotate:(Ljava/util/List;I)V
+java/util/Collections.singleton:(Ljava/lang/Object;)Ljava/util/Set;
+java/util/Collections.singletonIterator:(Ljava/lang/Object;)Ljava/util/Iterator;
+java/util/Collections.singletonList:(Ljava/lang/Object;)Ljava/util/List;
+java/util/Collections.singletonMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;
+java/util/Collections.singletonSpliterator:(Ljava/lang/Object;)Ljava/util/Spliterator;
+java/util/Collections.swap:(Ljava/util/List;II)V
+java/util/Collections.swap:([Ljava/lang/Object;II)V
+java/util/Collections.synchronizedCollection:(Ljava/util/Collection;)Ljava/util/Collection;
+java/util/Collections.synchronizedCollection:(Ljava/util/Collection;Ljava/lang/Object;)Ljava/util/Collection;
+java/util/Collections.synchronizedList:(Ljava/util/List;)Ljava/util/List;
+java/util/Collections.synchronizedList:(Ljava/util/List;Ljava/lang/Object;)Ljava/util/List;
+java/util/Collections.synchronizedMap:(Ljava/util/Map;)Ljava/util/Map;
+java/util/Collections.synchronizedNavigableMap:(Ljava/util/NavigableMap;)Ljava/util/NavigableMap;
+java/util/Collections.synchronizedNavigableSet:(Ljava/util/NavigableSet;)Ljava/util/NavigableSet;
+java/util/Collections.synchronizedSet:(Ljava/util/Set;)Ljava/util/Set;
+java/util/Collections.synchronizedSet:(Ljava/util/Set;Ljava/lang/Object;)Ljava/util/Set;
+java/util/Collections.synchronizedSortedMap:(Ljava/util/SortedMap;)Ljava/util/SortedMap;
+java/util/Collections.synchronizedSortedSet:(Ljava/util/SortedSet;)Ljava/util/SortedSet;
+java/util/Collections.unmodifiableCollection:(Ljava/util/Collection;)Ljava/util/Collection;
+java/util/Collections.unmodifiableList:(Ljava/util/List;)Ljava/util/List;
+java/util/Collections.unmodifiableMap:(Ljava/util/Map;)Ljava/util/Map;
+java/util/Collections.unmodifiableNavigableMap:(Ljava/util/NavigableMap;)Ljava/util/NavigableMap;
+java/util/Collections.unmodifiableNavigableSet:(Ljava/util/NavigableSet;)Ljava/util/NavigableSet;
+java/util/Collections.unmodifiableSet:(Ljava/util/Set;)Ljava/util/Set;
+java/util/Collections.unmodifiableSortedMap:(Ljava/util/SortedMap;)Ljava/util/SortedMap;
+java/util/Collections.unmodifiableSortedSet:(Ljava/util/SortedSet;)Ljava/util/SortedSet;
+java/util/Collections.zeroLengthArray:(Ljava/lang/Class;)[Ljava/lang/Object;
+java/util/ComparableTimSort.<init>:([Ljava/lang/Object;[Ljava/lang/Object;II)V
+java/util/ComparableTimSort.binarySort:([Ljava/lang/Object;III)V
+java/util/ComparableTimSort.countRunAndMakeAscending:([Ljava/lang/Object;II)I
+java/util/ComparableTimSort.ensureCapacity:(I)[Ljava/lang/Object;
+java/util/ComparableTimSort.gallopLeft:(Ljava/lang/Comparable;[Ljava/lang/Object;III)I
+java/util/ComparableTimSort.gallopRight:(Ljava/lang/Comparable;[Ljava/lang/Object;III)I
+java/util/ComparableTimSort.mergeAt:(I)V
+java/util/ComparableTimSort.mergeCollapse:()V
+java/util/ComparableTimSort.mergeForceCollapse:()V
+java/util/ComparableTimSort.mergeHi:(IIII)V
+java/util/ComparableTimSort.mergeLo:(IIII)V
+java/util/ComparableTimSort.minRunLength:(I)I
+java/util/ComparableTimSort.pushRun:(II)V
+java/util/ComparableTimSort.reverseRange:([Ljava/lang/Object;II)V
+java/util/ComparableTimSort.sort:([Ljava/lang/Object;II[Ljava/lang/Object;II)V
+java/util/Comparator.compare:(Ljava/lang/Object;Ljava/lang/Object;)I
+java/util/Comparator.comparing:(Ljava/util/function/Function;)Ljava/util/Comparator;
+java/util/Comparator.comparing:(Ljava/util/function/Function;Ljava/util/Comparator;)Ljava/util/Comparator;
+java/util/Comparator.comparingDouble:(Ljava/util/function/ToDoubleFunction;)Ljava/util/Comparator;
+java/util/Comparator.comparingInt:(Ljava/util/function/ToIntFunction;)Ljava/util/Comparator;
+java/util/Comparator.comparingLong:(Ljava/util/function/ToLongFunction;)Ljava/util/Comparator;
+java/util/Comparator.equals:(Ljava/lang/Object;)Z
+java/util/Comparator.lambda$thenComparing$36697e65$1:(Ljava/util/Comparator;Ljava/lang/Object;Ljava/lang/Object;)I
+java/util/Comparator.naturalOrder:()Ljava/util/Comparator;
+java/util/Comparator.nullsFirst:(Ljava/util/Comparator;)Ljava/util/Comparator;
+java/util/Comparator.nullsLast:(Ljava/util/Comparator;)Ljava/util/Comparator;
+java/util/Comparator.reverseOrder:()Ljava/util/Comparator;
+java/util/Comparator.reversed:()Ljava/util/Comparator;
+java/util/Comparator.thenComparing:(Ljava/util/Comparator;)Ljava/util/Comparator;
+java/util/Comparator.thenComparing:(Ljava/util/function/Function;)Ljava/util/Comparator;
+java/util/Comparator.thenComparing:(Ljava/util/function/Function;Ljava/util/Comparator;)Ljava/util/Comparator;
+java/util/Comparator.thenComparingDouble:(Ljava/util/function/ToDoubleFunction;)Ljava/util/Comparator;
+java/util/Comparator.thenComparingInt:(Ljava/util/function/ToIntFunction;)Ljava/util/Comparator;
+java/util/Comparator.thenComparingLong:(Ljava/util/function/ToLongFunction;)Ljava/util/Comparator;
+java/util/Comparators$NaturalOrderComparator.<clinit>:()V
+java/util/Comparators$NaturalOrderComparator.<init>:(Ljava/lang/String;I)V
+java/util/Comparators$NaturalOrderComparator.compare:(Ljava/lang/Comparable;Ljava/lang/Comparable;)I
+java/util/Comparators$NaturalOrderComparator.compare:(Ljava/lang/Object;Ljava/lang/Object;)I
+java/util/Comparators$NaturalOrderComparator.reversed:()Ljava/util/Comparator;
+java/util/Comparators$NullComparator.<init>:(ZLjava/util/Comparator;)V
+java/util/Comparators$NullComparator.compare:(Ljava/lang/Object;Ljava/lang/Object;)I
+java/util/Comparators$NullComparator.reversed:()Ljava/util/Comparator;
+java/util/Comparators$NullComparator.thenComparing:(Ljava/util/Comparator;)Ljava/util/Comparator;
+java/util/ConcurrentModificationException.<init>:()V
+java/util/ConcurrentModificationException.<init>:(Ljava/lang/String;)V
+java/util/ConcurrentModificationException.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/util/Currency$1.<init>:()V
+java/util/Currency$CurrencyNameGetter.<init>:()V
+java/util/Currency$CurrencyNameGetter.access$500:()Ljava/util/Currency$CurrencyNameGetter;
+java/util/Currency.<init>:(Ljava/lang/String;II)V
+java/util/Currency.countOccurrences:(Ljava/lang/String;C)I
+java/util/Currency.getCurrencyCode:()Ljava/lang/String;
+java/util/Currency.getDefaultFractionDigits:()I
+java/util/Currency.getMainTableEntry:(CC)I
+java/util/Currency.getNumericCode:()I
+java/util/Currency.setMainTableEntry:(CCI)V
+java/util/Currency.toString:()Ljava/lang/String;
+java/util/Date.<init>:(J)V
+java/util/Date.convertToAbbr:(Ljava/lang/StringBuilder;Ljava/lang/String;)Ljava/lang/StringBuilder;
+java/util/Date.setTime:(J)V
+java/util/Deque.add:(Ljava/lang/Object;)Z
+java/util/Deque.addFirst:(Ljava/lang/Object;)V
+java/util/Deque.addLast:(Ljava/lang/Object;)V
+java/util/Deque.contains:(Ljava/lang/Object;)Z
+java/util/Deque.descendingIterator:()Ljava/util/Iterator;
+java/util/Deque.element:()Ljava/lang/Object;
+java/util/Deque.getFirst:()Ljava/lang/Object;
+java/util/Deque.getLast:()Ljava/lang/Object;
+java/util/Deque.iterator:()Ljava/util/Iterator;
+java/util/Deque.offer:(Ljava/lang/Object;)Z
+java/util/Deque.offerFirst:(Ljava/lang/Object;)Z
+java/util/Deque.offerLast:(Ljava/lang/Object;)Z
+java/util/Deque.peek:()Ljava/lang/Object;
+java/util/Deque.peekFirst:()Ljava/lang/Object;
+java/util/Deque.peekLast:()Ljava/lang/Object;
+java/util/Deque.poll:()Ljava/lang/Object;
+java/util/Deque.pollFirst:()Ljava/lang/Object;
+java/util/Deque.pollLast:()Ljava/lang/Object;
+java/util/Deque.pop:()Ljava/lang/Object;
+java/util/Deque.push:(Ljava/lang/Object;)V
+java/util/Deque.remove:()Ljava/lang/Object;
+java/util/Deque.remove:(Ljava/lang/Object;)Z
+java/util/Deque.removeFirst:()Ljava/lang/Object;
+java/util/Deque.removeFirstOccurrence:(Ljava/lang/Object;)Z
+java/util/Deque.removeLast:()Ljava/lang/Object;
+java/util/Deque.removeLastOccurrence:(Ljava/lang/Object;)Z
+java/util/Deque.size:()I
+java/util/Dictionary.<init>:()V
+java/util/Dictionary.elements:()Ljava/util/Enumeration;
+java/util/Dictionary.get:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Dictionary.isEmpty:()Z
+java/util/Dictionary.keys:()Ljava/util/Enumeration;
+java/util/Dictionary.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Dictionary.remove:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Dictionary.size:()I
+java/util/DoubleSummaryStatistics.<init>:()V
+java/util/DoubleSummaryStatistics.getAverage:()D
+java/util/DoubleSummaryStatistics.getCount:()J
+java/util/DoubleSummaryStatistics.getMax:()D
+java/util/DoubleSummaryStatistics.getMin:()D
+java/util/DoubleSummaryStatistics.getSum:()D
+java/util/DoubleSummaryStatistics.sumWithCompensation:(D)V
+java/util/DualPivotQuicksort.<init>:()V
+java/util/DualPivotQuicksort.doSort:([CII[CII)V
+java/util/DualPivotQuicksort.doSort:([DII[DII)V
+java/util/DualPivotQuicksort.doSort:([FII[FII)V
+java/util/DualPivotQuicksort.doSort:([SII[SII)V
+java/util/DualPivotQuicksort.sort:([BII)V
+java/util/DualPivotQuicksort.sort:([CIIZ)V
+java/util/DualPivotQuicksort.sort:([CII[CII)V
+java/util/DualPivotQuicksort.sort:([DIIZ)V
+java/util/DualPivotQuicksort.sort:([FIIZ)V
+java/util/DualPivotQuicksort.sort:([IIIZ)V
+java/util/DualPivotQuicksort.sort:([III[III)V
+java/util/DualPivotQuicksort.sort:([JIIZ)V
+java/util/DualPivotQuicksort.sort:([JII[JII)V
+java/util/DualPivotQuicksort.sort:([SIIZ)V
+java/util/DualPivotQuicksort.sort:([SII[SII)V
+java/util/DuplicateFormatFlagsException.<init>:(Ljava/lang/String;)V
+java/util/DuplicateFormatFlagsException.getFlags:()Ljava/lang/String;
+java/util/EmptyStackException.<init>:()V
+java/util/EnumMap$1.<init>:()V
+java/util/EnumMap$1.hashCode:()I
+java/util/EnumMap$1.toString:()Ljava/lang/String;
+java/util/EnumMap$EntryIterator$Entry.<init>:(Ljava/util/EnumMap$EntryIterator;I)V
+java/util/EnumMap$EntryIterator$Entry.<init>:(Ljava/util/EnumMap$EntryIterator;ILjava/util/EnumMap$1;)V
+java/util/EnumMap$EntryIterator$Entry.access$1500:(Ljava/util/EnumMap$EntryIterator$Entry;)I
+java/util/EnumMap$EntryIterator$Entry.access$1502:(Ljava/util/EnumMap$EntryIterator$Entry;I)I
+java/util/EnumMap$EntryIterator$Entry.checkIndexForEntryUse:()V
+java/util/EnumMap$EntryIterator$Entry.equals:(Ljava/lang/Object;)Z
+java/util/EnumMap$EntryIterator$Entry.getKey:()Ljava/lang/Enum;
+java/util/EnumMap$EntryIterator$Entry.getKey:()Ljava/lang/Object;
+java/util/EnumMap$EntryIterator$Entry.getValue:()Ljava/lang/Object;
+java/util/EnumMap$EntryIterator$Entry.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/EnumMap$EntryIterator.<init>:(Ljava/util/EnumMap;)V
+java/util/EnumMap$EntryIterator.<init>:(Ljava/util/EnumMap;Ljava/util/EnumMap$1;)V
+java/util/EnumMap$EntryIterator.remove:()V
+java/util/EnumMap$EntrySet.<init>:(Ljava/util/EnumMap;)V
+java/util/EnumMap$EntrySet.<init>:(Ljava/util/EnumMap;Ljava/util/EnumMap$1;)V
+java/util/EnumMap$EntrySet.clear:()V
+java/util/EnumMap$EntrySet.fillEntryArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/EnumMap$EntrySet.iterator:()Ljava/util/Iterator;
+java/util/EnumMap$EntrySet.size:()I
+java/util/EnumMap$EntrySet.toArray:()[Ljava/lang/Object;
+java/util/EnumMap$EntrySet.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/EnumMap$EnumMapIterator.<init>:(Ljava/util/EnumMap;)V
+java/util/EnumMap$EnumMapIterator.<init>:(Ljava/util/EnumMap;Ljava/util/EnumMap$1;)V
+java/util/EnumMap$EnumMapIterator.checkLastReturnedIndex:()V
+java/util/EnumMap$EnumMapIterator.hasNext:()Z
+java/util/EnumMap$EnumMapIterator.remove:()V
+java/util/EnumMap$KeyIterator.<init>:(Ljava/util/EnumMap;)V
+java/util/EnumMap$KeyIterator.<init>:(Ljava/util/EnumMap;Ljava/util/EnumMap$1;)V
+java/util/EnumMap$KeySet.<init>:(Ljava/util/EnumMap;)V
+java/util/EnumMap$KeySet.<init>:(Ljava/util/EnumMap;Ljava/util/EnumMap$1;)V
+java/util/EnumMap$KeySet.clear:()V
+java/util/EnumMap$KeySet.iterator:()Ljava/util/Iterator;
+java/util/EnumMap$KeySet.size:()I
+java/util/EnumMap$ValueIterator.<init>:(Ljava/util/EnumMap;)V
+java/util/EnumMap$ValueIterator.<init>:(Ljava/util/EnumMap;Ljava/util/EnumMap$1;)V
+java/util/EnumMap$Values.<init>:(Ljava/util/EnumMap;)V
+java/util/EnumMap$Values.<init>:(Ljava/util/EnumMap;Ljava/util/EnumMap$1;)V
+java/util/EnumMap$Values.clear:()V
+java/util/EnumMap$Values.contains:(Ljava/lang/Object;)Z
+java/util/EnumMap$Values.iterator:()Ljava/util/Iterator;
+java/util/EnumMap$Values.remove:(Ljava/lang/Object;)Z
+java/util/EnumMap$Values.size:()I
+java/util/EnumMap.<clinit>:()V
+java/util/EnumMap.access$1100:(Ljava/util/EnumMap;)[Ljava/lang/Enum;
+java/util/EnumMap.access$1200:(Ljava/util/EnumMap;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/EnumMap.access$200:(Ljava/util/EnumMap;)I
+java/util/EnumMap.access$210:(Ljava/util/EnumMap;)I
+java/util/EnumMap.access$500:(Ljava/util/EnumMap;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/EnumMap.access$600:(Ljava/util/EnumMap;)[Ljava/lang/Object;
+java/util/EnumMap.clear:()V
+java/util/EnumMap.containsValue:(Ljava/lang/Object;)Z
+java/util/EnumMap.entrySet:()Ljava/util/Set;
+java/util/EnumMap.equals:(Ljava/lang/Object;)Z
+java/util/EnumMap.equals:(Ljava/util/EnumMap;)Z
+java/util/EnumMap.keySet:()Ljava/util/Set;
+java/util/EnumMap.maskNull:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/EnumMap.size:()I
+java/util/EnumMap.unmaskNull:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/EnumMap.values:()Ljava/util/Collection;
+java/util/EnumSet.<clinit>:()V
+java/util/EnumSet.<init>:(Ljava/lang/Class;[Ljava/lang/Enum;)V
+java/util/EnumSet.access$000:()[Ljava/lang/Enum;
+java/util/EnumSet.addAll:()V
+java/util/EnumSet.addRange:(Ljava/lang/Enum;Ljava/lang/Enum;)V
+java/util/EnumSet.complement:()V
+java/util/Enumeration.hasMoreElements:()Z
+java/util/Enumeration.nextElement:()Ljava/lang/Object;
+java/util/EventListenerProxy.<init>:(Ljava/util/EventListener;)V
+java/util/EventListenerProxy.getListener:()Ljava/util/EventListener;
+java/util/EventObject.<init>:(Ljava/lang/Object;)V
+java/util/EventObject.getSource:()Ljava/lang/Object;
+java/util/FormatFlagsConversionMismatchException.<init>:(Ljava/lang/String;C)V
+java/util/FormatFlagsConversionMismatchException.getConversion:()C
+java/util/FormatFlagsConversionMismatchException.getFlags:()Ljava/lang/String;
+java/util/FormatFlagsConversionMismatchException.getMessage:()Ljava/lang/String;
+java/util/Formattable.formatTo:(Ljava/util/Formatter;III)V
+java/util/FormattableFlags.<init>:()V
+java/util/Formatter$BigDecimalLayoutForm.<clinit>:()V
+java/util/Formatter$BigDecimalLayoutForm.<init>:(Ljava/lang/String;I)V
+java/util/Formatter$Conversion.<init>:()V
+java/util/Formatter$Conversion.isCharacter:(C)Z
+java/util/Formatter$Conversion.isFloat:(C)Z
+java/util/Formatter$Conversion.isGeneral:(C)Z
+java/util/Formatter$Conversion.isInteger:(C)Z
+java/util/Formatter$Conversion.isText:(C)Z
+java/util/Formatter$Conversion.isValid:(C)Z
+java/util/Formatter$DateTime.<init>:()V
+java/util/Formatter$DateTime.isValid:(C)Z
+java/util/Formatter$FixedString.<init>:(Ljava/util/Formatter;Ljava/lang/String;)V
+java/util/Formatter$FixedString.index:()I
+java/util/Formatter$FixedString.print:(Ljava/lang/Object;Ljava/util/Locale;)V
+java/util/Formatter$FixedString.toString:()Ljava/lang/String;
+java/util/Formatter$Flags.<clinit>:()V
+java/util/Formatter$Flags.<init>:(I)V
+java/util/Formatter$Flags.access$100:(Ljava/util/Formatter$Flags;Ljava/util/Formatter$Flags;)Ljava/util/Formatter$Flags;
+java/util/Formatter$Flags.add:(Ljava/util/Formatter$Flags;)Ljava/util/Formatter$Flags;
+java/util/Formatter$Flags.contains:(Ljava/util/Formatter$Flags;)Z
+java/util/Formatter$Flags.dup:()Ljava/util/Formatter$Flags;
+java/util/Formatter$Flags.parse:(C)Ljava/util/Formatter$Flags;
+java/util/Formatter$Flags.parse:(Ljava/lang/String;)Ljava/util/Formatter$Flags;
+java/util/Formatter$Flags.remove:(Ljava/util/Formatter$Flags;)Ljava/util/Formatter$Flags;
+java/util/Formatter$Flags.toString:()Ljava/lang/String;
+java/util/Formatter$Flags.toString:(Ljava/util/Formatter$Flags;)Ljava/lang/String;
+java/util/Formatter$Flags.valueOf:()I
+java/util/Formatter$FormatSpecifier$BigDecimalLayout.exponent:()[C
+java/util/Formatter$FormatSpecifier$BigDecimalLayout.hasDot:()Z
+java/util/Formatter$FormatSpecifier$BigDecimalLayout.layoutChars:()[C
+java/util/Formatter$FormatSpecifier$BigDecimalLayout.mantissa:()[C
+java/util/Formatter$FormatSpecifier$BigDecimalLayout.scale:()I
+java/util/Formatter$FormatSpecifier$BigDecimalLayout.toCharArray:(Ljava/lang/StringBuilder;)[C
+java/util/Formatter$FormatSpecifier.addDot:([C)[C
+java/util/Formatter$FormatSpecifier.addZeros:([CI)[C
+java/util/Formatter$FormatSpecifier.adjustWidth:(ILjava/util/Formatter$Flags;Z)I
+java/util/Formatter$FormatSpecifier.checkBadFlags:([Ljava/util/Formatter$Flags;)V
+java/util/Formatter$FormatSpecifier.checkCharacter:()V
+java/util/Formatter$FormatSpecifier.checkDateTime:()V
+java/util/Formatter$FormatSpecifier.checkFloat:()V
+java/util/Formatter$FormatSpecifier.checkGeneral:()V
+java/util/Formatter$FormatSpecifier.checkInteger:()V
+java/util/Formatter$FormatSpecifier.checkNumeric:()V
+java/util/Formatter$FormatSpecifier.checkText:()V
+java/util/Formatter$FormatSpecifier.conversion:()C
+java/util/Formatter$FormatSpecifier.conversion:(Ljava/lang/String;)C
+java/util/Formatter$FormatSpecifier.failConversion:(CLjava/lang/Object;)V
+java/util/Formatter$FormatSpecifier.failMismatch:(Ljava/util/Formatter$Flags;C)V
+java/util/Formatter$FormatSpecifier.flags:()Ljava/util/Formatter$Flags;
+java/util/Formatter$FormatSpecifier.flags:(Ljava/lang/String;)Ljava/util/Formatter$Flags;
+java/util/Formatter$FormatSpecifier.index:()I
+java/util/Formatter$FormatSpecifier.index:(Ljava/lang/String;)I
+java/util/Formatter$FormatSpecifier.justify:(Ljava/lang/String;)Ljava/lang/String;
+java/util/Formatter$FormatSpecifier.leadingSign:(Ljava/lang/StringBuilder;Z)Ljava/lang/StringBuilder;
+java/util/Formatter$FormatSpecifier.precision:()I
+java/util/Formatter$FormatSpecifier.precision:(Ljava/lang/String;)I
+java/util/Formatter$FormatSpecifier.toString:()Ljava/lang/String;
+java/util/Formatter$FormatSpecifier.trailingSign:(Ljava/lang/StringBuilder;Z)Ljava/lang/StringBuilder;
+java/util/Formatter$FormatSpecifier.trailingZeros:([CI)[C
+java/util/Formatter$FormatSpecifier.width:()I
+java/util/Formatter$FormatSpecifier.width:(Ljava/lang/String;)I
+java/util/Formatter$FormatString.index:()I
+java/util/Formatter$FormatString.print:(Ljava/lang/Object;Ljava/util/Locale;)V
+java/util/Formatter$FormatString.toString:()Ljava/lang/String;
+java/util/Formatter.access$000:(Ljava/util/Formatter;)Ljava/lang/Appendable;
+java/util/Formatter.access$200:()D
+java/util/Formatter.access$202:(D)D
+java/util/Formatter.access$300:(Ljava/util/Formatter;)C
+java/util/Formatter.checkText:(Ljava/lang/String;II)V
+java/util/Formatter.ensureOpen:()V
+java/util/Formatter.ioException:()Ljava/io/IOException;
+java/util/Formatter.locale:()Ljava/util/Locale;
+java/util/Formatter.nonNullAppendable:(Ljava/lang/Appendable;)Ljava/lang/Appendable;
+java/util/Formatter.out:()Ljava/lang/Appendable;
+java/util/FormatterClosedException.<init>:()V
+java/util/GregorianCalendar.getCalendarType:()Ljava/lang/String;
+java/util/GregorianCalendar.getGregorianChange:()Ljava/util/Date;
+java/util/GregorianCalendar.getMinimum:(I)I
+java/util/GregorianCalendar.getRolledValue:(IIII)I
+java/util/GregorianCalendar.isCutoverYear:(I)Z
+java/util/GregorianCalendar.isWeekDateSupported:()Z
+java/util/HashMap$EntryIterator.<init>:(Ljava/util/HashMap;)V
+java/util/HashMap$EntrySet.<init>:(Ljava/util/HashMap;)V
+java/util/HashMap$EntrySet.clear:()V
+java/util/HashMap$EntrySet.iterator:()Ljava/util/Iterator;
+java/util/HashMap$EntrySet.size:()I
+java/util/HashMap$EntrySet.spliterator:()Ljava/util/Spliterator;
+java/util/HashMap$EntrySpliterator.<init>:(Ljava/util/HashMap;IIII)V
+java/util/HashMap$EntrySpliterator.characteristics:()I
+java/util/HashMap$HashIterator.<init>:(Ljava/util/HashMap;)V
+java/util/HashMap$HashIterator.hasNext:()Z
+java/util/HashMap$HashIterator.nextNode:()Ljava/util/HashMap$Node;
+java/util/HashMap$HashMapSpliterator.<init>:(Ljava/util/HashMap;IIII)V
+java/util/HashMap$HashMapSpliterator.estimateSize:()J
+java/util/HashMap$HashMapSpliterator.getFence:()I
+java/util/HashMap$KeyIterator.<init>:(Ljava/util/HashMap;)V
+java/util/HashMap$KeySet.<init>:(Ljava/util/HashMap;)V
+java/util/HashMap$KeySet.clear:()V
+java/util/HashMap$KeySet.iterator:()Ljava/util/Iterator;
+java/util/HashMap$KeySet.size:()I
+java/util/HashMap$KeySet.spliterator:()Ljava/util/Spliterator;
+java/util/HashMap$KeySpliterator.<init>:(Ljava/util/HashMap;IIII)V
+java/util/HashMap$KeySpliterator.characteristics:()I
+java/util/HashMap$Node.<init>:(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Node;)V
+java/util/HashMap$Node.equals:(Ljava/lang/Object;)Z
+java/util/HashMap$Node.getKey:()Ljava/lang/Object;
+java/util/HashMap$Node.getValue:()Ljava/lang/Object;
+java/util/HashMap$Node.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/HashMap$TreeNode.<init>:(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Node;)V
+java/util/HashMap$TreeNode.balanceDeletion:(Ljava/util/HashMap$TreeNode;Ljava/util/HashMap$TreeNode;)Ljava/util/HashMap$TreeNode;
+java/util/HashMap$TreeNode.balanceInsertion:(Ljava/util/HashMap$TreeNode;Ljava/util/HashMap$TreeNode;)Ljava/util/HashMap$TreeNode;
+java/util/HashMap$TreeNode.checkInvariants:(Ljava/util/HashMap$TreeNode;)Z
+java/util/HashMap$TreeNode.moveRootToFront:([Ljava/util/HashMap$Node;Ljava/util/HashMap$TreeNode;)V
+java/util/HashMap$TreeNode.removeTreeNode:(Ljava/util/HashMap;[Ljava/util/HashMap$Node;Z)V
+java/util/HashMap$TreeNode.root:()Ljava/util/HashMap$TreeNode;
+java/util/HashMap$TreeNode.rotateLeft:(Ljava/util/HashMap$TreeNode;Ljava/util/HashMap$TreeNode;)Ljava/util/HashMap$TreeNode;
+java/util/HashMap$TreeNode.rotateRight:(Ljava/util/HashMap$TreeNode;Ljava/util/HashMap$TreeNode;)Ljava/util/HashMap$TreeNode;
+java/util/HashMap$TreeNode.untreeify:(Ljava/util/HashMap;)Ljava/util/HashMap$Node;
+java/util/HashMap$ValueIterator.<init>:(Ljava/util/HashMap;)V
+java/util/HashMap$ValueSpliterator.<init>:(Ljava/util/HashMap;IIII)V
+java/util/HashMap$ValueSpliterator.characteristics:()I
+java/util/HashMap$Values.<init>:(Ljava/util/HashMap;)V
+java/util/HashMap$Values.clear:()V
+java/util/HashMap$Values.contains:(Ljava/lang/Object;)Z
+java/util/HashMap$Values.iterator:()Ljava/util/Iterator;
+java/util/HashMap$Values.size:()I
+java/util/HashMap$Values.spliterator:()Ljava/util/Spliterator;
+java/util/HashMap.<init>:()V
+java/util/HashMap.afterNodeAccess:(Ljava/util/HashMap$Node;)V
+java/util/HashMap.afterNodeInsertion:(Z)V
+java/util/HashMap.afterNodeRemoval:(Ljava/util/HashMap$Node;)V
+java/util/HashMap.capacity:()I
+java/util/HashMap.clear:()V
+java/util/HashMap.compareComparables:(Ljava/lang/Class;Ljava/lang/Object;Ljava/lang/Object;)I
+java/util/HashMap.containsValue:(Ljava/lang/Object;)Z
+java/util/HashMap.entrySet:()Ljava/util/Set;
+java/util/HashMap.isEmpty:()Z
+java/util/HashMap.keySet:()Ljava/util/Set;
+java/util/HashMap.loadFactor:()F
+java/util/HashMap.newNode:(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Node;)Ljava/util/HashMap$Node;
+java/util/HashMap.newTreeNode:(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Node;)Ljava/util/HashMap$TreeNode;
+java/util/HashMap.reinitialize:()V
+java/util/HashMap.replacementNode:(Ljava/util/HashMap$Node;Ljava/util/HashMap$Node;)Ljava/util/HashMap$Node;
+java/util/HashMap.replacementTreeNode:(Ljava/util/HashMap$Node;Ljava/util/HashMap$Node;)Ljava/util/HashMap$TreeNode;
+java/util/HashMap.size:()I
+java/util/HashMap.tableSizeFor:(I)I
+java/util/HashMap.values:()Ljava/util/Collection;
+java/util/HashSet.<clinit>:()V
+java/util/HashSet.<init>:()V
+java/util/HashSet.clear:()V
+java/util/HashSet.isEmpty:()Z
+java/util/HashSet.iterator:()Ljava/util/Iterator;
+java/util/HashSet.size:()I
+java/util/HashSet.spliterator:()Ljava/util/Spliterator;
+java/util/Hashtable$Entry.<init>:(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V
+java/util/Hashtable$Entry.clone:()Ljava/lang/Object;
+java/util/Hashtable$Entry.equals:(Ljava/lang/Object;)Z
+java/util/Hashtable$Entry.getKey:()Ljava/lang/Object;
+java/util/Hashtable$Entry.getValue:()Ljava/lang/Object;
+java/util/Hashtable$Entry.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Hashtable$EntrySet.<init>:(Ljava/util/Hashtable;)V
+java/util/Hashtable$EntrySet.<init>:(Ljava/util/Hashtable;Ljava/util/Hashtable$1;)V
+java/util/Hashtable$EntrySet.clear:()V
+java/util/Hashtable$EntrySet.iterator:()Ljava/util/Iterator;
+java/util/Hashtable$EntrySet.size:()I
+java/util/Hashtable$Enumerator.<init>:(Ljava/util/Hashtable;IZ)V
+java/util/Hashtable$Enumerator.hasMoreElements:()Z
+java/util/Hashtable$Enumerator.hasNext:()Z
+java/util/Hashtable$Enumerator.next:()Ljava/lang/Object;
+java/util/Hashtable$Enumerator.nextElement:()Ljava/lang/Object;
+java/util/Hashtable$Enumerator.remove:()V
+java/util/Hashtable$KeySet.<init>:(Ljava/util/Hashtable;)V
+java/util/Hashtable$KeySet.<init>:(Ljava/util/Hashtable;Ljava/util/Hashtable$1;)V
+java/util/Hashtable$KeySet.clear:()V
+java/util/Hashtable$KeySet.iterator:()Ljava/util/Iterator;
+java/util/Hashtable$KeySet.size:()I
+java/util/Hashtable$ValueCollection.<init>:(Ljava/util/Hashtable;)V
+java/util/Hashtable$ValueCollection.<init>:(Ljava/util/Hashtable;Ljava/util/Hashtable$1;)V
+java/util/Hashtable$ValueCollection.clear:()V
+java/util/Hashtable$ValueCollection.contains:(Ljava/lang/Object;)Z
+java/util/Hashtable$ValueCollection.iterator:()Ljava/util/Iterator;
+java/util/Hashtable$ValueCollection.size:()I
+java/util/Hashtable.access$100:(Ljava/util/Hashtable;I)Ljava/util/Iterator;
+java/util/Hashtable.access$200:(Ljava/util/Hashtable;)I
+java/util/Hashtable.access$210:(Ljava/util/Hashtable;)I
+java/util/Hashtable.access$400:(Ljava/util/Hashtable;)[Ljava/util/Hashtable$Entry;
+java/util/Hashtable.access$500:(Ljava/util/Hashtable;)I
+java/util/Hashtable.access$508:(Ljava/util/Hashtable;)I
+java/util/Hashtable.clear:()V
+java/util/Hashtable.contains:(Ljava/lang/Object;)Z
+java/util/Hashtable.containsValue:(Ljava/lang/Object;)Z
+java/util/Hashtable.elements:()Ljava/util/Enumeration;
+java/util/Hashtable.entrySet:()Ljava/util/Set;
+java/util/Hashtable.equals:(Ljava/lang/Object;)Z
+java/util/Hashtable.getEnumeration:(I)Ljava/util/Enumeration;
+java/util/Hashtable.getIterator:(I)Ljava/util/Iterator;
+java/util/Hashtable.isEmpty:()Z
+java/util/Hashtable.keySet:()Ljava/util/Set;
+java/util/Hashtable.keys:()Ljava/util/Enumeration;
+java/util/Hashtable.size:()I
+java/util/Hashtable.values:()Ljava/util/Collection;
+java/util/IdentityHashMap$EntryIterator$Entry.<init>:(Ljava/util/IdentityHashMap$EntryIterator;I)V
+java/util/IdentityHashMap$EntryIterator$Entry.<init>:(Ljava/util/IdentityHashMap$EntryIterator;ILjava/util/IdentityHashMap$1;)V
+java/util/IdentityHashMap$EntryIterator$Entry.access$400:(Ljava/util/IdentityHashMap$EntryIterator$Entry;)I
+java/util/IdentityHashMap$EntryIterator$Entry.access$402:(Ljava/util/IdentityHashMap$EntryIterator$Entry;I)I
+java/util/IdentityHashMap$EntryIterator$Entry.checkIndexForEntryUse:()V
+java/util/IdentityHashMap$EntryIterator$Entry.equals:(Ljava/lang/Object;)Z
+java/util/IdentityHashMap$EntryIterator$Entry.getKey:()Ljava/lang/Object;
+java/util/IdentityHashMap$EntryIterator$Entry.getValue:()Ljava/lang/Object;
+java/util/IdentityHashMap$EntryIterator.<init>:(Ljava/util/IdentityHashMap;)V
+java/util/IdentityHashMap$EntryIterator.<init>:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V
+java/util/IdentityHashMap$EntrySet.<init>:(Ljava/util/IdentityHashMap;)V
+java/util/IdentityHashMap$EntrySet.<init>:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V
+java/util/IdentityHashMap$EntrySet.clear:()V
+java/util/IdentityHashMap$EntrySet.iterator:()Ljava/util/Iterator;
+java/util/IdentityHashMap$EntrySet.removeAll:(Ljava/util/Collection;)Z
+java/util/IdentityHashMap$EntrySet.size:()I
+java/util/IdentityHashMap$EntrySet.spliterator:()Ljava/util/Spliterator;
+java/util/IdentityHashMap$EntrySet.toArray:()[Ljava/lang/Object;
+java/util/IdentityHashMap$EntrySet.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/IdentityHashMap$EntrySpliterator.<init>:(Ljava/util/IdentityHashMap;IIII)V
+java/util/IdentityHashMap$EntrySpliterator.characteristics:()I
+java/util/IdentityHashMap$IdentityHashMapIterator.<init>:(Ljava/util/IdentityHashMap;)V
+java/util/IdentityHashMap$IdentityHashMapIterator.<init>:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V
+java/util/IdentityHashMap$IdentityHashMapIterator.hasNext:()Z
+java/util/IdentityHashMap$IdentityHashMapIterator.nextIndex:()I
+java/util/IdentityHashMap$IdentityHashMapSpliterator.<init>:(Ljava/util/IdentityHashMap;IIII)V
+java/util/IdentityHashMap$IdentityHashMapSpliterator.estimateSize:()J
+java/util/IdentityHashMap$IdentityHashMapSpliterator.getFence:()I
+java/util/IdentityHashMap$KeyIterator.<init>:(Ljava/util/IdentityHashMap;)V
+java/util/IdentityHashMap$KeyIterator.<init>:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V
+java/util/IdentityHashMap$KeySet.<init>:(Ljava/util/IdentityHashMap;)V
+java/util/IdentityHashMap$KeySet.<init>:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V
+java/util/IdentityHashMap$KeySet.clear:()V
+java/util/IdentityHashMap$KeySet.iterator:()Ljava/util/Iterator;
+java/util/IdentityHashMap$KeySet.removeAll:(Ljava/util/Collection;)Z
+java/util/IdentityHashMap$KeySet.size:()I
+java/util/IdentityHashMap$KeySet.spliterator:()Ljava/util/Spliterator;
+java/util/IdentityHashMap$KeySet.toArray:()[Ljava/lang/Object;
+java/util/IdentityHashMap$KeySet.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/IdentityHashMap$KeySpliterator.<init>:(Ljava/util/IdentityHashMap;IIII)V
+java/util/IdentityHashMap$KeySpliterator.characteristics:()I
+java/util/IdentityHashMap$ValueIterator.<init>:(Ljava/util/IdentityHashMap;)V
+java/util/IdentityHashMap$ValueIterator.<init>:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V
+java/util/IdentityHashMap$ValueSpliterator.<init>:(Ljava/util/IdentityHashMap;IIII)V
+java/util/IdentityHashMap$ValueSpliterator.characteristics:()I
+java/util/IdentityHashMap$Values.<init>:(Ljava/util/IdentityHashMap;)V
+java/util/IdentityHashMap$Values.<init>:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V
+java/util/IdentityHashMap$Values.clear:()V
+java/util/IdentityHashMap$Values.contains:(Ljava/lang/Object;)Z
+java/util/IdentityHashMap$Values.iterator:()Ljava/util/Iterator;
+java/util/IdentityHashMap$Values.remove:(Ljava/lang/Object;)Z
+java/util/IdentityHashMap$Values.size:()I
+java/util/IdentityHashMap$Values.spliterator:()Ljava/util/Spliterator;
+java/util/IdentityHashMap$Values.toArray:()[Ljava/lang/Object;
+java/util/IdentityHashMap$Values.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/IdentityHashMap.<clinit>:()V
+java/util/IdentityHashMap.<init>:()V
+java/util/IdentityHashMap.<init>:(I)V
+java/util/IdentityHashMap.access$000:(II)I
+java/util/IdentityHashMap.capacity:(I)I
+java/util/IdentityHashMap.clear:()V
+java/util/IdentityHashMap.containsValue:(Ljava/lang/Object;)Z
+java/util/IdentityHashMap.entrySet:()Ljava/util/Set;
+java/util/IdentityHashMap.init:(I)V
+java/util/IdentityHashMap.isEmpty:()Z
+java/util/IdentityHashMap.keySet:()Ljava/util/Set;
+java/util/IdentityHashMap.maskNull:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/IdentityHashMap.nextKeyIndex:(II)I
+java/util/IdentityHashMap.size:()I
+java/util/IdentityHashMap.unmaskNull:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/IdentityHashMap.values:()Ljava/util/Collection;
+java/util/IllegalFormatCodePointException.<init>:(I)V
+java/util/IllegalFormatCodePointException.getCodePoint:()I
+java/util/IllegalFormatConversionException.<init>:(CLjava/lang/Class;)V
+java/util/IllegalFormatConversionException.getArgumentClass:()Ljava/lang/Class;
+java/util/IllegalFormatConversionException.getConversion:()C
+java/util/IllegalFormatException.<init>:()V
+java/util/IllegalFormatFlagsException.<init>:(Ljava/lang/String;)V
+java/util/IllegalFormatFlagsException.getFlags:()Ljava/lang/String;
+java/util/IllegalFormatFlagsException.getMessage:()Ljava/lang/String;
+java/util/IllegalFormatPrecisionException.<init>:(I)V
+java/util/IllegalFormatPrecisionException.getMessage:()Ljava/lang/String;
+java/util/IllegalFormatPrecisionException.getPrecision:()I
+java/util/IllegalFormatWidthException.<init>:(I)V
+java/util/IllegalFormatWidthException.getMessage:()Ljava/lang/String;
+java/util/IllegalFormatWidthException.getWidth:()I
+java/util/IllformedLocaleException.<init>:()V
+java/util/IllformedLocaleException.<init>:(Ljava/lang/String;)V
+java/util/IllformedLocaleException.<init>:(Ljava/lang/String;I)V
+java/util/IllformedLocaleException.getErrorIndex:()I
+java/util/InputMismatchException.<init>:()V
+java/util/InputMismatchException.<init>:(Ljava/lang/String;)V
+java/util/IntSummaryStatistics.<init>:()V
+java/util/IntSummaryStatistics.accept:(I)V
+java/util/IntSummaryStatistics.combine:(Ljava/util/IntSummaryStatistics;)V
+java/util/IntSummaryStatistics.getAverage:()D
+java/util/IntSummaryStatistics.getCount:()J
+java/util/IntSummaryStatistics.getMax:()I
+java/util/IntSummaryStatistics.getMin:()I
+java/util/IntSummaryStatistics.getSum:()J
+java/util/Iterator.hasNext:()Z
+java/util/Iterator.next:()Ljava/lang/Object;
+java/util/Iterator.remove:()V
+java/util/JapaneseImperialCalendar.getCalendarType:()Ljava/lang/String;
+java/util/JapaneseImperialCalendar.getGreatestMinimum:(I)I
+java/util/JapaneseImperialCalendar.getMinimum:(I)I
+java/util/JapaneseImperialCalendar.getRolledValue:(IIII)I
+java/util/JumboEnumSet$EnumSetIterator.<init>:(Ljava/util/JumboEnumSet;)V
+java/util/JumboEnumSet$EnumSetIterator.hasNext:()Z
+java/util/JumboEnumSet$EnumSetIterator.next:()Ljava/lang/Enum;
+java/util/JumboEnumSet$EnumSetIterator.next:()Ljava/lang/Object;
+java/util/JumboEnumSet$EnumSetIterator.remove:()V
+java/util/JumboEnumSet.<init>:(Ljava/lang/Class;[Ljava/lang/Enum;)V
+java/util/JumboEnumSet.access$000:(Ljava/util/JumboEnumSet;)[J
+java/util/JumboEnumSet.access$110:(Ljava/util/JumboEnumSet;)I
+java/util/JumboEnumSet.addAll:()V
+java/util/JumboEnumSet.addRange:(Ljava/lang/Enum;Ljava/lang/Enum;)V
+java/util/JumboEnumSet.clear:()V
+java/util/JumboEnumSet.complement:()V
+java/util/JumboEnumSet.isEmpty:()Z
+java/util/JumboEnumSet.iterator:()Ljava/util/Iterator;
+java/util/JumboEnumSet.recalculateSize:()Z
+java/util/JumboEnumSet.size:()I
+java/util/LinkedHashMap$Entry.<init>:(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Node;)V
+java/util/LinkedHashMap$LinkedEntryIterator.<init>:(Ljava/util/LinkedHashMap;)V
+java/util/LinkedHashMap$LinkedEntrySet.<init>:(Ljava/util/LinkedHashMap;)V
+java/util/LinkedHashMap$LinkedEntrySet.clear:()V
+java/util/LinkedHashMap$LinkedEntrySet.iterator:()Ljava/util/Iterator;
+java/util/LinkedHashMap$LinkedEntrySet.size:()I
+java/util/LinkedHashMap$LinkedEntrySet.spliterator:()Ljava/util/Spliterator;
+java/util/LinkedHashMap$LinkedHashIterator.<init>:(Ljava/util/LinkedHashMap;)V
+java/util/LinkedHashMap$LinkedHashIterator.hasNext:()Z
+java/util/LinkedHashMap$LinkedHashIterator.nextNode:()Ljava/util/LinkedHashMap$Entry;
+java/util/LinkedHashMap$LinkedKeyIterator.<init>:(Ljava/util/LinkedHashMap;)V
+java/util/LinkedHashMap$LinkedKeySet.<init>:(Ljava/util/LinkedHashMap;)V
+java/util/LinkedHashMap$LinkedKeySet.clear:()V
+java/util/LinkedHashMap$LinkedKeySet.iterator:()Ljava/util/Iterator;
+java/util/LinkedHashMap$LinkedKeySet.size:()I
+java/util/LinkedHashMap$LinkedKeySet.spliterator:()Ljava/util/Spliterator;
+java/util/LinkedHashMap$LinkedValueIterator.<init>:(Ljava/util/LinkedHashMap;)V
+java/util/LinkedHashMap$LinkedValues.<init>:(Ljava/util/LinkedHashMap;)V
+java/util/LinkedHashMap$LinkedValues.clear:()V
+java/util/LinkedHashMap$LinkedValues.contains:(Ljava/lang/Object;)Z
+java/util/LinkedHashMap$LinkedValues.iterator:()Ljava/util/Iterator;
+java/util/LinkedHashMap$LinkedValues.size:()I
+java/util/LinkedHashMap$LinkedValues.spliterator:()Ljava/util/Spliterator;
+java/util/LinkedHashMap.<init>:()V
+java/util/LinkedHashMap.afterNodeAccess:(Ljava/util/HashMap$Node;)V
+java/util/LinkedHashMap.afterNodeRemoval:(Ljava/util/HashMap$Node;)V
+java/util/LinkedHashMap.clear:()V
+java/util/LinkedHashMap.containsValue:(Ljava/lang/Object;)Z
+java/util/LinkedHashMap.entrySet:()Ljava/util/Set;
+java/util/LinkedHashMap.keySet:()Ljava/util/Set;
+java/util/LinkedHashMap.linkNodeLast:(Ljava/util/LinkedHashMap$Entry;)V
+java/util/LinkedHashMap.newNode:(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Node;)Ljava/util/HashMap$Node;
+java/util/LinkedHashMap.newTreeNode:(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Node;)Ljava/util/HashMap$TreeNode;
+java/util/LinkedHashMap.reinitialize:()V
+java/util/LinkedHashMap.removeEldestEntry:(Ljava/util/Map$Entry;)Z
+java/util/LinkedHashMap.replacementNode:(Ljava/util/HashMap$Node;Ljava/util/HashMap$Node;)Ljava/util/HashMap$Node;
+java/util/LinkedHashMap.replacementTreeNode:(Ljava/util/HashMap$Node;Ljava/util/HashMap$Node;)Ljava/util/HashMap$TreeNode;
+java/util/LinkedHashMap.transferLinks:(Ljava/util/LinkedHashMap$Entry;Ljava/util/LinkedHashMap$Entry;)V
+java/util/LinkedHashMap.values:()Ljava/util/Collection;
+java/util/LinkedHashSet.spliterator:()Ljava/util/Spliterator;
+java/util/LinkedList$DescendingIterator.<init>:(Ljava/util/LinkedList;)V
+java/util/LinkedList$DescendingIterator.<init>:(Ljava/util/LinkedList;Ljava/util/LinkedList$1;)V
+java/util/LinkedList$DescendingIterator.hasNext:()Z
+java/util/LinkedList$DescendingIterator.next:()Ljava/lang/Object;
+java/util/LinkedList$DescendingIterator.remove:()V
+java/util/LinkedList$LLSpliterator.<init>:(Ljava/util/LinkedList;II)V
+java/util/LinkedList$LLSpliterator.characteristics:()I
+java/util/LinkedList$LLSpliterator.estimateSize:()J
+java/util/LinkedList$LLSpliterator.getEst:()I
+java/util/LinkedList$LLSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/LinkedList$ListItr.<init>:(Ljava/util/LinkedList;I)V
+java/util/LinkedList$ListItr.add:(Ljava/lang/Object;)V
+java/util/LinkedList$ListItr.checkForComodification:()V
+java/util/LinkedList$ListItr.hasNext:()Z
+java/util/LinkedList$ListItr.hasPrevious:()Z
+java/util/LinkedList$ListItr.next:()Ljava/lang/Object;
+java/util/LinkedList$ListItr.nextIndex:()I
+java/util/LinkedList$ListItr.previous:()Ljava/lang/Object;
+java/util/LinkedList$ListItr.previousIndex:()I
+java/util/LinkedList$ListItr.remove:()V
+java/util/LinkedList$ListItr.set:(Ljava/lang/Object;)V
+java/util/LinkedList$Node.<init>:(Ljava/util/LinkedList$Node;Ljava/lang/Object;Ljava/util/LinkedList$Node;)V
+java/util/LinkedList.<init>:()V
+java/util/LinkedList.<init>:(Ljava/util/Collection;)V
+java/util/LinkedList.add:(ILjava/lang/Object;)V
+java/util/LinkedList.add:(Ljava/lang/Object;)Z
+java/util/LinkedList.addAll:(ILjava/util/Collection;)Z
+java/util/LinkedList.addAll:(Ljava/util/Collection;)Z
+java/util/LinkedList.addFirst:(Ljava/lang/Object;)V
+java/util/LinkedList.addLast:(Ljava/lang/Object;)V
+java/util/LinkedList.checkElementIndex:(I)V
+java/util/LinkedList.checkPositionIndex:(I)V
+java/util/LinkedList.clear:()V
+java/util/LinkedList.contains:(Ljava/lang/Object;)Z
+java/util/LinkedList.descendingIterator:()Ljava/util/Iterator;
+java/util/LinkedList.element:()Ljava/lang/Object;
+java/util/LinkedList.get:(I)Ljava/lang/Object;
+java/util/LinkedList.getFirst:()Ljava/lang/Object;
+java/util/LinkedList.getLast:()Ljava/lang/Object;
+java/util/LinkedList.indexOf:(Ljava/lang/Object;)I
+java/util/LinkedList.isElementIndex:(I)Z
+java/util/LinkedList.isPositionIndex:(I)Z
+java/util/LinkedList.lastIndexOf:(Ljava/lang/Object;)I
+java/util/LinkedList.linkBefore:(Ljava/lang/Object;Ljava/util/LinkedList$Node;)V
+java/util/LinkedList.linkFirst:(Ljava/lang/Object;)V
+java/util/LinkedList.linkLast:(Ljava/lang/Object;)V
+java/util/LinkedList.listIterator:(I)Ljava/util/ListIterator;
+java/util/LinkedList.node:(I)Ljava/util/LinkedList$Node;
+java/util/LinkedList.offer:(Ljava/lang/Object;)Z
+java/util/LinkedList.offerFirst:(Ljava/lang/Object;)Z
+java/util/LinkedList.offerLast:(Ljava/lang/Object;)Z
+java/util/LinkedList.outOfBoundsMsg:(I)Ljava/lang/String;
+java/util/LinkedList.peek:()Ljava/lang/Object;
+java/util/LinkedList.peekFirst:()Ljava/lang/Object;
+java/util/LinkedList.peekLast:()Ljava/lang/Object;
+java/util/LinkedList.poll:()Ljava/lang/Object;
+java/util/LinkedList.pollFirst:()Ljava/lang/Object;
+java/util/LinkedList.pollLast:()Ljava/lang/Object;
+java/util/LinkedList.pop:()Ljava/lang/Object;
+java/util/LinkedList.push:(Ljava/lang/Object;)V
+java/util/LinkedList.remove:()Ljava/lang/Object;
+java/util/LinkedList.remove:(I)Ljava/lang/Object;
+java/util/LinkedList.remove:(Ljava/lang/Object;)Z
+java/util/LinkedList.removeFirst:()Ljava/lang/Object;
+java/util/LinkedList.removeFirstOccurrence:(Ljava/lang/Object;)Z
+java/util/LinkedList.removeLast:()Ljava/lang/Object;
+java/util/LinkedList.removeLastOccurrence:(Ljava/lang/Object;)Z
+java/util/LinkedList.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/LinkedList.size:()I
+java/util/LinkedList.spliterator:()Ljava/util/Spliterator;
+java/util/LinkedList.toArray:()[Ljava/lang/Object;
+java/util/LinkedList.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/LinkedList.unlink:(Ljava/util/LinkedList$Node;)Ljava/lang/Object;
+java/util/LinkedList.unlinkFirst:(Ljava/util/LinkedList$Node;)Ljava/lang/Object;
+java/util/LinkedList.unlinkLast:(Ljava/util/LinkedList$Node;)Ljava/lang/Object;
+java/util/List.add:(ILjava/lang/Object;)V
+java/util/List.add:(Ljava/lang/Object;)Z
+java/util/List.addAll:(ILjava/util/Collection;)Z
+java/util/List.addAll:(Ljava/util/Collection;)Z
+java/util/List.clear:()V
+java/util/List.contains:(Ljava/lang/Object;)Z
+java/util/List.containsAll:(Ljava/util/Collection;)Z
+java/util/List.equals:(Ljava/lang/Object;)Z
+java/util/List.get:(I)Ljava/lang/Object;
+java/util/List.hashCode:()I
+java/util/List.indexOf:(Ljava/lang/Object;)I
+java/util/List.isEmpty:()Z
+java/util/List.iterator:()Ljava/util/Iterator;
+java/util/List.lastIndexOf:(Ljava/lang/Object;)I
+java/util/List.listIterator:()Ljava/util/ListIterator;
+java/util/List.listIterator:(I)Ljava/util/ListIterator;
+java/util/List.remove:(I)Ljava/lang/Object;
+java/util/List.remove:(Ljava/lang/Object;)Z
+java/util/List.removeAll:(Ljava/util/Collection;)Z
+java/util/List.retainAll:(Ljava/util/Collection;)Z
+java/util/List.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/List.size:()I
+java/util/List.spliterator:()Ljava/util/Spliterator;
+java/util/List.subList:(II)Ljava/util/List;
+java/util/List.toArray:()[Ljava/lang/Object;
+java/util/List.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/ListIterator.add:(Ljava/lang/Object;)V
+java/util/ListIterator.hasNext:()Z
+java/util/ListIterator.hasPrevious:()Z
+java/util/ListIterator.next:()Ljava/lang/Object;
+java/util/ListIterator.nextIndex:()I
+java/util/ListIterator.previous:()Ljava/lang/Object;
+java/util/ListIterator.previousIndex:()I
+java/util/ListIterator.remove:()V
+java/util/ListIterator.set:(Ljava/lang/Object;)V
+java/util/ListResourceBundle.<init>:()V
+java/util/ListResourceBundle.getContents:()[[Ljava/lang/Object;
+java/util/Locale$Cache.createObject:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Locale$Cache.createObject:(Ljava/util/Locale$LocaleKey;)Ljava/util/Locale;
+java/util/Locale$Category.<clinit>:()V
+java/util/Locale$Category.<init>:(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+java/util/Locale$FilteringMode.<clinit>:()V
+java/util/Locale$FilteringMode.<init>:(Ljava/lang/String;I)V
+java/util/Locale$LanguageRange.equals:(Ljava/lang/Object;)Z
+java/util/Locale$LanguageRange.getRange:()Ljava/lang/String;
+java/util/Locale$LanguageRange.getWeight:()D
+java/util/Locale$LanguageRange.isSubtagIllFormed:(Ljava/lang/String;Z)Z
+java/util/Locale$LocaleKey.access$200:(Ljava/util/Locale$LocaleKey;)Lsun/util/locale/BaseLocale;
+java/util/Locale$LocaleKey.access$300:(Ljava/util/Locale$LocaleKey;)Lsun/util/locale/LocaleExtensions;
+java/util/Locale$LocaleKey.hashCode:()I
+java/util/Locale$LocaleNameGetter.<init>:()V
+java/util/Locale$LocaleNameGetter.access$500:()Ljava/util/Locale$LocaleNameGetter;
+java/util/Locale.<init>:(Lsun/util/locale/BaseLocale;Lsun/util/locale/LocaleExtensions;)V
+java/util/Locale.<init>:(Lsun/util/locale/BaseLocale;Lsun/util/locale/LocaleExtensions;Ljava/util/Locale$1;)V
+java/util/Locale.access$600:(Ljava/util/Locale;)Lsun/util/locale/BaseLocale;
+java/util/Locale.access$700:(Ljava/util/Locale;)Lsun/util/locale/LocaleExtensions;
+java/util/Locale.getBaseLocale:()Lsun/util/locale/BaseLocale;
+java/util/Locale.getDefault:()Ljava/util/Locale;
+java/util/Locale.getISO2Table:(Ljava/lang/String;)[Ljava/lang/String;
+java/util/Locale.getISO3Code:(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
+java/util/Locale.getISOCountries:()[Ljava/lang/String;
+java/util/Locale.getISOLanguages:()[Ljava/lang/String;
+java/util/Locale.getLocaleExtensions:()Lsun/util/locale/LocaleExtensions;
+java/util/Locale.hasExtensions:()Z
+java/util/LocaleISOData.<init>:()V
+java/util/LongSummaryStatistics.<init>:()V
+java/util/LongSummaryStatistics.accept:(I)V
+java/util/LongSummaryStatistics.accept:(J)V
+java/util/LongSummaryStatistics.combine:(Ljava/util/LongSummaryStatistics;)V
+java/util/LongSummaryStatistics.getAverage:()D
+java/util/LongSummaryStatistics.getCount:()J
+java/util/LongSummaryStatistics.getMax:()J
+java/util/LongSummaryStatistics.getMin:()J
+java/util/LongSummaryStatistics.getSum:()J
+java/util/Map$Entry.comparingByKey:()Ljava/util/Comparator;
+java/util/Map$Entry.comparingByKey:(Ljava/util/Comparator;)Ljava/util/Comparator;
+java/util/Map$Entry.comparingByValue:()Ljava/util/Comparator;
+java/util/Map$Entry.comparingByValue:(Ljava/util/Comparator;)Ljava/util/Comparator;
+java/util/Map$Entry.equals:(Ljava/lang/Object;)Z
+java/util/Map$Entry.getKey:()Ljava/lang/Object;
+java/util/Map$Entry.getValue:()Ljava/lang/Object;
+java/util/Map$Entry.hashCode:()I
+java/util/Map$Entry.lambda$comparingByKey$6d558cbf$1:(Ljava/util/Comparator;Ljava/util/Map$Entry;Ljava/util/Map$Entry;)I
+java/util/Map$Entry.lambda$comparingByKey$bbdbfea9$1:(Ljava/util/Map$Entry;Ljava/util/Map$Entry;)I
+java/util/Map$Entry.lambda$comparingByValue$1065357e$1:(Ljava/util/Map$Entry;Ljava/util/Map$Entry;)I
+java/util/Map$Entry.lambda$comparingByValue$827a17d5$1:(Ljava/util/Comparator;Ljava/util/Map$Entry;Ljava/util/Map$Entry;)I
+java/util/Map$Entry.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Map.clear:()V
+java/util/Map.containsKey:(Ljava/lang/Object;)Z
+java/util/Map.containsValue:(Ljava/lang/Object;)Z
+java/util/Map.entrySet:()Ljava/util/Set;
+java/util/Map.equals:(Ljava/lang/Object;)Z
+java/util/Map.get:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Map.getOrDefault:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Map.hashCode:()I
+java/util/Map.isEmpty:()Z
+java/util/Map.keySet:()Ljava/util/Set;
+java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Map.putAll:(Ljava/util/Map;)V
+java/util/Map.putIfAbsent:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Map.remove:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Map.remove:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Map.replace:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Map.replace:(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Map.size:()I
+java/util/Map.values:()Ljava/util/Collection;
+java/util/MissingFormatArgumentException.<init>:(Ljava/lang/String;)V
+java/util/MissingFormatArgumentException.getFormatSpecifier:()Ljava/lang/String;
+java/util/MissingFormatArgumentException.getMessage:()Ljava/lang/String;
+java/util/MissingFormatWidthException.<init>:(Ljava/lang/String;)V
+java/util/MissingFormatWidthException.getFormatSpecifier:()Ljava/lang/String;
+java/util/MissingFormatWidthException.getMessage:()Ljava/lang/String;
+java/util/MissingResourceException.<init>:(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
+java/util/MissingResourceException.<init>:(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)V
+java/util/MissingResourceException.getClassName:()Ljava/lang/String;
+java/util/MissingResourceException.getKey:()Ljava/lang/String;
+java/util/NavigableMap.ceilingEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/NavigableMap.ceilingKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/NavigableMap.descendingKeySet:()Ljava/util/NavigableSet;
+java/util/NavigableMap.descendingMap:()Ljava/util/NavigableMap;
+java/util/NavigableMap.firstEntry:()Ljava/util/Map$Entry;
+java/util/NavigableMap.floorEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/NavigableMap.floorKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/NavigableMap.headMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/NavigableMap.headMap:(Ljava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/NavigableMap.higherEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/NavigableMap.higherKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/NavigableMap.lastEntry:()Ljava/util/Map$Entry;
+java/util/NavigableMap.lowerEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/NavigableMap.lowerKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/NavigableMap.navigableKeySet:()Ljava/util/NavigableSet;
+java/util/NavigableMap.pollFirstEntry:()Ljava/util/Map$Entry;
+java/util/NavigableMap.pollLastEntry:()Ljava/util/Map$Entry;
+java/util/NavigableMap.subMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/NavigableMap.subMap:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/NavigableMap.tailMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/NavigableMap.tailMap:(Ljava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/NavigableSet.ceiling:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/NavigableSet.descendingIterator:()Ljava/util/Iterator;
+java/util/NavigableSet.descendingSet:()Ljava/util/NavigableSet;
+java/util/NavigableSet.floor:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/NavigableSet.headSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/NavigableSet.headSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/NavigableSet.higher:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/NavigableSet.iterator:()Ljava/util/Iterator;
+java/util/NavigableSet.lower:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/NavigableSet.pollFirst:()Ljava/lang/Object;
+java/util/NavigableSet.pollLast:()Ljava/lang/Object;
+java/util/NavigableSet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/NavigableSet.subSet:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/NavigableSet.tailSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/NavigableSet.tailSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/NoSuchElementException.<init>:()V
+java/util/NoSuchElementException.<init>:(Ljava/lang/String;)V
+java/util/Objects.compare:(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/Comparator;)I
+java/util/Objects.equals:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/Objects.isNull:(Ljava/lang/Object;)Z
+java/util/Objects.nonNull:(Ljava/lang/Object;)Z
+java/util/Objects.requireNonNull:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/Objects.requireNonNull:(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+java/util/Observable.<init>:()V
+java/util/Observable.addObserver:(Ljava/util/Observer;)V
+java/util/Observable.clearChanged:()V
+java/util/Observable.countObservers:()I
+java/util/Observable.deleteObserver:(Ljava/util/Observer;)V
+java/util/Observable.deleteObservers:()V
+java/util/Observable.hasChanged:()Z
+java/util/Observable.notifyObservers:()V
+java/util/Observable.notifyObservers:(Ljava/lang/Object;)V
+java/util/Observable.setChanged:()V
+java/util/Observer.update:(Ljava/util/Observable;Ljava/lang/Object;)V
+java/util/Optional.<clinit>:()V
+java/util/Optional.<init>:()V
+java/util/Optional.<init>:(Ljava/lang/Object;)V
+java/util/Optional.empty:()Ljava/util/Optional;
+java/util/Optional.equals:(Ljava/lang/Object;)Z
+java/util/Optional.get:()Ljava/lang/Object;
+java/util/Optional.isPresent:()Z
+java/util/Optional.of:(Ljava/lang/Object;)Ljava/util/Optional;
+java/util/Optional.ofNullable:(Ljava/lang/Object;)Ljava/util/Optional;
+java/util/Optional.orElse:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/OptionalDouble.<clinit>:()V
+java/util/OptionalDouble.<init>:()V
+java/util/OptionalDouble.<init>:(D)V
+java/util/OptionalDouble.empty:()Ljava/util/OptionalDouble;
+java/util/OptionalDouble.getAsDouble:()D
+java/util/OptionalDouble.isPresent:()Z
+java/util/OptionalDouble.of:(D)Ljava/util/OptionalDouble;
+java/util/OptionalDouble.orElse:(D)D
+java/util/OptionalInt.<clinit>:()V
+java/util/OptionalInt.<init>:()V
+java/util/OptionalInt.<init>:(I)V
+java/util/OptionalInt.empty:()Ljava/util/OptionalInt;
+java/util/OptionalInt.equals:(Ljava/lang/Object;)Z
+java/util/OptionalInt.getAsInt:()I
+java/util/OptionalInt.hashCode:()I
+java/util/OptionalInt.isPresent:()Z
+java/util/OptionalInt.of:(I)Ljava/util/OptionalInt;
+java/util/OptionalInt.orElse:(I)I
+java/util/OptionalLong.<clinit>:()V
+java/util/OptionalLong.<init>:()V
+java/util/OptionalLong.<init>:(J)V
+java/util/OptionalLong.empty:()Ljava/util/OptionalLong;
+java/util/OptionalLong.equals:(Ljava/lang/Object;)Z
+java/util/OptionalLong.getAsLong:()J
+java/util/OptionalLong.hashCode:()I
+java/util/OptionalLong.isPresent:()Z
+java/util/OptionalLong.of:(J)Ljava/util/OptionalLong;
+java/util/OptionalLong.orElse:(J)J
+java/util/PrimitiveIterator$OfDouble.nextDouble:()D
+java/util/PrimitiveIterator$OfInt.nextInt:()I
+java/util/PrimitiveIterator$OfLong.nextLong:()J
+java/util/PrimitiveIterator.forEachRemaining:(Ljava/lang/Object;)V
+java/util/PriorityQueue$Itr.<init>:(Ljava/util/PriorityQueue;)V
+java/util/PriorityQueue$Itr.<init>:(Ljava/util/PriorityQueue;Ljava/util/PriorityQueue$1;)V
+java/util/PriorityQueue$Itr.hasNext:()Z
+java/util/PriorityQueue$Itr.next:()Ljava/lang/Object;
+java/util/PriorityQueue$Itr.remove:()V
+java/util/PriorityQueue$PriorityQueueSpliterator.<init>:(Ljava/util/PriorityQueue;III)V
+java/util/PriorityQueue$PriorityQueueSpliterator.characteristics:()I
+java/util/PriorityQueue$PriorityQueueSpliterator.estimateSize:()J
+java/util/PriorityQueue$PriorityQueueSpliterator.getFence:()I
+java/util/PriorityQueue$PriorityQueueSpliterator.trySplit:()Ljava/util/PriorityQueue$PriorityQueueSpliterator;
+java/util/PriorityQueue$PriorityQueueSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/PriorityQueue.<init>:()V
+java/util/PriorityQueue.<init>:(I)V
+java/util/PriorityQueue.<init>:(ILjava/util/Comparator;)V
+java/util/PriorityQueue.<init>:(Ljava/util/Collection;)V
+java/util/PriorityQueue.<init>:(Ljava/util/Comparator;)V
+java/util/PriorityQueue.<init>:(Ljava/util/PriorityQueue;)V
+java/util/PriorityQueue.<init>:(Ljava/util/SortedSet;)V
+java/util/PriorityQueue.access$100:(Ljava/util/PriorityQueue;)I
+java/util/PriorityQueue.access$200:(Ljava/util/PriorityQueue;I)Ljava/lang/Object;
+java/util/PriorityQueue.add:(Ljava/lang/Object;)Z
+java/util/PriorityQueue.clear:()V
+java/util/PriorityQueue.comparator:()Ljava/util/Comparator;
+java/util/PriorityQueue.contains:(Ljava/lang/Object;)Z
+java/util/PriorityQueue.grow:(I)V
+java/util/PriorityQueue.heapify:()V
+java/util/PriorityQueue.hugeCapacity:(I)I
+java/util/PriorityQueue.indexOf:(Ljava/lang/Object;)I
+java/util/PriorityQueue.initElementsFromCollection:(Ljava/util/Collection;)V
+java/util/PriorityQueue.initFromCollection:(Ljava/util/Collection;)V
+java/util/PriorityQueue.initFromPriorityQueue:(Ljava/util/PriorityQueue;)V
+java/util/PriorityQueue.iterator:()Ljava/util/Iterator;
+java/util/PriorityQueue.offer:(Ljava/lang/Object;)Z
+java/util/PriorityQueue.peek:()Ljava/lang/Object;
+java/util/PriorityQueue.poll:()Ljava/lang/Object;
+java/util/PriorityQueue.remove:(Ljava/lang/Object;)Z
+java/util/PriorityQueue.removeAt:(I)Ljava/lang/Object;
+java/util/PriorityQueue.removeEq:(Ljava/lang/Object;)Z
+java/util/PriorityQueue.siftDown:(ILjava/lang/Object;)V
+java/util/PriorityQueue.siftDownComparable:(ILjava/lang/Object;)V
+java/util/PriorityQueue.siftDownUsingComparator:(ILjava/lang/Object;)V
+java/util/PriorityQueue.siftUp:(ILjava/lang/Object;)V
+java/util/PriorityQueue.siftUpComparable:(ILjava/lang/Object;)V
+java/util/PriorityQueue.siftUpUsingComparator:(ILjava/lang/Object;)V
+java/util/PriorityQueue.size:()I
+java/util/PriorityQueue.spliterator:()Ljava/util/Spliterator;
+java/util/PriorityQueue.toArray:()[Ljava/lang/Object;
+java/util/PriorityQueue.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Properties$LineReader.<init>:(Ljava/util/Properties;Ljava/io/InputStream;)V
+java/util/Properties$LineReader.<init>:(Ljava/util/Properties;Ljava/io/Reader;)V
+java/util/Properties$XmlSupport$1.<init>:()V
+java/util/Properties$XmlSupport.<init>:()V
+java/util/Properties.<clinit>:()V
+java/util/Properties.loadConvert:([CII[C)Ljava/lang/String;
+java/util/Properties.saveConvert:(Ljava/lang/String;ZZ)Ljava/lang/String;
+java/util/Properties.toHex:(I)C
+java/util/PropertyPermission.getActions:()Ljava/lang/String;
+java/util/PropertyPermission.getActions:(I)Ljava/lang/String;
+java/util/PropertyPermission.getMask:()I
+java/util/PropertyPermission.getMask:(Ljava/lang/String;)I
+java/util/PropertyPermissionCollection.elements:()Ljava/util/Enumeration;
+java/util/PropertyResourceBundle.handleGetObject:(Ljava/lang/String;)Ljava/lang/Object;
+java/util/PropertyResourceBundle.handleKeySet:()Ljava/util/Set;
+java/util/Queue.add:(Ljava/lang/Object;)Z
+java/util/Queue.element:()Ljava/lang/Object;
+java/util/Queue.offer:(Ljava/lang/Object;)Z
+java/util/Queue.peek:()Ljava/lang/Object;
+java/util/Queue.poll:()Ljava/lang/Object;
+java/util/Queue.remove:()Ljava/lang/Object;
+java/util/Random$RandomDoublesSpliterator.<init>:(Ljava/util/Random;JJDD)V
+java/util/Random$RandomDoublesSpliterator.characteristics:()I
+java/util/Random$RandomDoublesSpliterator.estimateSize:()J
+java/util/Random$RandomDoublesSpliterator.trySplit:()Ljava/util/Random$RandomDoublesSpliterator;
+java/util/Random$RandomDoublesSpliterator.trySplit:()Ljava/util/Spliterator$OfDouble;
+java/util/Random$RandomDoublesSpliterator.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Random$RandomDoublesSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Random$RandomIntsSpliterator.<init>:(Ljava/util/Random;JJII)V
+java/util/Random$RandomIntsSpliterator.characteristics:()I
+java/util/Random$RandomIntsSpliterator.estimateSize:()J
+java/util/Random$RandomIntsSpliterator.trySplit:()Ljava/util/Random$RandomIntsSpliterator;
+java/util/Random$RandomIntsSpliterator.trySplit:()Ljava/util/Spliterator$OfInt;
+java/util/Random$RandomIntsSpliterator.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Random$RandomIntsSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Random$RandomLongsSpliterator.<init>:(Ljava/util/Random;JJJJ)V
+java/util/Random$RandomLongsSpliterator.characteristics:()I
+java/util/Random$RandomLongsSpliterator.estimateSize:()J
+java/util/Random$RandomLongsSpliterator.trySplit:()Ljava/util/Random$RandomLongsSpliterator;
+java/util/Random$RandomLongsSpliterator.trySplit:()Ljava/util/Spliterator$OfLong;
+java/util/Random$RandomLongsSpliterator.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Random$RandomLongsSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Random.initialScramble:(J)J
+java/util/RegularEnumSet$EnumSetIterator.<init>:(Ljava/util/RegularEnumSet;)V
+java/util/RegularEnumSet$EnumSetIterator.hasNext:()Z
+java/util/RegularEnumSet$EnumSetIterator.next:()Ljava/lang/Enum;
+java/util/RegularEnumSet$EnumSetIterator.next:()Ljava/lang/Object;
+java/util/RegularEnumSet$EnumSetIterator.remove:()V
+java/util/RegularEnumSet.<init>:(Ljava/lang/Class;[Ljava/lang/Enum;)V
+java/util/RegularEnumSet.access$000:(Ljava/util/RegularEnumSet;)J
+java/util/RegularEnumSet.access$002:(Ljava/util/RegularEnumSet;J)J
+java/util/RegularEnumSet.addAll:()V
+java/util/RegularEnumSet.addRange:(Ljava/lang/Enum;Ljava/lang/Enum;)V
+java/util/RegularEnumSet.clear:()V
+java/util/RegularEnumSet.complement:()V
+java/util/RegularEnumSet.isEmpty:()Z
+java/util/RegularEnumSet.iterator:()Ljava/util/Iterator;
+java/util/RegularEnumSet.size:()I
+java/util/ResourceBundle$1.<init>:()V
+java/util/ResourceBundle$1.getKeys:()Ljava/util/Enumeration;
+java/util/ResourceBundle$1.handleGetObject:(Ljava/lang/String;)Ljava/lang/Object;
+java/util/ResourceBundle$1.toString:()Ljava/lang/String;
+java/util/ResourceBundle$BundleReference.getCacheKey:()Ljava/util/ResourceBundle$CacheKey;
+java/util/ResourceBundle$CacheKey.access$400:(Ljava/util/ResourceBundle$CacheKey;)Ljava/lang/Throwable;
+java/util/ResourceBundle$CacheKey.access$500:(Ljava/util/ResourceBundle$CacheKey;Ljava/lang/Throwable;)V
+java/util/ResourceBundle$CacheKey.access$600:(Ljava/util/ResourceBundle$CacheKey;)J
+java/util/ResourceBundle$CacheKey.access$602:(Ljava/util/ResourceBundle$CacheKey;J)J
+java/util/ResourceBundle$CacheKey.access$700:(Ljava/util/ResourceBundle$CacheKey;)J
+java/util/ResourceBundle$CacheKey.access$702:(Ljava/util/ResourceBundle$CacheKey;J)J
+java/util/ResourceBundle$CacheKey.getCause:()Ljava/lang/Throwable;
+java/util/ResourceBundle$CacheKey.getFormat:()Ljava/lang/String;
+java/util/ResourceBundle$CacheKey.getLocale:()Ljava/util/Locale;
+java/util/ResourceBundle$CacheKey.getName:()Ljava/lang/String;
+java/util/ResourceBundle$CacheKey.hashCode:()I
+java/util/ResourceBundle$CacheKey.setCause:(Ljava/lang/Throwable;)V
+java/util/ResourceBundle$CacheKey.setFormat:(Ljava/lang/String;)V
+java/util/ResourceBundle$CacheKeyReference.getCacheKey:()Ljava/util/ResourceBundle$CacheKey;
+java/util/ResourceBundle$Control$1.<init>:(Ljava/util/ResourceBundle$Control;ZLjava/lang/ClassLoader;Ljava/lang/String;)V
+java/util/ResourceBundle$Control.<init>:()V
+java/util/ResourceBundle$Control.access$300:()Ljava/util/ResourceBundle$Control;
+java/util/ResourceBundle$Control.getControl:(Ljava/util/List;)Ljava/util/ResourceBundle$Control;
+java/util/ResourceBundle$Control.getFormats:(Ljava/lang/String;)Ljava/util/List;
+java/util/ResourceBundle$Control.getNoFallbackControl:(Ljava/util/List;)Ljava/util/ResourceBundle$Control;
+java/util/ResourceBundle$Control.getTimeToLive:(Ljava/lang/String;Ljava/util/Locale;)J
+java/util/ResourceBundle$Control.toResourceName0:(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
+java/util/ResourceBundle$Control.toResourceName:(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;
+java/util/ResourceBundle$LoaderReference.getCacheKey:()Ljava/util/ResourceBundle$CacheKey;
+java/util/ResourceBundle$NoFallbackControl.<clinit>:()V
+java/util/ResourceBundle$NoFallbackControl.<init>:(Ljava/util/List;)V
+java/util/ResourceBundle$NoFallbackControl.access$1000:()Ljava/util/ResourceBundle$Control;
+java/util/ResourceBundle$NoFallbackControl.access$1100:()Ljava/util/ResourceBundle$Control;
+java/util/ResourceBundle$NoFallbackControl.access$1200:()Ljava/util/ResourceBundle$Control;
+java/util/ResourceBundle$NoFallbackControl.getFallbackLocale:(Ljava/lang/String;Ljava/util/Locale;)Ljava/util/Locale;
+java/util/ResourceBundle$RBClassLoader$1.<init>:()V
+java/util/ResourceBundle$RBClassLoader.access$000:()Ljava/util/ResourceBundle$RBClassLoader;
+java/util/ResourceBundle$SingleFormatControl.<clinit>:()V
+java/util/ResourceBundle$SingleFormatControl.<init>:(Ljava/util/List;)V
+java/util/ResourceBundle$SingleFormatControl.access$800:()Ljava/util/ResourceBundle$Control;
+java/util/ResourceBundle$SingleFormatControl.access$900:()Ljava/util/ResourceBundle$Control;
+java/util/ResourceBundle$SingleFormatControl.getFormats:(Ljava/lang/String;)Ljava/util/List;
+java/util/ResourceBundle.<init>:()V
+java/util/ResourceBundle.access$200:()Ljava/lang/ref/ReferenceQueue;
+java/util/ResourceBundle.checkList:(Ljava/util/List;)Z
+java/util/ResourceBundle.containsKey:(Ljava/lang/String;)Z
+java/util/ResourceBundle.getBaseBundleName:()Ljava/lang/String;
+java/util/ResourceBundle.getKeys:()Ljava/util/Enumeration;
+java/util/ResourceBundle.getLocale:()Ljava/util/Locale;
+java/util/ResourceBundle.handleGetObject:(Ljava/lang/String;)Ljava/lang/Object;
+java/util/ResourceBundle.handleKeySet:()Ljava/util/Set;
+java/util/ResourceBundle.isValidBundle:(Ljava/util/ResourceBundle;)Z
+java/util/ResourceBundle.keySet:()Ljava/util/Set;
+java/util/ResourceBundle.setParent:(Ljava/util/ResourceBundle;)V
+java/util/Scanner.buildIntegerPatternString:()Ljava/lang/String;
+java/util/Scanner.clearCaches:()V
+java/util/Scanner.delimiter:()Ljava/util/regex/Pattern;
+java/util/Scanner.ensureOpen:()V
+java/util/Scanner.getCachedResult:()Ljava/lang/String;
+java/util/Scanner.ioException:()Ljava/io/IOException;
+java/util/Scanner.locale:()Ljava/util/Locale;
+java/util/Scanner.radix:()I
+java/util/Scanner.remove:()V
+java/util/Scanner.revertState:()V
+java/util/Scanner.revertState:(Z)Z
+java/util/Scanner.saveState:()V
+java/util/Scanner.setRadix:(I)V
+java/util/Scanner.translateSavedIndexes:(I)V
+java/util/Scanner.useDelimiter:(Ljava/util/regex/Pattern;)Ljava/util/Scanner;
+java/util/Scanner.useRadix:(I)Ljava/util/Scanner;
+java/util/Scanner.useTypeCache:()V
+java/util/ServiceConfigurationError.<init>:(Ljava/lang/String;)V
+java/util/ServiceConfigurationError.<init>:(Ljava/lang/String;Ljava/lang/Throwable;)V
+java/util/ServiceLoader$1.<init>:(Ljava/util/ServiceLoader;)V
+java/util/ServiceLoader$1.remove:()V
+java/util/ServiceLoader$LazyIterator$1.<init>:(Ljava/util/ServiceLoader$LazyIterator;)V
+java/util/ServiceLoader$LazyIterator$2.<init>:(Ljava/util/ServiceLoader$LazyIterator;)V
+java/util/ServiceLoader$LazyIterator.<init>:(Ljava/util/ServiceLoader;Ljava/lang/Class;Ljava/lang/ClassLoader;)V
+java/util/ServiceLoader$LazyIterator.<init>:(Ljava/util/ServiceLoader;Ljava/lang/Class;Ljava/lang/ClassLoader;Ljava/util/ServiceLoader$1;)V
+java/util/ServiceLoader$LazyIterator.remove:()V
+java/util/ServiceLoader.access$400:(Ljava/util/ServiceLoader;)Ljava/util/LinkedHashMap;
+java/util/ServiceLoader.access$500:(Ljava/util/ServiceLoader;)Ljava/security/AccessControlContext;
+java/util/ServiceLoader.access$800:(Ljava/util/ServiceLoader;)Ljava/util/ServiceLoader$LazyIterator;
+java/util/ServiceLoader.iterator:()Ljava/util/Iterator;
+java/util/ServiceLoader.reload:()V
+java/util/Set.add:(Ljava/lang/Object;)Z
+java/util/Set.addAll:(Ljava/util/Collection;)Z
+java/util/Set.clear:()V
+java/util/Set.contains:(Ljava/lang/Object;)Z
+java/util/Set.containsAll:(Ljava/util/Collection;)Z
+java/util/Set.equals:(Ljava/lang/Object;)Z
+java/util/Set.hashCode:()I
+java/util/Set.isEmpty:()Z
+java/util/Set.iterator:()Ljava/util/Iterator;
+java/util/Set.remove:(Ljava/lang/Object;)Z
+java/util/Set.removeAll:(Ljava/util/Collection;)Z
+java/util/Set.retainAll:(Ljava/util/Collection;)Z
+java/util/Set.size:()I
+java/util/Set.spliterator:()Ljava/util/Spliterator;
+java/util/Set.toArray:()[Ljava/lang/Object;
+java/util/Set.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/SimpleTimeZone.decodeEndRule:()V
+java/util/SimpleTimeZone.decodeRules:()V
+java/util/SimpleTimeZone.decodeStartRule:()V
+java/util/SimpleTimeZone.getDSTSavings:()I
+java/util/SimpleTimeZone.getRawOffset:()I
+java/util/SimpleTimeZone.hasSameRules:(Ljava/util/TimeZone;)Z
+java/util/SimpleTimeZone.hashCode:()I
+java/util/SimpleTimeZone.invalidateCache:()V
+java/util/SimpleTimeZone.makeRulesCompatible:()V
+java/util/SimpleTimeZone.observesDaylightTime:()Z
+java/util/SimpleTimeZone.packRules:()[B
+java/util/SimpleTimeZone.packTimes:()[I
+java/util/SimpleTimeZone.setDSTSavings:(I)V
+java/util/SimpleTimeZone.setEndRule:(III)V
+java/util/SimpleTimeZone.setEndRule:(IIII)V
+java/util/SimpleTimeZone.setEndRule:(IIIIZ)V
+java/util/SimpleTimeZone.setRawOffset:(I)V
+java/util/SimpleTimeZone.setStartRule:(III)V
+java/util/SimpleTimeZone.setStartRule:(IIII)V
+java/util/SimpleTimeZone.setStartRule:(IIIIZ)V
+java/util/SimpleTimeZone.setStartYear:(I)V
+java/util/SimpleTimeZone.unpackRules:([B)V
+java/util/SimpleTimeZone.unpackTimes:([I)V
+java/util/SimpleTimeZone.useDaylightTime:()Z
+java/util/SortedMap.comparator:()Ljava/util/Comparator;
+java/util/SortedMap.entrySet:()Ljava/util/Set;
+java/util/SortedMap.firstKey:()Ljava/lang/Object;
+java/util/SortedMap.headMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/SortedMap.keySet:()Ljava/util/Set;
+java/util/SortedMap.lastKey:()Ljava/lang/Object;
+java/util/SortedMap.subMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/SortedMap.tailMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/SortedMap.values:()Ljava/util/Collection;
+java/util/SortedSet$1.<init>:(Ljava/util/SortedSet;Ljava/util/Collection;I)V
+java/util/SortedSet$1.getComparator:()Ljava/util/Comparator;
+java/util/SortedSet.comparator:()Ljava/util/Comparator;
+java/util/SortedSet.first:()Ljava/lang/Object;
+java/util/SortedSet.headSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/SortedSet.last:()Ljava/lang/Object;
+java/util/SortedSet.spliterator:()Ljava/util/Spliterator;
+java/util/SortedSet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/SortedSet.tailSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/Spliterator$OfDouble.forEachRemaining:(Ljava/lang/Object;)V
+java/util/Spliterator$OfDouble.forEachRemaining:(Ljava/util/function/DoubleConsumer;)V
+java/util/Spliterator$OfDouble.tryAdvance:(Ljava/lang/Object;)Z
+java/util/Spliterator$OfDouble.tryAdvance:(Ljava/util/function/DoubleConsumer;)Z
+java/util/Spliterator$OfDouble.trySplit:()Ljava/util/Spliterator$OfDouble;
+java/util/Spliterator$OfDouble.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Spliterator$OfDouble.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterator$OfInt.forEachRemaining:(Ljava/lang/Object;)V
+java/util/Spliterator$OfInt.forEachRemaining:(Ljava/util/function/IntConsumer;)V
+java/util/Spliterator$OfInt.tryAdvance:(Ljava/lang/Object;)Z
+java/util/Spliterator$OfInt.tryAdvance:(Ljava/util/function/IntConsumer;)Z
+java/util/Spliterator$OfInt.trySplit:()Ljava/util/Spliterator$OfInt;
+java/util/Spliterator$OfInt.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Spliterator$OfInt.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterator$OfLong.forEachRemaining:(Ljava/lang/Object;)V
+java/util/Spliterator$OfLong.forEachRemaining:(Ljava/util/function/LongConsumer;)V
+java/util/Spliterator$OfLong.tryAdvance:(Ljava/lang/Object;)Z
+java/util/Spliterator$OfLong.tryAdvance:(Ljava/util/function/LongConsumer;)Z
+java/util/Spliterator$OfLong.trySplit:()Ljava/util/Spliterator$OfLong;
+java/util/Spliterator$OfLong.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Spliterator$OfLong.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterator$OfPrimitive.forEachRemaining:(Ljava/lang/Object;)V
+java/util/Spliterator$OfPrimitive.tryAdvance:(Ljava/lang/Object;)Z
+java/util/Spliterator$OfPrimitive.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Spliterator$OfPrimitive.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterator.characteristics:()I
+java/util/Spliterator.estimateSize:()J
+java/util/Spliterator.forEachRemaining:(Ljava/util/function/Consumer;)V
+java/util/Spliterator.getComparator:()Ljava/util/Comparator;
+java/util/Spliterator.getExactSizeIfKnown:()J
+java/util/Spliterator.hasCharacteristics:(I)Z
+java/util/Spliterator.tryAdvance:(Ljava/util/function/Consumer;)Z
+java/util/Spliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterators$1Adapter.<init>:(Ljava/util/Spliterator;)V
+java/util/Spliterators$1Adapter.accept:(Ljava/lang/Object;)V
+java/util/Spliterators$1Adapter.hasNext:()Z
+java/util/Spliterators$1Adapter.next:()Ljava/lang/Object;
+java/util/Spliterators$2Adapter.<init>:(Ljava/util/Spliterator$OfInt;)V
+java/util/Spliterators$2Adapter.accept:(I)V
+java/util/Spliterators$2Adapter.hasNext:()Z
+java/util/Spliterators$2Adapter.nextInt:()I
+java/util/Spliterators$3Adapter.<init>:(Ljava/util/Spliterator$OfLong;)V
+java/util/Spliterators$3Adapter.accept:(J)V
+java/util/Spliterators$3Adapter.hasNext:()Z
+java/util/Spliterators$3Adapter.nextLong:()J
+java/util/Spliterators$4Adapter.<init>:(Ljava/util/Spliterator$OfDouble;)V
+java/util/Spliterators$4Adapter.accept:(D)V
+java/util/Spliterators$4Adapter.hasNext:()Z
+java/util/Spliterators$4Adapter.nextDouble:()D
+java/util/Spliterators$AbstractDoubleSpliterator$HoldingDoubleConsumer.<init>:()V
+java/util/Spliterators$AbstractDoubleSpliterator$HoldingDoubleConsumer.accept:(D)V
+java/util/Spliterators$AbstractDoubleSpliterator.<init>:(JI)V
+java/util/Spliterators$AbstractDoubleSpliterator.characteristics:()I
+java/util/Spliterators$AbstractDoubleSpliterator.estimateSize:()J
+java/util/Spliterators$AbstractIntSpliterator$HoldingIntConsumer.<init>:()V
+java/util/Spliterators$AbstractIntSpliterator$HoldingIntConsumer.accept:(I)V
+java/util/Spliterators$AbstractIntSpliterator.<init>:(JI)V
+java/util/Spliterators$AbstractIntSpliterator.characteristics:()I
+java/util/Spliterators$AbstractIntSpliterator.estimateSize:()J
+java/util/Spliterators$AbstractLongSpliterator$HoldingLongConsumer.<init>:()V
+java/util/Spliterators$AbstractLongSpliterator$HoldingLongConsumer.accept:(J)V
+java/util/Spliterators$AbstractLongSpliterator.<init>:(JI)V
+java/util/Spliterators$AbstractLongSpliterator.characteristics:()I
+java/util/Spliterators$AbstractLongSpliterator.estimateSize:()J
+java/util/Spliterators$AbstractSpliterator$HoldingConsumer.<init>:()V
+java/util/Spliterators$AbstractSpliterator$HoldingConsumer.accept:(Ljava/lang/Object;)V
+java/util/Spliterators$AbstractSpliterator.<init>:(JI)V
+java/util/Spliterators$AbstractSpliterator.characteristics:()I
+java/util/Spliterators$AbstractSpliterator.estimateSize:()J
+java/util/Spliterators$ArraySpliterator.<init>:([Ljava/lang/Object;I)V
+java/util/Spliterators$ArraySpliterator.<init>:([Ljava/lang/Object;III)V
+java/util/Spliterators$ArraySpliterator.characteristics:()I
+java/util/Spliterators$ArraySpliterator.estimateSize:()J
+java/util/Spliterators$ArraySpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterators$DoubleArraySpliterator.<init>:([DI)V
+java/util/Spliterators$DoubleArraySpliterator.<init>:([DIII)V
+java/util/Spliterators$DoubleArraySpliterator.characteristics:()I
+java/util/Spliterators$DoubleArraySpliterator.estimateSize:()J
+java/util/Spliterators$DoubleArraySpliterator.trySplit:()Ljava/util/Spliterator$OfDouble;
+java/util/Spliterators$DoubleArraySpliterator.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Spliterators$DoubleArraySpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterators$DoubleIteratorSpliterator.<init>:(Ljava/util/PrimitiveIterator$OfDouble;I)V
+java/util/Spliterators$DoubleIteratorSpliterator.<init>:(Ljava/util/PrimitiveIterator$OfDouble;JI)V
+java/util/Spliterators$DoubleIteratorSpliterator.characteristics:()I
+java/util/Spliterators$DoubleIteratorSpliterator.estimateSize:()J
+java/util/Spliterators$EmptySpliterator$OfDouble.<init>:()V
+java/util/Spliterators$EmptySpliterator$OfDouble.forEachRemaining:(Ljava/util/function/DoubleConsumer;)V
+java/util/Spliterators$EmptySpliterator$OfDouble.tryAdvance:(Ljava/util/function/DoubleConsumer;)Z
+java/util/Spliterators$EmptySpliterator$OfDouble.trySplit:()Ljava/util/Spliterator$OfDouble;
+java/util/Spliterators$EmptySpliterator$OfDouble.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Spliterators$EmptySpliterator$OfInt.<init>:()V
+java/util/Spliterators$EmptySpliterator$OfInt.forEachRemaining:(Ljava/util/function/IntConsumer;)V
+java/util/Spliterators$EmptySpliterator$OfInt.tryAdvance:(Ljava/util/function/IntConsumer;)Z
+java/util/Spliterators$EmptySpliterator$OfInt.trySplit:()Ljava/util/Spliterator$OfInt;
+java/util/Spliterators$EmptySpliterator$OfInt.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Spliterators$EmptySpliterator$OfLong.<init>:()V
+java/util/Spliterators$EmptySpliterator$OfLong.forEachRemaining:(Ljava/util/function/LongConsumer;)V
+java/util/Spliterators$EmptySpliterator$OfLong.tryAdvance:(Ljava/util/function/LongConsumer;)Z
+java/util/Spliterators$EmptySpliterator$OfLong.trySplit:()Ljava/util/Spliterator$OfLong;
+java/util/Spliterators$EmptySpliterator$OfLong.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Spliterators$EmptySpliterator$OfRef.<init>:()V
+java/util/Spliterators$EmptySpliterator$OfRef.forEachRemaining:(Ljava/util/function/Consumer;)V
+java/util/Spliterators$EmptySpliterator$OfRef.tryAdvance:(Ljava/util/function/Consumer;)Z
+java/util/Spliterators$EmptySpliterator.<init>:()V
+java/util/Spliterators$EmptySpliterator.characteristics:()I
+java/util/Spliterators$EmptySpliterator.estimateSize:()J
+java/util/Spliterators$EmptySpliterator.forEachRemaining:(Ljava/lang/Object;)V
+java/util/Spliterators$EmptySpliterator.tryAdvance:(Ljava/lang/Object;)Z
+java/util/Spliterators$EmptySpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterators$IntArraySpliterator.<init>:([II)V
+java/util/Spliterators$IntArraySpliterator.<init>:([IIII)V
+java/util/Spliterators$IntArraySpliterator.characteristics:()I
+java/util/Spliterators$IntArraySpliterator.estimateSize:()J
+java/util/Spliterators$IntArraySpliterator.trySplit:()Ljava/util/Spliterator$OfInt;
+java/util/Spliterators$IntArraySpliterator.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Spliterators$IntArraySpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterators$IntIteratorSpliterator.<init>:(Ljava/util/PrimitiveIterator$OfInt;I)V
+java/util/Spliterators$IntIteratorSpliterator.<init>:(Ljava/util/PrimitiveIterator$OfInt;JI)V
+java/util/Spliterators$IntIteratorSpliterator.characteristics:()I
+java/util/Spliterators$IntIteratorSpliterator.estimateSize:()J
+java/util/Spliterators$IteratorSpliterator.<init>:(Ljava/util/Collection;I)V
+java/util/Spliterators$IteratorSpliterator.<init>:(Ljava/util/Iterator;I)V
+java/util/Spliterators$IteratorSpliterator.<init>:(Ljava/util/Iterator;JI)V
+java/util/Spliterators$IteratorSpliterator.characteristics:()I
+java/util/Spliterators$IteratorSpliterator.estimateSize:()J
+java/util/Spliterators$IteratorSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterators$LongArraySpliterator.<init>:([JI)V
+java/util/Spliterators$LongArraySpliterator.<init>:([JIII)V
+java/util/Spliterators$LongArraySpliterator.characteristics:()I
+java/util/Spliterators$LongArraySpliterator.estimateSize:()J
+java/util/Spliterators$LongArraySpliterator.trySplit:()Ljava/util/Spliterator$OfLong;
+java/util/Spliterators$LongArraySpliterator.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/Spliterators$LongArraySpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Spliterators$LongIteratorSpliterator.<init>:(Ljava/util/PrimitiveIterator$OfLong;I)V
+java/util/Spliterators$LongIteratorSpliterator.<init>:(Ljava/util/PrimitiveIterator$OfLong;JI)V
+java/util/Spliterators$LongIteratorSpliterator.characteristics:()I
+java/util/Spliterators$LongIteratorSpliterator.estimateSize:()J
+java/util/Spliterators.<clinit>:()V
+java/util/Spliterators.<init>:()V
+java/util/Spliterators.checkFromToBounds:(III)V
+java/util/Spliterators.emptyDoubleSpliterator:()Ljava/util/Spliterator$OfDouble;
+java/util/Spliterators.emptyIntSpliterator:()Ljava/util/Spliterator$OfInt;
+java/util/Spliterators.emptyLongSpliterator:()Ljava/util/Spliterator$OfLong;
+java/util/Spliterators.emptySpliterator:()Ljava/util/Spliterator;
+java/util/Spliterators.iterator:(Ljava/util/Spliterator$OfDouble;)Ljava/util/PrimitiveIterator$OfDouble;
+java/util/Spliterators.iterator:(Ljava/util/Spliterator$OfInt;)Ljava/util/PrimitiveIterator$OfInt;
+java/util/Spliterators.iterator:(Ljava/util/Spliterator$OfLong;)Ljava/util/PrimitiveIterator$OfLong;
+java/util/Spliterators.iterator:(Ljava/util/Spliterator;)Ljava/util/Iterator;
+java/util/Spliterators.spliterator:(Ljava/util/Collection;I)Ljava/util/Spliterator;
+java/util/Spliterators.spliterator:(Ljava/util/Iterator;JI)Ljava/util/Spliterator;
+java/util/Spliterators.spliterator:(Ljava/util/PrimitiveIterator$OfDouble;JI)Ljava/util/Spliterator$OfDouble;
+java/util/Spliterators.spliterator:(Ljava/util/PrimitiveIterator$OfInt;JI)Ljava/util/Spliterator$OfInt;
+java/util/Spliterators.spliterator:(Ljava/util/PrimitiveIterator$OfLong;JI)Ljava/util/Spliterator$OfLong;
+java/util/Spliterators.spliterator:([DI)Ljava/util/Spliterator$OfDouble;
+java/util/Spliterators.spliterator:([DIII)Ljava/util/Spliterator$OfDouble;
+java/util/Spliterators.spliterator:([II)Ljava/util/Spliterator$OfInt;
+java/util/Spliterators.spliterator:([IIII)Ljava/util/Spliterator$OfInt;
+java/util/Spliterators.spliterator:([JI)Ljava/util/Spliterator$OfLong;
+java/util/Spliterators.spliterator:([JIII)Ljava/util/Spliterator$OfLong;
+java/util/Spliterators.spliterator:([Ljava/lang/Object;I)Ljava/util/Spliterator;
+java/util/Spliterators.spliterator:([Ljava/lang/Object;III)Ljava/util/Spliterator;
+java/util/Spliterators.spliteratorUnknownSize:(Ljava/util/Iterator;I)Ljava/util/Spliterator;
+java/util/Spliterators.spliteratorUnknownSize:(Ljava/util/PrimitiveIterator$OfDouble;I)Ljava/util/Spliterator$OfDouble;
+java/util/Spliterators.spliteratorUnknownSize:(Ljava/util/PrimitiveIterator$OfInt;I)Ljava/util/Spliterator$OfInt;
+java/util/Spliterators.spliteratorUnknownSize:(Ljava/util/PrimitiveIterator$OfLong;I)Ljava/util/Spliterator$OfLong;
+java/util/SplittableRandom$RandomDoublesSpliterator.<init>:(Ljava/util/SplittableRandom;JJDD)V
+java/util/SplittableRandom$RandomDoublesSpliterator.characteristics:()I
+java/util/SplittableRandom$RandomDoublesSpliterator.estimateSize:()J
+java/util/SplittableRandom$RandomDoublesSpliterator.trySplit:()Ljava/util/Spliterator$OfDouble;
+java/util/SplittableRandom$RandomDoublesSpliterator.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/SplittableRandom$RandomDoublesSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/SplittableRandom$RandomDoublesSpliterator.trySplit:()Ljava/util/SplittableRandom$RandomDoublesSpliterator;
+java/util/SplittableRandom$RandomIntsSpliterator.<init>:(Ljava/util/SplittableRandom;JJII)V
+java/util/SplittableRandom$RandomIntsSpliterator.characteristics:()I
+java/util/SplittableRandom$RandomIntsSpliterator.estimateSize:()J
+java/util/SplittableRandom$RandomIntsSpliterator.trySplit:()Ljava/util/Spliterator$OfInt;
+java/util/SplittableRandom$RandomIntsSpliterator.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/SplittableRandom$RandomIntsSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/SplittableRandom$RandomIntsSpliterator.trySplit:()Ljava/util/SplittableRandom$RandomIntsSpliterator;
+java/util/SplittableRandom$RandomLongsSpliterator.<init>:(Ljava/util/SplittableRandom;JJJJ)V
+java/util/SplittableRandom$RandomLongsSpliterator.characteristics:()I
+java/util/SplittableRandom$RandomLongsSpliterator.estimateSize:()J
+java/util/SplittableRandom$RandomLongsSpliterator.trySplit:()Ljava/util/Spliterator$OfLong;
+java/util/SplittableRandom$RandomLongsSpliterator.trySplit:()Ljava/util/Spliterator$OfPrimitive;
+java/util/SplittableRandom$RandomLongsSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/SplittableRandom$RandomLongsSpliterator.trySplit:()Ljava/util/SplittableRandom$RandomLongsSpliterator;
+java/util/SplittableRandom.<init>:(J)V
+java/util/SplittableRandom.<init>:(JJ)V
+java/util/SplittableRandom.internalNextInt:(II)I
+java/util/SplittableRandom.internalNextLong:(JJ)J
+java/util/SplittableRandom.mix32:(J)I
+java/util/SplittableRandom.mix64:(J)J
+java/util/SplittableRandom.mixGamma:(J)J
+java/util/SplittableRandom.nextBoolean:()Z
+java/util/SplittableRandom.nextDouble:()D
+java/util/SplittableRandom.nextInt:()I
+java/util/SplittableRandom.nextInt:(I)I
+java/util/SplittableRandom.nextInt:(II)I
+java/util/SplittableRandom.nextLong:()J
+java/util/SplittableRandom.nextLong:(J)J
+java/util/SplittableRandom.nextLong:(JJ)J
+java/util/SplittableRandom.nextSeed:()J
+java/util/SplittableRandom.split:()Ljava/util/SplittableRandom;
+java/util/Stack.<init>:()V
+java/util/StringJoiner.<init>:(Ljava/lang/CharSequence;)V
+java/util/StringJoiner.<init>:(Ljava/lang/CharSequence;Ljava/lang/CharSequence;Ljava/lang/CharSequence;)V
+java/util/StringJoiner.add:(Ljava/lang/CharSequence;)Ljava/util/StringJoiner;
+java/util/StringJoiner.length:()I
+java/util/StringJoiner.merge:(Ljava/util/StringJoiner;)Ljava/util/StringJoiner;
+java/util/StringJoiner.prepareBuilder:()Ljava/lang/StringBuilder;
+java/util/StringJoiner.setEmptyValue:(Ljava/lang/CharSequence;)Ljava/util/StringJoiner;
+java/util/StringTokenizer.<init>:(Ljava/lang/String;)V
+java/util/StringTokenizer.<init>:(Ljava/lang/String;Ljava/lang/String;)V
+java/util/StringTokenizer.<init>:(Ljava/lang/String;Ljava/lang/String;Z)V
+java/util/StringTokenizer.countTokens:()I
+java/util/StringTokenizer.hasMoreElements:()Z
+java/util/StringTokenizer.hasMoreTokens:()Z
+java/util/StringTokenizer.isDelimiter:(I)Z
+java/util/StringTokenizer.nextElement:()Ljava/lang/Object;
+java/util/StringTokenizer.nextToken:()Ljava/lang/String;
+java/util/StringTokenizer.nextToken:(Ljava/lang/String;)Ljava/lang/String;
+java/util/StringTokenizer.scanToken:(I)I
+java/util/StringTokenizer.setMaxDelimCodePoint:()V
+java/util/StringTokenizer.skipDelimiters:(I)I
+java/util/SubList$1.add:(Ljava/lang/Object;)V
+java/util/SubList$1.hasNext:()Z
+java/util/SubList$1.hasPrevious:()Z
+java/util/SubList$1.next:()Ljava/lang/Object;
+java/util/SubList$1.nextIndex:()I
+java/util/SubList$1.previous:()Ljava/lang/Object;
+java/util/SubList$1.previousIndex:()I
+java/util/SubList$1.remove:()V
+java/util/SubList$1.set:(Ljava/lang/Object;)V
+java/util/SubList.access$000:(Ljava/util/SubList;)I
+java/util/SubList.access$100:(Ljava/util/SubList;)Ljava/util/AbstractList;
+java/util/SubList.access$200:(Ljava/util/SubList;)I
+java/util/SubList.access$208:(Ljava/util/SubList;)I
+java/util/SubList.access$210:(Ljava/util/SubList;)I
+java/util/SubList.add:(ILjava/lang/Object;)V
+java/util/SubList.checkForComodification:()V
+java/util/SubList.get:(I)Ljava/lang/Object;
+java/util/SubList.outOfBoundsMsg:(I)Ljava/lang/String;
+java/util/SubList.rangeCheck:(I)V
+java/util/SubList.rangeCheckForAdd:(I)V
+java/util/SubList.remove:(I)Ljava/lang/Object;
+java/util/SubList.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/SubList.size:()I
+java/util/TaskQueue.<init>:()V
+java/util/TaskQueue.add:(Ljava/util/TimerTask;)V
+java/util/TaskQueue.clear:()V
+java/util/TaskQueue.fixDown:(I)V
+java/util/TaskQueue.fixUp:(I)V
+java/util/TaskQueue.get:(I)Ljava/util/TimerTask;
+java/util/TaskQueue.getMin:()Ljava/util/TimerTask;
+java/util/TaskQueue.heapify:()V
+java/util/TaskQueue.isEmpty:()Z
+java/util/TaskQueue.quickRemove:(I)V
+java/util/TaskQueue.removeMin:()V
+java/util/TaskQueue.rescheduleMin:(J)V
+java/util/TaskQueue.size:()I
+java/util/TimSort.<init>:([Ljava/lang/Object;Ljava/util/Comparator;[Ljava/lang/Object;II)V
+java/util/TimSort.binarySort:([Ljava/lang/Object;IIILjava/util/Comparator;)V
+java/util/TimSort.countRunAndMakeAscending:([Ljava/lang/Object;IILjava/util/Comparator;)I
+java/util/TimSort.ensureCapacity:(I)[Ljava/lang/Object;
+java/util/TimSort.gallopLeft:(Ljava/lang/Object;[Ljava/lang/Object;IIILjava/util/Comparator;)I
+java/util/TimSort.gallopRight:(Ljava/lang/Object;[Ljava/lang/Object;IIILjava/util/Comparator;)I
+java/util/TimSort.mergeAt:(I)V
+java/util/TimSort.mergeCollapse:()V
+java/util/TimSort.mergeForceCollapse:()V
+java/util/TimSort.mergeHi:(IIII)V
+java/util/TimSort.mergeLo:(IIII)V
+java/util/TimSort.minRunLength:(I)I
+java/util/TimSort.pushRun:(II)V
+java/util/TimSort.reverseRange:([Ljava/lang/Object;II)V
+java/util/TimSort.sort:([Ljava/lang/Object;IILjava/util/Comparator;[Ljava/lang/Object;II)V
+java/util/TimeZone$1.<init>:(Ljava/lang/String;)V
+java/util/TimeZone.<init>:()V
+java/util/TimeZone.getDSTSavings:()I
+java/util/TimeZone.getID:()Ljava/lang/String;
+java/util/TimeZone.getOffset:(IIIIII)I
+java/util/TimeZone.getOffset:(J)I
+java/util/TimeZone.getOffsets:(J[I)I
+java/util/TimeZone.getRawOffset:()I
+java/util/TimeZone.hasSameRules:(Ljava/util/TimeZone;)Z
+java/util/TimeZone.inDaylightTime:(Ljava/util/Date;)Z
+java/util/TimeZone.setID:(Ljava/lang/String;)V
+java/util/TimeZone.setRawOffset:(I)V
+java/util/TimeZone.useDaylightTime:()Z
+java/util/Timer$1.<init>:(Ljava/util/Timer;)V
+java/util/Timer.access$000:(Ljava/util/Timer;)Ljava/util/TaskQueue;
+java/util/Timer.access$100:(Ljava/util/Timer;)Ljava/util/TimerThread;
+java/util/Timer.purge:()I
+java/util/TimerTask.<init>:()V
+java/util/TimerTask.cancel:()Z
+java/util/TimerTask.run:()V
+java/util/TimerTask.scheduledExecutionTime:()J
+java/util/TooManyListenersException.<init>:()V
+java/util/TooManyListenersException.<init>:(Ljava/lang/String;)V
+java/util/TreeMap$AscendingSubMap$AscendingEntrySetView.<init>:(Ljava/util/TreeMap$AscendingSubMap;)V
+java/util/TreeMap$AscendingSubMap.<init>:(Ljava/util/TreeMap;ZLjava/lang/Object;ZZLjava/lang/Object;Z)V
+java/util/TreeMap$AscendingSubMap.comparator:()Ljava/util/Comparator;
+java/util/TreeMap$AscendingSubMap.descendingMap:()Ljava/util/NavigableMap;
+java/util/TreeMap$AscendingSubMap.entrySet:()Ljava/util/Set;
+java/util/TreeMap$DescendingKeyIterator.<init>:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$DescendingKeyIterator.remove:()V
+java/util/TreeMap$DescendingKeySpliterator.<init>:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;III)V
+java/util/TreeMap$DescendingKeySpliterator.characteristics:()I
+java/util/TreeMap$DescendingSubMap$DescendingEntrySetView.<init>:(Ljava/util/TreeMap$DescendingSubMap;)V
+java/util/TreeMap$DescendingSubMap.<init>:(Ljava/util/TreeMap;ZLjava/lang/Object;ZZLjava/lang/Object;Z)V
+java/util/TreeMap$DescendingSubMap.comparator:()Ljava/util/Comparator;
+java/util/TreeMap$DescendingSubMap.descendingMap:()Ljava/util/NavigableMap;
+java/util/TreeMap$DescendingSubMap.entrySet:()Ljava/util/Set;
+java/util/TreeMap$Entry.<init>:(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$Entry.equals:(Ljava/lang/Object;)Z
+java/util/TreeMap$Entry.getKey:()Ljava/lang/Object;
+java/util/TreeMap$Entry.getValue:()Ljava/lang/Object;
+java/util/TreeMap$Entry.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$EntryIterator.<init>:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$EntrySet.<init>:(Ljava/util/TreeMap;)V
+java/util/TreeMap$EntrySet.clear:()V
+java/util/TreeMap$EntrySet.contains:(Ljava/lang/Object;)Z
+java/util/TreeMap$EntrySet.iterator:()Ljava/util/Iterator;
+java/util/TreeMap$EntrySet.remove:(Ljava/lang/Object;)Z
+java/util/TreeMap$EntrySet.size:()I
+java/util/TreeMap$EntrySet.spliterator:()Ljava/util/Spliterator;
+java/util/TreeMap$EntrySpliterator.<init>:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;III)V
+java/util/TreeMap$EntrySpliterator.characteristics:()I
+java/util/TreeMap$EntrySpliterator.getComparator:()Ljava/util/Comparator;
+java/util/TreeMap$EntrySpliterator.lambda$getComparator$d5a01062$1:(Ljava/util/Map$Entry;Ljava/util/Map$Entry;)I
+java/util/TreeMap$KeyIterator.<init>:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$KeySet.<init>:(Ljava/util/NavigableMap;)V
+java/util/TreeMap$KeySet.ceiling:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$KeySet.descendingIterator:()Ljava/util/Iterator;
+java/util/TreeMap$KeySet.descendingSet:()Ljava/util/NavigableSet;
+java/util/TreeMap$KeySet.floor:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$KeySet.headSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/TreeMap$KeySet.headSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/TreeMap$KeySet.higher:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$KeySet.iterator:()Ljava/util/Iterator;
+java/util/TreeMap$KeySet.lower:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$KeySet.pollFirst:()Ljava/lang/Object;
+java/util/TreeMap$KeySet.pollLast:()Ljava/lang/Object;
+java/util/TreeMap$KeySet.spliterator:()Ljava/util/Spliterator;
+java/util/TreeMap$KeySet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/TreeMap$KeySet.subSet:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/TreeMap$KeySet.tailSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/TreeMap$KeySet.tailSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/TreeMap$KeySpliterator.<init>:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;III)V
+java/util/TreeMap$KeySpliterator.characteristics:()I
+java/util/TreeMap$KeySpliterator.getComparator:()Ljava/util/Comparator;
+java/util/TreeMap$NavigableSubMap$DescendingSubMapEntryIterator.<init>:(Ljava/util/TreeMap$NavigableSubMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$NavigableSubMap$DescendingSubMapKeyIterator.<init>:(Ljava/util/TreeMap$NavigableSubMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$NavigableSubMap$DescendingSubMapKeyIterator.characteristics:()I
+java/util/TreeMap$NavigableSubMap$DescendingSubMapKeyIterator.estimateSize:()J
+java/util/TreeMap$NavigableSubMap$DescendingSubMapKeyIterator.trySplit:()Ljava/util/Spliterator;
+java/util/TreeMap$NavigableSubMap$EntrySetView.<init>:(Ljava/util/TreeMap$NavigableSubMap;)V
+java/util/TreeMap$NavigableSubMap$EntrySetView.contains:(Ljava/lang/Object;)Z
+java/util/TreeMap$NavigableSubMap$EntrySetView.isEmpty:()Z
+java/util/TreeMap$NavigableSubMap$EntrySetView.remove:(Ljava/lang/Object;)Z
+java/util/TreeMap$NavigableSubMap$SubMapEntryIterator.<init>:(Ljava/util/TreeMap$NavigableSubMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$NavigableSubMap$SubMapIterator.<init>:(Ljava/util/TreeMap$NavigableSubMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$NavigableSubMap$SubMapIterator.hasNext:()Z
+java/util/TreeMap$NavigableSubMap$SubMapIterator.nextEntry:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap$SubMapIterator.prevEntry:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap$SubMapIterator.removeAscending:()V
+java/util/TreeMap$NavigableSubMap$SubMapIterator.removeDescending:()V
+java/util/TreeMap$NavigableSubMap$SubMapKeyIterator.<init>:(Ljava/util/TreeMap$NavigableSubMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$NavigableSubMap$SubMapKeyIterator.characteristics:()I
+java/util/TreeMap$NavigableSubMap$SubMapKeyIterator.estimateSize:()J
+java/util/TreeMap$NavigableSubMap$SubMapKeyIterator.trySplit:()Ljava/util/Spliterator;
+java/util/TreeMap$NavigableSubMap.<init>:(Ljava/util/TreeMap;ZLjava/lang/Object;ZZLjava/lang/Object;Z)V
+java/util/TreeMap$NavigableSubMap.absCeiling:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.absFloor:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.absHighFence:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.absHigher:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.absHighest:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.absLowFence:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.absLower:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.absLowest:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.ceilingEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/TreeMap$NavigableSubMap.ceilingKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$NavigableSubMap.containsKey:(Ljava/lang/Object;)Z
+java/util/TreeMap$NavigableSubMap.descendingKeyIterator:()Ljava/util/Iterator;
+java/util/TreeMap$NavigableSubMap.firstEntry:()Ljava/util/Map$Entry;
+java/util/TreeMap$NavigableSubMap.firstKey:()Ljava/lang/Object;
+java/util/TreeMap$NavigableSubMap.floorEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/TreeMap$NavigableSubMap.floorKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$NavigableSubMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$NavigableSubMap.higherEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/TreeMap$NavigableSubMap.higherKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$NavigableSubMap.inClosedRange:(Ljava/lang/Object;)Z
+java/util/TreeMap$NavigableSubMap.inRange:(Ljava/lang/Object;)Z
+java/util/TreeMap$NavigableSubMap.inRange:(Ljava/lang/Object;Z)Z
+java/util/TreeMap$NavigableSubMap.keyIterator:()Ljava/util/Iterator;
+java/util/TreeMap$NavigableSubMap.keySet:()Ljava/util/Set;
+java/util/TreeMap$NavigableSubMap.keySpliterator:()Ljava/util/Spliterator;
+java/util/TreeMap$NavigableSubMap.lastEntry:()Ljava/util/Map$Entry;
+java/util/TreeMap$NavigableSubMap.lastKey:()Ljava/lang/Object;
+java/util/TreeMap$NavigableSubMap.lowerEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/TreeMap$NavigableSubMap.lowerKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$NavigableSubMap.navigableKeySet:()Ljava/util/NavigableSet;
+java/util/TreeMap$NavigableSubMap.pollFirstEntry:()Ljava/util/Map$Entry;
+java/util/TreeMap$NavigableSubMap.pollLastEntry:()Ljava/util/Map$Entry;
+java/util/TreeMap$NavigableSubMap.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$NavigableSubMap.remove:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap$NavigableSubMap.subCeiling:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.subFloor:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.subHigher:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.subHighest:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.subLower:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.subLowest:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap$NavigableSubMap.tooHigh:(Ljava/lang/Object;)Z
+java/util/TreeMap$NavigableSubMap.tooLow:(Ljava/lang/Object;)Z
+java/util/TreeMap$PrivateEntryIterator.<init>:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$PrivateEntryIterator.hasNext:()Z
+java/util/TreeMap$PrivateEntryIterator.nextEntry:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap$PrivateEntryIterator.prevEntry:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap$PrivateEntryIterator.remove:()V
+java/util/TreeMap$SubMap.<init>:(Ljava/util/TreeMap;)V
+java/util/TreeMap$SubMap.comparator:()Ljava/util/Comparator;
+java/util/TreeMap$SubMap.entrySet:()Ljava/util/Set;
+java/util/TreeMap$SubMap.firstKey:()Ljava/lang/Object;
+java/util/TreeMap$SubMap.headMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/TreeMap$SubMap.lastKey:()Ljava/lang/Object;
+java/util/TreeMap$SubMap.readResolve:()Ljava/lang/Object;
+java/util/TreeMap$SubMap.subMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/TreeMap$SubMap.tailMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/TreeMap$TreeMapSpliterator.<init>:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;III)V
+java/util/TreeMap$TreeMapSpliterator.estimateSize:()J
+java/util/TreeMap$TreeMapSpliterator.getEstimate:()I
+java/util/TreeMap$ValueIterator.<init>:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap$ValueSpliterator.<init>:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;III)V
+java/util/TreeMap$ValueSpliterator.characteristics:()I
+java/util/TreeMap$Values.<init>:(Ljava/util/TreeMap;)V
+java/util/TreeMap$Values.clear:()V
+java/util/TreeMap$Values.contains:(Ljava/lang/Object;)Z
+java/util/TreeMap$Values.iterator:()Ljava/util/Iterator;
+java/util/TreeMap$Values.remove:(Ljava/lang/Object;)Z
+java/util/TreeMap$Values.size:()I
+java/util/TreeMap$Values.spliterator:()Ljava/util/Spliterator;
+java/util/TreeMap.<clinit>:()V
+java/util/TreeMap.<init>:()V
+java/util/TreeMap.<init>:(Ljava/util/Comparator;)V
+java/util/TreeMap.access$000:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap.access$100:(Ljava/util/TreeMap;)I
+java/util/TreeMap.access$200:()Ljava/lang/Object;
+java/util/TreeMap.access$300:(Ljava/util/TreeMap;)Ljava/util/Comparator;
+java/util/TreeMap.access$400:(Ljava/util/TreeMap;)I
+java/util/TreeMap.access$500:(Ljava/util/TreeMap;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.ceilingEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/TreeMap.ceilingKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap.clear:()V
+java/util/TreeMap.colorOf:(Ljava/util/TreeMap$Entry;)Z
+java/util/TreeMap.comparator:()Ljava/util/Comparator;
+java/util/TreeMap.compare:(Ljava/lang/Object;Ljava/lang/Object;)I
+java/util/TreeMap.computeRedLevel:(I)I
+java/util/TreeMap.containsKey:(Ljava/lang/Object;)Z
+java/util/TreeMap.containsValue:(Ljava/lang/Object;)Z
+java/util/TreeMap.deleteEntry:(Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap.descendingKeyIterator:()Ljava/util/Iterator;
+java/util/TreeMap.descendingKeySet:()Ljava/util/NavigableSet;
+java/util/TreeMap.descendingKeySpliterator:()Ljava/util/Spliterator;
+java/util/TreeMap.descendingMap:()Ljava/util/NavigableMap;
+java/util/TreeMap.entrySet:()Ljava/util/Set;
+java/util/TreeMap.exportEntry:(Ljava/util/TreeMap$Entry;)Ljava/util/Map$Entry;
+java/util/TreeMap.firstEntry:()Ljava/util/Map$Entry;
+java/util/TreeMap.firstKey:()Ljava/lang/Object;
+java/util/TreeMap.fixAfterDeletion:(Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap.fixAfterInsertion:(Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap.floorEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/TreeMap.floorKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap.getCeilingEntry:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.getEntry:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.getEntryUsingComparator:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.getFirstEntry:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap.getFloorEntry:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.getHigherEntry:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.getLastEntry:()Ljava/util/TreeMap$Entry;
+java/util/TreeMap.getLowerEntry:(Ljava/lang/Object;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.headMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/TreeMap.headMap:(Ljava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/TreeMap.higherEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/TreeMap.higherKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap.key:(Ljava/util/TreeMap$Entry;)Ljava/lang/Object;
+java/util/TreeMap.keyIterator:()Ljava/util/Iterator;
+java/util/TreeMap.keyOrNull:(Ljava/util/TreeMap$Entry;)Ljava/lang/Object;
+java/util/TreeMap.keySet:()Ljava/util/Set;
+java/util/TreeMap.keySpliterator:()Ljava/util/Spliterator;
+java/util/TreeMap.keySpliteratorFor:(Ljava/util/NavigableMap;)Ljava/util/Spliterator;
+java/util/TreeMap.lastEntry:()Ljava/util/Map$Entry;
+java/util/TreeMap.lastKey:()Ljava/lang/Object;
+java/util/TreeMap.leftOf:(Ljava/util/TreeMap$Entry;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.lowerEntry:(Ljava/lang/Object;)Ljava/util/Map$Entry;
+java/util/TreeMap.lowerKey:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap.navigableKeySet:()Ljava/util/NavigableSet;
+java/util/TreeMap.parentOf:(Ljava/util/TreeMap$Entry;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.pollFirstEntry:()Ljava/util/Map$Entry;
+java/util/TreeMap.pollLastEntry:()Ljava/util/Map$Entry;
+java/util/TreeMap.predecessor:(Ljava/util/TreeMap$Entry;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap.remove:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap.replace:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeMap.replace:(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/TreeMap.rightOf:(Ljava/util/TreeMap$Entry;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.rotateLeft:(Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap.rotateRight:(Ljava/util/TreeMap$Entry;)V
+java/util/TreeMap.setColor:(Ljava/util/TreeMap$Entry;Z)V
+java/util/TreeMap.size:()I
+java/util/TreeMap.subMap:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/TreeMap.subMap:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/TreeMap.successor:(Ljava/util/TreeMap$Entry;)Ljava/util/TreeMap$Entry;
+java/util/TreeMap.tailMap:(Ljava/lang/Object;)Ljava/util/SortedMap;
+java/util/TreeMap.tailMap:(Ljava/lang/Object;Z)Ljava/util/NavigableMap;
+java/util/TreeMap.valEquals:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/TreeMap.values:()Ljava/util/Collection;
+java/util/TreeSet.<clinit>:()V
+java/util/TreeSet.<init>:()V
+java/util/TreeSet.<init>:(Ljava/util/Comparator;)V
+java/util/TreeSet.<init>:(Ljava/util/NavigableMap;)V
+java/util/TreeSet.ceiling:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeSet.descendingIterator:()Ljava/util/Iterator;
+java/util/TreeSet.descendingSet:()Ljava/util/NavigableSet;
+java/util/TreeSet.floor:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeSet.headSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/TreeSet.headSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/TreeSet.higher:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeSet.iterator:()Ljava/util/Iterator;
+java/util/TreeSet.lower:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/TreeSet.pollFirst:()Ljava/lang/Object;
+java/util/TreeSet.pollLast:()Ljava/lang/Object;
+java/util/TreeSet.spliterator:()Ljava/util/Spliterator;
+java/util/TreeSet.subSet:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/TreeSet.subSet:(Ljava/lang/Object;ZLjava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/TreeSet.tailSet:(Ljava/lang/Object;)Ljava/util/SortedSet;
+java/util/TreeSet.tailSet:(Ljava/lang/Object;Z)Ljava/util/NavigableSet;
+java/util/Tripwire.<init>:()V
+java/util/UUID$Holder.<init>:()V
+java/util/UUID.<init>:(JJ)V
+java/util/UUID.clockSequence:()I
+java/util/UUID.compareTo:(Ljava/lang/Object;)I
+java/util/UUID.compareTo:(Ljava/util/UUID;)I
+java/util/UUID.digits:(JI)Ljava/lang/String;
+java/util/UUID.equals:(Ljava/lang/Object;)Z
+java/util/UUID.getLeastSignificantBits:()J
+java/util/UUID.getMostSignificantBits:()J
+java/util/UUID.hashCode:()I
+java/util/UUID.node:()J
+java/util/UUID.timestamp:()J
+java/util/UUID.toString:()Ljava/lang/String;
+java/util/UUID.variant:()I
+java/util/UUID.version:()I
+java/util/UnknownFormatConversionException.<init>:(Ljava/lang/String;)V
+java/util/UnknownFormatConversionException.getConversion:()Ljava/lang/String;
+java/util/UnknownFormatFlagsException.<init>:(Ljava/lang/String;)V
+java/util/UnknownFormatFlagsException.getFlags:()Ljava/lang/String;
+java/util/UnknownFormatFlagsException.getMessage:()Ljava/lang/String;
+java/util/Vector$1.<init>:(Ljava/util/Vector;)V
+java/util/Vector$1.hasMoreElements:()Z
+java/util/Vector$1.nextElement:()Ljava/lang/Object;
+java/util/Vector$Itr.<init>:(Ljava/util/Vector;)V
+java/util/Vector$Itr.<init>:(Ljava/util/Vector;Ljava/util/Vector$1;)V
+java/util/Vector$Itr.checkForComodification:()V
+java/util/Vector$Itr.hasNext:()Z
+java/util/Vector$Itr.next:()Ljava/lang/Object;
+java/util/Vector$Itr.remove:()V
+java/util/Vector$ListItr.<init>:(Ljava/util/Vector;I)V
+java/util/Vector$ListItr.hasPrevious:()Z
+java/util/Vector$ListItr.nextIndex:()I
+java/util/Vector$ListItr.previousIndex:()I
+java/util/Vector$VectorSpliterator.<init>:(Ljava/util/Vector;[Ljava/lang/Object;III)V
+java/util/Vector$VectorSpliterator.characteristics:()I
+java/util/Vector$VectorSpliterator.estimateSize:()J
+java/util/Vector$VectorSpliterator.getFence:()I
+java/util/Vector$VectorSpliterator.trySplit:()Ljava/util/Spliterator;
+java/util/Vector.<init>:()V
+java/util/Vector.<init>:(I)V
+java/util/Vector.<init>:(II)V
+java/util/Vector.<init>:(Ljava/util/Collection;)V
+java/util/Vector.add:(ILjava/lang/Object;)V
+java/util/Vector.add:(Ljava/lang/Object;)Z
+java/util/Vector.addAll:(ILjava/util/Collection;)Z
+java/util/Vector.addAll:(Ljava/util/Collection;)Z
+java/util/Vector.addElement:(Ljava/lang/Object;)V
+java/util/Vector.capacity:()I
+java/util/Vector.clear:()V
+java/util/Vector.contains:(Ljava/lang/Object;)Z
+java/util/Vector.copyInto:([Ljava/lang/Object;)V
+java/util/Vector.elementAt:(I)Ljava/lang/Object;
+java/util/Vector.elementData:(I)Ljava/lang/Object;
+java/util/Vector.elements:()Ljava/util/Enumeration;
+java/util/Vector.ensureCapacity:(I)V
+java/util/Vector.ensureCapacityHelper:(I)V
+java/util/Vector.firstElement:()Ljava/lang/Object;
+java/util/Vector.get:(I)Ljava/lang/Object;
+java/util/Vector.grow:(I)V
+java/util/Vector.hugeCapacity:(I)I
+java/util/Vector.indexOf:(Ljava/lang/Object;)I
+java/util/Vector.indexOf:(Ljava/lang/Object;I)I
+java/util/Vector.insertElementAt:(Ljava/lang/Object;I)V
+java/util/Vector.isEmpty:()Z
+java/util/Vector.iterator:()Ljava/util/Iterator;
+java/util/Vector.lastElement:()Ljava/lang/Object;
+java/util/Vector.lastIndexOf:(Ljava/lang/Object;)I
+java/util/Vector.lastIndexOf:(Ljava/lang/Object;I)I
+java/util/Vector.listIterator:()Ljava/util/ListIterator;
+java/util/Vector.listIterator:(I)Ljava/util/ListIterator;
+java/util/Vector.remove:(I)Ljava/lang/Object;
+java/util/Vector.remove:(Ljava/lang/Object;)Z
+java/util/Vector.removeAllElements:()V
+java/util/Vector.removeElement:(Ljava/lang/Object;)Z
+java/util/Vector.removeElementAt:(I)V
+java/util/Vector.removeRange:(II)V
+java/util/Vector.set:(ILjava/lang/Object;)Ljava/lang/Object;
+java/util/Vector.setElementAt:(Ljava/lang/Object;I)V
+java/util/Vector.setSize:(I)V
+java/util/Vector.size:()I
+java/util/Vector.sort:(Ljava/util/Comparator;)V
+java/util/Vector.spliterator:()Ljava/util/Spliterator;
+java/util/Vector.toArray:()[Ljava/lang/Object;
+java/util/Vector.toArray:([Ljava/lang/Object;)[Ljava/lang/Object;
+java/util/Vector.trimToSize:()V
+java/util/WeakHashMap$Entry.getValue:()Ljava/lang/Object;
+java/util/WeakHashMap$Entry.setValue:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/WeakHashMap$EntrySet.<init>:(Ljava/util/WeakHashMap;)V
+java/util/WeakHashMap$EntrySet.<init>:(Ljava/util/WeakHashMap;Ljava/util/WeakHashMap$1;)V
+java/util/WeakHashMap$EntrySet.spliterator:()Ljava/util/Spliterator;
+java/util/WeakHashMap$EntrySpliterator.<init>:(Ljava/util/WeakHashMap;IIII)V
+java/util/WeakHashMap$EntrySpliterator.characteristics:()I
+java/util/WeakHashMap$KeySet.<init>:(Ljava/util/WeakHashMap;)V
+java/util/WeakHashMap$KeySet.<init>:(Ljava/util/WeakHashMap;Ljava/util/WeakHashMap$1;)V
+java/util/WeakHashMap$KeySet.spliterator:()Ljava/util/Spliterator;
+java/util/WeakHashMap$KeySpliterator.<init>:(Ljava/util/WeakHashMap;IIII)V
+java/util/WeakHashMap$KeySpliterator.characteristics:()I
+java/util/WeakHashMap$ValueSpliterator.<init>:(Ljava/util/WeakHashMap;IIII)V
+java/util/WeakHashMap$ValueSpliterator.characteristics:()I
+java/util/WeakHashMap$Values.<init>:(Ljava/util/WeakHashMap;)V
+java/util/WeakHashMap$Values.<init>:(Ljava/util/WeakHashMap;Ljava/util/WeakHashMap$1;)V
+java/util/WeakHashMap$Values.spliterator:()Ljava/util/Spliterator;
+java/util/WeakHashMap$WeakHashMapSpliterator.<init>:(Ljava/util/WeakHashMap;IIII)V
+java/util/WeakHashMap.<clinit>:()V
+java/util/WeakHashMap.entrySet:()Ljava/util/Set;
+java/util/WeakHashMap.eq:(Ljava/lang/Object;Ljava/lang/Object;)Z
+java/util/WeakHashMap.indexFor:(II)I
+java/util/WeakHashMap.keySet:()Ljava/util/Set;
+java/util/WeakHashMap.maskNull:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/WeakHashMap.newTable:(I)[Ljava/util/WeakHashMap$Entry;
+java/util/WeakHashMap.unmaskNull:(Ljava/lang/Object;)Ljava/lang/Object;
+java/util/WeakHashMap.values:()Ljava/util/Collection;
\ No newline at end of file
diff --git a/experimental/sandbox/src/main/resources/logback.xml b/experimental/sandbox/src/main/resources/logback.xml
new file mode 100644
index 0000000000..cc95f6a9ef
--- /dev/null
+++ b/experimental/sandbox/src/main/resources/logback.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<configuration>
+
+    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>whitelistclassloader.log</file>
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <!-- daily rollover -->
+            <fileNamePattern>whitelistclassloader.%d{yyyy-MM-dd}.log</fileNamePattern>
+        </rollingPolicy>
+
+        <encoder>
+            <pattern>%date [%thread] %-5level %logger{35} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="DEBUG">
+        <appender-ref ref="FILE"/>
+    </root>
+
+</configuration>
diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/CandidateMethodTest.java b/experimental/sandbox/src/test/java/net/corda/sandbox/CandidateMethodTest.java
new file mode 100644
index 0000000000..0f63c67e9c
--- /dev/null
+++ b/experimental/sandbox/src/test/java/net/corda/sandbox/CandidateMethodTest.java
@@ -0,0 +1,39 @@
+package net.corda.sandbox;
+
+import net.corda.sandbox.CandidateMethod;
+import org.junit.Test;
+import org.slf4j.LoggerFactory;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Tests governing the CandidateMethod
+ */
+public class CandidateMethodTest {
+
+    private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(CandidateMethodTest.class);
+    private final static String OBJECT_INIT_METHOD = "java/lang/Object.<init>:()V";
+    private final static String SYSTEM_OUT_PRINTLN = "java/io/PrintStream.println:(Ljava/lang/String;)V";
+
+    private CandidateMethod candidateMethod;
+
+    @Test
+    public void given_NewCandidateMethod_when_GetState_then_StateIsUndetermined() {
+        candidateMethod = CandidateMethod.of(OBJECT_INIT_METHOD);
+        assertEquals(CandidateMethod.State.MENTIONED, candidateMethod.getCurrentState());
+    }
+
+    @Test
+    public void given_CandidateMethod_when_proven_then_StateIsDeterministic() {
+        candidateMethod = CandidateMethod.proven(OBJECT_INIT_METHOD);
+        assertEquals(CandidateMethod.State.DETERMINISTIC, candidateMethod.getCurrentState());
+    }
+
+    @Test
+    public void given_CandidateMethod_when_disallowed_then_StateIsDisallowed() {
+        candidateMethod = CandidateMethod.of(SYSTEM_OUT_PRINTLN);
+        candidateMethod.disallowed("dummy");
+        assertEquals(CandidateMethod.State.DISALLOWED, candidateMethod.getCurrentState());
+    }
+
+}
diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/Constants.java b/experimental/sandbox/src/test/java/net/corda/sandbox/Constants.java
new file mode 100644
index 0000000000..9c2ae06b4e
--- /dev/null
+++ b/experimental/sandbox/src/test/java/net/corda/sandbox/Constants.java
@@ -0,0 +1,11 @@
+package net.corda.sandbox;
+
+class Constants {
+    public final static String INVALID_CLASS = "foobar";
+    public final static String BASE_DETERMINISTIC_METHODS = "resource/CallObjectMethods";
+    public final static String SYSTEM_OUT_PRINTLN_CLASS = "resource/CallPrintln";
+    public final static String INVOKEDYNAMIC_METHOD_CLASS = "resource/UseLambdaToForceInvokeDynamic";
+    public final static String NATIVE_METHOD_CLASS = "resource/CallNative";
+    public final static String BASIC_COLLECTIONS_CLASS = "resource/UseBasicCollections";
+    public final static String FINALIZER_CLASS = "resource/UseFinalizer";
+}
diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/TestUtils.java b/experimental/sandbox/src/test/java/net/corda/sandbox/TestUtils.java
new file mode 100644
index 0000000000..f3684d094f
--- /dev/null
+++ b/experimental/sandbox/src/test/java/net/corda/sandbox/TestUtils.java
@@ -0,0 +1,146 @@
+package net.corda.sandbox;
+
+import net.corda.sandbox.costing.*;
+import org.junit.*;
+
+import javax.xml.bind.*;
+import java.io.*;
+import java.nio.file.FileSystem;
+import java.nio.file.*;
+import java.nio.file.attribute.*;
+import java.util.*;
+
+import static org.junit.Assert.*;
+
+public class TestUtils {
+
+    private static Path jarFSDir = null;
+    private static Path tmpdir;
+
+    public static void setPathToTmpJar(final String resourcePathToJar) throws IOException {
+        // Copy resource jar to tmp dir
+        tmpdir = Files.createTempDirectory(Paths.get("/tmp"), "wlcl-tmp-test");
+        final InputStream in = TestUtils.class.getResourceAsStream(resourcePathToJar);
+        Path copiedJar = tmpdir.resolve("tmp-resource.jar");
+        Files.copy(in, copiedJar, StandardCopyOption.REPLACE_EXISTING);
+
+        final FileSystem fs = FileSystems.newFileSystem(copiedJar, null);
+        jarFSDir = fs.getRootDirectories().iterator().next();
+    }
+
+    public static Path copySandboxJarToTmpDir(final String resourcePathToJar) throws IOException {
+        final InputStream in = TestUtils.class.getResourceAsStream(resourcePathToJar);
+        Path sandboxJar = tmpdir.resolve("tmp-sandbox.jar");
+        Files.copy(in, sandboxJar, StandardCopyOption.REPLACE_EXISTING);
+        final FileSystem sandboxFs = FileSystems.newFileSystem(sandboxJar, null);
+        
+        return sandboxFs.getRootDirectories().iterator().next();
+    }
+    
+    public static Path getJarFSRoot() {
+        return jarFSDir;
+    }
+
+    public static void cleanupTmpJar() throws IOException {
+        Files.walkFileTree(tmpdir, new Reaper());
+    }
+
+    public static void checkAllCosts(final int allocCost, final int jumpCost, final int invokeCost, final int throwCost) {
+        Assert.assertEquals(allocCost, RuntimeCostAccounter.getAllocationCost());
+        assertEquals(jumpCost, RuntimeCostAccounter.getJumpCost());
+        assertEquals(invokeCost, RuntimeCostAccounter.getInvokeCost());
+        assertEquals(throwCost, RuntimeCostAccounter.getThrowCost());
+    }
+
+    public static Class<?> transformClass(final String classFName, final int originalLength, final int newLength) throws IOException, Exception {
+        byte[] basic = getBytes(classFName);
+        assertEquals(originalLength, basic.length);
+        final byte[] tfmd = instrumentWithCosts(basic, new HashSet<>());
+        final Path testdir = Files.createTempDirectory(Paths.get("/tmp"), "greymalkin-test-");
+        final Path out = testdir.resolve(classFName);
+        Files.createDirectories(out.getParent());
+        Files.write(out, tfmd);
+        if (newLength > 0) {
+            assertEquals(newLength, tfmd.length);
+        }
+        final MyClassloader mycl = new MyClassloader();
+        final Class<?> clz = mycl.byPath(out);
+
+        Files.walkFileTree(testdir, new Reaper());
+
+        return clz;
+    }
+
+    public static Class<?> transformClass(final String resourceMethodAccessIsRewrittenclass, int i) throws Exception {
+        return transformClass(resourceMethodAccessIsRewrittenclass, i, -1);
+    }
+
+    public static byte[] getBytes(final String original) throws IOException {
+        return Files.readAllBytes(jarFSDir.resolve(original));
+    }
+
+    // Helper for finding the correct offsets if they change
+    public static void printBytes(byte[] data) {
+        byte[] datum = new byte[1];
+        for (int i=0; i < data.length; i++) {
+            datum[0] = data[i];
+            System.out.println(i +" : "+ DatatypeConverter.printHexBinary(datum));
+        }
+    }
+
+    public static int findOffset(byte[] classBytes, byte[] originalSeq) {
+        int offset = 0;
+        for (int i=415; i < classBytes.length; i++) {
+            if (classBytes[i] != originalSeq[offset]) {
+                offset = 0;
+                continue;
+            }
+            if (offset == originalSeq.length - 1) {
+                return i - offset;
+            }
+            offset++;
+        }
+        
+        return -1;
+    }
+
+    public static byte[] instrumentWithCosts(byte[] basic, Set<String> hashSet) throws Exception {
+        final WhitelistClassLoader wlcl = WhitelistClassLoader.of("/tmp");
+        return wlcl.instrumentWithCosts(basic, hashSet);
+    }
+
+    
+    public static final class MyClassloader extends ClassLoader {
+
+        public Class<?> byPath(Path p) throws IOException {
+            final byte[] buffy = Files.readAllBytes(p);
+            return defineClass(null, buffy, 0, buffy.length);
+        }
+    }
+
+    public static final class Reaper extends SimpleFileVisitor<Path> {
+
+        @Override
+        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
+                throws IOException {
+            Files.delete(file);
+            return FileVisitResult.CONTINUE;
+        }
+
+        @Override
+        public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
+            Files.delete(file);
+            return FileVisitResult.CONTINUE;
+        }
+
+        @Override
+        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+            if (exc == null) {
+                Files.delete(dir);
+                return FileVisitResult.CONTINUE;
+            } else {
+                throw exc;
+            }
+        }
+    }
+}
diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/WhitelistClassLoaderTest.java b/experimental/sandbox/src/test/java/net/corda/sandbox/WhitelistClassLoaderTest.java
new file mode 100644
index 0000000000..3c427527c6
--- /dev/null
+++ b/experimental/sandbox/src/test/java/net/corda/sandbox/WhitelistClassLoaderTest.java
@@ -0,0 +1,158 @@
+package net.corda.sandbox;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.*;
+
+public class WhitelistClassLoaderTest {
+
+    private static WhitelistClassLoader wlcl;
+
+    @BeforeClass
+    public static void setup() throws Exception {
+        TestUtils.setPathToTmpJar("/resource.jar");
+    }
+
+    @Before
+    public void setupIndividualTest() throws Exception {
+        wlcl = WhitelistClassLoader.of(TestUtils.getJarFSRoot());
+    }
+
+    @AfterClass
+    public static void shutdown() throws Exception {
+        TestUtils.cleanupTmpJar();
+    }
+
+    @Test
+    public void given_ValidBasicMethods_then_ClassCanBeLoaded() throws Exception {
+        Class<?> clz = wlcl.loadClass("resource.CallObjectMethods");
+        assertNotNull("Loaded class appears to be null", clz);
+    }
+
+    @Test(expected = ClassNotFoundException.class)
+    public void given_ValidIOMethod_then_ClassCannotBeLoaded() throws Exception {
+        Class<?> clz = wlcl.loadClass("resource.CallPrintln");
+
+        fail("Class should not load");
+    }
+
+    @Test(expected = ClassNotFoundException.class)
+    public void given_InvokeDynamic_then_ClassCannotBeLoaded() throws Exception {
+        Class<?> clz = wlcl.loadClass("resource.UseLambdaToForceInvokeDynamic");
+        fail("Class should not load");
+    }
+
+    @Test
+    public void given_BasicCollections_then_ClassCanBeLoaded() throws Exception {
+        wlcl.addJarToSandbox(TestUtils.copySandboxJarToTmpDir("/sandbox.jar"));
+        final Class<?> clz = wlcl.loadClass("resource.UseBasicCollections");
+
+        assertNotNull("Loaded class appears to be null", clz);
+    }
+
+    @Test
+    public void given_SimpleLinkedClasses_then_ClassCanBeLoaded() throws Exception {
+        Class<?> clz = wlcl.loadClass("resource.ARefersToB");
+        assertNotNull("Loaded class appears to be null", clz);
+    }
+
+    @Test
+    public void given_DeeplyTransitivelyLinkedClasses_then_ClassCanBeLoaded() throws Exception {
+        Class<?> clz = wlcl.loadClass("transitive.Chain4701");
+        assertNotNull("Loaded class appears to be null", clz);
+        final Object o = clz.newInstance();
+        assertNotNull("Created object appears to be null", o);
+    }
+
+    @Test(expected = ClassNotFoundException.class)
+    public void given_OverlyDeeplyTransitivelyLinkedClasses_then_ClassCanBeLoaded() throws Exception {
+        Class<?> clz = wlcl.loadClass("transitive.Chain4498");
+        fail("Class should not have loaded, but it did");
+    }
+
+    @Test
+    @Ignore
+    public void foo_tesst() throws Exception {
+        Class<?> clz = null;
+        try {
+            clz = wlcl.loadClass("transitive.Chain4498");
+        } catch (final Throwable e) {
+        }
+        System.out.println("Handled first OK");
+        assertNull(clz);
+
+        // RESET
+        setupIndividualTest();
+//        clz = wlcl.loadClass("transitive.Chain4501");
+        clz = wlcl.loadClass("transitive.Chain4601");
+        assertNotNull("Loaded class appears to be null", clz);
+        final Object o = clz.newInstance();
+        assertNotNull("Created object appears to be null", o);
+    }
+
+    @Test
+    public void given_SimpleCyclicClasses_then_ClassCanBeLoaded() throws Exception {
+        Class<?> clz = wlcl.loadClass("resource.ARefersToBCyclic");
+        assertNotNull("Loaded class appears to be null", clz);
+        final Object o = clz.newInstance();
+        assertTrue("New object should be a Runnable", o instanceof Runnable);
+        Runnable r = (Runnable) o;
+        r.run();
+        assertTrue("Execution of run failed", true);
+    }
+
+    @Test
+    public void given_MultipleTransformedClasses_then_ClassCanBeLoaded() throws Exception {
+        final Class<?> clz = wlcl.loadClass("resource.ObjectArrayAlloc");
+        assertNotNull("ObjectArrayAlloc class could not be transformed and loaded", clz);
+        final Object o = clz.newInstance();
+        final Method allocObj = clz.getMethod("addEntry");
+        final Object ret = allocObj.invoke(o);
+        assertTrue(ret instanceof String);
+        final String s = (String) ret;
+        assertEquals("324Foo", s);
+    }
+
+    @Test
+    public void test_test_exceptions() throws Exception {
+        final Class<?> clz = wlcl.loadClass("resource.ThrowExceptions");
+        assertNotNull("ThrowExceptions class could not be transformed and loaded", clz);
+    }
+  
+    
+    // TODO Test cases that terminate when other resource limits are broken
+    @Test
+    public void when_too_much_memory_is_allocated_then_thread_dies() throws Exception {
+        final Class<?> clz = wlcl.loadClass("resource.LargeByteArrayAlloc");
+        final AtomicBoolean executed = new AtomicBoolean(false);
+
+        Runnable r = () -> {
+            try {
+                final Object o = clz.newInstance();
+                final Method allocObj = clz.getMethod("addEntry");
+                final Object ret = allocObj.invoke(o);
+            } catch (InvocationTargetException invx) {
+                return;
+            } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | SecurityException | IllegalArgumentException ex) {
+            }
+            executed.set(true);
+            while (true) {
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException ex) {
+                    return;
+                }
+            }
+        };
+
+        Thread t = new Thread(r);
+        t.start();
+        t.join();
+        // Belt and braces - did the thread die before it could flip the AtomicBoolean
+        assertFalse("Executed condition should be false", executed.get());
+    }
+
+}
diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/costing/DeterministicClassInstrumenterTest.java b/experimental/sandbox/src/test/java/net/corda/sandbox/costing/DeterministicClassInstrumenterTest.java
new file mode 100644
index 0000000000..c276907870
--- /dev/null
+++ b/experimental/sandbox/src/test/java/net/corda/sandbox/costing/DeterministicClassInstrumenterTest.java
@@ -0,0 +1,75 @@
+package net.corda.sandbox.costing;
+
+import net.corda.sandbox.*;
+import org.junit.*;
+
+import java.io.*;
+import java.lang.reflect.*;
+import java.net.*;
+import java.util.*;
+
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author ben
+ */
+public class DeterministicClassInstrumenterTest {
+
+    @BeforeClass
+    public static void setup_resource_jar() throws IOException, URISyntaxException {
+        TestUtils.setPathToTmpJar("/resource.jar");
+    }
+
+    @AfterClass
+    public static void kill_resource_jar() throws IOException {
+        TestUtils.cleanupTmpJar();
+    }
+
+    @Test
+    public void when_given_simple_code_it_executes() throws Exception {
+        final Class<?> clz = TestUtils.transformClass("resource/CallObjectMethods.class", 525, 731);
+        final Object o = clz.newInstance();
+        final Method allocObj = clz.getMethod("callBasicMethodsOnObject");
+        final Object ret = allocObj.invoke(o);
+        assertTrue(ret instanceof Boolean);
+        final Boolean s = (Boolean) ret;
+        assertTrue(s);
+
+    }
+
+    @Test
+    public void when_monitors_are_present_then_they_are_removed() throws Exception {
+        Class<?> clz = TestUtils.transformClass("resource/SynchronizedBlock.class", 522, 720);
+        Object o = clz.newInstance();
+        Method allocObj = clz.getMethod("exampleBlockSynchronized");
+        Object ret = allocObj.invoke(o);
+        assertEquals("Synched", ret);
+
+        clz = TestUtils.transformClass("resource/SynchronizedMethod.class", 420, 593);
+        o = clz.newInstance();
+        allocObj = clz.getMethod("exampleSynchronized");
+        ret = allocObj.invoke(o);
+        assertEquals("SynchedMethod", ret);
+    }
+
+    @Test
+    public void when_monitors_are_present_then_byte_stream_is_altered() throws Exception {
+        // Do an actual byte check
+        byte[] basic = TestUtils.getBytes("resource/SynchronizedBlock.class");
+        final byte[] tfmd = TestUtils.instrumentWithCosts(basic, new HashSet<>());
+
+        // -62 is really 0xc2 but signed bytes in Java :(
+        final byte[] originalSeq = {0x2a, 0x59, 0x4c, -62, 0x12, 0x02, 0x2b, -61};
+        final byte[] tfmdSeq = {0x2a, 0x59, 0x4c, 0x57, 0x12, 0x02, 0x2b, 0x57};
+
+//        TestUtils.printBytes(basic);
+        final int origOffset = TestUtils.findOffset(basic, originalSeq);
+        final int tmfdOffset = TestUtils.findOffset(tfmd, tfmdSeq);
+        
+        for (int i = 0; i < originalSeq.length; i++) {
+            assertEquals(originalSeq[i], basic[origOffset + i]);
+            assertEquals(tfmdSeq[i], tfmd[tmfdOffset + i]);
+        }
+    }
+}
diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/costing/SandboxedRewritingTest.java b/experimental/sandbox/src/test/java/net/corda/sandbox/costing/SandboxedRewritingTest.java
new file mode 100644
index 0000000000..15bd7dafe2
--- /dev/null
+++ b/experimental/sandbox/src/test/java/net/corda/sandbox/costing/SandboxedRewritingTest.java
@@ -0,0 +1,121 @@
+package net.corda.sandbox.costing;
+
+import net.corda.sandbox.TestUtils;
+import static net.corda.sandbox.TestUtils.*;
+import net.corda.sandbox.Utils;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.net.URISyntaxException;
+import org.junit.AfterClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.BeforeClass;
+
+/**
+ *
+ * @author ben
+ */
+public class SandboxedRewritingTest {
+
+    @Before
+    public void setup() {
+        RuntimeCostAccounter.resetCounters();
+    }
+
+    @BeforeClass
+    public static void setup_resource_jar() throws IOException, URISyntaxException {
+        TestUtils.setPathToTmpJar("/resource.jar");
+    }
+
+    @AfterClass
+    public static void kill_resource_jar() throws IOException {
+        TestUtils.cleanupTmpJar();
+    }
+
+    @Test
+    public void testRewriting() {
+        String rewritten = Utils.sandboxInternalTypeName("java/lang/Object");
+        assertEquals("Expected Object::equals to be unchanged, but it was: " + rewritten, "java/lang/Object", rewritten);
+        rewritten = Utils.sandboxInternalTypeName("java/util/ArrayList");
+        assertEquals("Expected ArrayList::new to be sandboxed, but it was: " + rewritten, "sandbox/java/util/ArrayList", rewritten);
+        rewritten = Utils.sandboxInternalTypeName("sandbox/java/util/ArrayList");
+        assertEquals("Expected sandboxed ArrayList::new to be left unchanged, but it was: " + rewritten, "sandbox/java/util/ArrayList", rewritten);
+    }
+
+    @Test
+    public void when_desc_is_provided_it_is_correctly_rewritten() {
+        final String voidSig = "()V";
+        final String rwVoidSig = Utils.rewriteDescInternal(voidSig);
+        assertEquals("Expected " + voidSig + " to be unchanged, but it was: " + rwVoidSig, rwVoidSig, voidSig);
+
+        final String primSig = "(IIJ)Z";
+        final String rwPrimSig = Utils.rewriteDescInternal(primSig);
+        assertEquals("Expected " + primSig + " to be unchanged, but it was: " + rwPrimSig, rwPrimSig, primSig);
+
+        final String toStringSig = "()Ljava/lang/String;";
+        final String rwToStringSig = Utils.rewriteDescInternal(toStringSig);
+        assertEquals("Expected " + toStringSig + " to be unchanged, but it was: " + rwToStringSig, rwToStringSig, toStringSig);
+
+        final String listGetterSig = "()Ljava/util/ArrayList;";
+        final String exListGetterSig = "()Lsandbox/java/util/ArrayList;";
+        final String rwListGetterSig = Utils.rewriteDescInternal(listGetterSig);
+        assertEquals("Expected " + listGetterSig + " to be " + exListGetterSig + ", but it was: " + rwListGetterSig, exListGetterSig, rwListGetterSig);
+
+        final String sandboxListGetterSig = "()Lsandbox/java/util/ArrayList;";
+        final String rwSandboxListGetterSig = Utils.rewriteDescInternal(sandboxListGetterSig);
+        assertEquals("Expected " + sandboxListGetterSig + " to be unchanged, but it was: " + rwSandboxListGetterSig, sandboxListGetterSig, rwSandboxListGetterSig);
+
+        final String twoSig = "(Ljava/util/HashMap;)Ljava/util/Set;";
+        final String exTwoSig = "(Lsandbox/java/util/HashMap;)Lsandbox/java/util/Set;";
+        final String rwTwoSig = Utils.rewriteDescInternal(twoSig);
+        assertEquals("Expected " + twoSig + " to be " + exTwoSig + ", but it was: " + rwTwoSig, exTwoSig, rwTwoSig);
+
+        final String arrSig = "(Ljava/util/HashMap;)[Ljava/util/Set;";
+        final String exArrSig = "(Lsandbox/java/util/HashMap;)[Lsandbox/java/util/Set;";
+        final String rwArrSig = Utils.rewriteDescInternal(arrSig);
+        assertEquals("Expected " + arrSig + " to be " + exArrSig + ", but it was: " + rwArrSig, exArrSig, rwArrSig);
+
+        final String compArrSig = "([[IJLjava/util/HashMap;)[[Ljava/util/Set;";
+        final String exCompArrSig = "([[IJLsandbox/java/util/HashMap;)[[Lsandbox/java/util/Set;";
+        final String rwCompArrSig = Utils.rewriteDescInternal(compArrSig);
+        assertEquals("Expected " + compArrSig + " to be " + exCompArrSig + ", but it was: " + rwCompArrSig, exCompArrSig, rwCompArrSig);
+    }
+
+    @Test
+    public void actually_rewrite_a_method_access_and_check_it_works_as_expected() throws Exception {
+        final Class<?> clz = transformClass("resource/MethodAccessIsRewritten.class", 412);
+        final String className = clz.getName();
+        assertEquals("Incorrect rewritten class name: ", "sandbox.resource.MethodAccessIsRewritten", className);
+        final Object o = clz.newInstance();
+        final Method m = clz.getMethod("makeObject");
+        final Object ret = m.invoke(o);
+        assertTrue(Object.class == ret.getClass());
+        checkAllCosts(1, 0, 2, 0);
+    }
+
+    @Test
+    public void actually_rewrite_calls_to_object_methods() throws Exception {
+        final Class<?> clz = transformClass("resource/CallObjectMethods.class", 525);
+        final String className = clz.getName();
+        assertEquals("Incorrect rewritten class name: ", "sandbox.resource.CallObjectMethods", className);
+        final Object o = clz.newInstance();
+        final Method m = clz.getMethod("callBasicMethodsOnObject");
+        final Object ret = m.invoke(o);
+        assertTrue(Boolean.class == ret.getClass());
+        assertTrue((Boolean) ret);
+        checkAllCosts(0, 2, 3, 0);
+    }
+
+    @Test
+    public void check_primitive_array_allocation() throws Exception {
+        final Class<?> clz = transformClass("resource/SimpleArrayAlloc.class", 727);
+        final String className = clz.getName();
+        assertEquals("Incorrect rewritten class name: ", "sandbox.resource.SimpleArrayAlloc", className);
+        final Method m = clz.getMethod("allocPrimitiveArrays");
+        final Object ret = m.invoke(null);
+        assertNull(ret);
+        checkAllCosts(778, 1, 0, 0);
+    }
+
+}
diff --git a/experimental/sandbox/src/test/java/sandbox/greymalkin/StringReturner.java b/experimental/sandbox/src/test/java/sandbox/greymalkin/StringReturner.java
new file mode 100644
index 0000000000..e0aee3b576
--- /dev/null
+++ b/experimental/sandbox/src/test/java/sandbox/greymalkin/StringReturner.java
@@ -0,0 +1,11 @@
+package sandbox.greymalkin;
+
+/**
+ *
+ * @author ben
+ */
+// Simple hack for now, generalise to lambdas later...
+public interface StringReturner {
+
+    String addEntry();
+}
diff --git a/experimental/sandbox/src/test/resources/java/lang/Exception.class b/experimental/sandbox/src/test/resources/java/lang/Exception.class
new file mode 100644
index 0000000000..8b94ceab66
Binary files /dev/null and b/experimental/sandbox/src/test/resources/java/lang/Exception.class differ
diff --git a/experimental/sandbox/src/test/resources/java/lang/Throwable.class b/experimental/sandbox/src/test/resources/java/lang/Throwable.class
new file mode 100644
index 0000000000..1dc06ac1bf
Binary files /dev/null and b/experimental/sandbox/src/test/resources/java/lang/Throwable.class differ
diff --git a/experimental/sandbox/src/test/resources/java/lang/reflect/Array.class b/experimental/sandbox/src/test/resources/java/lang/reflect/Array.class
new file mode 100644
index 0000000000..cc3bb2c04e
Binary files /dev/null and b/experimental/sandbox/src/test/resources/java/lang/reflect/Array.class differ
diff --git a/experimental/sandbox/src/test/resources/java/util/ArrayList.class b/experimental/sandbox/src/test/resources/java/util/ArrayList.class
new file mode 100644
index 0000000000..d5cb2f68ab
Binary files /dev/null and b/experimental/sandbox/src/test/resources/java/util/ArrayList.class differ
diff --git a/experimental/sandbox/src/test/resources/java/util/Arrays.class b/experimental/sandbox/src/test/resources/java/util/Arrays.class
new file mode 100644
index 0000000000..db37dfa016
Binary files /dev/null and b/experimental/sandbox/src/test/resources/java/util/Arrays.class differ
diff --git a/experimental/sandbox/src/test/resources/logback-test.xml b/experimental/sandbox/src/test/resources/logback-test.xml
new file mode 100644
index 0000000000..b1cff282fb
--- /dev/null
+++ b/experimental/sandbox/src/test/resources/logback-test.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<configuration>
+
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <charset>UTF-8</charset>
+            <Pattern>%d %-4relative [%thread] %-5level %logger{35} - %msg%n</Pattern>
+        </encoder>
+    </appender>
+
+    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>whitelistclassloader-test.log</file>
+        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+            <!-- daily rollover -->
+            <fileNamePattern>whitelistclassloader-test.%d{yyyy-MM-dd}.log</fileNamePattern>
+        </rollingPolicy>
+
+        <encoder>
+            <pattern>%date [%thread] %-5level %logger{35} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="CONSOLE"/>
+        <appender-ref ref="FILE"/>
+    </root>
+
+</configuration>
diff --git a/experimental/sandbox/src/test/resources/resource.jar b/experimental/sandbox/src/test/resources/resource.jar
new file mode 100644
index 0000000000..f8e81ad535
Binary files /dev/null and b/experimental/sandbox/src/test/resources/resource.jar differ
diff --git a/experimental/sandbox/src/test/resources/sandbox.jar b/experimental/sandbox/src/test/resources/sandbox.jar
new file mode 100644
index 0000000000..500bfb42b2
Binary files /dev/null and b/experimental/sandbox/src/test/resources/sandbox.jar differ
diff --git a/settings.gradle b/settings.gradle
index 63b9bcbe18..89b4247424 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -7,6 +7,7 @@ include 'core'
 include 'node'
 include 'client'
 include 'experimental'
+include 'experimental:sandbox'
 include 'test-utils'
 include 'tools:explorer'
 include 'tools:loadtest'