diff --git a/.idea/compiler.xml b/.idea/compiler.xml index 8fd9ac3695..ef69357c69 100644 --- a/.idea/compiler.xml +++ b/.idea/compiler.xml @@ -49,6 +49,8 @@ + + @@ -113,6 +115,8 @@ + + @@ -322,4 +326,4 @@ - \ No newline at end of file + diff --git a/build.gradle b/build.gradle index 263aba1889..405c55f958 100644 --- a/build.gradle +++ b/build.gradle @@ -86,7 +86,7 @@ buildscript { ext.snappy_version = '0.4' ext.fast_classpath_scanner_version = '2.12.3' ext.jcabi_manifests_version = '1.1' - ext.picocli_version = '3.3.0' + ext.picocli_version = '3.5.2' // Name of the IntelliJ SDK created for the deterministic Java rt.jar. // ext.deterministic_idea_sdk = '1.8 (Deterministic)' @@ -187,7 +187,7 @@ allprojects { jvmTarget = "1.8" javaParameters = true // Useful for reflection. freeCompilerArgs = ['-Xjvm-default=compatibility'] - allWarningsAsErrors = project.hasProperty('compilation.allWarningsAsErrors') ? project.property('compilation.allWarningsAsErrors').toBoolean() : true + allWarningsAsErrors = project.hasProperty('compilation.allWarningsAsErrors') ? project.property('compilation.allWarningsAsErrors').toBoolean() : false } } @@ -203,7 +203,7 @@ allprojects { } tasks.withType(Test) { - failFast = project.hasProperty('tests.failFast') ? project.property('tests.failFast').toBoolean() : true + failFast = project.hasProperty('tests.failFast') ? project.property('tests.failFast').toBoolean() : false // Prevent the project from creating temporary files outside of the build directory. systemProperty 'java.io.tmpdir', buildDir.absolutePath diff --git a/config/dev/log4j2.xml b/config/dev/log4j2.xml index e9ab55aa5e..105898c03c 100644 --- a/config/dev/log4j2.xml +++ b/config/dev/log4j2.xml @@ -43,7 +43,7 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/djvm/src/test/kotlin/foo/bar/sandbox/A.kt b/djvm/src/test/kotlin/foo/bar/sandbox/A.kt new file mode 100644 index 0000000000..9ef5599041 --- /dev/null +++ b/djvm/src/test/kotlin/foo/bar/sandbox/A.kt @@ -0,0 +1,9 @@ +package foo.bar.sandbox + +class A : Callable { + override fun call() { + synchronized(this) { + return + } + } +} diff --git a/djvm/src/test/kotlin/foo/bar/sandbox/B.kt b/djvm/src/test/kotlin/foo/bar/sandbox/B.kt new file mode 100644 index 0000000000..b0bb7c2b32 --- /dev/null +++ b/djvm/src/test/kotlin/foo/bar/sandbox/B.kt @@ -0,0 +1,10 @@ +package foo.bar.sandbox + +class B : Callable { + override fun call() { + var x = 0 + for (i in 1..30) { + x += 1 + } + } +} diff --git a/djvm/src/test/kotlin/foo/bar/sandbox/C.kt b/djvm/src/test/kotlin/foo/bar/sandbox/C.kt new file mode 100644 index 0000000000..5e11a4e158 --- /dev/null +++ b/djvm/src/test/kotlin/foo/bar/sandbox/C.kt @@ -0,0 +1,11 @@ +package foo.bar.sandbox + +import org.assertj.core.api.Assertions.assertThat + +class C : Callable { + override fun call() { + val obj = MyObject() + assertThat(obj.hashCode()).isEqualTo(0) + } +} + diff --git a/djvm/src/test/kotlin/foo/bar/sandbox/Callable.kt b/djvm/src/test/kotlin/foo/bar/sandbox/Callable.kt new file mode 100644 index 0000000000..e92f2ba5ac --- /dev/null +++ b/djvm/src/test/kotlin/foo/bar/sandbox/Callable.kt @@ -0,0 +1,13 @@ +package foo.bar.sandbox + +/** + * Interface used for implementing test classes. + */ +interface Callable { + + /** + * Entry point. + */ + fun call() + +} diff --git a/djvm/src/test/kotlin/foo/bar/sandbox/Empty.kt b/djvm/src/test/kotlin/foo/bar/sandbox/Empty.kt new file mode 100644 index 0000000000..d6ff37a8e4 --- /dev/null +++ b/djvm/src/test/kotlin/foo/bar/sandbox/Empty.kt @@ -0,0 +1,5 @@ +package foo.bar.sandbox + +class Empty : Callable { + override fun call() {} +} diff --git a/djvm/src/test/kotlin/foo/bar/sandbox/KotlinClass.kt b/djvm/src/test/kotlin/foo/bar/sandbox/KotlinClass.kt new file mode 100644 index 0000000000..44ea7e29f7 --- /dev/null +++ b/djvm/src/test/kotlin/foo/bar/sandbox/KotlinClass.kt @@ -0,0 +1,12 @@ +package foo.bar.sandbox + +import java.util.* + +fun testRandom(): Int { + val random = Random() + return random.nextInt() +} + +fun String.toNumber(): Int { + return this.toInt() +} diff --git a/djvm/src/test/kotlin/foo/bar/sandbox/MyObject.kt b/djvm/src/test/kotlin/foo/bar/sandbox/MyObject.kt new file mode 100644 index 0000000000..2d08d11d37 --- /dev/null +++ b/djvm/src/test/kotlin/foo/bar/sandbox/MyObject.kt @@ -0,0 +1,3 @@ +package foo.bar.sandbox + +class MyObject diff --git a/djvm/src/test/kotlin/foo/bar/sandbox/StrictFloat.kt b/djvm/src/test/kotlin/foo/bar/sandbox/StrictFloat.kt new file mode 100644 index 0000000000..0d30565a98 --- /dev/null +++ b/djvm/src/test/kotlin/foo/bar/sandbox/StrictFloat.kt @@ -0,0 +1,10 @@ +package foo.bar.sandbox + +class StrictFloat : Callable { + override fun call() { + val d = java.lang.Double.MIN_VALUE + val x = d / 2 * 2 + assert(x.toString() == "0.0") + } +} + diff --git a/djvm/src/test/kotlin/net/corda/djvm/TestBase.kt b/djvm/src/test/kotlin/net/corda/djvm/TestBase.kt new file mode 100644 index 0000000000..333516c06a --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/TestBase.kt @@ -0,0 +1,169 @@ +package net.corda.djvm + +import foo.bar.sandbox.Callable +import net.corda.djvm.analysis.AnalysisConfiguration +import net.corda.djvm.analysis.AnalysisContext +import net.corda.djvm.analysis.ClassAndMemberVisitor +import net.corda.djvm.analysis.Whitelist +import net.corda.djvm.assertions.AssertionExtensions.assertThat +import net.corda.djvm.code.DefinitionProvider +import net.corda.djvm.code.Emitter +import net.corda.djvm.execution.ExecutionProfile +import net.corda.djvm.messages.Severity +import net.corda.djvm.references.ClassHierarchy +import net.corda.djvm.rewiring.LoadedClass +import net.corda.djvm.rules.Rule +import net.corda.djvm.source.ClassSource +import net.corda.djvm.utilities.Discovery +import net.corda.djvm.validation.RuleValidator +import org.objectweb.asm.ClassReader +import org.objectweb.asm.ClassVisitor +import java.lang.reflect.InvocationTargetException + +open class TestBase { + + companion object { + + val ALL_RULES = Discovery.find() + + val ALL_EMITTERS = Discovery.find() + + val ALL_DEFINITION_PROVIDERS = Discovery.find() + + val BLANK = emptySet() + + val DEFAULT = (ALL_RULES + ALL_EMITTERS + ALL_DEFINITION_PROVIDERS) + .toSet().distinctBy { it.javaClass } + + /** + * Get the full name of type [T]. + */ + inline fun nameOf(prefix: String = "") = + "$prefix${T::class.java.name.replace('.', '/')}" + + } + + /** + * Default analysis configuration. + */ + val configuration = AnalysisConfiguration(Whitelist.MINIMAL) + + /** + * Default analysis context + */ + val context: AnalysisContext + get() = AnalysisContext.fromConfiguration(configuration, emptyList()) + + /** + * Short-hand for analysing and validating a class. + */ + inline fun validate( + minimumSeverityLevel: Severity = Severity.INFORMATIONAL, + noinline block: (RuleValidator.(AnalysisContext) -> Unit) + ) { + val reader = ClassReader(T::class.java.name) + val configuration = AnalysisConfiguration(minimumSeverityLevel = minimumSeverityLevel) + val validator = RuleValidator(ALL_RULES, configuration) + val context = AnalysisContext.fromConfiguration( + configuration, + listOf(ClassSource.fromClassName(reader.className)) + ) + validator.analyze(reader, context) + block(validator, context) + } + + /** + * Short-hand for analysing a class. + */ + inline fun analyze(block: (ClassAndMemberVisitor.(AnalysisContext) -> Unit)) { + val validator = RuleValidator(emptyList(), configuration) + block(validator, context) + } + + /** + * Run action on a separate thread to ensure that the code is run off a clean slate. The sandbox context is local to + * the current thread, so this allows inspection of the cost summary object, etc. from within the provided delegate. + */ + fun sandbox( + vararg options: Any, + pinnedClasses: Set> = emptySet(), + minimumSeverityLevel: Severity = Severity.WARNING, + enableTracing: Boolean = true, + action: SandboxRuntimeContext.() -> Unit + ) { + val rules = mutableListOf() + val emitters = mutableListOf() + val definitionProviders = mutableListOf() + val classSources = mutableListOf() + var executionProfile = ExecutionProfile.UNLIMITED + var whitelist = Whitelist.MINIMAL + for (option in options) { + when (option) { + is Rule -> rules.add(option) + is Emitter -> emitters.add(option) + is DefinitionProvider -> definitionProviders.add(option) + is ExecutionProfile -> executionProfile = option + is ClassSource -> classSources.add(option) + is Whitelist -> whitelist = option + is List<*> -> { + rules.addAll(option.filterIsInstance()) + emitters.addAll(option.filterIsInstance()) + definitionProviders.addAll(option.filterIsInstance()) + } + } + } + var thrownException: Throwable? = null + Thread { + try { + val pinnedTestClasses = pinnedClasses.map { it.name.replace('.', '/') }.toSet() + val analysisConfiguration = AnalysisConfiguration( + whitelist = whitelist, + additionalPinnedClasses = pinnedTestClasses, + minimumSeverityLevel = minimumSeverityLevel + ) + SandboxRuntimeContext(SandboxConfiguration.of( + executionProfile, rules, emitters, definitionProviders, enableTracing, analysisConfiguration + ), classSources).use { + assertThat(runtimeCosts).areZero() + action(this) + } + } catch (exception: Throwable) { + thrownException = exception + } + }.apply { + start() + join() + } + throw thrownException ?: return + } + + /** + * Get a class reference from a class hierarchy based on [T]. + */ + inline fun ClassHierarchy.get() = this[nameOf()]!! + + /** + * Create a new instance of a class using the sandbox class loader. + */ + inline fun SandboxRuntimeContext.newCallable() = + classLoader.loadClassAndBytes(ClassSource.fromClassName(T::class.java.name), context) + + /** + * Run the entry-point of the loaded [Callable] class. + */ + fun LoadedClass.createAndInvoke(methodName: String = "call") { + val instance = type.newInstance() + val method = instance.javaClass.getMethod(methodName) + try { + method.invoke(instance) + } catch (ex: InvocationTargetException) { + throw ex.targetException + } + } + + /** + * Stub visitor. + */ + protected class Visitor : ClassVisitor(ClassAndMemberVisitor.API_VERSION) + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/analysis/ClassAndMemberVisitorTest.kt b/djvm/src/test/kotlin/net/corda/djvm/analysis/ClassAndMemberVisitorTest.kt new file mode 100644 index 0000000000..fa5d9ffbf0 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/analysis/ClassAndMemberVisitorTest.kt @@ -0,0 +1,211 @@ +package net.corda.djvm.analysis + +import net.corda.djvm.TestBase +import net.corda.djvm.annotations.NonDeterministic +import net.corda.djvm.assertions.AssertionExtensions.hasClass +import net.corda.djvm.assertions.AssertionExtensions.hasInstruction +import net.corda.djvm.assertions.AssertionExtensions.hasMember +import net.corda.djvm.code.EmitterModule +import net.corda.djvm.code.Instruction +import net.corda.djvm.code.instructions.MemberAccessInstruction +import net.corda.djvm.code.instructions.TryFinallyBlock +import net.corda.djvm.code.instructions.TypeInstruction +import net.corda.djvm.references.ClassRepresentation +import net.corda.djvm.references.Member +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test + +@Suppress("unused") +class ClassAndMemberVisitorTest : TestBase() { + + @Test + fun `can traverse classes`() { + val classesVisited = mutableSetOf() + val visitor = object : ClassAndMemberVisitor() { + override fun visitClass(clazz: ClassRepresentation): ClassRepresentation { + classesVisited.add(clazz) + return clazz + } + } + + visitor.analyze(context) + assertThat(classesVisited) + .hasSize(1) + .hasClass() + + visitor.analyze(context) + assertThat(classesVisited) + .hasSize(2) + .hasClass() + .hasClass() + } + + private class TestClass + + private class AnotherTestClass + + @Test + fun `can traverse fields`() { + val membersVisited = mutableSetOf() + val visitor = object : ClassAndMemberVisitor() { + override fun visitField(clazz: ClassRepresentation, field: Member): Member { + membersVisited.add(field) + return field + } + } + visitor.analyze(context) + assertThat(membersVisited) + .hasSize(3) + .hasMember("one", "Z") + .hasMember("two", "Ljava/lang/String;") + .hasMember("three", "I") + } + + private class TestClassWithFields { + + @JvmField + val one: Boolean = false + + @JvmField + val two: String = "" + + @JvmField + val three: Int = 0 + + } + + @Test + fun `can traverse methods`() { + val membersVisited = mutableSetOf() + val visitor = object : ClassAndMemberVisitor() { + override fun visitMethod(clazz: ClassRepresentation, method: Member): Member { + membersVisited.add(method) + return method + } + } + visitor.analyze(context) + assertThat(membersVisited) + .hasSize(3) + .hasMember("", "()V") + .hasMember("foo", "()Ljava/lang/String;") + .hasMember("bar", "()I") + } + + private class TestClassWithMethods { + + fun foo(): String = "" + + fun bar(): Int = 0 + + } + + @Test + fun `can traverse class annotations`() { + val annotations = mutableSetOf() + val visitor = object : ClassAndMemberVisitor() { + override fun visitClassAnnotation(clazz: ClassRepresentation, descriptor: String) { + annotations.add(descriptor) + } + } + visitor.analyze(context) + assertThat(annotations) + .hasSize(2) + .contains("Lkotlin/Metadata;") + .contains("Lnet/corda/djvm/annotations/NonDeterministic;") + } + + @NonDeterministic + private class TestClassWithAnnotations + + @Test + fun `can traverse member annotations`() { + val annotations = mutableSetOf() + val visitor = object : ClassAndMemberVisitor() { + override fun visitMemberAnnotation(clazz: ClassRepresentation, member: Member, descriptor: String) { + annotations.add("${member.memberName}:$descriptor") + } + } + visitor.analyze(context) + assertThat(annotations) + .hasSize(2) + .contains("field\$annotations:Lnet/corda/djvm/annotations/NonDeterministic;") + .contains("method:Lnet/corda/djvm/annotations/NonDeterministic;") + } + + private class TestClassWithMemberAnnotations { + + @NonDeterministic + val field: Boolean = false + + @NonDeterministic + fun method() { + } + + } + + @Test + fun `can traverse class sources`() { + val sources = mutableSetOf() + val visitor = object : ClassAndMemberVisitor() { + override fun visitSource(clazz: ClassRepresentation, source: String) { + sources.add(source) + } + } + visitor.analyze(context) + val expectedSource = ".*ClassAndMemberVisitorTest.kt" + assertThat(sources) + .hasSize(1) + .`as`("HasSource($expectedSource)") + .anySatisfy { assertThat(it).containsPattern(expectedSource) } + } + + @Test + fun `can traverse instructions`() { + val instructions = mutableSetOf>() + val visitor = object : ClassAndMemberVisitor() { + override fun visitInstruction(method: Member, emitter: EmitterModule, instruction: Instruction) { + instructions.add(Pair(method, instruction)) + } + } + visitor.analyze(context) + assertThat(instructions) + .isNotEmpty + .hasInstruction( + "foo", "sandbox/java/lang/Object" + ) { + assertThat(it.typeName).isEqualTo("sandbox/java/lang/Object") + } + .hasInstruction( + "foo", "sandbox/java/lang/Object::()V" + ) { + assertThat(it.owner).isEqualTo("sandbox/java/lang/Object") + assertThat(it.memberName).isEqualTo("") + assertThat(it.signature).isEqualTo("()V") + } + .hasInstruction( + "foo", "sandbox/java/lang/Object:hashCode()I" + ) { + assertThat(it.owner).isEqualTo("sandbox/java/lang/Object") + assertThat(it.memberName).isEqualTo("hashCode") + assertThat(it.signature).isEqualTo("()I") + } + .hasInstruction("bar", "TryFinallyBlock") + .hasInstruction("bar", "MemberAccessInstruction") + } + + private class TestClassWithCode { + + fun foo(): Int { + val obj = sandbox.java.lang.Object() + return obj.hashCode() + } + + fun bar() { + synchronized(this) { + assertThat(1).isEqualTo(1) + } + } + + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/analysis/ClassResolverTest.kt b/djvm/src/test/kotlin/net/corda/djvm/analysis/ClassResolverTest.kt new file mode 100644 index 0000000000..8f39f32808 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/analysis/ClassResolverTest.kt @@ -0,0 +1,50 @@ +package net.corda.djvm.analysis + +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test + +class ClassResolverTest { + + private val resolver = ClassResolver(emptySet(), Whitelist.MINIMAL, "sandbox/") + + @Test + fun `can resolve class name`() { + assertThat(resolver.resolve("java/lang/Object")).isEqualTo("java/lang/Object") + assertThat(resolver.resolve("java/lang/String")).isEqualTo("java/lang/String") + assertThat(resolver.resolve("foo/bar/Test")).isEqualTo("sandbox/foo/bar/Test") + } + + @Test + fun `can resolve class name for arrays`() { + assertThat(resolver.resolve("[Ljava/lang/Object;")).isEqualTo("[Ljava/lang/Object;") + assertThat(resolver.resolve("[Ljava/lang/String;")).isEqualTo("[Ljava/lang/String;") + assertThat(resolver.resolve("[Lfoo/bar/Test;")).isEqualTo("[Lsandbox/foo/bar/Test;") + assertThat(resolver.resolve("[[Ljava/lang/Object;")).isEqualTo("[[Ljava/lang/Object;") + assertThat(resolver.resolve("[[Ljava/lang/String;")).isEqualTo("[[Ljava/lang/String;") + assertThat(resolver.resolve("[[Lfoo/bar/Test;")).isEqualTo("[[Lsandbox/foo/bar/Test;") + assertThat(resolver.resolve("[[[Ljava/lang/Object;")).isEqualTo("[[[Ljava/lang/Object;") + assertThat(resolver.resolve("[[[Ljava/lang/String;")).isEqualTo("[[[Ljava/lang/String;") + assertThat(resolver.resolve("[[[Lfoo/bar/Test;")).isEqualTo("[[[Lsandbox/foo/bar/Test;") + } + + @Test + fun `can resolve binary class name`() { + assertThat(resolver.resolveNormalized("java.lang.Object")).isEqualTo("java.lang.Object") + assertThat(resolver.resolveNormalized("foo.bar.Test")).isEqualTo("sandbox.foo.bar.Test") + } + + @Test + fun `can resolve type descriptor`() { + assertThat(resolver.resolveDescriptor("V")).isEqualTo("V") + assertThat(resolver.resolveDescriptor("L")).isEqualTo("L") + assertThat(resolver.resolveDescriptor("()V")).isEqualTo("()V") + assertThat(resolver.resolveDescriptor("(I)V")).isEqualTo("(I)V") + assertThat(resolver.resolveDescriptor("(IJ)V")).isEqualTo("(IJ)V") + assertThat(resolver.resolveDescriptor("Ljava/lang/Object;")).isEqualTo("Ljava/lang/Object;") + assertThat(resolver.resolveDescriptor("Ljava/lang/Object;I")).isEqualTo("Ljava/lang/Object;I") + assertThat(resolver.resolveDescriptor("Lcom/somewhere/Hello;")).isEqualTo("Lsandbox/com/somewhere/Hello;") + assertThat(resolver.resolveDescriptor("JLFoo;LBar;I")).isEqualTo("JLsandbox/Foo;Lsandbox/Bar;I") + assertThat(resolver.resolveDescriptor("(LFoo;)LBar;")).isEqualTo("(Lsandbox/Foo;)Lsandbox/Bar;") + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/analysis/ReferenceValidatorTest.kt b/djvm/src/test/kotlin/net/corda/djvm/analysis/ReferenceValidatorTest.kt new file mode 100644 index 0000000000..816b232864 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/analysis/ReferenceValidatorTest.kt @@ -0,0 +1,66 @@ +package net.corda.djvm.analysis + +import net.corda.djvm.TestBase +import net.corda.djvm.execution.SandboxedRunnable +import net.corda.djvm.validation.ReferenceValidator +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test + +class ReferenceValidatorTest : TestBase() { + + private fun validator(whitelist: Whitelist = Whitelist.MINIMAL) = + ReferenceValidator(AnalysisConfiguration(whitelist)) + + @Test + fun `can validate when there are no references`() = analyze { context -> + analyze(context) + val (_, messages) = validator().validate(context, this) + assertThat(messages.count).isEqualTo(0) + } + + private class EmptyRunnable : SandboxedRunnable { + override fun run(input: Int): Int? { + return null + } + } + + @Test + fun `can validate when there are references`() = analyze { context -> + analyze(context) + analyze(context) + val (_, messages) = validator().validate(context, this) + assertThat(messages.count).isEqualTo(0) + } + + private class RunnableWithReferences : SandboxedRunnable { + override fun run(input: Int): Int? { + return TestRandom().nextInt() + } + } + + private class TestRandom { + external fun nextInt(): Int + } + + @Test + fun `can validate when there are transient references`() = analyze { context -> + analyze(context) + analyze(context) + analyze(context) + val (_, messages) = validator().validate(context, this) + assertThat(messages.count).isEqualTo(0) + } + + private class RunnableWithTransientReferences : SandboxedRunnable { + override fun run(input: Int): Int? { + return ReferencedClass().test() + } + } + + private class ReferencedClass { + fun test(): Int { + return TestRandom().nextInt() + } + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/analysis/SourceLocationTest.kt b/djvm/src/test/kotlin/net/corda/djvm/analysis/SourceLocationTest.kt new file mode 100644 index 0000000000..c5919232b5 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/analysis/SourceLocationTest.kt @@ -0,0 +1,40 @@ +package net.corda.djvm.analysis + +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test + +class SourceLocationTest { + + @Test + fun `can derive description of source location without source`() { + val location = SourceLocation(className = "net/foo/Bar") + assertThat(location.format()) + .contains("net/foo/Bar") + assertThat(location.copy(memberName = "baz").format()) + .contains("net/foo/Bar") + assertThat(location.copy(memberName = "baz", lineNumber = 15).format()) + .contains("net/foo/Bar") + .contains("line 15") + assertThat(location.copy(memberName = "baz", signature = "(I)V", lineNumber = 15).format()) + .contains("net/foo/Bar") + .contains("line 15") + .contains("baz(Integer)") + } + + @Test + fun `can derive description of source location with source`() { + val location = SourceLocation(className = "net/foo/Bar", sourceFile = "Bar.kt") + assertThat(location.format()) + .contains("Bar.kt") + assertThat(location.copy(memberName = "baz").format()) + .contains("Bar.kt") + assertThat(location.copy(memberName = "baz", lineNumber = 15).format()) + .contains("Bar.kt") + .contains("line 15") + assertThat(location.copy(memberName = "baz", signature = "(I)V", lineNumber = 15).format()) + .contains("Bar.kt") + .contains("line 15") + .contains("baz(Integer)") + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/analysis/WhitelistTest.kt b/djvm/src/test/kotlin/net/corda/djvm/analysis/WhitelistTest.kt new file mode 100644 index 0000000000..a817be4108 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/analysis/WhitelistTest.kt @@ -0,0 +1,44 @@ +package net.corda.djvm.analysis + +import net.corda.djvm.TestBase +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test + +class WhitelistTest : TestBase() { + + @Test + fun `can determine when a class is whitelisted when namespace is covered`() { + val whitelist = Whitelist.MINIMAL + assertThat(whitelist.matches("java/lang/Object")).isTrue() + assertThat(whitelist.matches("java/lang/Object.:()V")).isTrue() + assertThat(whitelist.matches("java/lang/Integer")).isTrue() + assertThat(whitelist.matches("java/lang/Integer.:(I)V")).isTrue() + } + + @Test + fun `can determine when a class is not whitelisted when namespace is covered`() { + val whitelist = Whitelist.MINIMAL + assertThat(whitelist.matches("java/util/Random")).isFalse() + assertThat(whitelist.matches("java/util/Random.:()V")).isFalse() + assertThat(whitelist.matches("java/util/Random.nextInt:()I")).isFalse() + } + + @Test + fun `can determine when a class is whitelisted when namespace is not covered`() { + val whitelist = Whitelist.MINIMAL + setOf( + "^org/assertj/.*$".toRegex(), + "^org/junit/.*$".toRegex() + ) + assertThat(whitelist.matches("org/junit/Test")).isTrue() + assertThat(whitelist.matches("org/assertj/core/api/Assertions")).isTrue() + assertThat(whitelist.matches("net/foo/bar/Baz")).isFalse() + } + + @Test + fun `can determine when a namespace is not covered`() { + val whitelist = Whitelist.MINIMAL + assertThat(whitelist.matches("java/lang/Object")).isTrue() + assertThat(whitelist.matches("org/junit/Test")).isFalse() + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertionExtensions.kt b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertionExtensions.kt new file mode 100644 index 0000000000..a86706551a --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertionExtensions.kt @@ -0,0 +1,71 @@ +package net.corda.djvm.assertions + +import net.corda.djvm.TestBase +import net.corda.djvm.code.Instruction +import net.corda.djvm.costing.RuntimeCostSummary +import net.corda.djvm.messages.MessageCollection +import net.corda.djvm.messages.Message +import net.corda.djvm.references.ClassRepresentation +import net.corda.djvm.references.ClassHierarchy +import net.corda.djvm.references.Member +import net.corda.djvm.references.ReferenceMap +import net.corda.djvm.rewiring.LoadedClass +import org.assertj.core.api.Assertions +import org.assertj.core.api.Assertions.assertThat +import org.assertj.core.api.IterableAssert +import org.assertj.core.api.ListAssert +import org.assertj.core.api.ThrowableAssertAlternative + +/** + * Extensions used for testing. + */ +object AssertionExtensions { + + fun assertThat(loadedClass: LoadedClass) = + AssertiveClassWithByteCode(loadedClass) + + fun assertThat(costs: RuntimeCostSummary) = + AssertiveRuntimeCostSummary(costs) + + fun assertThat(messages: MessageCollection) = + AssertiveMessages(messages) + + fun assertThat(hierarchy: ClassHierarchy) = + AssertiveClassHierarchy(hierarchy) + + fun assertThat(references: ReferenceMap) = + AssertiveReferenceMap(references) + + inline fun IterableAssert.hasClass(): IterableAssert = this + .`as`("HasClass(${T::class.java.name})") + .anySatisfy { + assertThat(it.name).isEqualTo(TestBase.nameOf()) + } + + fun IterableAssert.hasMember(name: String, signature: String): IterableAssert = this + .`as`("HasMember($name:$signature)") + .anySatisfy { + assertThat(it.memberName).isEqualTo(name) + assertThat(it.signature).isEqualTo(signature) + } + + inline fun IterableAssert>.hasInstruction( + methodName: String, description: String, noinline predicate: ((TInstruction) -> Unit)? = null + ): IterableAssert> = this + .`as`("Has(${TInstruction::class.java.name} in $methodName(), $description)") + .anySatisfy { + assertThat(it.first.memberName).isEqualTo(methodName) + assertThat(it.second).isInstanceOf(TInstruction::class.java) + predicate?.invoke(it.second as TInstruction) + } + + fun ThrowableAssertAlternative.withProblem(message: String): ThrowableAssertAlternative = this + .withStackTraceContaining(message) + + fun ListAssert.withMessage(message: String): ListAssert = this + .`as`("HasMessage($message)") + .anySatisfy { + Assertions.assertThat(it.message).contains(message) + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassHierarchy.kt b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassHierarchy.kt new file mode 100644 index 0000000000..310016df5d --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassHierarchy.kt @@ -0,0 +1,24 @@ +package net.corda.djvm.assertions + +import net.corda.djvm.references.ClassHierarchy +import org.assertj.core.api.Assertions + +open class AssertiveClassHierarchy(protected val hierarchy: ClassHierarchy) { + + fun hasCount(count: Int): AssertiveClassHierarchy { + Assertions.assertThat(hierarchy.names.size) + .`as`("Number of classes") + .isEqualTo(count) + return this + } + + fun hasClass(name: String): AssertiveClassHierarchyWithClass { + Assertions.assertThat(hierarchy.names) + .`as`("Class($name)") + .anySatisfy { + Assertions.assertThat(it).isEqualTo(name) + } + return AssertiveClassHierarchyWithClass(hierarchy, name) + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassHierarchyWithClass.kt b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassHierarchyWithClass.kt new file mode 100644 index 0000000000..6450485143 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassHierarchyWithClass.kt @@ -0,0 +1,47 @@ +package net.corda.djvm.assertions + +import net.corda.djvm.references.ClassRepresentation +import net.corda.djvm.references.ClassHierarchy +import org.assertj.core.api.Assertions + +open class AssertiveClassHierarchyWithClass( + hierarchy: ClassHierarchy, + private val className: String +) : AssertiveClassHierarchy(hierarchy) { + + private val clazz: ClassRepresentation + get() = hierarchy[className]!! + + fun withInterfaceCount(count: Int): AssertiveClassHierarchyWithClass { + Assertions.assertThat(clazz.interfaces.size) + .`as`("$clazz.InterfaceCount($count)") + .isEqualTo(count) + return this + } + + fun withInterface(name: String): AssertiveClassHierarchyWithClass { + Assertions.assertThat(clazz.interfaces).contains(name) + return this + } + + fun withMemberCount(count: Int): AssertiveClassHierarchyWithClass { + Assertions.assertThat(clazz.members.size) + .`as`("MemberCount($className)") + .isEqualTo(count) + return this + } + + fun withMember(name: String, signature: String): AssertiveClassHierarchyWithClassAndMember { + Assertions.assertThat(clazz.members.values) + .`as`("Member($className.$name:$signature") + .anySatisfy { + Assertions.assertThat(it.memberName).isEqualTo(name) + Assertions.assertThat(it.signature).isEqualTo(signature) + } + val member = clazz.members.values.first { + it.memberName == name && it.signature == signature + } + return AssertiveClassHierarchyWithClassAndMember(hierarchy, className, member) + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassHierarchyWithClassAndMember.kt b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassHierarchyWithClassAndMember.kt new file mode 100644 index 0000000000..38d6269559 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassHierarchyWithClassAndMember.kt @@ -0,0 +1,28 @@ +package net.corda.djvm.assertions + +import net.corda.djvm.references.ClassHierarchy +import net.corda.djvm.references.Member +import org.assertj.core.api.Assertions + +@Suppress("unused", "CanBeParameter") +class AssertiveClassHierarchyWithClassAndMember( + hierarchy: ClassHierarchy, + private val className: String, + private val member: Member +) : AssertiveClassHierarchyWithClass(hierarchy, className) { + + fun withAccessFlag(flag: Int): AssertiveClassHierarchyWithClassAndMember { + Assertions.assertThat(member.access and flag) + .`as`("$member.AccessFlag($flag)") + .isNotEqualTo(0) + return this + } + + fun withNoAccessFlag(flag: Int): AssertiveClassHierarchyWithClassAndMember { + Assertions.assertThat(member.access and flag) + .`as`("$member.AccessFlag($flag)") + .isEqualTo(0) + return this + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassWithByteCode.kt b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassWithByteCode.kt new file mode 100644 index 0000000000..457b71c96f --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveClassWithByteCode.kt @@ -0,0 +1,27 @@ +package net.corda.djvm.assertions + +import net.corda.djvm.rewiring.LoadedClass +import org.assertj.core.api.Assertions + +class AssertiveClassWithByteCode(private val loadedClass: LoadedClass) { + + fun isSandboxed(): AssertiveClassWithByteCode { + Assertions.assertThat(loadedClass.type.name).startsWith("sandbox.") + return this + } + + fun hasNotBeenModified(): AssertiveClassWithByteCode { + Assertions.assertThat(loadedClass.byteCode.isModified) + .`as`("Byte code has been modified") + .isEqualTo(false) + return this + } + + fun hasBeenModified(): AssertiveClassWithByteCode { + Assertions.assertThat(loadedClass.byteCode.isModified) + .`as`("Byte code has been modified") + .isEqualTo(true) + return this + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveMessages.kt b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveMessages.kt new file mode 100644 index 0000000000..45ad527225 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveMessages.kt @@ -0,0 +1,68 @@ +package net.corda.djvm.assertions + +import net.corda.djvm.messages.MessageCollection +import net.corda.djvm.messages.Severity +import org.assertj.core.api.Assertions + +@Suppress("unused") +class AssertiveMessages(private val messages: MessageCollection) { + + fun isEmpty() { + hasErrorCount(0) + hasWarningCount(0) + hasInfoCount(0) + } + + fun hasErrorCount(count: Int): AssertiveMessages { + Assertions.assertThat(messages.statistics[Severity.ERROR]) + .`as`("Number of errors") + .withFailMessage(formatMessages(Severity.ERROR, count)) + .isEqualTo(count) + return this + } + + fun hasWarningCount(count: Int): AssertiveMessages { + Assertions.assertThat(messages.statistics[Severity.WARNING]) + .`as`("Number of warnings") + .withFailMessage(formatMessages(Severity.WARNING, count)) + .isEqualTo(count) + return this + } + + fun hasInfoCount(count: Int): AssertiveMessages { + Assertions.assertThat(messages.statistics[Severity.INFORMATIONAL]) + .`as`("Number of informational messages") + .withFailMessage(formatMessages(Severity.INFORMATIONAL, count)) + .isEqualTo(count) + return this + } + + fun hasTraceCount(count: Int): AssertiveMessages { + Assertions.assertThat(messages.statistics[Severity.TRACE]) + .`as`("Number of trace messages") + .withFailMessage(formatMessages(Severity.TRACE, count)) + .isEqualTo(count) + return this + } + + fun withMessage(message: String): AssertiveMessages { + Assertions.assertThat(messages.sorted()) + .`as`("Has message: $message") + .anySatisfy { + Assertions.assertThat(it.message).contains(message) + } + return this + } + + private fun formatMessages(severity: Severity, expectedCount: Int): String { + val filteredMessages = messages.sorted().filter { it.severity == severity } + return StringBuilder().apply { + append("Found ${filteredMessages.count()} message(s) of severity $severity, ") + appendln("expected $expectedCount:") + for (message in filteredMessages) { + appendln(" - $message") + } + }.toString() + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveReferenceMap.kt b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveReferenceMap.kt new file mode 100644 index 0000000000..4168e318db --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveReferenceMap.kt @@ -0,0 +1,46 @@ +package net.corda.djvm.assertions + +import net.corda.djvm.references.ClassReference +import net.corda.djvm.references.MemberReference +import net.corda.djvm.references.ReferenceMap +import org.assertj.core.api.Assertions + +@Suppress("unused") +open class AssertiveReferenceMap(private val references: ReferenceMap) { + + fun hasCount(count: Int): AssertiveReferenceMap { + val allReferences = references.joinToString("\n") { " - $it" } + Assertions.assertThat(references.size) + .overridingErrorMessage("Expected $count reference(s), found:\n$allReferences") + .isEqualTo(count) + return this + } + + fun hasClass(clazz: String): AssertiveReferenceMapWithEntity { + Assertions.assertThat(references.iterator()) + .`as`("Class($clazz)") + .anySatisfy { + Assertions.assertThat(it).isInstanceOf(ClassReference::class.java) + if (it is ClassReference) { + Assertions.assertThat(it.className).isEqualTo(clazz) + } + } + val reference = ClassReference(clazz) + return AssertiveReferenceMapWithEntity(references, reference, references.locationsFromReference(reference)) + } + + fun hasMember(owner: String, member: String, signature: String): AssertiveReferenceMapWithEntity { + Assertions.assertThat(references.iterator()) + .`as`("Member($owner.$member)") + .anySatisfy { + Assertions.assertThat(it).isInstanceOf(MemberReference::class.java) + if (it is MemberReference) { + Assertions.assertThat(it.className).isEqualTo(owner) + Assertions.assertThat(it.memberName).isEqualTo(member) + } + } + val reference = MemberReference(owner, member, signature) + return AssertiveReferenceMapWithEntity(references, reference, references.locationsFromReference(reference)) + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveReferenceMapWithEntity.kt b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveReferenceMapWithEntity.kt new file mode 100644 index 0000000000..ec19591eac --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveReferenceMapWithEntity.kt @@ -0,0 +1,21 @@ +package net.corda.djvm.assertions + +import net.corda.djvm.analysis.SourceLocation +import net.corda.djvm.references.EntityReference +import net.corda.djvm.references.ReferenceMap +import org.assertj.core.api.Assertions + +class AssertiveReferenceMapWithEntity( + references: ReferenceMap, + private val entity: EntityReference, + private val locations: Set +) : AssertiveReferenceMap(references) { + + fun withLocationCount(count: Int): AssertiveReferenceMapWithEntity { + Assertions.assertThat(locations.size) + .`as`("LocationCount($entity)") + .isEqualTo(count) + return this + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveRuntimeCostSummary.kt b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveRuntimeCostSummary.kt new file mode 100644 index 0000000000..5ac1e33538 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/assertions/AssertiveRuntimeCostSummary.kt @@ -0,0 +1,58 @@ +package net.corda.djvm.assertions + +import net.corda.djvm.costing.RuntimeCostSummary +import org.assertj.core.api.Assertions + +@Suppress("MemberVisibilityCanBePrivate") +class AssertiveRuntimeCostSummary(private val costs: RuntimeCostSummary) { + + fun areZero() { + hasAllocationCost(0) + hasInvocationCost(0) + hasJumpCost(0) + hasThrowCost(0) + } + + fun hasAllocationCost(cost: Long): AssertiveRuntimeCostSummary { + Assertions.assertThat(costs.allocationCost.value) + .`as`("Allocation cost") + .isEqualTo(cost) + return this + } + + fun hasInvocationCost(cost: Long): AssertiveRuntimeCostSummary { + Assertions.assertThat(costs.invocationCost.value) + .`as`("Invocation cost") + .isEqualTo(cost) + return this + } + + fun hasInvocationCostGreaterThanOrEqualTo(cost: Long): AssertiveRuntimeCostSummary { + Assertions.assertThat(costs.invocationCost.value) + .`as`("Invocation cost") + .isGreaterThanOrEqualTo(cost) + return this + } + + fun hasJumpCost(cost: Long): AssertiveRuntimeCostSummary { + Assertions.assertThat(costs.jumpCost.value) + .`as`("Jump cost") + .isEqualTo(cost) + return this + } + + fun hasJumpCostGreaterThanOrEqualTo(cost: Long): AssertiveRuntimeCostSummary { + Assertions.assertThat(costs.jumpCost.value) + .`as`("Jump cost") + .isGreaterThanOrEqualTo(cost) + return this + } + + fun hasThrowCost(cost: Long): AssertiveRuntimeCostSummary { + Assertions.assertThat(costs.throwCost.value) + .`as`("Throw cost") + .isEqualTo(cost) + return this + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/code/ClassMutatorTest.kt b/djvm/src/test/kotlin/net/corda/djvm/code/ClassMutatorTest.kt new file mode 100644 index 0000000000..c5dc170b9c --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/code/ClassMutatorTest.kt @@ -0,0 +1,76 @@ +package net.corda.djvm.code + +import net.corda.djvm.TestBase +import net.corda.djvm.analysis.AnalysisRuntimeContext +import net.corda.djvm.references.ClassRepresentation +import net.corda.djvm.references.Member +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test +import org.objectweb.asm.Opcodes.ACC_STRICT + +@Suppress("unused") +class ClassMutatorTest : TestBase() { + + @Test + fun `can mutate class definition`() { + var hasProvidedDefinition = false + val definitionProvider = object : ClassDefinitionProvider { + override fun define(context: AnalysisRuntimeContext, clazz: ClassRepresentation): ClassRepresentation { + hasProvidedDefinition = true + return clazz.copy(access = clazz.access or ACC_STRICT) + } + } + val context = context + val mutator = ClassMutator(Visitor(), configuration, listOf(definitionProvider)) + mutator.analyze(context) + assertThat(hasProvidedDefinition).isTrue() + assertThat(context.classes.get().access or ACC_STRICT).isNotEqualTo(0) + } + + class TestClass + + @Test + fun `can mutate member definition`() { + var hasProvidedDefinition = false + val definitionProvider = object : MemberDefinitionProvider { + override fun define(context: AnalysisRuntimeContext, member: Member): Member { + hasProvidedDefinition = true + return member.copy(access = member.access or ACC_STRICT) + } + } + val context = context + val mutator = ClassMutator(Visitor(), configuration, listOf(definitionProvider)) + mutator.analyze(context) + assertThat(hasProvidedDefinition).isTrue() + for (member in context.classes.get().members.values) { + assertThat(member.access or ACC_STRICT).isNotEqualTo(0) + } + } + + class TestClassWithMembers { + fun foo() {} + fun bar(): Int = 0 + fun baz(): Double = 1.0 + } + + @Test + fun `can mutate code`() { + var hasEmittedCode = false + var shouldPreventDefault = false + val emitter = object : Emitter { + override fun emit(context: EmitterContext, instruction: Instruction) = context.emit { + loadConstant(0) + pop() + preventDefault() + hasEmittedCode = hasEmittedCustomCode + shouldPreventDefault = !emitDefaultInstruction + } + } + val context = context + val mutator = ClassMutator(Visitor(), configuration, emitters = listOf(emitter)) + mutator.analyze(context) + assertThat(hasEmittedCode).isTrue() + assertThat(shouldPreventDefault).isTrue() + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/code/EmitterModuleTest.kt b/djvm/src/test/kotlin/net/corda/djvm/code/EmitterModuleTest.kt new file mode 100644 index 0000000000..0289fbd4d9 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/code/EmitterModuleTest.kt @@ -0,0 +1,47 @@ +package net.corda.djvm.code + +import net.corda.djvm.TestBase +import net.corda.djvm.analysis.ClassAndMemberVisitor +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test +import org.objectweb.asm.ClassVisitor +import org.objectweb.asm.MethodVisitor +import org.objectweb.asm.Opcodes.NEW + +class EmitterModuleTest : TestBase() { + + @Test + fun `can emit code to method body`() { + var hasEmittedTypeInstruction = false + val methodVisitor = object : MethodVisitor(ClassAndMemberVisitor.API_VERSION) { + override fun visitTypeInsn(opcode: Int, type: String?) { + if (opcode == NEW && type == java.lang.String::class.java.name) { + hasEmittedTypeInstruction = true + } + } + } + val visitor = object : ClassVisitor(ClassAndMemberVisitor.API_VERSION) { + override fun visitMethod( + access: Int, name: String?, descriptor: String?, signature: String?, exceptions: Array? + ): MethodVisitor { + return methodVisitor + } + } + val emitter = object : Emitter { + override fun emit(context: EmitterContext, instruction: Instruction) = context.emit { + @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN") + new() + } + + } + val context = context + val mutator = ClassMutator(visitor, configuration, emitters = listOf(emitter)) + mutator.analyze(context) + assertThat(hasEmittedTypeInstruction).isTrue() + } + + class TestClass { + fun foo() {} + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/costing/RuntimeCostTest.kt b/djvm/src/test/kotlin/net/corda/djvm/costing/RuntimeCostTest.kt new file mode 100644 index 0000000000..e44fb883db --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/costing/RuntimeCostTest.kt @@ -0,0 +1,31 @@ +package net.corda.djvm.costing + +import org.assertj.core.api.Assertions.assertThat +import org.assertj.core.api.Assertions.assertThatExceptionOfType +import org.junit.Test + +class RuntimeCostTest { + + @Test + fun `can increment cost`() { + val cost = RuntimeCost(10, { "failed" }) + cost.increment(1) + assertThat(cost.value).isEqualTo(1) + } + + @Test + fun `cannot increment cost beyond threshold`() { + Thread { + val cost = RuntimeCost(10, { "failed in ${it.name}" }) + assertThatExceptionOfType(ThresholdViolationException::class.java) + .isThrownBy { cost.increment(11) } + .withMessage("failed in Foo") + assertThat(cost.value).isEqualTo(11) + }.apply { + name = "Foo" + start() + join() + } + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/execution/SandboxExecutorTest.kt b/djvm/src/test/kotlin/net/corda/djvm/execution/SandboxExecutorTest.kt new file mode 100644 index 0000000000..a677b4fd35 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/execution/SandboxExecutorTest.kt @@ -0,0 +1,310 @@ +package net.corda.djvm.execution + +import foo.bar.sandbox.MyObject +import foo.bar.sandbox.testRandom +import foo.bar.sandbox.toNumber +import net.corda.djvm.TestBase +import net.corda.djvm.analysis.Whitelist +import net.corda.djvm.assertions.AssertionExtensions.withProblem +import net.corda.djvm.costing.ThresholdViolationException +import net.corda.djvm.rewiring.SandboxClassLoadingException +import org.assertj.core.api.Assertions.assertThat +import org.assertj.core.api.Assertions.assertThatExceptionOfType +import org.junit.Test +import java.nio.file.Files +import java.util.* + +class SandboxExecutorTest : TestBase() { + + @Test + fun `can load and execute runnable`() = sandbox(Whitelist.MINIMAL) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + val summary = contractExecutor.run(1) + val result = summary.result + assertThat(result).isEqualTo("sandbox") + } + + class TestSandboxedRunnable : SandboxedRunnable { + override fun run(input: Int): String? { + return "sandbox" + } + } + + @Test + fun `can load and execute contract`() = sandbox( + pinnedClasses = setOf(Transaction::class.java) + ) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + val tx = Transaction(1) + assertThatExceptionOfType(SandboxException::class.java) + .isThrownBy { contractExecutor.run(tx) } + .withCauseInstanceOf(IllegalArgumentException::class.java) + .withMessageContaining("Contract constraint violated") + } + + class Contract : SandboxedRunnable { + override fun run(input: Transaction?) { + throw IllegalArgumentException("Contract constraint violated") + } + } + + data class Transaction(val id: Int?) + + @Test + fun `can load and execute code that overrides object hash code`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + val summary = contractExecutor.run(0) + val result = summary.result + assertThat(result).isEqualTo(0xfed_c0de + 2) + } + + class TestObjectHashCode : SandboxedRunnable { + override fun run(input: Int): Int? { + val obj = Object() + val hash1 = obj.hashCode() + val hash2 = obj.hashCode() + assert(hash1 == hash2) + return Object().hashCode() + } + } + + @Test + fun `can load and execute code that overrides object hash code when derived`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + val summary = contractExecutor.run(0) + val result = summary.result + assertThat(result).isEqualTo(0xfed_c0de + 1) + } + + class TestObjectHashCodeWithHierarchy : SandboxedRunnable { + override fun run(input: Int): Int? { + val obj = MyObject() + return obj.hashCode() + } + } + + @Test + fun `can detect breached threshold`() = sandbox(DEFAULT, ExecutionProfile.DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + assertThatExceptionOfType(SandboxException::class.java) + .isThrownBy { contractExecutor.run(0) } + .withMessageContaining("terminated due to excessive use of looping") + } + + class TestThresholdBreach : SandboxedRunnable { + private var x = 0 + override fun run(input: Int): Int? { + for (i in 0..1_000_000) { + x += 1 + } + return x + } + } + + @Test + fun `can detect stack overflow`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + assertThatExceptionOfType(SandboxException::class.java) + .isThrownBy { contractExecutor.run(0) } + .withCauseInstanceOf(StackOverflowError::class.java) + } + + class TestStackOverflow : SandboxedRunnable { + override fun run(input: Int): Int? { + return a() + } + + private fun a(): Int = b() + private fun b(): Int = a() + } + + + @Test + fun `can detect illegal references in Kotlin meta-classes`() = sandbox(DEFAULT, ExecutionProfile.DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + assertThatExceptionOfType(SandboxException::class.java) + .isThrownBy { contractExecutor.run(0) } + .withMessageContaining("java/util/Random.(): Disallowed reference to reflection API; sun.misc.Unsafe.getUnsafe()") + } + + class TestKotlinMetaClasses : SandboxedRunnable { + override fun run(input: Int): Int? { + val someNumber = testRandom() + return "12345".toNumber() * someNumber + } + } + + @Test + fun `cannot execute runnable that references non-deterministic code`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + assertThatExceptionOfType(SandboxException::class.java) + .isThrownBy { contractExecutor.run(0) } + .withCauseInstanceOf(SandboxClassLoadingException::class.java) + .withProblem("java/util/Random.(): Disallowed reference to reflection API; sun.misc.Unsafe.getUnsafe()") + } + + class TestNonDeterministicCode : SandboxedRunnable { + override fun run(input: Int): Int? { + return Random().nextInt() + } + } + + @Test + fun `cannot execute runnable that catches ThreadDeath`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + assertThatExceptionOfType(SandboxException::class.java) + .isThrownBy { contractExecutor.run(0) } + .withCauseInstanceOf(SandboxClassLoadingException::class.java) + .withMessageContaining("Disallowed catch of ThreadDeath exception") + .withMessageContaining(TestCatchThreadDeath::class.java.simpleName) + } + + class TestCatchThreadDeath : SandboxedRunnable { + override fun run(input: Int): Int? { + return try { + 0 + } catch (exception: ThreadDeath) { + 1 + } + } + } + + @Test + fun `cannot execute runnable that catches ThresholdViolationException`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + assertThatExceptionOfType(SandboxException::class.java) + .isThrownBy { contractExecutor.run(0) } + .withCauseInstanceOf(SandboxClassLoadingException::class.java) + .withMessageContaining("Disallowed catch of threshold violation exception") + .withMessageContaining(TestCatchThresholdViolationException::class.java.simpleName) + } + + class TestCatchThresholdViolationException : SandboxedRunnable { + override fun run(input: Int): Int? { + return try { + 0 + } catch (exception: ThresholdViolationException) { + 1 + } + } + } + + @Test + fun `can catch Throwable`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + contractExecutor.run(1).apply { + assertThat(result).isEqualTo(1) + } + } + + @Test + fun `can catch Error`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + contractExecutor.run(2).apply { + assertThat(result).isEqualTo(2) + } + } + + @Test + fun `cannot catch ThreadDeath`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + assertThatExceptionOfType(SandboxException::class.java) + .isThrownBy { contractExecutor.run(3) } + .withCauseInstanceOf(ThreadDeath::class.java) + } + + class TestCatchThrowableAndError : SandboxedRunnable { + override fun run(input: Int): Int? { + return try { + when (input) { + 1 -> throw Throwable() + 2 -> throw Error() + else -> 0 + } + } catch (exception: Error) { + 2 + } catch (exception: Throwable) { + 1 + } + } + } + + class TestCatchThrowableErrorAndThreadDeath : SandboxedRunnable { + override fun run(input: Int): Int? { + return try { + when (input) { + 1 -> throw Throwable() + 2 -> throw Error() + 3 -> throw ThreadDeath() + else -> 0 + } + } catch (exception: Error) { + 2 + } catch (exception: Throwable) { + 1 + } + } + } + + @Test + fun `cannot persist state across sessions`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + val result1 = contractExecutor.run(0) + val result2 = contractExecutor.run(0) + assertThat(result1.result) + .isEqualTo(result2.result) + .isEqualTo(1) + } + + class TestStatePersistence : SandboxedRunnable { + override fun run(input: Int): Int? { + ReferencedClass.value += 1 + return ReferencedClass.value + } + } + + object ReferencedClass { + @JvmField + var value = 0 + } + + @Test + fun `can load and execute code that uses IO`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + assertThatExceptionOfType(SandboxException::class.java) + .isThrownBy { contractExecutor.run(0) } + .withCauseInstanceOf(SandboxClassLoadingException::class.java) + .withMessageContaining("Files.walk(Path, Integer, FileVisitOption[]): Disallowed dynamic invocation in method") + } + + class TestIO : SandboxedRunnable { + override fun run(input: Int): Int? { + val file = Files.createTempFile("test", ".dat") + Files.newBufferedWriter(file).use { + it.write("Hello world!") + } + return 0 + } + } + + @Test + fun `can load and execute code that uses reflection`() = sandbox(DEFAULT) { + val contractExecutor = DeterministicSandboxExecutor(configuration) + assertThatExceptionOfType(SandboxException::class.java) + .isThrownBy { contractExecutor.run(0) } + .withCauseInstanceOf(SandboxClassLoadingException::class.java) + .withMessageContaining("Disallowed reference to reflection API") + .withMessageContaining("java.lang.Class.newInstance()") + .withMessageContaining("java.lang.reflect.Method.invoke(Object, Object[])") + } + + class TestReflection : SandboxedRunnable { + override fun run(input: Int): Int? { + val clazz = Object::class.java + val obj = clazz.newInstance() + val result = clazz.methods.first().invoke(obj) + return obj.hashCode() + result.hashCode() + } + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/formatter/MemberFormatterTest.kt b/djvm/src/test/kotlin/net/corda/djvm/formatter/MemberFormatterTest.kt new file mode 100644 index 0000000000..4a937ee996 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/formatter/MemberFormatterTest.kt @@ -0,0 +1,93 @@ +package net.corda.djvm.formatter + +import net.corda.djvm.formatting.MemberFormatter +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test + +class MemberFormatterTest { + + private val formatter = MemberFormatter() + + @Test + fun `can format empty signatures`() { + assertThat(formatter.format("")).isEqualTo("") + assertThat(formatter.format(" ")).isEqualTo("") + assertThat(formatter.format("()")).isEqualTo("") + assertThat(formatter.format("()V")).isEqualTo("") + assertThat(formatter.format("()I")).isEqualTo("") + } + + @Test + fun `can format signatures with a single parameter of primitive type`() { + assertThat(formatter.format("(Z)V")).isEqualTo("Boolean") + assertThat(formatter.format("(B)V")).isEqualTo("Byte") + assertThat(formatter.format("(C)V")).isEqualTo("Character") + assertThat(formatter.format("(S)V")).isEqualTo("Short") + assertThat(formatter.format("(I)V")).isEqualTo("Integer") + assertThat(formatter.format("(J)V")).isEqualTo("Long") + assertThat(formatter.format("(F)V")).isEqualTo("Float") + assertThat(formatter.format("(D)V")).isEqualTo("Double") + } + + @Test + fun `can format signatures with a single parameter of non-primitive type`() { + assertThat(formatter.format("(LString;)V")).isEqualTo("String") + assertThat(formatter.format("(Ljava/lang/String;)V")).isEqualTo("String") + assertThat(formatter.format("(Ljava/sql/SqlException;)V")).isEqualTo("SqlException") + } + + @Test + fun `can format signatures with a single array parameter`() { + assertThat(formatter.format("([Z)V")).isEqualTo("Boolean[]") + assertThat(formatter.format("([B)V")).isEqualTo("Byte[]") + assertThat(formatter.format("([C)V")).isEqualTo("Character[]") + assertThat(formatter.format("([S)V")).isEqualTo("Short[]") + assertThat(formatter.format("([I)V")).isEqualTo("Integer[]") + assertThat(formatter.format("([J)V")).isEqualTo("Long[]") + assertThat(formatter.format("([F)V")).isEqualTo("Float[]") + assertThat(formatter.format("([D)V")).isEqualTo("Double[]") + assertThat(formatter.format("([[D)V")).isEqualTo("Double[][]") + assertThat(formatter.format("([LString;)V")).isEqualTo("String[]") + assertThat(formatter.format("([Ljava/lang/String;)V")).isEqualTo("String[]") + } + + @Test + fun `can format signatures with two parameters of primitive types`() { + assertThat(formatter.format("(ZZ)V")).isEqualTo("Boolean, Boolean") + assertThat(formatter.format("(BZ)V")).isEqualTo("Byte, Boolean") + assertThat(formatter.format("(CI)V")).isEqualTo("Character, Integer") + assertThat(formatter.format("(SF)V")).isEqualTo("Short, Float") + assertThat(formatter.format("(IJ)V")).isEqualTo("Integer, Long") + } + + @Test + fun `can format signatures with multiple array parameters`() { + assertThat(formatter.format("([Z[Z)V")).isEqualTo("Boolean[], Boolean[]") + assertThat(formatter.format("([Ljava/lang/String;I)V")).isEqualTo("String[], Integer") + assertThat(formatter.format("([[Ljava/lang/String;I)V")).isEqualTo("String[][], Integer") + assertThat(formatter.format("(J[Ljava/lang/String;I)V")).isEqualTo("Long, String[], Integer") + } + + @Test + fun `can format signatures with parameters of a mix of primitive and non-primitive types`() { + assertThat(formatter.format("(ZLjava/lang/String;)V")) + .isEqualTo("Boolean, String") + assertThat(formatter.format("(Ljava/lang/String;Z)V")) + .isEqualTo("String, Boolean") + assertThat(formatter.format("(Ljava/lang/String;Ljava/math/BigInteger;)V")) + .isEqualTo("String, BigInteger") + assertThat(formatter.format("(Ljava/lang/String;IJLjava/math/BigInteger;)V")) + .isEqualTo("String, Integer, Long, BigInteger") + } + + @Test + fun `can format signatures with numerous parameters`() { + assertThat(formatter.format("(IIIII)V")) + .isEqualTo("Integer, Integer, Integer, Integer, Integer") + assertThat(formatter.format("(IZIZI)V")) + .isEqualTo("Integer, Boolean, Integer, Boolean, Integer") + assertThat(formatter.format("(SIIIJ)V")) + .isEqualTo("Short, Integer, Integer, Integer, Long") + } + +} \ No newline at end of file diff --git a/djvm/src/test/kotlin/net/corda/djvm/references/ClassHierarchyTest.kt b/djvm/src/test/kotlin/net/corda/djvm/references/ClassHierarchyTest.kt new file mode 100644 index 0000000000..6e8080743c --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/references/ClassHierarchyTest.kt @@ -0,0 +1,196 @@ +package net.corda.djvm.references + +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test +import org.objectweb.asm.Opcodes + +class ClassHierarchyTest { + + private val classModule = ClassModule() + + private val memberModule = MemberModule() + + private val classes = ClassHierarchy() + + @Test + fun `can register class in hierarchy`() { + val clazz = clazz() + classes.add(clazz) + assertThat(classes.contains(clazz.name)).isTrue() + } + + @Test + fun `can register multiple classes in hierarchy`() { + val clazz1 = clazz() + val clazz2 = clazz() + classes.add(clazz1) + classes.add(clazz2) + assertThat(classes.names).contains(clazz1.name, clazz2.name) + } + + private open class Foo + + private class Bar : Foo() + + @Test + fun `can derive members from classes in hierarchy`() { + val clazz1 = clazz() + .withMember("method", "()V") + classes.add(clazz1) + val member = classes.getMember(clazz().name, "method", "()V") + assertThat(member) + .isNotNull() + .hasFieldOrPropertyWithValue("className", clazz().name) + .hasFieldOrPropertyWithValue("memberName", "method") + .hasFieldOrPropertyWithValue("signature", "()V") + } + + @Test + fun `cannot derive non-existent members from classes in hierarchy`() { + val clazz1 = clazz() + .withMember("method", "()V") + classes.add(clazz1) + val member = classes.getMember(clazz().name, "nonExistent", "()V") + assertThat(member).isNull() + } + + @Test + fun `can derive inherited members from classes in hierarchy`() { + val clazz1 = clazz() + .withMember("method", "()V") + val clazz2 = clazzWithSuper() + classes.add(clazz1) + classes.add(clazz2) + val member = classes.getMember(clazz().name, "method", "()V") + assertThat(member) + .isNotNull() + .hasFieldOrPropertyWithValue("className", clazz().name) + .hasFieldOrPropertyWithValue("memberName", "method") + .hasFieldOrPropertyWithValue("signature", "()V") + } + + @Test + fun `can derive members from classes with ancestors in hierarchy`() { + val clazz1 = clazz() + val clazz2 = clazzWithSuper() + .withMember("method", "()V") + classes.add(clazz1) + classes.add(clazz2) + val member = classes.getMember(clazz().name, "method", "()V") + assertThat(member) + .isNotNull() + .hasFieldOrPropertyWithValue("className", clazz().name) + .hasFieldOrPropertyWithValue("memberName", "method") + .hasFieldOrPropertyWithValue("signature", "()V") + } + + @Test + fun `can derive inherited members from classes in hierarchy when multiple levels deep`() { + val clazz1 = clazz() + .withMember("method", "()V") + val clazz2 = clazzWithSuper() + .withMember("method", "()V") + val clazz3 = clazzWithSuper() + val clazz4 = clazzWithSuper() + classes.add(clazz1) + classes.add(clazz2) + classes.add(clazz3) + classes.add(clazz4) + val member = classes.getMember(clazz().name, "method", "()V") + assertThat(member) + .isNotNull() + .hasFieldOrPropertyWithValue("className", clazz().name) + .hasFieldOrPropertyWithValue("memberName", "method") + .hasFieldOrPropertyWithValue("signature", "()V") + } + + @Test + fun `can derive the correct inherited member from classes in hierarchy when multiple variants of member exists`() { + val clazz1 = clazz() + .withMember("method", "()V") + .withMember("method", "(I)V") + val clazz2 = clazzWithSuper() + .withMember("method", "(J)V") + .withMember("anotherMethod", "([B)V") + val clazz3 = clazzWithSuper() + .withMember("method", "(B)V") + val clazz4 = clazzWithSuper() + .withMember("anotherMethod", "([B)V") + classes.add(clazz1) + classes.add(clazz2) + classes.add(clazz3) + classes.add(clazz4) + + var member = classes.getMember(clazz().name, "method", "()V") + assertThat(member) + .isNotNull() + .hasFieldOrPropertyWithValue("className", clazz().name) + .hasFieldOrPropertyWithValue("memberName", "method") + .hasFieldOrPropertyWithValue("signature", "()V") + + member = classes.getMember(clazz().name, "method", "(I)V") + assertThat(member) + .isNotNull() + .hasFieldOrPropertyWithValue("className", clazz().name) + .hasFieldOrPropertyWithValue("memberName", "method") + .hasFieldOrPropertyWithValue("signature", "(I)V") + + member = classes.getMember(clazz().name, "method", "(J)V") + assertThat(member) + .isNotNull() + .hasFieldOrPropertyWithValue("className", clazz().name) + .hasFieldOrPropertyWithValue("memberName", "method") + .hasFieldOrPropertyWithValue("signature", "(J)V") + + member = classes.getMember(clazz().name, "method", "(B)V") + assertThat(member) + .isNotNull() + .hasFieldOrPropertyWithValue("className", clazz().name) + .hasFieldOrPropertyWithValue("memberName", "method") + .hasFieldOrPropertyWithValue("signature", "(B)V") + + member = classes.getMember(clazz().name, "anotherMethod", "([B)V") + assertThat(member) + .isNotNull() + .hasFieldOrPropertyWithValue("className", clazz().name) + .hasFieldOrPropertyWithValue("memberName", "anotherMethod") + .hasFieldOrPropertyWithValue("signature", "([B)V") + + member = classes.getMember(clazz().name, "anotherMethod", "([B)V") + assertThat(member) + .isNotNull() + .hasFieldOrPropertyWithValue("className", clazz().name) + .hasFieldOrPropertyWithValue("memberName", "anotherMethod") + .hasFieldOrPropertyWithValue("signature", "([B)V") + } + + private open class FirstClass + + private open class SecondClass : FirstClass() + + private open class ThirdClass : SecondClass() + + private class FourthClass : ThirdClass() + + private inline fun clazz() = + T::class.java.let { + val className = classModule.getBinaryClassName(it.name) + ClassRepresentation(0, 0, className, sourceFile = "${it.simpleName}.kt") + } + + private inline fun clazzWithSuper() = + T::class.java.let { + val apiVersion = Opcodes.V1_8 + val access = 0 + val className = classModule.getBinaryClassName(it.name) + val superClassName = TSuper::class.java.let { + classModule.getBinaryClassName(it.name) + } + ClassRepresentation(apiVersion, access, className, superClassName, sourceFile = "${it.simpleName}.kt") + } + + private fun ClassRepresentation.withMember(memberName: String, signature: String, generics: String = "") = this.apply { + memberModule.addToClass(this, Member(0, this.name, memberName, signature, generics)) + } + +} \ No newline at end of file diff --git a/djvm/src/test/kotlin/net/corda/djvm/references/ClassModuleTest.kt b/djvm/src/test/kotlin/net/corda/djvm/references/ClassModuleTest.kt new file mode 100644 index 0000000000..fd62f4f2fe --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/references/ClassModuleTest.kt @@ -0,0 +1,68 @@ +package net.corda.djvm.references + +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test + +class ClassModuleTest { + + private val module = ClassModule() + + @Test + fun `can detect arrays from type descriptors`() { + assertThat(module.isArray("java/lang/String")).isFalse() + assertThat(module.isArray("[Ljava/lang/String;")).isTrue() + assertThat(module.isArray("[[[Ljava/lang/String;")).isTrue() + } + + @Test + fun `can derive full source locations`() { + assertThat(module.getFullSourceLocation(clazz())) + .isEqualTo("net/corda/djvm/references/ClassModuleTest.kt") + } + + @Test + fun `can get binary class name from string`() { + assertThat(module.getBinaryClassName("Foo")).isEqualTo("Foo") + assertThat(module.getBinaryClassName("com.foo.Bar")).isEqualTo("com/foo/Bar") + assertThat(module.getBinaryClassName("com/foo/Bar")).isEqualTo("com/foo/Bar") + } + + @Test + fun `can get formatted class name from string`() { + assertThat(module.getFormattedClassName("Foo")).isEqualTo("Foo") + assertThat(module.getFormattedClassName("com/foo/Bar")).isEqualTo("com.foo.Bar") + assertThat(module.getFormattedClassName("com.foo.Bar")).isEqualTo("com.foo.Bar") + } + + @Test + fun `can get shortened class name from string`() { + assertThat(module.getShortName("Foo")).isEqualTo("Foo") + assertThat(module.getShortName("com/foo/Bar")).isEqualTo("Bar") + assertThat(module.getShortName("com.foo.Bar")).isEqualTo("Bar") + } + + @Test + fun `can derive normalized class names from binary representation`() { + assertThat(module.normalizeClassName("")).isEqualTo("") + assertThat(module.normalizeClassName('Z')).isEqualTo("java/lang/Boolean") + assertThat(module.normalizeClassName('B')).isEqualTo("java/lang/Byte") + assertThat(module.normalizeClassName('C')).isEqualTo("java/lang/Character") + assertThat(module.normalizeClassName('S')).isEqualTo("java/lang/Short") + assertThat(module.normalizeClassName('I')).isEqualTo("java/lang/Integer") + assertThat(module.normalizeClassName('J')).isEqualTo("java/lang/Long") + assertThat(module.normalizeClassName('F')).isEqualTo("java/lang/Float") + assertThat(module.normalizeClassName('D')).isEqualTo("java/lang/Double") + assertThat(module.normalizeClassName('X')).isEqualTo("X") + assertThat(module.normalizeClassName("XXX")).isEqualTo("XXX") + assertThat(module.normalizeClassName("Ljava/util/Random;")).isEqualTo("java/util/Random") + assertThat(module.normalizeClassName("[Ljava/util/Random;")).isEqualTo("java/util/Random[]") + assertThat(module.normalizeClassName("[[Ljava/util/Random;")).isEqualTo("java/util/Random[][]") + } + + private inline fun clazz() = + T::class.java.let { + val className = module.getBinaryClassName(it.name) + ClassRepresentation(0, 0, className, className, sourceFile = "${it.simpleName}.kt") + } + +} \ No newline at end of file diff --git a/djvm/src/test/kotlin/net/corda/djvm/references/MemberModuleTest.kt b/djvm/src/test/kotlin/net/corda/djvm/references/MemberModuleTest.kt new file mode 100644 index 0000000000..616a7ca7b6 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/references/MemberModuleTest.kt @@ -0,0 +1,143 @@ +package net.corda.djvm.references + +import net.corda.djvm.annotations.NonDeterministic +import org.assertj.core.api.Assertions.assertThat +import org.jetbrains.annotations.NotNull +import org.junit.Test + +class MemberModuleTest { + + private val module = MemberModule() + + @Test + fun `can detect empty parameter list based on signature`() { + assertThat(module.numberOfArguments("")).isEqualTo(0) + assertThat(module.numberOfArguments("()V")).isEqualTo(0) + } + + @Test + fun `can detect number of parameters based on trivial signature`() { + assertThat(module.numberOfArguments("(I)V")).isEqualTo(1) + assertThat(module.numberOfArguments("(IJ)V")).isEqualTo(2) + } + + @Test + fun `can detect number of parameters based on signature containing arrays`() { + assertThat(module.numberOfArguments("([IJ)V")).isEqualTo(2) + assertThat(module.numberOfArguments("([[I[J)V")).isEqualTo(2) + assertThat(module.numberOfArguments("(B[[I[J)V")).isEqualTo(3) + assertThat(module.numberOfArguments("(B[[I[JI)V")).isEqualTo(4) + } + + @Test + fun `can detect number of parameters based on signature containing delegates`() { + assertThat(module.numberOfArguments("(B[[I[J(I)I)V")).isEqualTo(4) + assertThat(module.numberOfArguments("(B[[I[J(I)IJ)V")).isEqualTo(5) + } + + @Test + fun `can detect number of parameters based on signature with long names`() { + assertThat(module.numberOfArguments("(ILjava/lang/String;)V")).isEqualTo(2) + assertThat(module.numberOfArguments("(ILfoo/Bar;JLbar/Foo;)V")).isEqualTo(4) + } + + @Test + fun `can detect void returns based on signature`() { + assertThat(module.returnsValueOrReference("()V")).isEqualTo(false) + assertThat(module.returnsValueOrReference("(Ljava/lang/String;[IJ)V")).isEqualTo(false) + } + + @Test + fun `can detect primitive value returns based on signature`() { + assertThat(module.returnsValueOrReference("()I")).isEqualTo(true) + assertThat(module.returnsValueOrReference("(IJ)I")).isEqualTo(true) + assertThat(module.returnsValueOrReference("([IJ)I")).isEqualTo(true) + assertThat(module.returnsValueOrReference("(Ljava/lang/String;[IJ)I")).isEqualTo(true) + } + + @Test + fun `can detect array value returns based on signature`() { + assertThat(module.returnsValueOrReference("()[B")).isEqualTo(true) + assertThat(module.returnsValueOrReference("(IJ)[[Z")).isEqualTo(true) + } + + @Test + fun `can detect object returns based on signature`() { + assertThat(module.returnsValueOrReference("()Ljava/lang/Object;")).isEqualTo(true) + assertThat(module.returnsValueOrReference("()Lfoo/bar/Baz;")).isEqualTo(true) + } + + @Test + fun `can get qualifying identifier`() { + assertThat(module.getQualifyingIdentifier("foo", "()V")).isEqualTo("foo:()V") + assertThat(module.getQualifyingIdentifier("bar", "(IJ)Z")).isEqualTo("bar:(IJ)Z") + } + + @Test + fun `can detect class references in signatures`() { + assertThat(module.findReferencedClasses(reference("()V"))) + .containsExactly() + assertThat(module.findReferencedClasses(reference("(IJ)V"))) + .containsExactly() + assertThat(module.findReferencedClasses(reference("(Lcom/foo/Bar;)V"))) + .containsExactly("com/foo/Bar") + assertThat(module.findReferencedClasses(reference("(Lcom/foo/Bar;Lnet/bar/Baz;)V"))) + .containsExactly("com/foo/Bar", "net/bar/Baz") + assertThat(module.findReferencedClasses(reference("(ILcom/foo/Bar;JLnet/bar/Baz;Z)V"))) + .containsExactly("com/foo/Bar", "net/bar/Baz") + assertThat(module.findReferencedClasses(reference("(ILcom/foo/Bar;JLnet/bar/Baz;Z)Lnet/a/B;"))) + .containsExactly("com/foo/Bar", "net/bar/Baz", "net/a/B") + } + + @Test + fun `can determine if annotation is one for marking class or member non-deterministic`() { + assertThat(module.isNonDeterministic(NotNull::class.java.descriptor)).isFalse() + assertThat(module.isNonDeterministic(NonDeterministic::class.java.descriptor)).isTrue() + } + + @Test + fun `can detect fields from signatures`() { + assertThat(module.isField(reference("()V"))).isFalse() + assertThat(module.isField(reference("(IJ)V"))).isFalse() + assertThat(module.isField(reference("(IJ)Lfoo/Bar;"))).isFalse() + assertThat(module.isField(reference("(Ljava/lang/String;J)V"))).isFalse() + assertThat(module.isField(reference("(Ljava/lang/String;J)Lfoo/Bar;"))).isFalse() + assertThat(module.isField(reference("V"))).isTrue() + assertThat(module.isField(reference("[Z"))).isTrue() + assertThat(module.isField(reference("Ljava/lang/String;"))).isTrue() + assertThat(module.isField(reference("[Ljava/lang/String;"))).isTrue() + } + + @Test + fun `can detect methods from signatures`() { + assertThat(module.isMethod(reference("()V"))).isTrue() + assertThat(module.isMethod(reference("(IJ)V"))).isTrue() + assertThat(module.isMethod(reference("(IJ)Lfoo/Bar;"))).isTrue() + assertThat(module.isMethod(reference("(Ljava/lang/String;J)V"))).isTrue() + assertThat(module.isMethod(reference("(Ljava/lang/String;J)Lfoo/Bar;"))).isTrue() + assertThat(module.isMethod(reference("V"))).isFalse() + assertThat(module.isMethod(reference("[Z"))).isFalse() + assertThat(module.isMethod(reference("Ljava/lang/String;"))).isFalse() + assertThat(module.isMethod(reference("[Ljava/lang/String;"))).isFalse() + } + + @Test + fun `can detect constructors from signatures`() { + assertThat(module.isConstructor(member("foo"))).isFalse() + assertThat(module.isConstructor(member("helloWorld"))).isFalse() + assertThat(module.isConstructor(member("init"))).isFalse() + assertThat(module.isConstructor(member(""))).isFalse() + assertThat(module.isConstructor(member(""))).isTrue() + assertThat(module.isConstructor(member(""))).isTrue() + } + + private val java.lang.Class<*>.descriptor: String + get() = "L${name.replace('.', '/')};" + + private fun member(member: String) = + MemberReference("", member, "") + + private fun reference(signature: String) = + MemberReference("", "", signature) + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/rewiring/ClassRewriterTest.kt b/djvm/src/test/kotlin/net/corda/djvm/rewiring/ClassRewriterTest.kt new file mode 100644 index 0000000000..6abcca8e21 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/rewiring/ClassRewriterTest.kt @@ -0,0 +1,64 @@ +package net.corda.djvm.rewiring + +import foo.bar.sandbox.A +import foo.bar.sandbox.B +import foo.bar.sandbox.Empty +import foo.bar.sandbox.StrictFloat +import net.corda.djvm.TestBase +import net.corda.djvm.assertions.AssertionExtensions.assertThat +import net.corda.djvm.costing.ThresholdViolationException +import net.corda.djvm.execution.ExecutionProfile +import org.assertj.core.api.Assertions.assertThatExceptionOfType +import org.junit.Test + +class ClassRewriterTest : TestBase() { + + @Test + fun `empty transformer does nothing`() = sandbox(BLANK) { + val callable = newCallable() + assertThat(callable).hasNotBeenModified() + callable.createAndInvoke() + assertThat(runtimeCosts).areZero() + } + + @Test + fun `can transform class`() = sandbox(DEFAULT) { + val callable = newCallable() + assertThat(callable).hasBeenModified() + callable.createAndInvoke() + assertThat(runtimeCosts).hasInvocationCost(1) + } + + @Test + fun `can transform another class`() = sandbox(DEFAULT) { + val callable = newCallable() + assertThat(callable).hasBeenModified() + assertThat(callable).isSandboxed() + callable.createAndInvoke() + assertThat(runtimeCosts) + .hasInvocationCostGreaterThanOrEqualTo(1) // Includes static constructor calls for java.lang.Math, etc. + .hasJumpCostGreaterThanOrEqualTo(30 * 2 + 1) + } + + @Test + fun `cannot breach threshold`() = sandbox(ExecutionProfile.DISABLE_BRANCHING, DEFAULT) { + val callable = newCallable() + assertThat(callable).hasBeenModified() + assertThat(callable).isSandboxed() + assertThatExceptionOfType(ThresholdViolationException::class.java).isThrownBy { + callable.createAndInvoke() + }.withMessageContaining("terminated due to excessive use of looping") + assertThat(runtimeCosts) + .hasAllocationCost(0) + .hasInvocationCost(1) + .hasJumpCost(1) + } + + @Test + fun `can transform class into using strictfp`() = sandbox(DEFAULT) { + val callable = newCallable() + assertThat(callable).hasBeenModified() + callable.createAndInvoke() + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/rules/ReferenceExtractorTest.kt b/djvm/src/test/kotlin/net/corda/djvm/rules/ReferenceExtractorTest.kt new file mode 100644 index 0000000000..3ea655c24f --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/rules/ReferenceExtractorTest.kt @@ -0,0 +1,62 @@ +package net.corda.djvm.rules + +import foo.bar.sandbox.Callable +import net.corda.djvm.TestBase +import net.corda.djvm.assertions.AssertionExtensions.assertThat +import org.junit.Test +import java.util.* + +class ReferenceExtractorTest : TestBase() { + + @Test + fun `can find method references`() = validate { context -> + assertThat(context.references) + .hasClass("java/util/Random") + .withLocationCount(1) + .hasMember("java/lang/Object", "", "()V") + .withLocationCount(1) + .hasMember("java/util/Random", "", "()V") + .withLocationCount(1) + .hasMember("java/util/Random", "nextInt", "()I") + .withLocationCount(1) + } + + class A : Callable { + override fun call() { + synchronized(this) { + Random().nextInt() + } + } + } + + @Test + fun `can find field references`() = validate { context -> + assertThat(context.references) + .hasMember(B::class.java.name.replace('.', '/'), "foo", "Ljava/lang/String;") + } + + class B { + @JvmField + val foo: String = "" + + fun test(): String { + return foo + } + } + + @Test + fun `can find class references`() = validate { context -> + assertThat(context.references) + .hasClass(A::class.java.name.replace('.', '/')) + } + + class C { + @JvmField + val foo: A? = null + + fun test(): A? { + return foo + } + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/rules/RuleValidatorTest.kt b/djvm/src/test/kotlin/net/corda/djvm/rules/RuleValidatorTest.kt new file mode 100644 index 0000000000..260cfc6488 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/rules/RuleValidatorTest.kt @@ -0,0 +1,68 @@ +package net.corda.djvm.rules + +import foo.bar.sandbox.Callable +import net.corda.djvm.TestBase +import net.corda.djvm.assertions.AssertionExtensions.assertThat +import net.corda.djvm.messages.Severity +import org.junit.Test +import org.objectweb.asm.Opcodes +import sandbox.greymalkin.StringReturner + +class RuleValidatorTest : TestBase() { + + @Test + fun `can validate empty class`() = validate(Severity.TRACE) { context -> + assertThat(context.classes) + .hasCount(1) + .hasClass(nameOf()) + .withMemberCount(1) + .withMember("", "()V") + assertThat(context.messages) + .hasErrorCount(0) + .hasWarningCount(0) + .hasInfoCount(0) + .hasTraceCount(2) + .withMessage("Synchronization specifier will be ignored") + .withMessage("Strict floating-point arithmetic will be applied") + } + + class Empty + + @Test + fun `can validate class`() = validate(Severity.TRACE) { context -> + assertThat(context.classes) + .hasCount(1) + .hasClass(nameOf()) + .withInterfaceCount(1) + .withInterface(nameOf()) + .withMemberCount(2) + .withMember("", "()V") + .withMember("call", "()V") + .withNoAccessFlag(Opcodes.ACC_STRICT) + assertThat(context.messages) + .hasErrorCount(0) + .hasWarningCount(0) + .hasInfoCount(1) + .withMessage("Stripped monitoring instruction") + .hasTraceCount(4) + .withMessage("Synchronization specifier will be ignored") + .withMessage("Strict floating-point arithmetic will be applied") + } + + class A : Callable { + override fun call() { + synchronized(this) { } + } + } + + @Test + fun `can reject invalid class from sandbox package`() = validate { context -> + assertThat(context.classes) + .hasCount(1) + assertThat(context.messages) + .hasErrorCount(1) + .withMessage("Cannot load class explicitly defined in the 'sandbox' root package; " + + "sandbox/greymalkin/StringReturner") + } + +} diff --git a/djvm/src/test/kotlin/net/corda/djvm/source/SourceClassLoaderTest.kt b/djvm/src/test/kotlin/net/corda/djvm/source/SourceClassLoaderTest.kt new file mode 100644 index 0000000000..3837948678 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/source/SourceClassLoaderTest.kt @@ -0,0 +1,105 @@ +package net.corda.djvm.source + +import net.corda.djvm.analysis.ClassResolver +import net.corda.djvm.analysis.Whitelist +import org.assertj.core.api.Assertions.assertThat +import org.junit.After +import org.junit.Test +import java.nio.file.Files +import java.nio.file.Path + +class SourceClassLoaderTest { + + private val classResolver = ClassResolver(emptySet(), Whitelist.MINIMAL, "") + + @Test + fun `can load class from Java's lang package when no files are provided to the class loader`() { + val classLoader = SourceClassLoader(emptyList(), classResolver) + val clazz = classLoader.loadClass("java.lang.Boolean") + assertThat(clazz.simpleName).isEqualTo("Boolean") + } + + @Test(expected = ClassNotFoundException::class) + fun `cannot load arbitrary class when no files are provided to the class loader`() { + val classLoader = SourceClassLoader(emptyList(), classResolver) + classLoader.loadClass("net.foo.NonExistentClass") + } + + @Test + fun `can load class when JAR file is provided to the class loader`() { + useTemporaryFile("jar-with-single-class.jar") { + val classLoader = SourceClassLoader(this, classResolver) + val clazz = classLoader.loadClass("net.foo.Bar") + assertThat(clazz.simpleName).isEqualTo("Bar") + } + } + + @Test(expected = ClassNotFoundException::class) + fun `cannot load arbitrary class when JAR file is provided to the class loader`() { + useTemporaryFile("jar-with-single-class.jar") { + val classLoader = SourceClassLoader(this, classResolver) + classLoader.loadClass("net.foo.NonExistentClass") + } + } + + @Test + fun `can load classes when multiple JAR files are provided to the class loader`() { + useTemporaryFile("jar-with-single-class.jar", "jar-with-two-classes.jar") { + val classLoader = SourceClassLoader(this, classResolver) + val firstClass = classLoader.loadClass("com.somewhere.Test") + assertThat(firstClass.simpleName).isEqualTo("Test") + val secondClass = classLoader.loadClass("com.somewhere.AnotherTest") + assertThat(secondClass.simpleName).isEqualTo("AnotherTest") + } + } + + @Test(expected = ClassNotFoundException::class) + fun `cannot load arbitrary class when multiple JAR files are provided to the class loader`() { + useTemporaryFile("jar-with-single-class.jar", "jar-with-two-classes.jar") { + val classLoader = SourceClassLoader(this, classResolver) + classLoader.loadClass("com.somewhere.NonExistentClass") + } + } + + @Test + fun `can load class when folder containing JAR file is provided to the class loader`() { + useTemporaryFile("jar-with-single-class.jar", "jar-with-two-classes.jar") { + val (first, second) = this + val directory = first.parent + val classLoader = SourceClassLoader(listOf(directory), classResolver) + assertThat(classLoader.resolvedUrls).anySatisfy { + assertThat(it).isEqualTo(first.toUri().toURL()) + }.anySatisfy { + assertThat(it).isEqualTo(second.toUri().toURL()) + } + } + } + + @After + fun cleanup() { + openedFiles.forEach { + try { + Files.deleteIfExists(it) + } catch (exception: Exception) { + // Ignore + } + } + } + + private val openedFiles = mutableListOf() + + private fun useTemporaryFile(vararg resourceNames: String, action: List.() -> Unit) { + val paths = resourceNames.map { resourceName -> + val stream = SourceClassLoaderTest::class.java.getResourceAsStream("/$resourceName") + ?: throw Exception("Cannot find resource \"$resourceName\"") + Files.createTempFile("source-class-loader", ".jar").apply { + Files.newOutputStream(this).use { + stream.copyTo(it) + } + } + } + openedFiles.addAll(paths) + action(paths) + } + +} \ No newline at end of file diff --git a/djvm/src/test/kotlin/net/corda/djvm/utilities/DiscoveryTest.kt b/djvm/src/test/kotlin/net/corda/djvm/utilities/DiscoveryTest.kt new file mode 100644 index 0000000000..e470165426 --- /dev/null +++ b/djvm/src/test/kotlin/net/corda/djvm/utilities/DiscoveryTest.kt @@ -0,0 +1,33 @@ +package net.corda.djvm.utilities + +import net.corda.djvm.TestBase +import net.corda.djvm.code.DefinitionProvider +import net.corda.djvm.code.Emitter +import net.corda.djvm.rules.Rule +import org.assertj.core.api.Assertions.assertThat +import org.junit.Test + +class DiscoveryTest : TestBase() { + + @Test + fun `can discover rules automatically`() { + val rules = ALL_RULES + assertThat(rules.size).isGreaterThan(0) + assertThat(rules).allMatch { it is Rule } + } + + @Test + fun `can discover definition providers automatically`() { + val definitionProviders = ALL_DEFINITION_PROVIDERS + assertThat(definitionProviders.size).isGreaterThan(0) + assertThat(definitionProviders).allMatch { it is DefinitionProvider } + } + + @Test + fun `can discover emitters automatically`() { + val emitters = ALL_EMITTERS + assertThat(emitters.size).isGreaterThan(0) + assertThat(emitters).allMatch { it is Emitter } + } + +} diff --git a/djvm/src/test/kotlin/sandbox/greymalkin/StringReturner.kt b/djvm/src/test/kotlin/sandbox/greymalkin/StringReturner.kt new file mode 100644 index 0000000000..62645d8f46 --- /dev/null +++ b/djvm/src/test/kotlin/sandbox/greymalkin/StringReturner.kt @@ -0,0 +1,8 @@ +package sandbox.greymalkin + +// Simple hack for now, generalise to lambdas later... +interface StringReturner { + + fun addEntry(): String + +} diff --git a/djvm/src/test/resources/jar-with-single-class.jar b/djvm/src/test/resources/jar-with-single-class.jar new file mode 100644 index 0000000000..af784110bf Binary files /dev/null and b/djvm/src/test/resources/jar-with-single-class.jar differ diff --git a/djvm/src/test/resources/jar-with-two-classes.jar b/djvm/src/test/resources/jar-with-two-classes.jar new file mode 100644 index 0000000000..9e0f50e44f Binary files /dev/null and b/djvm/src/test/resources/jar-with-two-classes.jar differ diff --git a/djvm/src/test/resources/log4j2.xml b/djvm/src/test/resources/log4j2.xml new file mode 100644 index 0000000000..93e84b6252 --- /dev/null +++ b/djvm/src/test/resources/log4j2.xml @@ -0,0 +1,39 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docs/source/key-concepts-djvm.rst b/docs/source/key-concepts-djvm.rst new file mode 100644 index 0000000000..457b6aabaa --- /dev/null +++ b/docs/source/key-concepts-djvm.rst @@ -0,0 +1,376 @@ +Deterministic JVM +================= + +.. contents:: + :depth: 2 + +Introduction +~~~~~~~~~~~~ + +The code in the DJVM module has not yet been integrated with the rest of the platform. It will eventually become a +part of the node and enforce deterministic and secure execution of smart contract code, which is mobile and may +propagate around the network without human intervention. + +Currently, it stands alone as an evaluation version. We want to give developers the ability to start trying it out and +get used to developing deterministic code under the set of constraints that we envision will be placed on contract code +in the future. + +.. warning:: + The deterministic sandbox is currently a standalone evaluation version of what we, in the future, want to integrate + with the Corda platform to protect execution of contract code and ensure deterministic behaviour. + + +Motivation and Overview +~~~~~~~~~~~~~~~~~~~~~~~ + +It is important that all nodes that process a transaction always agree on whether it is valid or not. Because +transaction types are defined using JVM byte code, this means that the execution of that byte code must be fully +deterministic. Out of the box a standard JVM is not fully deterministic, thus we must make some modifications in order +to satisfy our requirements. + +So, what does it mean for a piece of code to be fully deterministic? Ultimately, it means that the code, when viewed +as a function, is pure. In other words, given the same set of inputs, it will always produce the same set of outputs +without inflicting any side-effects that might later affect the computation. + + +Non-Determinism +............... + +For a program running on the JVM, non-determinism could be introduced by a range of sources, for instance: + + - **External input**, *e.g.*, the file system, network, system properties and clocks. + + - **Random number generators**. + + - **Halting criteria**, *e.g.*, different decisions about when to terminate long running programs. + + - **Hash-codes**, or more specifically ``Object.hashCode()``, which is typically implemented either by returning a + pointer address or by assigning the object a random number. This could, for instance, surface as different iteration + orders over hash maps and hash sets, or be used as non-pure input into arbitrary expressions. + + - Differences in hardware **floating point arithmetic**. + + - **Multi-threading** and consequent differences in scheduling strategies, affinity, *etc.* + + - Differences in **API implementations** between nodes. + + - **Garbage collector callbacks**. + +To ensure that the contract verification function is fully pure even in the face of infinite loops we want to use a +custom-built JVM sandbox. The sandbox performs static analysis of loaded byte code and a rewriting pass to allow for +necessary instrumentation and constraint hardening. + +The byte code rewriting further allows us to patch up and control the default behaviour of things like the hash-code +generation for ``java.lang.Object``. Contract code is rewritten the first time it needs to be executed and then stored +for future use. + +Abstraction +........... + +The sandbox is abstracted away as an executor which takes as input an implementation of the interface +``SandboxedRunnable``, dereferenced by a ``ClassSource``. This interface has a single method that +needs implementing, namely ``run(Input): Output``. + +A ``ClassSource`` object referencing such an implementation can be passed into the ``SandboxExecutor`` together with an input of type ``Input``. The executor has operations for both execution and static +validation, namely ``run()`` and ``validate()``. These methods both return a summary object. + + * In the case of execution, this summary object has information about: + * Whether or not the runnable was successfully executed. + * If successful, the return value of ``SandboxedRunnable.run()``. + * If failed, the exception that was raised. + * And in both cases, a summary of all accrued costs during execution. + + * For validation, the summary contains: + * A type hierarchy of classes and interfaces loaded and touched by the sandbox's class loader during analysis, each + of which contain information about the respective transformations applied as well as meta-data about the types + themselves and all references made from said classes. + * A list of messages generated during the analysis. These can be of different severity, and only messages of + severity ``ERROR`` will prevent execution. + +The sandbox has a configuration that applies to the execution of a specific runnable. This configuration, on a higher +level, contains a set of rules, definition providers, emitters and a whitelist. + +.. image:: resources/djvm-overview.png + +The set of rules is what defines the constraints posed on the runtime environment. A rule can act on three different +levels, namely on a type-, member- or instruction-level. The set of rules get processed and validated by the +``RuleValidator`` prior to execution. + +Similarly, there is a set of definition providers which can be used to modify the definition of either a type or a +type's members. This is what controls things like ensuring that all methods implement strict floating point arithmetic, +and normalisation of synchronised methods. + +Lastly, there is a set of emitters. These are used to instrument the byte code for cost accounting purposes, and also +to inject code for checks that we want to perform at runtime or modifications to out-of-the-box behaviour. + + +Static Byte Code Analysis +~~~~~~~~~~~~~~~~~~~~~~~~~ + +In summary, the byte code analysis currently performs the following checks. This is not an exhaustive list as further +work may well introduce additional constraints that we would want to place on the sandbox environment. + +.. contents:: + :local: + +.. note:: + It is worth noting that not only smart contract code is instrumented by the sandbox, but all code that it can + transitively reach. In particular this means that the Java runtime classes (that have not been whitelisted) and any + other library code used in the program are also instrumented and persisted ahead of time. + + +Disallow Catching ThreadDeath Exception +....................................... + +Prevents exception handlers from catching ``ThreadDeath`` exceptions. If the developer attempts to catch an ``Error`` +or a ``Throwable`` (both being transitive parent types of ``ThreadDeath``), an explicit check will be injected into the +byte code to verify that exceptions that are trying to kill the current thread are not being silenced. Consequently, +the user will not be able to bypass an exit signal. + + +Disallow Catching ThresholdViolationException +............................................. + +The ``ThresholdViolationException`` is, as the name suggests, used to signal to the sandbox that a cost tracked by the +runtime cost accountant has been breached. For obvious reasons, the sandbox needs to protect against user code that +tries to catch such exceptions, as doing so would allow the user to bypass the thresholds set out in the execution +profile. + + +Only Allow Explicitly Whitelisted Runtime API +............................................. + +Ensures that constant pool references are mapped against a verified subset of the Java runtime libraries. Said subset +excludes functionality that contract code should not have access to, such as native code. This whitelist has been +trimmed down to the bare minimum needed, a few classes in ``java.lang``, so that also the Java runtime libraries +themselves are subjected to the same amount of scrutiny that the rest of the code is. + + +Disallow Dynamic Invocation +........................... + +Forbids ``invokedynamic`` byte code as the libraries that support this functionality have historically had security +problems and it is primarily needed only by scripting languages. In the future, this constraint will be eased to allow +for dynamic invocation in the specific lambda and string concatenation meta-factories used by Java code itself. + + +Disallow Native Methods +....................... + +Forbids native methods as these provide the user access into operating system functionality such as file handling, +network requests, general hardware interaction, threading, *etc.* These all constitute sources of non-determinism, and +allowing such code to be called arbitrarily from the JVM would require deterministic guarantees on the native machine +code level. This falls out of scope for the DJVM. + +Java runtime classes that call into native code and that are needed from within the sandbox environment, can be +whitelisted explicitly. + + +Disallow Finalizer Methods +.......................... + +Forbids finalizers as these can be called at unpredictable times during execution, given that their invocation is +controlled by the garbage collector. As stated in the standard Java documentation: + +.. + + Called by the garbage collector on an object when garbage collection determines that there are no more references + to the object. + + +Disallow Overridden Sandbox Package +................................... + +Forbids attempts to override rewritten classes. For instance, loading a class ``com.foo.Bar`` into the sandbox, +analyses it, rewrites it and places it into ``sandbox.com.foo.Bar``. Attempts to place originating classes in the +top-level ``sandbox`` package will therefore fail as this poses a security risk. Doing so would essentially bypass rule +validation and instrumentation. + + +Disallow Breakpoints +.................... + +For obvious reasons, the breakpoint operation code is forbidden as this can be exploited to unpredictably suspend code +execution and consequently interfere with any time bounds placed on the execution. + + +Disallow Reflection +................... + +For now, the use of reflection APIs is forbidden as the unmanaged use of these can provide means of breaking out of the +protected sandbox environment. + + +Disallow Unsupported API Versions +................................. + +Ensures that loaded classes are targeting an API version between 1.5 and 1.8 (inclusive). This is merely to limit the +breadth of APIs from the standard runtime that needs auditing. + + +Runtime Costing +~~~~~~~~~~~~~~~ + +The runtime accountant inserts calls to an accounting object before expensive byte code. The goal of this rewrite is to +deterministically terminate code that has run for an unacceptably long amount of time or used an unacceptable amount of +memory. Types of expensive byte code include method invocation, memory allocation, branching and exception throwing. + +The cost instrumentation strategy used is a simple one: just counting byte code that are known to be expensive to +execute. The methods can be limited in size and jumps count towards the costing budget, allowing us to determine a +consistent halting criteria. However it is still possible to construct byte code sequences by hand that take excessive +amounts of time to execute. The cost instrumentation is designed to ensure that infinite loops are terminated and that +if the cost of verifying a transaction becomes unexpectedly large (*e.g.*, contains algorithms with complexity +exponential in transaction size) that all nodes agree precisely on when to quit. It is not intended as a protection +against denial of service attacks. If a node is sending you transactions that appear designed to simply waste your CPU +time then simply blocking that node is sufficient to solve the problem, given the lack of global broadcast. + +The budgets are separate per operation code type, so there is no unified cost model. Additionally the instrumentation is +high overhead. A more sophisticated design would be to calculate byte code costs statically as much as possible ahead of +time, by instrumenting only the entry point of 'accounting blocks', *i.e.*, runs of basic blocks that end with either a +method return or a backwards jump. Because only an abstract cost matters (this is not a profiler tool) and because the +limits are expected to bet set relatively high, there is no need to instrument every basic block. Using the max of both +sides of a branch is sufficient when neither branch target contains a backwards jump. This sort of design will be +investigated if the per category budget accounting turns out to be insufficient. + +A further complexity comes from the need to constrain memory usage. The sandbox imposes a quota on bytes allocated +rather than bytes retained in order to simplify the implementation. This strategy is unnecessarily harsh on smart +contracts that churn large quantities of garbage yet have relatively small peak heap sizes and, again, it may be that +in practice a more sophisticated strategy that integrates with the garbage collector is required in order to set quotas +to a usefully generic level. + +.. note:: + The current thresholds have been set arbitrarily for demonstration purposes and should not be relied upon as + sensible defaults in a production environment. + + +Instrumentation and Rewriting +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Always Use Strict Floating Point Arithmetic +........................................... + +Sets the ``strictfp`` flag on all methods, which requires the JVM to do floating point arithmetic in a hardware +independent fashion. Whilst we anticipate that floating point arithmetic is unlikely to feature in most smart contracts +(big integer and big decimal libraries are available), it is available for those who want to use it. + + +Always Use Exact Math +..................... + +Replaces integer and long addition and multiplication with calls to ``Math.addExact()`` and ``Math.multiplyExact``, +respectively. Further work can be done to implement exact operations for increments, decrements and subtractions as +well. These calls into ``java.lang.Math`` essentially implement checked arithmetic over integers, which will throw an +exception if the operation overflows. + + +Always Inherit From Sandboxed Object +.................................... + +As mentioned further up, ``Object.hashCode()`` is typically implemented using either the memory address of the object +or a random number; which are both non-deterministic. The DJVM shields the runtime from this source of non-determinism +by rewriting all classes that inherit from ``java.lang.Object`` to derive from ``sandbox.java.lang.Object`` instead. +This sandboxed ``Object`` implementation takes a hash-code as an input argument to the primary constructor, persists it +and returns the value from the ``hashCode()`` method implementation. It also has an overridden implementation of +``toString()``. + +The loaded classes are further rewritten in two ways: + + * All allocations of new objects of type ``java.lang.Object`` get mapped into using the sandboxed object. + + * Calls to the constructor of ``java.lang.Object`` get mapped to the constructor of ``sandbox.java.lang.Object`` + instead, passing in a constant value for now. In the future, we can easily have this passed-in hash-code be a pseudo + random number seeded with, for instance, the hash of the transaction or some other dynamic value, provided of course + that it is deterministically derived. + + +Disable Synchronised Methods and Blocks +....................................... + +Since Java's multi-threading API has been excluded from the whitelist, synchronised methods and code blocks have little +use in sandboxed code. Consequently, we log informational messages about occurrences of this in your sandboxed code and +automatically transform them into ordinary methods and code blocks instead. + + +Future Work +~~~~~~~~~~~ + +Further work is planned: + + * To enable controlled use of reflection APIs. + + * Strip out the dependency on the extensive whitelist of underlying Java + runtime classes. + + * Currently, dynamic invocation is disallowed. Allow specific lambda and + string concatenation meta-factories used by Java code itself. + + * Map more mathematical operations to use their 'exact' counterparts. + + * General tightening of the enforced constraints. + + * Cost accounting of runtime metrics such as memory allocation, branching and + exception handling. More specifically defining sensible runtime thresholds + and make further improvements to the instrumentation. + + * More sophisticated runtime accounting as discussed in `Runtime Costing`_. + + +Command-line Tool +~~~~~~~~~~~~~~~~~ + +Open your terminal and navigate to the ``djvm`` folder. Then issue the following command: + +:: + + djvm > ./shell/install + + +This will build the DJVM tool and install a shortcut on Bash-enabled systems. It will also generate a Bash completion +file and store it in the ``shell`` folder. This file can be sourced from your Bash initialisation script. + +:: + + djvm > cd ~ + ~ > djvm + +Now, you can create a new Java file from a skeleton that ``djvm`` provides, compile the file, and consequently run it +by issuing the following commands: + +:: + + ~ > djvm new Hello + ~ > vim tmp/net/corda/sandbox/Hello.java + ~ > djvm build Hello + ~ > djvm run Hello + +This run will produce some output similar to this: + +:: + + Running class net.corda.sandbox.Hello... + Execution successful + - result = null + + Runtime Cost Summary: + - allocations = 0 + - invocations = 1 + - jumps = 0 + - throws = 0 + +The output should be pretty self-explanatory, but just to summarise: + + * It prints out the return value from the ``SandboxedRunnable.run()`` method implemented in + ``net.corda.sandbox.Hello``. + + * It also prints out the aggregated costs for allocations, invocations, jumps and throws. + +Other commands to be aware of are: + + * ``djvm check`` which allows you to perform the up-front static analysis without running the code. + + * ``djvm inspect`` which allows you to inspect what byte code modifications will be applied to a class. + + * ``djvm show`` which displays the transformed byte code of a class, *i.e.*, the end result and not the difference. + + * ``djvm whitelist`` which displays the content of the whitelist in use. diff --git a/docs/source/key-concepts.rst b/docs/source/key-concepts.rst index e0d5508229..8fcfd61d9f 100644 --- a/docs/source/key-concepts.rst +++ b/docs/source/key-concepts.rst @@ -24,6 +24,7 @@ This section should be read in order: key-concepts-node key-concepts-tearoffs key-concepts-tradeoffs + key-concepts-djvm The detailed thinking and rationale behind these concepts are presented in two white papers: diff --git a/docs/source/resources/djvm-overview.png b/docs/source/resources/djvm-overview.png new file mode 100644 index 0000000000..1a33881f3d Binary files /dev/null and b/docs/source/resources/djvm-overview.png differ diff --git a/experimental/sandbox/README.md b/experimental/sandbox/README.md deleted file mode 100644 index 30f3f74298..0000000000 --- a/experimental/sandbox/README.md +++ /dev/null @@ -1,22 +0,0 @@ -# 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 deleted file mode 100644 index 64c08930f3..0000000000 --- a/experimental/sandbox/build.gradle +++ /dev/null @@ -1,49 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -apply plugin: 'java' -apply plugin: 'kotlin' - -buildscript { - ext.asm_version = '5.1' - ext.logback_version = '1.2.3' -} - -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:$jopt_simple_version" - - // Simple Logging Facade: makes the code independent of the chosen logging framework. - compile "org.slf4j:slf4j-api:$slf4j_version" - compile "ch.qos.logback:logback-classic:$logback_version" - - testCompile "junit:junit:$junit_version" -} - -task standaloneJar(type: Jar) { - // Create a fat jar by packing all deps into the output - from { - configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } - } - with jar - manifest { - attributes( - 'Main-Class': 'net.corda.sandbox.tools.SandboxCreator', - 'Automatic-Module-Name': 'net.corda.sandbox.creator' - ) - } - archiveName "corda-sandbox-creator-${version}.jar" -} diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/CandidacyStatus.java b/experimental/sandbox/src/main/java/net/corda/sandbox/CandidacyStatus.java deleted file mode 100644 index c742cee8c8..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/CandidacyStatus.java +++ /dev/null @@ -1,225 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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; - -/** - * 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 candidateMethods = new TreeMap<>(); - - // Backlog of methodSignatures that may have come in from other loaded classes - private final Set 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 - */ - void putIfAbsent(final String signature, final CandidateMethod candidate) { - candidateMethods.putIfAbsent(signature, candidate); - } - - /** - * @param methodSignature - * @return true if the input was absent from the underlying map - */ - public boolean putIfAbsent(final String methodSignature) { - return candidateMethods.putIfAbsent(methodSignature, CandidateMethod.of(methodSignature)) == null; - } - - /** - * 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 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 getCandidateMethods() { - return candidateMethods; - } - - public void addToBacklog(final String discoveredMethod) { - if (!backlog.contains(discoveredMethod)) { - backlog.add(discoveredMethod); - } - } - - public List 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 getDisallowedMethods() { - final Set out = new HashSet<>(); - for (final Map.Entry stringCandidateMethodEntry : candidateMethods.entrySet()) { - final CandidateMethod candidate = stringCandidateMethodEntry.getValue(); - if (candidate.getCurrentState() == CandidateMethod.State.DISALLOWED) { - out.add(stringCandidateMethodEntry.getKey()); - } - } - - 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; - return this.recursiveDepth == other.recursiveDepth; - } -} diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/CandidateMethod.java b/experimental/sandbox/src/main/java/net/corda/sandbox/CandidateMethod.java deleted file mode 100644 index bc7a1cd7a1..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/CandidateMethod.java +++ /dev/null @@ -1,120 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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: - *

- *

    - *
  • {@link CandidateMethod.State#DETERMINISTIC} - It's deterministic and therefore is allowed to be loaded.
    • - *
  • {@link CandidateMethod.State#DISALLOWED} - It's not deterministic and won't be allowed to be loaded.
    • - *
  • {@link CandidateMethod.State#SCANNED} - We're not sure if it's deterministic or not.
    • - *
- *

- * 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 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 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 deleted file mode 100644 index 9df01b5919..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxAwareClassWriter.java +++ /dev/null @@ -1,92 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 loads 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; - Class 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 deleted file mode 100644 index ff4eb919b8..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/SandboxRemapper.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 deleted file mode 100644 index d5be161248..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/Utils.java +++ /dev/null @@ -1,207 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -package net.corda.sandbox; - -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -/** - * @author ben - */ -public final class Utils { - - public static final String SANDBOX_PREFIX_INTERNAL = "sandbox/"; - - public static final 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.isEmpty()) { - 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) { - return !JAVA_PATTERN_QUALIFIED.asPredicate().test(qualifiedClassName); - } - - /** - * 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; - } - - return !SANDBOX_PATTERN_INTERNAL.asPredicate().test(clazzName); - } - - -} diff --git a/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassLoader.java b/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassLoader.java deleted file mode 100644 index fa34c1cab5..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassLoader.java +++ /dev/null @@ -1,368 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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> loadedClasses; - - private final Map transformedClasses; - - private final List primaryClasspathSearchPath = new ArrayList<>(); - - private final List 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) { - 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 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 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 void createJar() throws IOException, URISyntaxException { - final Map 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 Map.Entry stringEntry : transformedClasses.entrySet()) { - final byte[] newClassDef = stringEntry.getValue(); - final String relativePathName = Utils.convertQualifiedClassNameToInternalForm(stringEntry.getKey()) + ".class"; - final Path outPath = jarRoot.resolve(relativePathName); - - Files.createDirectories(outPath.getParent()); - Files.write(outPath, newClassDef); - } - } - } - - /** - * 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 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 deleted file mode 100644 index b2fd28250c..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/WhitelistClassloadingException.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 deleted file mode 100644 index 3826f4d4b6..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/Contract.java +++ /dev/null @@ -1,58 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 deleted file mode 100644 index c2d3e443f9..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/ContractExecutor.java +++ /dev/null @@ -1,34 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 deleted file mode 100644 index 06487859db..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/costing/RuntimeCostAccounter.java +++ /dev/null @@ -1,167 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 allocationCost = ThreadLocal.withInitial(() -> 0L); - - private static final ThreadLocal jumpCost = ThreadLocal.withInitial(() -> 0L); - - private static final ThreadLocal invokeCost = ThreadLocal.withInitial(() -> 0L); - - private static final ThreadLocal throwCost = ThreadLocal.withInitial(() -> 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 deleted file mode 100644 index 44d0232046..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/tools/SandboxCreator.java +++ /dev/null @@ -1,137 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 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 "; - - private final String basePathName; - private final String outputJarName; - private final WhitelistClassLoader wlcl; - private final boolean hasInputJar; - - private static final 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 deleted file mode 100644 index 07cc7d4c0a..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/CostInstrumentingMethodVisitor.java +++ /dev/null @@ -1,175 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 deleted file mode 100644 index 78da5e5509..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/DefinitelyDisallowedMethodVisitor.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 deleted file mode 100644 index cb22e2bf30..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/SandboxPathVisitor.java +++ /dev/null @@ -1,67 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 { - - 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 deleted file mode 100644 index a3a8bb29a8..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingClassVisitor.java +++ /dev/null @@ -1,197 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 org.objectweb.asm.ClassVisitor; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -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 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; - } - } - } - - /** - * 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 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 deleted file mode 100644 index 468ffe884b..0000000000 --- a/experimental/sandbox/src/main/java/net/corda/sandbox/visitors/WhitelistCheckingMethodVisitor.java +++ /dev/null @@ -1,182 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -package net.corda.sandbox.visitors; - -import net.corda.sandbox.CandidacyStatus; -import net.corda.sandbox.CandidateMethod; -import org.objectweb.asm.Handle; -import org.objectweb.asm.MethodVisitor; -import org.objectweb.asm.Opcodes; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -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. - *

- * 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 deleted file mode 100644 index 5606e3b5bb..0000000000 --- a/experimental/sandbox/src/main/java/sandbox/net/corda/sandbox/costing/RuntimeCostAccounter.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 deleted file mode 100644 index 20b889ce57..0000000000 --- a/experimental/sandbox/src/main/resources/java.base.deterministic +++ /dev/null @@ -1,3 +0,0 @@ -java/lang/Object.equals:(Ljava/lang/Object;)Z -java/lang/Object.getClass:()Ljava/lang/Class; -java/lang/Object.:()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 deleted file mode 100644 index 110b1a2125..0000000000 --- a/experimental/sandbox/src/main/resources/java.base.disallowed +++ /dev/null @@ -1 +0,0 @@ -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 deleted file mode 100644 index 592806e0ad..0000000000 --- a/experimental/sandbox/src/main/resources/java.base.hand-picked +++ /dev/null @@ -1,9 +0,0 @@ -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.:()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.:(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 deleted file mode 100644 index 319cdd98fe..0000000000 --- a/experimental/sandbox/src/main/resources/java8.interfaces_for_compat +++ /dev/null @@ -1,2 +0,0 @@ -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 deleted file mode 100644 index cbca492750..0000000000 --- a/experimental/sandbox/src/main/resources/java8.scan.java.lang +++ /dev/null @@ -1,1039 +0,0 @@ -java/lang/AbstractMethodError.:()V -java/lang/AbstractMethodError.:(Ljava/lang/String;)V -java/lang/AbstractStringBuilder.:()V -java/lang/AbstractStringBuilder.:(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.:()V -java/lang/ApplicationShutdownHooks.:()V -java/lang/ArithmeticException.:()V -java/lang/ArithmeticException.:(Ljava/lang/String;)V -java/lang/ArrayIndexOutOfBoundsException.:()V -java/lang/ArrayIndexOutOfBoundsException.:(Ljava/lang/String;)V -java/lang/ArrayStoreException.:()V -java/lang/ArrayStoreException.:(Ljava/lang/String;)V -java/lang/AssertionError.:()V -java/lang/AssertionError.:(C)V -java/lang/AssertionError.:(I)V -java/lang/AssertionError.:(J)V -java/lang/AssertionError.:(Ljava/lang/String;)V -java/lang/AssertionError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/AssertionError.:(Z)V -java/lang/AssertionStatusDirectives.:()V -java/lang/AutoCloseable.close:()V -java/lang/Boolean.:(Ljava/lang/String;)V -java/lang/Boolean.:(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.:()V -java/lang/BootstrapMethodError.:(Ljava/lang/String;)V -java/lang/BootstrapMethodError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Byte$ByteCache.:()V -java/lang/Byte$ByteCache.:()V -java/lang/Byte.:(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.:(Ljava/lang/CharSequence;)V -java/lang/CharSequence$1CharIterator.hasNext:()Z -java/lang/CharSequence$1CodePointIterator.:(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.:()V -java/lang/Character$CharacterCache.:()V -java/lang/Character$Subset.:(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.:(Ljava/lang/String;I)V -java/lang/Character.:(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.:()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.:()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.:()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.:()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.:()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.:()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.:()V -java/lang/CharacterDataPrivateUse.:()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.:()V -java/lang/CharacterDataUndefined.:()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.:()V -java/lang/CharacterName.:()V -java/lang/Class$1.:(Ljava/lang/Class;Ljava/lang/reflect/Constructor;)V -java/lang/Class$2.:(Ljava/lang/Class;)V -java/lang/Class$3.:()V -java/lang/Class$4.:(Ljava/lang/Class;Ljava/lang/reflect/Method;)V -java/lang/Class$AnnotationData.:(Ljava/util/Map;Ljava/util/Map;I)V -java/lang/Class$Atomic.:()V -java/lang/Class$EnclosingMethodInfo.:([Ljava/lang/Object;)V -java/lang/Class$EnclosingMethodInfo.:([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.:()V -java/lang/Class$MethodArray.:(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.:(I)V -java/lang/Class.:()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.:()V -java/lang/ClassCastException.:(Ljava/lang/String;)V -java/lang/ClassCircularityError.:()V -java/lang/ClassCircularityError.:(Ljava/lang/String;)V -java/lang/ClassFormatError.:()V -java/lang/ClassFormatError.:(Ljava/lang/String;)V -java/lang/ClassLoader$1.:(Ljava/lang/ClassLoader;Ljava/lang/SecurityManager;Ljava/lang/String;I)V -java/lang/ClassLoader$2.:(Ljava/util/Enumeration;)V -java/lang/ClassLoader$3.:(Ljava/io/File;)V -java/lang/ClassLoader$NativeLibrary.:(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.:()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.:()V -java/lang/ClassNotFoundException.:(Ljava/lang/String;)V -java/lang/ClassNotFoundException.:(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.:()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.:()V -java/lang/CloneNotSupportedException.:(Ljava/lang/String;)V -java/lang/Comparable.compareTo:(Ljava/lang/Object;)I -java/lang/Compiler$1.:()V -java/lang/Compiler.:()V -java/lang/ConditionalSpecialCasing$Entry.:(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.:()V -java/lang/ConditionalSpecialCasing.isCased:(I)Z -java/lang/ConditionalSpecialCasing.isSoftDotted:(I)Z -java/lang/Double.:(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.:(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.:()V -java/lang/Error.:(Ljava/lang/String;)V -java/lang/Error.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Error.:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V -java/lang/Exception.:()V -java/lang/Exception.:(Ljava/lang/String;)V -java/lang/Exception.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Exception.:(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.:(D)V -java/lang/Float.:(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.:()V -java/lang/IllegalAccessError.:(Ljava/lang/String;)V -java/lang/IllegalAccessException.:()V -java/lang/IllegalAccessException.:(Ljava/lang/String;)V -java/lang/IllegalArgumentException.:()V -java/lang/IllegalArgumentException.:(Ljava/lang/String;)V -java/lang/IllegalArgumentException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/IllegalMonitorStateException.:()V -java/lang/IllegalMonitorStateException.:(Ljava/lang/String;)V -java/lang/IllegalStateException.:()V -java/lang/IllegalStateException.:(Ljava/lang/String;)V -java/lang/IllegalStateException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/IllegalThreadStateException.:()V -java/lang/IllegalThreadStateException.:(Ljava/lang/String;)V -java/lang/IncompatibleClassChangeError.:()V -java/lang/IncompatibleClassChangeError.:(Ljava/lang/String;)V -java/lang/IndexOutOfBoundsException.:()V -java/lang/IndexOutOfBoundsException.:(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.:()V -java/lang/InstantiationError.:(Ljava/lang/String;)V -java/lang/InstantiationException.:()V -java/lang/InstantiationException.:(Ljava/lang/String;)V -java/lang/Integer$IntegerCache.:()V -java/lang/Integer.:(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.:()V -java/lang/InternalError.:(Ljava/lang/String;)V -java/lang/InternalError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/InterruptedException.:()V -java/lang/InterruptedException.:(Ljava/lang/String;)V -java/lang/Iterable.iterator:()Ljava/util/Iterator; -java/lang/LinkageError.:()V -java/lang/LinkageError.:(Ljava/lang/String;)V -java/lang/LinkageError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Long$LongCache.:()V -java/lang/Long$LongCache.:()V -java/lang/Long.:(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.:()V -java/lang/Math.:()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.:()V -java/lang/NegativeArraySizeException.:(Ljava/lang/String;)V -java/lang/NoClassDefFoundError.:()V -java/lang/NoClassDefFoundError.:(Ljava/lang/String;)V -java/lang/NoSuchFieldError.:()V -java/lang/NoSuchFieldError.:(Ljava/lang/String;)V -java/lang/NoSuchFieldException.:()V -java/lang/NoSuchFieldException.:(Ljava/lang/String;)V -java/lang/NoSuchMethodError.:()V -java/lang/NoSuchMethodError.:(Ljava/lang/String;)V -java/lang/NoSuchMethodException.:()V -java/lang/NoSuchMethodException.:(Ljava/lang/String;)V -java/lang/NullPointerException.:()V -java/lang/NullPointerException.:(Ljava/lang/String;)V -java/lang/Number.:()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.:()V -java/lang/NumberFormatException.:(Ljava/lang/String;)V -java/lang/Object.:()V -java/lang/Object.equals:(Ljava/lang/Object;)Z -java/lang/Object.getClass:()Ljava/lang/Class; -java/lang/OutOfMemoryError.:()V -java/lang/OutOfMemoryError.:(Ljava/lang/String;)V -java/lang/Package$1.:(Ljava/lang/String;Ljava/lang/String;)V -java/lang/Package$1PackageInfoProxy.:(Ljava/lang/Package;)V -java/lang/Package.:(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.:()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.:()V -java/lang/ProcessBuilder$Redirect$1.type:()Ljava/lang/ProcessBuilder$Redirect$Type; -java/lang/ProcessBuilder$Redirect$2.:()V -java/lang/ProcessBuilder$Redirect$2.type:()Ljava/lang/ProcessBuilder$Redirect$Type; -java/lang/ProcessBuilder$Redirect$3.:(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.:(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.:(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.:()V -java/lang/ProcessBuilder$Redirect$Type.:(Ljava/lang/String;I)V -java/lang/ProcessBuilder$Redirect.:()V -java/lang/ProcessBuilder$Redirect.:(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.:(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.:(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.:(Ljava/util/Map$Entry;)V -java/lang/ProcessEnvironment$StringEntry.access$600:(Ljava/lang/ProcessEnvironment$StringEntry;)Ljava/util/Map$Entry; -java/lang/ProcessEnvironment$StringEntrySet$2.:(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.:(Ljava/lang/String;[B)V -java/lang/ProcessEnvironment$Value.equals:(Ljava/lang/Object;)Z -java/lang/ProcessEnvironment$Variable.:(Ljava/lang/String;[B)V -java/lang/ProcessEnvironment$Variable.equals:(Ljava/lang/Object;)Z -java/lang/ProcessEnvironment.:()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.:()V -java/lang/Readable.read:(Ljava/nio/CharBuffer;)I -java/lang/ReflectiveOperationException.:()V -java/lang/ReflectiveOperationException.:(Ljava/lang/String;)V -java/lang/ReflectiveOperationException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Runnable.run:()V -java/lang/Runtime.:()V -java/lang/Runtime.:()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.:()V -java/lang/RuntimeException.:(Ljava/lang/String;)V -java/lang/RuntimeException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/RuntimeException.:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V -java/lang/SecurityException.:()V -java/lang/SecurityException.:(Ljava/lang/String;)V -java/lang/SecurityException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/SecurityManager$1.:(Ljava/lang/SecurityManager;)V -java/lang/SecurityManager$2.:(Ljava/lang/SecurityManager;)V -java/lang/SecurityManager.getInCheck:()Z -java/lang/Short$ShortCache.:()V -java/lang/Short$ShortCache.:()V -java/lang/Short.:(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.:()V -java/lang/Shutdown$Lock.:(Ljava/lang/Shutdown$1;)V -java/lang/Shutdown.:()V -java/lang/Shutdown.:()V -java/lang/Shutdown.runHooks:()V -java/lang/Shutdown.setRunFinalizersOnExit:(Z)V -java/lang/StackOverflowError.:()V -java/lang/StackOverflowError.:(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.:()V -java/lang/StrictMath.:()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.:()V -java/lang/String$CaseInsensitiveComparator.:(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.:()V -java/lang/String.:()V -java/lang/String.:(Ljava/lang/String;)V -java/lang/String.:([BI)V -java/lang/String.:([BIII)V -java/lang/String.:([CZ)V -java/lang/String.:([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.:()V -java/lang/StringBuffer.:(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.:()V -java/lang/StringBuilder.:(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.:()V -java/lang/StringCoding.access$000:(IF)I -java/lang/StringCoding.scale:(IF)I -java/lang/StringIndexOutOfBoundsException.:()V -java/lang/StringIndexOutOfBoundsException.:(I)V -java/lang/StringIndexOutOfBoundsException.:(Ljava/lang/String;)V -java/lang/SuppressWarnings.value:()[Ljava/lang/String; -java/lang/System$1.:(Ljava/lang/SecurityManager;)V -java/lang/System$2.:()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.:()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.:(Ljava/lang/ClassLoader;)V -java/lang/Terminator$1.:()V -java/lang/Terminator.:()V -java/lang/Terminator.:()V -java/lang/Terminator.teardown:()V -java/lang/Thread$1.:(Ljava/lang/Class;)V -java/lang/Thread$Caches.:()V -java/lang/Thread$State.:()V -java/lang/Thread$State.:(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.:()V -java/lang/ThreadGroup.:()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.:()V -java/lang/Throwable$PrintStreamOrWriter.:(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.:()V -java/lang/Throwable$WrappedPrintStream.:(Ljava/io/PrintStream;)V -java/lang/Throwable$WrappedPrintStream.lock:()Ljava/lang/Object; -java/lang/Throwable$WrappedPrintWriter.:(Ljava/io/PrintWriter;)V -java/lang/Throwable$WrappedPrintWriter.lock:()Ljava/lang/Object; -java/lang/Throwable.:()V -java/lang/Throwable.:(Ljava/lang/String;)V -java/lang/Throwable.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Throwable.:(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.:()V -java/lang/UNIXProcess$2.:()V -java/lang/UNIXProcess$3.:(Ljava/lang/UNIXProcess;[I)V -java/lang/UNIXProcess$4.:(Ljava/lang/UNIXProcess;)V -java/lang/UNIXProcess$LaunchMechanism.:()V -java/lang/UNIXProcess$LaunchMechanism.:(Ljava/lang/String;II)V -java/lang/UNIXProcess$LaunchMechanism.access$300:(Ljava/lang/UNIXProcess$LaunchMechanism;)I -java/lang/UNIXProcess$ProcessReaperThreadFactory$1.:()V -java/lang/UNIXProcess$ProcessReaperThreadFactory.:()V -java/lang/UNIXProcess$ProcessReaperThreadFactory.:(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.:()V -java/lang/UnknownError.:(Ljava/lang/String;)V -java/lang/UnsatisfiedLinkError.:()V -java/lang/UnsatisfiedLinkError.:(Ljava/lang/String;)V -java/lang/UnsupportedClassVersionError.:()V -java/lang/UnsupportedClassVersionError.:(Ljava/lang/String;)V -java/lang/UnsupportedOperationException.:()V -java/lang/UnsupportedOperationException.:(Ljava/lang/String;)V -java/lang/UnsupportedOperationException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/VerifyError.:()V -java/lang/VerifyError.:(Ljava/lang/String;)V -java/lang/VirtualMachineError.:()V -java/lang/VirtualMachineError.:(Ljava/lang/String;)V -java/lang/VirtualMachineError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Void.:()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 deleted file mode 100644 index ad2d2afcea..0000000000 --- a/experimental/sandbox/src/main/resources/java8.scan.java.lang_and_reflect +++ /dev/null @@ -1,1210 +0,0 @@ -java/lang/AbstractMethodError.:()V -java/lang/AbstractMethodError.:(Ljava/lang/String;)V -java/lang/AbstractStringBuilder.:()V -java/lang/AbstractStringBuilder.:(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.:()V -java/lang/ApplicationShutdownHooks.:()V -java/lang/ArithmeticException.:()V -java/lang/ArithmeticException.:(Ljava/lang/String;)V -java/lang/ArrayIndexOutOfBoundsException.:()V -java/lang/ArrayIndexOutOfBoundsException.:(Ljava/lang/String;)V -java/lang/ArrayStoreException.:()V -java/lang/ArrayStoreException.:(Ljava/lang/String;)V -java/lang/AssertionError.:()V -java/lang/AssertionError.:(C)V -java/lang/AssertionError.:(I)V -java/lang/AssertionError.:(J)V -java/lang/AssertionError.:(Ljava/lang/String;)V -java/lang/AssertionError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/AssertionError.:(Z)V -java/lang/AssertionStatusDirectives.:()V -java/lang/AutoCloseable.close:()V -java/lang/Boolean.:(Ljava/lang/String;)V -java/lang/Boolean.:(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.:()V -java/lang/BootstrapMethodError.:(Ljava/lang/String;)V -java/lang/BootstrapMethodError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Byte$ByteCache.:()V -java/lang/Byte$ByteCache.:()V -java/lang/Byte.:(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.:(Ljava/lang/CharSequence;)V -java/lang/CharSequence$1CharIterator.hasNext:()Z -java/lang/CharSequence$1CodePointIterator.:(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.:()V -java/lang/Character$CharacterCache.:()V -java/lang/Character$Subset.:(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.:(Ljava/lang/String;I)V -java/lang/Character.:(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.:()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.:()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.:()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.:()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.:()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.:()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.:()V -java/lang/CharacterDataPrivateUse.:()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.:()V -java/lang/CharacterDataUndefined.:()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.:()V -java/lang/CharacterName.:()V -java/lang/Class$1.:(Ljava/lang/Class;Ljava/lang/reflect/Constructor;)V -java/lang/Class$2.:(Ljava/lang/Class;)V -java/lang/Class$3.:()V -java/lang/Class$4.:(Ljava/lang/Class;Ljava/lang/reflect/Method;)V -java/lang/Class$AnnotationData.:(Ljava/util/Map;Ljava/util/Map;I)V -java/lang/Class$Atomic.:()V -java/lang/Class$EnclosingMethodInfo.:([Ljava/lang/Object;)V -java/lang/Class$EnclosingMethodInfo.:([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.:()V -java/lang/Class$MethodArray.:(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.:(I)V -java/lang/Class.:()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.:()V -java/lang/ClassCastException.:(Ljava/lang/String;)V -java/lang/ClassCircularityError.:()V -java/lang/ClassCircularityError.:(Ljava/lang/String;)V -java/lang/ClassFormatError.:()V -java/lang/ClassFormatError.:(Ljava/lang/String;)V -java/lang/ClassLoader$1.:(Ljava/lang/ClassLoader;Ljava/lang/SecurityManager;Ljava/lang/String;I)V -java/lang/ClassLoader$2.:(Ljava/util/Enumeration;)V -java/lang/ClassLoader$3.:(Ljava/io/File;)V -java/lang/ClassLoader$NativeLibrary.:(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.:()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.:()V -java/lang/ClassNotFoundException.:(Ljava/lang/String;)V -java/lang/ClassNotFoundException.:(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.:()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.:()V -java/lang/CloneNotSupportedException.:(Ljava/lang/String;)V -java/lang/Comparable.compareTo:(Ljava/lang/Object;)I -java/lang/Compiler$1.:()V -java/lang/Compiler.:()V -java/lang/ConditionalSpecialCasing$Entry.:(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.:()V -java/lang/ConditionalSpecialCasing.isCased:(I)Z -java/lang/ConditionalSpecialCasing.isSoftDotted:(I)Z -java/lang/Double.:(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.:(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.:()V -java/lang/Error.:(Ljava/lang/String;)V -java/lang/Error.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Error.:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V -java/lang/Exception.:()V -java/lang/Exception.:(Ljava/lang/String;)V -java/lang/Exception.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Exception.:(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.:(D)V -java/lang/Float.:(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.:()V -java/lang/IllegalAccessError.:(Ljava/lang/String;)V -java/lang/IllegalAccessException.:()V -java/lang/IllegalAccessException.:(Ljava/lang/String;)V -java/lang/IllegalArgumentException.:()V -java/lang/IllegalArgumentException.:(Ljava/lang/String;)V -java/lang/IllegalArgumentException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/IllegalMonitorStateException.:()V -java/lang/IllegalMonitorStateException.:(Ljava/lang/String;)V -java/lang/IllegalStateException.:()V -java/lang/IllegalStateException.:(Ljava/lang/String;)V -java/lang/IllegalStateException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/IllegalThreadStateException.:()V -java/lang/IllegalThreadStateException.:(Ljava/lang/String;)V -java/lang/IncompatibleClassChangeError.:()V -java/lang/IncompatibleClassChangeError.:(Ljava/lang/String;)V -java/lang/IndexOutOfBoundsException.:()V -java/lang/IndexOutOfBoundsException.:(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.:()V -java/lang/InstantiationError.:(Ljava/lang/String;)V -java/lang/InstantiationException.:()V -java/lang/InstantiationException.:(Ljava/lang/String;)V -java/lang/Integer$IntegerCache.:()V -java/lang/Integer.:(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.:()V -java/lang/InternalError.:(Ljava/lang/String;)V -java/lang/InternalError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/InterruptedException.:()V -java/lang/InterruptedException.:(Ljava/lang/String;)V -java/lang/Iterable.iterator:()Ljava/util/Iterator; -java/lang/LinkageError.:()V -java/lang/LinkageError.:(Ljava/lang/String;)V -java/lang/LinkageError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Long$LongCache.:()V -java/lang/Long$LongCache.:()V -java/lang/Long.:(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.:()V -java/lang/Math.:()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.:()V -java/lang/NegativeArraySizeException.:(Ljava/lang/String;)V -java/lang/NoClassDefFoundError.:()V -java/lang/NoClassDefFoundError.:(Ljava/lang/String;)V -java/lang/NoSuchFieldError.:()V -java/lang/NoSuchFieldError.:(Ljava/lang/String;)V -java/lang/NoSuchFieldException.:()V -java/lang/NoSuchFieldException.:(Ljava/lang/String;)V -java/lang/NoSuchMethodError.:()V -java/lang/NoSuchMethodError.:(Ljava/lang/String;)V -java/lang/NoSuchMethodException.:()V -java/lang/NoSuchMethodException.:(Ljava/lang/String;)V -java/lang/NullPointerException.:()V -java/lang/NullPointerException.:(Ljava/lang/String;)V -java/lang/Number.:()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.:()V -java/lang/NumberFormatException.:(Ljava/lang/String;)V -java/lang/Object.:()V -java/lang/Object.equals:(Ljava/lang/Object;)Z -java/lang/Object.getClass:()Ljava/lang/Class; -java/lang/OutOfMemoryError.:()V -java/lang/OutOfMemoryError.:(Ljava/lang/String;)V -java/lang/Package$1.:(Ljava/lang/String;Ljava/lang/String;)V -java/lang/Package$1PackageInfoProxy.:(Ljava/lang/Package;)V -java/lang/Package.:(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.:()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.:()V -java/lang/ProcessBuilder$Redirect$1.type:()Ljava/lang/ProcessBuilder$Redirect$Type; -java/lang/ProcessBuilder$Redirect$2.:()V -java/lang/ProcessBuilder$Redirect$2.type:()Ljava/lang/ProcessBuilder$Redirect$Type; -java/lang/ProcessBuilder$Redirect$3.:(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.:(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.:(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.:()V -java/lang/ProcessBuilder$Redirect$Type.:(Ljava/lang/String;I)V -java/lang/ProcessBuilder$Redirect.:()V -java/lang/ProcessBuilder$Redirect.:(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.:(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.:(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.:(Ljava/util/Map$Entry;)V -java/lang/ProcessEnvironment$StringEntry.access$600:(Ljava/lang/ProcessEnvironment$StringEntry;)Ljava/util/Map$Entry; -java/lang/ProcessEnvironment$StringEntrySet$2.:(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.:(Ljava/lang/String;[B)V -java/lang/ProcessEnvironment$Value.equals:(Ljava/lang/Object;)Z -java/lang/ProcessEnvironment$Variable.:(Ljava/lang/String;[B)V -java/lang/ProcessEnvironment$Variable.equals:(Ljava/lang/Object;)Z -java/lang/ProcessEnvironment.:()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.:()V -java/lang/Readable.read:(Ljava/nio/CharBuffer;)I -java/lang/ReflectiveOperationException.:()V -java/lang/ReflectiveOperationException.:(Ljava/lang/String;)V -java/lang/ReflectiveOperationException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Runnable.run:()V -java/lang/Runtime.:()V -java/lang/Runtime.:()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.:()V -java/lang/RuntimeException.:(Ljava/lang/String;)V -java/lang/RuntimeException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/RuntimeException.:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V -java/lang/SecurityException.:()V -java/lang/SecurityException.:(Ljava/lang/String;)V -java/lang/SecurityException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/SecurityManager$1.:(Ljava/lang/SecurityManager;)V -java/lang/SecurityManager$2.:(Ljava/lang/SecurityManager;)V -java/lang/SecurityManager.getInCheck:()Z -java/lang/Short$ShortCache.:()V -java/lang/Short$ShortCache.:()V -java/lang/Short.:(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.:()V -java/lang/Shutdown$Lock.:(Ljava/lang/Shutdown$1;)V -java/lang/Shutdown.:()V -java/lang/Shutdown.:()V -java/lang/Shutdown.runHooks:()V -java/lang/Shutdown.setRunFinalizersOnExit:(Z)V -java/lang/StackOverflowError.:()V -java/lang/StackOverflowError.:(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.:()V -java/lang/StrictMath.:()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.:()V -java/lang/String$CaseInsensitiveComparator.:(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.:()V -java/lang/String.:()V -java/lang/String.:(Ljava/lang/String;)V -java/lang/String.:([BI)V -java/lang/String.:([BIII)V -java/lang/String.:([CZ)V -java/lang/String.:([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.:()V -java/lang/StringBuffer.:(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.:()V -java/lang/StringBuilder.:(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.:()V -java/lang/StringCoding.access$000:(IF)I -java/lang/StringCoding.scale:(IF)I -java/lang/StringIndexOutOfBoundsException.:()V -java/lang/StringIndexOutOfBoundsException.:(I)V -java/lang/StringIndexOutOfBoundsException.:(Ljava/lang/String;)V -java/lang/SuppressWarnings.value:()[Ljava/lang/String; -java/lang/System$1.:(Ljava/lang/SecurityManager;)V -java/lang/System$2.:()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.:()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.:(Ljava/lang/ClassLoader;)V -java/lang/Terminator$1.:()V -java/lang/Terminator.:()V -java/lang/Terminator.:()V -java/lang/Terminator.teardown:()V -java/lang/Thread$1.:(Ljava/lang/Class;)V -java/lang/Thread$Caches.:()V -java/lang/Thread$State.:()V -java/lang/Thread$State.:(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.:()V -java/lang/ThreadGroup.:()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.:()V -java/lang/Throwable$PrintStreamOrWriter.:(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.:()V -java/lang/Throwable$WrappedPrintStream.:(Ljava/io/PrintStream;)V -java/lang/Throwable$WrappedPrintStream.lock:()Ljava/lang/Object; -java/lang/Throwable$WrappedPrintWriter.:(Ljava/io/PrintWriter;)V -java/lang/Throwable$WrappedPrintWriter.lock:()Ljava/lang/Object; -java/lang/Throwable.:()V -java/lang/Throwable.:(Ljava/lang/String;)V -java/lang/Throwable.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Throwable.:(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.:()V -java/lang/UNIXProcess$2.:()V -java/lang/UNIXProcess$3.:(Ljava/lang/UNIXProcess;[I)V -java/lang/UNIXProcess$4.:(Ljava/lang/UNIXProcess;)V -java/lang/UNIXProcess$LaunchMechanism.:()V -java/lang/UNIXProcess$LaunchMechanism.:(Ljava/lang/String;II)V -java/lang/UNIXProcess$LaunchMechanism.access$300:(Ljava/lang/UNIXProcess$LaunchMechanism;)I -java/lang/UNIXProcess$ProcessReaperThreadFactory$1.:()V -java/lang/UNIXProcess$ProcessReaperThreadFactory.:()V -java/lang/UNIXProcess$ProcessReaperThreadFactory.:(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.:()V -java/lang/UnknownError.:(Ljava/lang/String;)V -java/lang/UnsatisfiedLinkError.:()V -java/lang/UnsatisfiedLinkError.:(Ljava/lang/String;)V -java/lang/UnsupportedClassVersionError.:()V -java/lang/UnsupportedClassVersionError.:(Ljava/lang/String;)V -java/lang/UnsupportedOperationException.:()V -java/lang/UnsupportedOperationException.:(Ljava/lang/String;)V -java/lang/UnsupportedOperationException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/VerifyError.:()V -java/lang/VerifyError.:(Ljava/lang/String;)V -java/lang/VirtualMachineError.:()V -java/lang/VirtualMachineError.:(Ljava/lang/String;)V -java/lang/VirtualMachineError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Void.:()V -java/lang/reflect/AccessibleObject.:()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.:()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.:(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.:()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.:(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.:()V -java/lang/reflect/GenericSignatureFormatError.:(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.:(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.:()V -java/lang/reflect/MalformedParametersException.:()V -java/lang/reflect/MalformedParametersException.:(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.:(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.:()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.:(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.:(Ljava/lang/reflect/Constructor;)V -java/lang/reflect/Proxy$Key1.hashCode:()I -java/lang/reflect/Proxy$Key2.hashCode:()I -java/lang/reflect/Proxy$KeyFactory.:()V -java/lang/reflect/Proxy$KeyFactory.:(Ljava/lang/reflect/Proxy$1;)V -java/lang/reflect/Proxy$KeyX.hashCode:()I -java/lang/reflect/Proxy$ProxyClassFactory.:()V -java/lang/reflect/Proxy$ProxyClassFactory.:(Ljava/lang/reflect/Proxy$1;)V -java/lang/reflect/Proxy.:()V -java/lang/reflect/Proxy.access$200:()Ljava/lang/Object; -java/lang/reflect/ReflectAccess.:()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.:(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.:()V -java/lang/reflect/WeakCache$CacheKey.hashCode:()I -java/lang/reflect/WeakCache$CacheValue.hashCode:()I -java/lang/reflect/WeakCache$Factory.:(Ljava/lang/reflect/WeakCache;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/util/concurrent/ConcurrentMap;)V -java/lang/reflect/WeakCache$LookupValue.:(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 deleted file mode 100644 index fa79a124b3..0000000000 --- a/experimental/sandbox/src/main/resources/java8.scan.java.lang_and_util +++ /dev/null @@ -1,4429 +0,0 @@ -java/lang/AbstractMethodError.:()V -java/lang/AbstractMethodError.:(Ljava/lang/String;)V -java/lang/AbstractStringBuilder.:()V -java/lang/AbstractStringBuilder.:(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.:()V -java/lang/ApplicationShutdownHooks.:()V -java/lang/ApplicationShutdownHooks.:()V -java/lang/ArithmeticException.:()V -java/lang/ArithmeticException.:(Ljava/lang/String;)V -java/lang/ArrayIndexOutOfBoundsException.:()V -java/lang/ArrayIndexOutOfBoundsException.:(I)V -java/lang/ArrayIndexOutOfBoundsException.:(Ljava/lang/String;)V -java/lang/ArrayStoreException.:()V -java/lang/ArrayStoreException.:(Ljava/lang/String;)V -java/lang/AssertionError.:()V -java/lang/AssertionError.:(C)V -java/lang/AssertionError.:(I)V -java/lang/AssertionError.:(J)V -java/lang/AssertionError.:(Ljava/lang/String;)V -java/lang/AssertionError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/AssertionError.:(Z)V -java/lang/AssertionStatusDirectives.:()V -java/lang/AutoCloseable.close:()V -java/lang/Boolean.:(Ljava/lang/String;)V -java/lang/Boolean.:(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.:()V -java/lang/BootstrapMethodError.:(Ljava/lang/String;)V -java/lang/BootstrapMethodError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Byte$ByteCache.:()V -java/lang/Byte$ByteCache.:()V -java/lang/Byte.:(B)V -java/lang/Byte.:(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.:(Ljava/lang/CharSequence;)V -java/lang/CharSequence$1CharIterator.hasNext:()Z -java/lang/CharSequence$1CharIterator.nextInt:()I -java/lang/CharSequence$1CodePointIterator.:(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.:()V -java/lang/Character$CharacterCache.:()V -java/lang/Character$Subset.:(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.:(Ljava/lang/String;)V -java/lang/Character$UnicodeBlock.:(Ljava/lang/String;Ljava/lang/String;)V -java/lang/Character$UnicodeBlock.:(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.:(Ljava/lang/String;I)V -java/lang/Character$UnicodeScript.of:(I)Ljava/lang/Character$UnicodeScript; -java/lang/Character.:(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.:()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.:()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.:()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.:()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.:()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.:()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.:()V -java/lang/CharacterDataPrivateUse.:()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.:()V -java/lang/CharacterDataUndefined.:()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.:()V -java/lang/CharacterName.:()V -java/lang/Class$1.:(Ljava/lang/Class;Ljava/lang/reflect/Constructor;)V -java/lang/Class$2.:(Ljava/lang/Class;)V -java/lang/Class$3.:()V -java/lang/Class$4.:(Ljava/lang/Class;Ljava/lang/reflect/Method;)V -java/lang/Class$AnnotationData.:(Ljava/util/Map;Ljava/util/Map;I)V -java/lang/Class$Atomic.:()V -java/lang/Class$EnclosingMethodInfo.:([Ljava/lang/Object;)V -java/lang/Class$EnclosingMethodInfo.:([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.:()V -java/lang/Class$MethodArray.:(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.:(I)V -java/lang/Class.:()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.:()V -java/lang/ClassCastException.:(Ljava/lang/String;)V -java/lang/ClassCircularityError.:()V -java/lang/ClassCircularityError.:(Ljava/lang/String;)V -java/lang/ClassFormatError.:()V -java/lang/ClassFormatError.:(Ljava/lang/String;)V -java/lang/ClassLoader$1.:(Ljava/lang/ClassLoader;Ljava/lang/SecurityManager;Ljava/lang/String;I)V -java/lang/ClassLoader$2.:(Ljava/util/Enumeration;)V -java/lang/ClassLoader$2.hasMoreElements:()Z -java/lang/ClassLoader$3.:(Ljava/io/File;)V -java/lang/ClassLoader$NativeLibrary.:(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.:()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.:()V -java/lang/ClassNotFoundException.:(Ljava/lang/String;)V -java/lang/ClassNotFoundException.:(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.:()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.:()V -java/lang/CloneNotSupportedException.:(Ljava/lang/String;)V -java/lang/Comparable.compareTo:(Ljava/lang/Object;)I -java/lang/Compiler$1.:()V -java/lang/Compiler.:()V -java/lang/ConditionalSpecialCasing$Entry.:(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.:()V -java/lang/ConditionalSpecialCasing.isCased:(I)Z -java/lang/ConditionalSpecialCasing.isSoftDotted:(I)Z -java/lang/Double.:(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.:(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.:()V -java/lang/Error.:(Ljava/lang/String;)V -java/lang/Error.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Error.:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V -java/lang/Exception.:()V -java/lang/Exception.:(Ljava/lang/String;)V -java/lang/Exception.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Exception.:(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.:(D)V -java/lang/Float.:(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.:()V -java/lang/IllegalAccessError.:(Ljava/lang/String;)V -java/lang/IllegalAccessException.:()V -java/lang/IllegalAccessException.:(Ljava/lang/String;)V -java/lang/IllegalArgumentException.:()V -java/lang/IllegalArgumentException.:(Ljava/lang/String;)V -java/lang/IllegalArgumentException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/IllegalMonitorStateException.:()V -java/lang/IllegalMonitorStateException.:(Ljava/lang/String;)V -java/lang/IllegalStateException.:()V -java/lang/IllegalStateException.:(Ljava/lang/String;)V -java/lang/IllegalStateException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/IllegalThreadStateException.:()V -java/lang/IllegalThreadStateException.:(Ljava/lang/String;)V -java/lang/IncompatibleClassChangeError.:()V -java/lang/IncompatibleClassChangeError.:(Ljava/lang/String;)V -java/lang/IndexOutOfBoundsException.:()V -java/lang/IndexOutOfBoundsException.:(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.:()V -java/lang/InstantiationError.:(Ljava/lang/String;)V -java/lang/InstantiationException.:()V -java/lang/InstantiationException.:(Ljava/lang/String;)V -java/lang/Integer$IntegerCache.:()V -java/lang/Integer.:(I)V -java/lang/Integer.:(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.:()V -java/lang/InternalError.:(Ljava/lang/String;)V -java/lang/InternalError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/InterruptedException.:()V -java/lang/InterruptedException.:(Ljava/lang/String;)V -java/lang/Iterable.iterator:()Ljava/util/Iterator; -java/lang/Iterable.spliterator:()Ljava/util/Spliterator; -java/lang/LinkageError.:()V -java/lang/LinkageError.:(Ljava/lang/String;)V -java/lang/LinkageError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Long$LongCache.:()V -java/lang/Long$LongCache.:()V -java/lang/Long.:(J)V -java/lang/Long.:(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.:()V -java/lang/Math.:()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.:()V -java/lang/NegativeArraySizeException.:(Ljava/lang/String;)V -java/lang/NoClassDefFoundError.:()V -java/lang/NoClassDefFoundError.:(Ljava/lang/String;)V -java/lang/NoSuchFieldError.:()V -java/lang/NoSuchFieldError.:(Ljava/lang/String;)V -java/lang/NoSuchFieldException.:()V -java/lang/NoSuchFieldException.:(Ljava/lang/String;)V -java/lang/NoSuchMethodError.:()V -java/lang/NoSuchMethodError.:(Ljava/lang/String;)V -java/lang/NoSuchMethodException.:()V -java/lang/NoSuchMethodException.:(Ljava/lang/String;)V -java/lang/NullPointerException.:()V -java/lang/NullPointerException.:(Ljava/lang/String;)V -java/lang/Number.:()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.:()V -java/lang/NumberFormatException.:(Ljava/lang/String;)V -java/lang/NumberFormatException.forInputString:(Ljava/lang/String;)Ljava/lang/NumberFormatException; -java/lang/Object.:()V -java/lang/Object.equals:(Ljava/lang/Object;)Z -java/lang/Object.getClass:()Ljava/lang/Class; -java/lang/OutOfMemoryError.:()V -java/lang/OutOfMemoryError.:(Ljava/lang/String;)V -java/lang/Package$1.:(Ljava/lang/String;Ljava/lang/String;)V -java/lang/Package$1PackageInfoProxy.:(Ljava/lang/Package;)V -java/lang/Package.:(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.:()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.:()V -java/lang/ProcessBuilder$Redirect$1.type:()Ljava/lang/ProcessBuilder$Redirect$Type; -java/lang/ProcessBuilder$Redirect$2.:()V -java/lang/ProcessBuilder$Redirect$2.type:()Ljava/lang/ProcessBuilder$Redirect$Type; -java/lang/ProcessBuilder$Redirect$3.:(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.:(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.:(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.:()V -java/lang/ProcessBuilder$Redirect$Type.:(Ljava/lang/String;I)V -java/lang/ProcessBuilder$Redirect.:()V -java/lang/ProcessBuilder$Redirect.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(Ljava/lang/ProcessEnvironment$StringKeySet;)V -java/lang/ProcessEnvironment$StringKeySet$1.hasNext:()Z -java/lang/ProcessEnvironment$StringKeySet$1.remove:()V -java/lang/ProcessEnvironment$StringKeySet.:(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.:(Ljava/lang/ProcessEnvironment$StringValues;)V -java/lang/ProcessEnvironment$StringValues$1.hasNext:()Z -java/lang/ProcessEnvironment$StringValues$1.remove:()V -java/lang/ProcessEnvironment$StringValues.:(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.:(Ljava/lang/String;[B)V -java/lang/ProcessEnvironment$Value.equals:(Ljava/lang/Object;)Z -java/lang/ProcessEnvironment$Variable.:(Ljava/lang/String;[B)V -java/lang/ProcessEnvironment$Variable.equals:(Ljava/lang/Object;)Z -java/lang/ProcessEnvironment.:()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.:()V -java/lang/Readable.read:(Ljava/nio/CharBuffer;)I -java/lang/ReflectiveOperationException.:()V -java/lang/ReflectiveOperationException.:(Ljava/lang/String;)V -java/lang/ReflectiveOperationException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Runnable.run:()V -java/lang/Runtime.:()V -java/lang/Runtime.:()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.:()V -java/lang/RuntimeException.:(Ljava/lang/String;)V -java/lang/RuntimeException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/RuntimeException.:(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V -java/lang/SecurityException.:()V -java/lang/SecurityException.:(Ljava/lang/String;)V -java/lang/SecurityException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/SecurityManager$1.:(Ljava/lang/SecurityManager;)V -java/lang/SecurityManager$2.:(Ljava/lang/SecurityManager;)V -java/lang/SecurityManager.getInCheck:()Z -java/lang/Short$ShortCache.:()V -java/lang/Short$ShortCache.:()V -java/lang/Short.:(Ljava/lang/String;)V -java/lang/Short.:(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.:()V -java/lang/Shutdown$Lock.:(Ljava/lang/Shutdown$1;)V -java/lang/Shutdown.:()V -java/lang/Shutdown.:()V -java/lang/Shutdown.add:(IZLjava/lang/Runnable;)V -java/lang/Shutdown.runHooks:()V -java/lang/Shutdown.setRunFinalizersOnExit:(Z)V -java/lang/StackOverflowError.:()V -java/lang/StackOverflowError.:(Ljava/lang/String;)V -java/lang/StackTraceElement.:(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.:()V -java/lang/StrictMath.:()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.:()V -java/lang/String$CaseInsensitiveComparator.:(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.:()V -java/lang/String.:()V -java/lang/String.:(Ljava/lang/String;)V -java/lang/String.:([BI)V -java/lang/String.:([BIII)V -java/lang/String.:([C)V -java/lang/String.:([CII)V -java/lang/String.:([CZ)V -java/lang/String.:([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.:()V -java/lang/StringBuffer.:(I)V -java/lang/StringBuffer.:(Ljava/lang/CharSequence;)V -java/lang/StringBuffer.:(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.:()V -java/lang/StringBuilder.:(I)V -java/lang/StringBuilder.:(Ljava/lang/CharSequence;)V -java/lang/StringBuilder.:(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.:()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.:()V -java/lang/StringIndexOutOfBoundsException.:(I)V -java/lang/StringIndexOutOfBoundsException.:(Ljava/lang/String;)V -java/lang/SuppressWarnings.value:()[Ljava/lang/String; -java/lang/System$1.:(Ljava/lang/SecurityManager;)V -java/lang/System$2.:()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.:()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.:(Ljava/lang/ClassLoader;)V -java/lang/Terminator$1.:()V -java/lang/Terminator.:()V -java/lang/Terminator.:()V -java/lang/Terminator.teardown:()V -java/lang/Thread$1.:(Ljava/lang/Class;)V -java/lang/Thread$Caches.:()V -java/lang/Thread$State.:()V -java/lang/Thread$State.:(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.:()V -java/lang/ThreadGroup.:()V -java/lang/ThreadGroup.:(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.:()V -java/lang/Throwable$PrintStreamOrWriter.:(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.:()V -java/lang/Throwable$SentinelHolder.:()V -java/lang/Throwable$WrappedPrintStream.:(Ljava/io/PrintStream;)V -java/lang/Throwable$WrappedPrintStream.lock:()Ljava/lang/Object; -java/lang/Throwable$WrappedPrintWriter.:(Ljava/io/PrintWriter;)V -java/lang/Throwable$WrappedPrintWriter.lock:()Ljava/lang/Object; -java/lang/Throwable.:()V -java/lang/Throwable.:(Ljava/lang/String;)V -java/lang/Throwable.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Throwable.:(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.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/TypeNotPresentException.typeName:()Ljava/lang/String; -java/lang/UNIXProcess$1.:()V -java/lang/UNIXProcess$2.:()V -java/lang/UNIXProcess$3.:(Ljava/lang/UNIXProcess;[I)V -java/lang/UNIXProcess$4.:(Ljava/lang/UNIXProcess;)V -java/lang/UNIXProcess$LaunchMechanism.:()V -java/lang/UNIXProcess$LaunchMechanism.:(Ljava/lang/String;II)V -java/lang/UNIXProcess$LaunchMechanism.access$300:(Ljava/lang/UNIXProcess$LaunchMechanism;)I -java/lang/UNIXProcess$ProcessReaperThreadFactory$1.:()V -java/lang/UNIXProcess$ProcessReaperThreadFactory.:()V -java/lang/UNIXProcess$ProcessReaperThreadFactory.:(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.:()V -java/lang/UnknownError.:(Ljava/lang/String;)V -java/lang/UnsatisfiedLinkError.:()V -java/lang/UnsatisfiedLinkError.:(Ljava/lang/String;)V -java/lang/UnsupportedClassVersionError.:()V -java/lang/UnsupportedClassVersionError.:(Ljava/lang/String;)V -java/lang/UnsupportedOperationException.:()V -java/lang/UnsupportedOperationException.:(Ljava/lang/String;)V -java/lang/UnsupportedOperationException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/VerifyError.:()V -java/lang/VerifyError.:(Ljava/lang/String;)V -java/lang/VirtualMachineError.:()V -java/lang/VirtualMachineError.:(Ljava/lang/String;)V -java/lang/VirtualMachineError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/lang/Void.:()V -java/lang/reflect/AccessibleObject.:()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.:()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.:(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.:()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.:(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.:()V -java/lang/reflect/GenericSignatureFormatError.:(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.:(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.:()V -java/lang/reflect/MalformedParametersException.:()V -java/lang/reflect/MalformedParametersException.:(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.:(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.:()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.:(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.:(Ljava/lang/reflect/Constructor;)V -java/lang/reflect/Proxy$Key1.hashCode:()I -java/lang/reflect/Proxy$Key2.hashCode:()I -java/lang/reflect/Proxy$KeyFactory.:()V -java/lang/reflect/Proxy$KeyFactory.:(Ljava/lang/reflect/Proxy$1;)V -java/lang/reflect/Proxy$KeyX.hashCode:()I -java/lang/reflect/Proxy$ProxyClassFactory.:()V -java/lang/reflect/Proxy$ProxyClassFactory.:(Ljava/lang/reflect/Proxy$1;)V -java/lang/reflect/Proxy.:()V -java/lang/reflect/Proxy.access$200:()Ljava/lang/Object; -java/lang/reflect/ReflectAccess.:()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.:(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.:()V -java/lang/reflect/WeakCache$CacheKey.hashCode:()I -java/lang/reflect/WeakCache$CacheValue.hashCode:()I -java/lang/reflect/WeakCache$Factory.:(Ljava/lang/reflect/WeakCache;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/util/concurrent/ConcurrentMap;)V -java/lang/reflect/WeakCache$LookupValue.:(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.:()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.:(Ljava/util/AbstractList;)V -java/util/AbstractList$Itr.:(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.:(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.:()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.:(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.:(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.:(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.:(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.:(Ljava/lang/Object;Ljava/lang/Object;)V -java/util/AbstractMap$SimpleEntry.:(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.:(Ljava/lang/Object;Ljava/lang/Object;)V -java/util/AbstractMap$SimpleImmutableEntry.:(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.:()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.:()V -java/util/AbstractSequentialList.:()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.:()V -java/util/ArrayDeque$DeqIterator.:(Ljava/util/ArrayDeque;)V -java/util/ArrayDeque$DeqIterator.:(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.:(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.:(Ljava/util/ArrayDeque;)V -java/util/ArrayDeque$DescendingIterator.:(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.:()V -java/util/ArrayDeque.:(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.:(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.:(Ljava/util/ArrayList;)V -java/util/ArrayList$Itr.:(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.:(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.:(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.:(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.:()V -java/util/ArrayList.:()V -java/util/ArrayList.:(I)V -java/util/ArrayList.:(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.:()V -java/util/Arrays$ArrayList.:([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.:()V -java/util/Arrays$LegacyMergeSort.access$000:()Z -java/util/Arrays$NaturalOrder.:()V -java/util/Arrays$NaturalOrder.:()V -java/util/Arrays$NaturalOrder.compare:(Ljava/lang/Object;Ljava/lang/Object;)I -java/util/Arrays.:()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.:()V -java/util/ArraysParallelSortHelpers$FJChar.:()V -java/util/ArraysParallelSortHelpers$FJDouble.:()V -java/util/ArraysParallelSortHelpers$FJFloat.:()V -java/util/ArraysParallelSortHelpers$FJInt.:()V -java/util/ArraysParallelSortHelpers$FJLong.:()V -java/util/ArraysParallelSortHelpers$FJObject.:()V -java/util/ArraysParallelSortHelpers$FJShort.:()V -java/util/ArraysParallelSortHelpers$Relay.compute:()V -java/util/ArraysParallelSortHelpers.:()V -java/util/Base64$Decoder.:()V -java/util/Base64$Decoder.:(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.:()V -java/util/Base64$Encoder.:(Z[BIZ)V -java/util/Base64$Encoder.:(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.:()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.:(Ljava/util/BitSet;)V -java/util/BitSet$1BitSetIterator.hasNext:()Z -java/util/BitSet$1BitSetIterator.nextInt:()I -java/util/BitSet.:()V -java/util/BitSet.:(I)V -java/util/BitSet.:([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.:(Ljava/util/Calendar;Ljava/io/ObjectInputStream;)V -java/util/Calendar$AvailableCalendarTypes.:()V -java/util/Calendar$AvailableCalendarTypes.access$000:()Ljava/util/Set; -java/util/Calendar$Builder.:()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.:()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.:(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.:(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.:(Ljava/util/Collection;)V -java/util/Collections$3.hasMoreElements:()Z -java/util/Collections$3.nextElement:()Ljava/lang/Object; -java/util/Collections$AsLIFOQueue.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(Ljava/util/List;Ljava/lang/Class;)V -java/util/Collections$CheckedRandomAccessList.subList:(II)Ljava/util/List; -java/util/Collections$CheckedSet.:(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.:(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.:(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.:(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.:()V -java/util/Collections$EmptyEnumeration.:()V -java/util/Collections$EmptyEnumeration.hasMoreElements:()Z -java/util/Collections$EmptyEnumeration.nextElement:()Ljava/lang/Object; -java/util/Collections$EmptyIterator.:()V -java/util/Collections$EmptyIterator.:()V -java/util/Collections$EmptyIterator.:(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.:()V -java/util/Collections$EmptyList.:(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.:()V -java/util/Collections$EmptyListIterator.:()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.:()V -java/util/Collections$EmptyMap.:(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.:()V -java/util/Collections$EmptySet.:(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.:()V -java/util/Collections$ReverseComparator.:()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.:(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.:(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.:(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.:(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.:(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.:(Ljava/util/Collection;)V -java/util/Collections$SynchronizedCollection.:(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.:(Ljava/util/List;)V -java/util/Collections$SynchronizedList.:(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.:(Ljava/util/Map;)V -java/util/Collections$SynchronizedMap.:(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.:(Ljava/util/NavigableMap;)V -java/util/Collections$SynchronizedNavigableMap.:(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.:(Ljava/util/NavigableSet;)V -java/util/Collections$SynchronizedNavigableSet.:(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.:(Ljava/util/List;)V -java/util/Collections$SynchronizedRandomAccessList.:(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.:(Ljava/util/Set;)V -java/util/Collections$SynchronizedSet.:(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.:(Ljava/util/SortedMap;)V -java/util/Collections$SynchronizedSortedMap.:(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.:(Ljava/util/SortedSet;)V -java/util/Collections$SynchronizedSortedSet.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:(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.:()V -java/util/Collections$UnmodifiableNavigableMap$EmptyNavigableMap.navigableKeySet:()Ljava/util/NavigableSet; -java/util/Collections$UnmodifiableNavigableMap$EmptyNavigableMap.readResolve:()Ljava/lang/Object; -java/util/Collections$UnmodifiableNavigableMap.:()V -java/util/Collections$UnmodifiableNavigableMap.:(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.:()V -java/util/Collections$UnmodifiableNavigableSet$EmptyNavigableSet.readResolve:()Ljava/lang/Object; -java/util/Collections$UnmodifiableNavigableSet.:()V -java/util/Collections$UnmodifiableNavigableSet.:(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.:(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.:(Ljava/util/Set;)V -java/util/Collections$UnmodifiableSet.equals:(Ljava/lang/Object;)Z -java/util/Collections$UnmodifiableSet.hashCode:()I -java/util/Collections$UnmodifiableSortedMap.:(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.:(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.:()V -java/util/Collections.:()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.:([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.:()V -java/util/Comparators$NaturalOrderComparator.:(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.:(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.:()V -java/util/ConcurrentModificationException.:(Ljava/lang/String;)V -java/util/ConcurrentModificationException.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/util/Currency$1.:()V -java/util/Currency$CurrencyNameGetter.:()V -java/util/Currency$CurrencyNameGetter.access$500:()Ljava/util/Currency$CurrencyNameGetter; -java/util/Currency.:(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.:(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.:()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.:()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.:()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.:(Ljava/lang/String;)V -java/util/DuplicateFormatFlagsException.getFlags:()Ljava/lang/String; -java/util/EmptyStackException.:()V -java/util/EnumMap$1.:()V -java/util/EnumMap$1.hashCode:()I -java/util/EnumMap$1.toString:()Ljava/lang/String; -java/util/EnumMap$EntryIterator$Entry.:(Ljava/util/EnumMap$EntryIterator;I)V -java/util/EnumMap$EntryIterator$Entry.:(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.:(Ljava/util/EnumMap;)V -java/util/EnumMap$EntryIterator.:(Ljava/util/EnumMap;Ljava/util/EnumMap$1;)V -java/util/EnumMap$EntryIterator.remove:()V -java/util/EnumMap$EntrySet.:(Ljava/util/EnumMap;)V -java/util/EnumMap$EntrySet.:(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.:(Ljava/util/EnumMap;)V -java/util/EnumMap$EnumMapIterator.:(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.:(Ljava/util/EnumMap;)V -java/util/EnumMap$KeyIterator.:(Ljava/util/EnumMap;Ljava/util/EnumMap$1;)V -java/util/EnumMap$KeySet.:(Ljava/util/EnumMap;)V -java/util/EnumMap$KeySet.:(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.:(Ljava/util/EnumMap;)V -java/util/EnumMap$ValueIterator.:(Ljava/util/EnumMap;Ljava/util/EnumMap$1;)V -java/util/EnumMap$Values.:(Ljava/util/EnumMap;)V -java/util/EnumMap$Values.:(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.:()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.:()V -java/util/EnumSet.:(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.:(Ljava/util/EventListener;)V -java/util/EventListenerProxy.getListener:()Ljava/util/EventListener; -java/util/EventObject.:(Ljava/lang/Object;)V -java/util/EventObject.getSource:()Ljava/lang/Object; -java/util/FormatFlagsConversionMismatchException.:(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.:()V -java/util/Formatter$BigDecimalLayoutForm.:()V -java/util/Formatter$BigDecimalLayoutForm.:(Ljava/lang/String;I)V -java/util/Formatter$Conversion.:()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.:()V -java/util/Formatter$DateTime.isValid:(C)Z -java/util/Formatter$FixedString.:(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.:()V -java/util/Formatter$Flags.:(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.:()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.:(Ljava/util/HashMap;)V -java/util/HashMap$EntrySet.:(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.:(Ljava/util/HashMap;IIII)V -java/util/HashMap$EntrySpliterator.characteristics:()I -java/util/HashMap$HashIterator.:(Ljava/util/HashMap;)V -java/util/HashMap$HashIterator.hasNext:()Z -java/util/HashMap$HashIterator.nextNode:()Ljava/util/HashMap$Node; -java/util/HashMap$HashMapSpliterator.:(Ljava/util/HashMap;IIII)V -java/util/HashMap$HashMapSpliterator.estimateSize:()J -java/util/HashMap$HashMapSpliterator.getFence:()I -java/util/HashMap$KeyIterator.:(Ljava/util/HashMap;)V -java/util/HashMap$KeySet.:(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.:(Ljava/util/HashMap;IIII)V -java/util/HashMap$KeySpliterator.characteristics:()I -java/util/HashMap$Node.:(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.:(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.:(Ljava/util/HashMap;)V -java/util/HashMap$ValueSpliterator.:(Ljava/util/HashMap;IIII)V -java/util/HashMap$ValueSpliterator.characteristics:()I -java/util/HashMap$Values.:(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.:()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.:()V -java/util/HashSet.:()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.:(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.:(Ljava/util/Hashtable;)V -java/util/Hashtable$EntrySet.:(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.:(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.:(Ljava/util/Hashtable;)V -java/util/Hashtable$KeySet.:(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.:(Ljava/util/Hashtable;)V -java/util/Hashtable$ValueCollection.:(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.:(Ljava/util/IdentityHashMap$EntryIterator;I)V -java/util/IdentityHashMap$EntryIterator$Entry.:(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.:(Ljava/util/IdentityHashMap;)V -java/util/IdentityHashMap$EntryIterator.:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V -java/util/IdentityHashMap$EntrySet.:(Ljava/util/IdentityHashMap;)V -java/util/IdentityHashMap$EntrySet.:(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.:(Ljava/util/IdentityHashMap;IIII)V -java/util/IdentityHashMap$EntrySpliterator.characteristics:()I -java/util/IdentityHashMap$IdentityHashMapIterator.:(Ljava/util/IdentityHashMap;)V -java/util/IdentityHashMap$IdentityHashMapIterator.:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V -java/util/IdentityHashMap$IdentityHashMapIterator.hasNext:()Z -java/util/IdentityHashMap$IdentityHashMapIterator.nextIndex:()I -java/util/IdentityHashMap$IdentityHashMapSpliterator.:(Ljava/util/IdentityHashMap;IIII)V -java/util/IdentityHashMap$IdentityHashMapSpliterator.estimateSize:()J -java/util/IdentityHashMap$IdentityHashMapSpliterator.getFence:()I -java/util/IdentityHashMap$KeyIterator.:(Ljava/util/IdentityHashMap;)V -java/util/IdentityHashMap$KeyIterator.:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V -java/util/IdentityHashMap$KeySet.:(Ljava/util/IdentityHashMap;)V -java/util/IdentityHashMap$KeySet.:(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.:(Ljava/util/IdentityHashMap;IIII)V -java/util/IdentityHashMap$KeySpliterator.characteristics:()I -java/util/IdentityHashMap$ValueIterator.:(Ljava/util/IdentityHashMap;)V -java/util/IdentityHashMap$ValueIterator.:(Ljava/util/IdentityHashMap;Ljava/util/IdentityHashMap$1;)V -java/util/IdentityHashMap$ValueSpliterator.:(Ljava/util/IdentityHashMap;IIII)V -java/util/IdentityHashMap$ValueSpliterator.characteristics:()I -java/util/IdentityHashMap$Values.:(Ljava/util/IdentityHashMap;)V -java/util/IdentityHashMap$Values.:(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.:()V -java/util/IdentityHashMap.:()V -java/util/IdentityHashMap.:(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.:(I)V -java/util/IllegalFormatCodePointException.getCodePoint:()I -java/util/IllegalFormatConversionException.:(CLjava/lang/Class;)V -java/util/IllegalFormatConversionException.getArgumentClass:()Ljava/lang/Class; -java/util/IllegalFormatConversionException.getConversion:()C -java/util/IllegalFormatException.:()V -java/util/IllegalFormatFlagsException.:(Ljava/lang/String;)V -java/util/IllegalFormatFlagsException.getFlags:()Ljava/lang/String; -java/util/IllegalFormatFlagsException.getMessage:()Ljava/lang/String; -java/util/IllegalFormatPrecisionException.:(I)V -java/util/IllegalFormatPrecisionException.getMessage:()Ljava/lang/String; -java/util/IllegalFormatPrecisionException.getPrecision:()I -java/util/IllegalFormatWidthException.:(I)V -java/util/IllegalFormatWidthException.getMessage:()Ljava/lang/String; -java/util/IllegalFormatWidthException.getWidth:()I -java/util/IllformedLocaleException.:()V -java/util/IllformedLocaleException.:(Ljava/lang/String;)V -java/util/IllformedLocaleException.:(Ljava/lang/String;I)V -java/util/IllformedLocaleException.getErrorIndex:()I -java/util/InputMismatchException.:()V -java/util/InputMismatchException.:(Ljava/lang/String;)V -java/util/IntSummaryStatistics.:()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.:(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.:(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.:(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/HashMap$Node;)V -java/util/LinkedHashMap$LinkedEntryIterator.:(Ljava/util/LinkedHashMap;)V -java/util/LinkedHashMap$LinkedEntrySet.:(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.:(Ljava/util/LinkedHashMap;)V -java/util/LinkedHashMap$LinkedHashIterator.hasNext:()Z -java/util/LinkedHashMap$LinkedHashIterator.nextNode:()Ljava/util/LinkedHashMap$Entry; -java/util/LinkedHashMap$LinkedKeyIterator.:(Ljava/util/LinkedHashMap;)V -java/util/LinkedHashMap$LinkedKeySet.:(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.:(Ljava/util/LinkedHashMap;)V -java/util/LinkedHashMap$LinkedValues.:(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.:()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.:(Ljava/util/LinkedList;)V -java/util/LinkedList$DescendingIterator.:(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.:(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.:(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.:(Ljava/util/LinkedList$Node;Ljava/lang/Object;Ljava/util/LinkedList$Node;)V -java/util/LinkedList.:()V -java/util/LinkedList.:(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.:()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.:()V -java/util/Locale$Category.:(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V -java/util/Locale$FilteringMode.:()V -java/util/Locale$FilteringMode.:(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.:()V -java/util/Locale$LocaleNameGetter.access$500:()Ljava/util/Locale$LocaleNameGetter; -java/util/Locale.:(Lsun/util/locale/BaseLocale;Lsun/util/locale/LocaleExtensions;)V -java/util/Locale.:(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.:()V -java/util/LongSummaryStatistics.:()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.:(Ljava/lang/String;)V -java/util/MissingFormatArgumentException.getFormatSpecifier:()Ljava/lang/String; -java/util/MissingFormatArgumentException.getMessage:()Ljava/lang/String; -java/util/MissingFormatWidthException.:(Ljava/lang/String;)V -java/util/MissingFormatWidthException.getFormatSpecifier:()Ljava/lang/String; -java/util/MissingFormatWidthException.getMessage:()Ljava/lang/String; -java/util/MissingResourceException.:(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V -java/util/MissingResourceException.:(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.:()V -java/util/NoSuchElementException.:(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.:()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.:()V -java/util/Optional.:()V -java/util/Optional.:(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.:()V -java/util/OptionalDouble.:()V -java/util/OptionalDouble.:(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.:()V -java/util/OptionalInt.:()V -java/util/OptionalInt.:(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.:()V -java/util/OptionalLong.:()V -java/util/OptionalLong.:(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.:(Ljava/util/PriorityQueue;)V -java/util/PriorityQueue$Itr.:(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.:(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.:()V -java/util/PriorityQueue.:(I)V -java/util/PriorityQueue.:(ILjava/util/Comparator;)V -java/util/PriorityQueue.:(Ljava/util/Collection;)V -java/util/PriorityQueue.:(Ljava/util/Comparator;)V -java/util/PriorityQueue.:(Ljava/util/PriorityQueue;)V -java/util/PriorityQueue.:(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.:(Ljava/util/Properties;Ljava/io/InputStream;)V -java/util/Properties$LineReader.:(Ljava/util/Properties;Ljava/io/Reader;)V -java/util/Properties$XmlSupport$1.:()V -java/util/Properties$XmlSupport.:()V -java/util/Properties.:()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.:(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.:(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.:(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.:(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.:(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.:()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.:(Ljava/util/ResourceBundle$Control;ZLjava/lang/ClassLoader;Ljava/lang/String;)V -java/util/ResourceBundle$Control.:()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.:()V -java/util/ResourceBundle$NoFallbackControl.:(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.:()V -java/util/ResourceBundle$RBClassLoader.access$000:()Ljava/util/ResourceBundle$RBClassLoader; -java/util/ResourceBundle$SingleFormatControl.:()V -java/util/ResourceBundle$SingleFormatControl.:(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.:()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.:(Ljava/lang/String;)V -java/util/ServiceConfigurationError.:(Ljava/lang/String;Ljava/lang/Throwable;)V -java/util/ServiceLoader$1.:(Ljava/util/ServiceLoader;)V -java/util/ServiceLoader$1.remove:()V -java/util/ServiceLoader$LazyIterator$1.:(Ljava/util/ServiceLoader$LazyIterator;)V -java/util/ServiceLoader$LazyIterator$2.:(Ljava/util/ServiceLoader$LazyIterator;)V -java/util/ServiceLoader$LazyIterator.:(Ljava/util/ServiceLoader;Ljava/lang/Class;Ljava/lang/ClassLoader;)V -java/util/ServiceLoader$LazyIterator.:(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.:(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.:(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.:(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.:(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.:(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.:()V -java/util/Spliterators$AbstractDoubleSpliterator$HoldingDoubleConsumer.accept:(D)V -java/util/Spliterators$AbstractDoubleSpliterator.:(JI)V -java/util/Spliterators$AbstractDoubleSpliterator.characteristics:()I -java/util/Spliterators$AbstractDoubleSpliterator.estimateSize:()J -java/util/Spliterators$AbstractIntSpliterator$HoldingIntConsumer.:()V -java/util/Spliterators$AbstractIntSpliterator$HoldingIntConsumer.accept:(I)V -java/util/Spliterators$AbstractIntSpliterator.:(JI)V -java/util/Spliterators$AbstractIntSpliterator.characteristics:()I -java/util/Spliterators$AbstractIntSpliterator.estimateSize:()J -java/util/Spliterators$AbstractLongSpliterator$HoldingLongConsumer.:()V -java/util/Spliterators$AbstractLongSpliterator$HoldingLongConsumer.accept:(J)V -java/util/Spliterators$AbstractLongSpliterator.:(JI)V -java/util/Spliterators$AbstractLongSpliterator.characteristics:()I -java/util/Spliterators$AbstractLongSpliterator.estimateSize:()J -java/util/Spliterators$AbstractSpliterator$HoldingConsumer.:()V -java/util/Spliterators$AbstractSpliterator$HoldingConsumer.accept:(Ljava/lang/Object;)V -java/util/Spliterators$AbstractSpliterator.:(JI)V -java/util/Spliterators$AbstractSpliterator.characteristics:()I -java/util/Spliterators$AbstractSpliterator.estimateSize:()J -java/util/Spliterators$ArraySpliterator.:([Ljava/lang/Object;I)V -java/util/Spliterators$ArraySpliterator.:([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.:([DI)V -java/util/Spliterators$DoubleArraySpliterator.:([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.:(Ljava/util/PrimitiveIterator$OfDouble;I)V -java/util/Spliterators$DoubleIteratorSpliterator.:(Ljava/util/PrimitiveIterator$OfDouble;JI)V -java/util/Spliterators$DoubleIteratorSpliterator.characteristics:()I -java/util/Spliterators$DoubleIteratorSpliterator.estimateSize:()J -java/util/Spliterators$EmptySpliterator$OfDouble.:()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.:()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.:()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.:()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.:()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.:([II)V -java/util/Spliterators$IntArraySpliterator.:([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.:(Ljava/util/PrimitiveIterator$OfInt;I)V -java/util/Spliterators$IntIteratorSpliterator.:(Ljava/util/PrimitiveIterator$OfInt;JI)V -java/util/Spliterators$IntIteratorSpliterator.characteristics:()I -java/util/Spliterators$IntIteratorSpliterator.estimateSize:()J -java/util/Spliterators$IteratorSpliterator.:(Ljava/util/Collection;I)V -java/util/Spliterators$IteratorSpliterator.:(Ljava/util/Iterator;I)V -java/util/Spliterators$IteratorSpliterator.:(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.:([JI)V -java/util/Spliterators$LongArraySpliterator.:([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.:(Ljava/util/PrimitiveIterator$OfLong;I)V -java/util/Spliterators$LongIteratorSpliterator.:(Ljava/util/PrimitiveIterator$OfLong;JI)V -java/util/Spliterators$LongIteratorSpliterator.characteristics:()I -java/util/Spliterators$LongIteratorSpliterator.estimateSize:()J -java/util/Spliterators.:()V -java/util/Spliterators.:()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.:(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.:(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.:(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.:(J)V -java/util/SplittableRandom.:(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.:()V -java/util/StringJoiner.:(Ljava/lang/CharSequence;)V -java/util/StringJoiner.:(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.:(Ljava/lang/String;)V -java/util/StringTokenizer.:(Ljava/lang/String;Ljava/lang/String;)V -java/util/StringTokenizer.:(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.:()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.:([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.:(Ljava/lang/String;)V -java/util/TimeZone.:()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.:(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.:()V -java/util/TimerTask.cancel:()Z -java/util/TimerTask.run:()V -java/util/TimerTask.scheduledExecutionTime:()J -java/util/TooManyListenersException.:()V -java/util/TooManyListenersException.:(Ljava/lang/String;)V -java/util/TreeMap$AscendingSubMap$AscendingEntrySetView.:(Ljava/util/TreeMap$AscendingSubMap;)V -java/util/TreeMap$AscendingSubMap.:(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.:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;)V -java/util/TreeMap$DescendingKeyIterator.remove:()V -java/util/TreeMap$DescendingKeySpliterator.:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;III)V -java/util/TreeMap$DescendingKeySpliterator.characteristics:()I -java/util/TreeMap$DescendingSubMap$DescendingEntrySetView.:(Ljava/util/TreeMap$DescendingSubMap;)V -java/util/TreeMap$DescendingSubMap.:(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.:(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.:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;)V -java/util/TreeMap$EntrySet.:(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.:(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.:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;)V -java/util/TreeMap$KeySet.:(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.:(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.:(Ljava/util/TreeMap$NavigableSubMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;)V -java/util/TreeMap$NavigableSubMap$DescendingSubMapKeyIterator.:(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.:(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.:(Ljava/util/TreeMap$NavigableSubMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;)V -java/util/TreeMap$NavigableSubMap$SubMapIterator.:(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.:(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.:(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.:(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.:(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.:(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.:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;)V -java/util/TreeMap$ValueSpliterator.:(Ljava/util/TreeMap;Ljava/util/TreeMap$Entry;Ljava/util/TreeMap$Entry;III)V -java/util/TreeMap$ValueSpliterator.characteristics:()I -java/util/TreeMap$Values.:(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.:()V -java/util/TreeMap.:()V -java/util/TreeMap.:(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.:()V -java/util/TreeSet.:()V -java/util/TreeSet.:(Ljava/util/Comparator;)V -java/util/TreeSet.:(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.:()V -java/util/UUID$Holder.:()V -java/util/UUID.:(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.:(Ljava/lang/String;)V -java/util/UnknownFormatConversionException.getConversion:()Ljava/lang/String; -java/util/UnknownFormatFlagsException.:(Ljava/lang/String;)V -java/util/UnknownFormatFlagsException.getFlags:()Ljava/lang/String; -java/util/UnknownFormatFlagsException.getMessage:()Ljava/lang/String; -java/util/Vector$1.:(Ljava/util/Vector;)V -java/util/Vector$1.hasMoreElements:()Z -java/util/Vector$1.nextElement:()Ljava/lang/Object; -java/util/Vector$Itr.:(Ljava/util/Vector;)V -java/util/Vector$Itr.:(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.:(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.:(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.:()V -java/util/Vector.:(I)V -java/util/Vector.:(II)V -java/util/Vector.:(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.:(Ljava/util/WeakHashMap;)V -java/util/WeakHashMap$EntrySet.:(Ljava/util/WeakHashMap;Ljava/util/WeakHashMap$1;)V -java/util/WeakHashMap$EntrySet.spliterator:()Ljava/util/Spliterator; -java/util/WeakHashMap$EntrySpliterator.:(Ljava/util/WeakHashMap;IIII)V -java/util/WeakHashMap$EntrySpliterator.characteristics:()I -java/util/WeakHashMap$KeySet.:(Ljava/util/WeakHashMap;)V -java/util/WeakHashMap$KeySet.:(Ljava/util/WeakHashMap;Ljava/util/WeakHashMap$1;)V -java/util/WeakHashMap$KeySet.spliterator:()Ljava/util/Spliterator; -java/util/WeakHashMap$KeySpliterator.:(Ljava/util/WeakHashMap;IIII)V -java/util/WeakHashMap$KeySpliterator.characteristics:()I -java/util/WeakHashMap$ValueSpliterator.:(Ljava/util/WeakHashMap;IIII)V -java/util/WeakHashMap$ValueSpliterator.characteristics:()I -java/util/WeakHashMap$Values.:(Ljava/util/WeakHashMap;)V -java/util/WeakHashMap$Values.:(Ljava/util/WeakHashMap;Ljava/util/WeakHashMap$1;)V -java/util/WeakHashMap$Values.spliterator:()Ljava/util/Spliterator; -java/util/WeakHashMap$WeakHashMapSpliterator.:(Ljava/util/WeakHashMap;IIII)V -java/util/WeakHashMap.:()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 deleted file mode 100644 index 2bbd1aa908..0000000000 --- a/experimental/sandbox/src/main/resources/logback.xml +++ /dev/null @@ -1,31 +0,0 @@ - - - - - - - - whitelistclassloader.log - - - whitelistclassloader.%d{yyyy-MM-dd}.log - - - - %date [%thread] %-5level %logger{35} - %msg%n - - - - - - - - diff --git a/experimental/sandbox/src/test/java/net/corda/sandbox/CandidateMethodTest.java b/experimental/sandbox/src/test/java/net/corda/sandbox/CandidateMethodTest.java deleted file mode 100644 index 8b48746c25..0000000000 --- a/experimental/sandbox/src/test/java/net/corda/sandbox/CandidateMethodTest.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -package net.corda.sandbox; - -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 static final String OBJECT_INIT_METHOD = "java/lang/Object.:()V"; - private static final 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 deleted file mode 100644 index fda7f308ee..0000000000 --- a/experimental/sandbox/src/test/java/net/corda/sandbox/Constants.java +++ /dev/null @@ -1,21 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -package net.corda.sandbox; - -class Constants { - public static final String INVALID_CLASS = "foobar"; - public static final String BASE_DETERMINISTIC_METHODS = "resource/CallObjectMethods"; - public static final String SYSTEM_OUT_PRINTLN_CLASS = "resource/CallPrintln"; - public static final String INVOKEDYNAMIC_METHOD_CLASS = "resource/UseLambdaToForceInvokeDynamic"; - public static final String NATIVE_METHOD_CLASS = "resource/CallNative"; - public static final String BASIC_COLLECTIONS_CLASS = "resource/UseBasicCollections"; - public static final 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 deleted file mode 100644 index 348cf3e4c6..0000000000 --- a/experimental/sandbox/src/test/java/net/corda/sandbox/TestUtils.java +++ /dev/null @@ -1,169 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -package net.corda.sandbox; - -import net.corda.sandbox.costing.RuntimeCostAccounter; -import org.junit.Assert; - -import javax.xml.bind.DatatypeConverter; -import java.io.IOException; -import java.io.InputStream; -import java.nio.file.*; -import java.nio.file.attribute.BasicFileAttributes; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import static org.junit.Assert.assertEquals; - -public class TestUtils { - - private static List tmpFileSystems = new ArrayList<>(); - 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("wlcl-tmp-test"); - Path copiedJar = tmpdir.resolve("tmp-resource.jar"); - try (final InputStream in = TestUtils.class.getResourceAsStream(resourcePathToJar)) { - Files.copy(in, copiedJar, StandardCopyOption.REPLACE_EXISTING); - } - final FileSystem fs = FileSystems.newFileSystem(copiedJar, null); - tmpFileSystems.add(fs); - jarFSDir = fs.getRootDirectories().iterator().next(); - } - - public static Path copySandboxJarToTmpDir(final String resourcePathToJar) throws IOException { - - Path sandboxJar = tmpdir.resolve("tmp-sandbox.jar"); - try (final InputStream in = TestUtils.class.getResourceAsStream(resourcePathToJar)) { - Files.copy(in, sandboxJar, StandardCopyOption.REPLACE_EXISTING); - } - final FileSystem sandboxFs = FileSystems.newFileSystem(sandboxJar, null); - tmpFileSystems.add(sandboxFs); - return sandboxFs.getRootDirectories().iterator().next(); - } - - public static Path getJarFSRoot() { - return jarFSDir; - } - - public static void cleanupTmpJar() throws IOException { - for (FileSystem fs : tmpFileSystems) { - fs.close(); - } - tmpFileSystems.clear(); - jarFSDir = null; - Files.walkFileTree(tmpdir, new Reaper()); - tmpdir = null; - } - - 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 Exception { - byte[] basic = getBytes(classFName); - assertEquals(originalLength, basic.length); - final byte[] tfmd = instrumentWithCosts(basic, new HashSet<>()); - final Path testdir = Files.createTempDirectory("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 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 { - - @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 deleted file mode 100644 index 4e3ab755b6..0000000000 --- a/experimental/sandbox/src/test/java/net/corda/sandbox/WhitelistClassLoaderTest.java +++ /dev/null @@ -1,171 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -package net.corda.sandbox; - -import static org.junit.Assert.*; - -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); - } - - //TODO This code frequently throws StackOverflowException, despite this being explicitly what the code is trying to prevent!! - @Ignore - @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 deleted file mode 100644 index 343f2ca7b2..0000000000 --- a/experimental/sandbox/src/test/java/net/corda/sandbox/costing/DeterministicClassInstrumenterTest.java +++ /dev/null @@ -1,84 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 deleted file mode 100644 index 4fb4aa4a45..0000000000 --- a/experimental/sandbox/src/test/java/net/corda/sandbox/costing/SandboxedRewritingTest.java +++ /dev/null @@ -1,136 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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(ret.getClass() == Object.class); - 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 deleted file mode 100644 index 36b5dd9752..0000000000 --- a/experimental/sandbox/src/test/java/sandbox/greymalkin/StringReturner.java +++ /dev/null @@ -1,20 +0,0 @@ -/* - * R3 Proprietary and Confidential - * - * Copyright (c) 2018 R3 Limited. All rights reserved. - * - * The intellectual and technical concepts contained herein are proprietary to R3 and its suppliers and are protected by trade secret law. - * - * Distribution of this file or any portion thereof via any medium without the express permission of R3 is strictly prohibited. - */ - -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 deleted file mode 100644 index 8b94ceab66..0000000000 Binary files a/experimental/sandbox/src/test/resources/java/lang/Exception.class and /dev/null differ diff --git a/experimental/sandbox/src/test/resources/java/lang/Throwable.class b/experimental/sandbox/src/test/resources/java/lang/Throwable.class deleted file mode 100644 index 1dc06ac1bf..0000000000 Binary files a/experimental/sandbox/src/test/resources/java/lang/Throwable.class and /dev/null 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 deleted file mode 100644 index cc3bb2c04e..0000000000 Binary files a/experimental/sandbox/src/test/resources/java/lang/reflect/Array.class and /dev/null differ diff --git a/experimental/sandbox/src/test/resources/java/util/ArrayList.class b/experimental/sandbox/src/test/resources/java/util/ArrayList.class deleted file mode 100644 index d5cb2f68ab..0000000000 Binary files a/experimental/sandbox/src/test/resources/java/util/ArrayList.class and /dev/null differ diff --git a/experimental/sandbox/src/test/resources/java/util/Arrays.class b/experimental/sandbox/src/test/resources/java/util/Arrays.class deleted file mode 100644 index db37dfa016..0000000000 Binary files a/experimental/sandbox/src/test/resources/java/util/Arrays.class and /dev/null differ diff --git a/experimental/sandbox/src/test/resources/logback-test.xml b/experimental/sandbox/src/test/resources/logback-test.xml deleted file mode 100644 index 284da3593c..0000000000 --- a/experimental/sandbox/src/test/resources/logback-test.xml +++ /dev/null @@ -1,39 +0,0 @@ - - - - - - - - - UTF-8 - %d %-4relative [%thread] %-5level %logger{35} - %msg%n - - - - - whitelistclassloader-test.log - - - whitelistclassloader-test.%d{yyyy-MM-dd}.log - - - - %date [%thread] %-5level %logger{35} - %msg%n - - - - - - - - - diff --git a/experimental/sandbox/src/test/resources/resource.jar b/experimental/sandbox/src/test/resources/resource.jar deleted file mode 100644 index f8e81ad535..0000000000 Binary files a/experimental/sandbox/src/test/resources/resource.jar and /dev/null differ diff --git a/experimental/sandbox/src/test/resources/sandbox.jar b/experimental/sandbox/src/test/resources/sandbox.jar deleted file mode 100644 index 500bfb42b2..0000000000 Binary files a/experimental/sandbox/src/test/resources/sandbox.jar and /dev/null differ diff --git a/node/capsule/build.gradle b/node/capsule/build.gradle index 5bd5889185..a5b82ffcef 100644 --- a/node/capsule/build.gradle +++ b/node/capsule/build.gradle @@ -75,6 +75,8 @@ task buildCordaJAR(type: FatCapsule, dependsOn: project(':node').compileJava) { } } +build.dependsOn buildCordaJAR + artifacts { runtimeArtifacts buildCordaJAR publish buildCordaJAR { diff --git a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt index 2b87983d05..041cfadcc5 100644 --- a/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt +++ b/node/src/main/kotlin/net/corda/node/internal/NodeStartup.kt @@ -51,6 +51,7 @@ import org.slf4j.bridge.SLF4JBridgeHandler import sun.misc.VMSupport import java.io.Console import java.io.File +import java.io.IOException import java.io.RandomAccessFile import java.lang.management.ManagementFactory import java.net.InetAddress @@ -465,23 +466,31 @@ open class NodeStartup(val args: Array) { // exists, we try to take the file lock first before replacing it and if that fails it means we're being started // twice with the same directory: that's a user error and we should bail out. val pidFile = (baseDirectory / "process-id").toFile() - pidFile.createNewFile() - val pidFileRw = RandomAccessFile(pidFile, "rw") - val pidFileLock = pidFileRw.channel.tryLock() - if (pidFileLock == null) { - println("It appears there is already a node running with the specified data directory $baseDirectory") - println("Shut that other node down and try again. It may have process ID ${pidFile.readText()}") + try { + pidFile.createNewFile() + val pidFileRw = RandomAccessFile(pidFile, "rw") + val pidFileLock = pidFileRw.channel.tryLock() + + if (pidFileLock == null) { + println("It appears there is already a node running with the specified data directory $baseDirectory") + println("Shut that other node down and try again. It may have process ID ${pidFile.readText()}") + System.exit(1) + } + pidFile.deleteOnExit() + // Avoid the lock being garbage collected. We don't really need to release it as the OS will do so for us + // when our process shuts down, but we try in stop() anyway just to be nice. + addShutdownHook { + pidFileLock.release() + } + val ourProcessID: String = ManagementFactory.getRuntimeMXBean().name.split("@")[0] + pidFileRw.setLength(0) + pidFileRw.write(ourProcessID.toByteArray()) + } catch (ex: IOException) { + val appUser = System.getProperty("user.name") + println("Application user '$appUser' does not have necessary permissions for Node base directory '$baseDirectory'.") + println("Corda Node process in now exiting. Please check directory permissions and try starting the Node again.") System.exit(1) } - pidFile.deleteOnExit() - // Avoid the lock being garbage collected. We don't really need to release it as the OS will do so for us - // when our process shuts down, but we try in stop() anyway just to be nice. - addShutdownHook { - pidFileLock.release() - } - val ourProcessID: String = ManagementFactory.getRuntimeMXBean().name.split("@")[0] - pidFileRw.setLength(0) - pidFileRw.write(ourProcessID.toByteArray()) } protected open fun initLogging(cmdlineOptions: CmdLineOptions) { diff --git a/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt b/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt index 13b1749da1..2eba17c305 100644 --- a/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt +++ b/node/src/main/kotlin/net/corda/node/services/messaging/RPCServer.kt @@ -315,7 +315,18 @@ class RPCServer( private fun clientArtemisMessageHandler(artemisMessage: ClientMessage) { lifeCycle.requireState(State.STARTED) val clientToServer = RPCApi.ClientToServer.fromClientMessage(artemisMessage) - log.debug { "-> RPC -> $clientToServer" } + if (log.isDebugEnabled) { + when (clientToServer) { + is RPCApi.ClientToServer.RpcRequest -> { + val username = artemisMessage.getStringProperty("_AMQ_VALIDATED_USER") ?: "(unknown)" + // Don't print the whole object because most of the data is useless. + log.debug { "-> RPC by $username -> ${clientToServer.methodName}" } + } + is RPCApi.ClientToServer.ObservablesClosed -> { + log.debug { "-> RPC observable closed -> $clientToServer"} + } + } + } try { when (clientToServer) { is RPCApi.ClientToServer.RpcRequest -> { @@ -360,12 +371,15 @@ class RPCServer( return Try.on { try { CURRENT_RPC_CONTEXT.set(context) - log.debug { "Calling $methodName" } + log.trace { "Calling $methodName" } val method = methodTable[methodName] ?: throw RPCException("Received RPC for unknown method $methodName - possible client/server version skew?") method.invoke(ops, *arguments.toTypedArray()) } catch (e: InvocationTargetException) { throw e.cause ?: RPCException("Caught InvocationTargetException without cause") + } catch (e: Exception) { + log.warn("Caught exception attempting to invoke RPC $methodName", e) + throw e } finally { CURRENT_RPC_CONTEXT.remove() } diff --git a/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/SerializerFactory.kt b/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/SerializerFactory.kt index a4e1aabd65..23a7b16951 100644 --- a/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/SerializerFactory.kt +++ b/serialization/src/main/kotlin/net/corda/serialization/internal/amqp/SerializerFactory.kt @@ -155,9 +155,11 @@ open class SerializerFactory( } } Enum::class.java.isAssignableFrom(actualClass ?: declaredClass) -> { - logger.info("class=[${actualClass?.simpleName} | $declaredClass] is an enumeration " - + "declaredType=${declaredType.typeName} " - + "isEnum=${declaredType::class.java.isEnum}") + logger.trace { + "class=[${actualClass?.simpleName} | $declaredClass] is an enumeration " + + "declaredType=${declaredType.typeName} " + + "isEnum=${declaredType::class.java.isEnum}" + } serializersByType.computeIfAbsent(actualClass ?: declaredClass) { whitelist.requireWhitelisted(actualType) @@ -265,7 +267,7 @@ open class SerializerFactory( * that expects to find getters and a constructor with a parameter for each property. */ open fun register(customSerializer: CustomSerializer) { - logger.info ("action=\"Registering custom serializer\", class=\"${customSerializer.type}\"") + logger.trace("action=\"Registering custom serializer\", class=\"${customSerializer.type}\"") if (!serializersByDescriptor.containsKey(customSerializer.typeDescriptor)) { customSerializers += customSerializer serializersByDescriptor[customSerializer.typeDescriptor] = customSerializer @@ -276,7 +278,7 @@ open class SerializerFactory( } fun registerExternal(customSerializer: CorDappCustomSerializer) { - logger.info ("action=\"Registering external serializer\", class=\"${customSerializer.type}\"") + logger.trace("action=\"Registering external serializer\", class=\"${customSerializer.type}\"") if (!serializersByDescriptor.containsKey(customSerializer.typeDescriptor)) { customSerializers += customSerializer serializersByDescriptor[customSerializer.typeDescriptor] = customSerializer @@ -290,14 +292,14 @@ open class SerializerFactory( private fun processSchema(schemaAndDescriptor: FactorySchemaAndDescriptor, sentinel: Boolean = false) { val metaSchema = CarpenterMetaSchema.newInstance() for (typeNotation in schemaAndDescriptor.schemas.schema.types) { - logger.debug { "descriptor=${schemaAndDescriptor.typeDescriptor}, typeNotation=${typeNotation.name}" } + logger.trace { "descriptor=${schemaAndDescriptor.typeDescriptor}, typeNotation=${typeNotation.name}" } try { val serialiser = processSchemaEntry(typeNotation) // if we just successfully built a serializer for the type but the type fingerprint // doesn't match that of the serialised object then we are dealing with different // instance of the class, as such we need to build an EvolutionSerializer if (serialiser.typeDescriptor != typeNotation.descriptor.name) { - logger.info("typeNotation=${typeNotation.name} action=\"requires Evolution\"") + logger.trace { "typeNotation=${typeNotation.name} action=\"requires Evolution\"" } getEvolutionSerializer(typeNotation, serialiser, schemaAndDescriptor.schemas) } } catch (e: ClassNotFoundException) { @@ -306,7 +308,7 @@ open class SerializerFactory( throw e } else { - logger.info("typeNotation=\"${typeNotation.name}\" action=\"carpentry required\"") + logger.trace { "typeNotation=\"${typeNotation.name}\" action=\"carpentry required\"" } } metaSchema.buildFor(typeNotation, classloader) } diff --git a/settings.gradle b/settings.gradle index 6fd80d0dc0..81b775f657 100644 --- a/settings.gradle +++ b/settings.gradle @@ -25,12 +25,13 @@ include 'client:jackson' include 'client:jfx' include 'client:mock' include 'client:rpc' +include 'djvm' +include 'djvm:cli' include 'webserver' include 'webserver:webcapsule' include 'experimental' include 'experimental:avalanche' include 'experimental:behave' -include 'experimental:sandbox' include 'experimental:quasar-hook' include 'experimental:kryo-hook' // include 'experimental:intellij-plugin' @@ -64,6 +65,7 @@ include 'tools:dbmigration' include 'tools:shell' include 'tools:shell-cli' include 'tools:network-bootstrapper' +include 'tools:cliutils' include 'example-code' project(':example-code').projectDir = file("$settingsDir/docs/source/example-code") include 'samples:attachment-demo' diff --git a/tools/bootstrapper/build.gradle b/tools/bootstrapper/build.gradle index e8bec2a7c7..c0c8616e53 100644 --- a/tools/bootstrapper/build.gradle +++ b/tools/bootstrapper/build.gradle @@ -17,6 +17,7 @@ description 'Network bootstrapper' dependencies { compile project(':node-api') + compile project(':tools:cliutils') compile "info.picocli:picocli:$picocli_version" compile "org.slf4j:jul-to-slf4j:$slf4j_version" compile "org.apache.logging.log4j:log4j-slf4j-impl:$log4j_version" diff --git a/tools/bootstrapper/src/main/kotlin/net/corda/bootstrapper/Main.kt b/tools/bootstrapper/src/main/kotlin/net/corda/bootstrapper/Main.kt index f89750246f..a75c92d53d 100644 --- a/tools/bootstrapper/src/main/kotlin/net/corda/bootstrapper/Main.kt +++ b/tools/bootstrapper/src/main/kotlin/net/corda/bootstrapper/Main.kt @@ -1,38 +1,17 @@ package net.corda.bootstrapper -import com.jcabi.manifests.Manifests -import net.corda.core.internal.* +import net.corda.cliutils.CordaCliWrapper +import net.corda.cliutils.start import net.corda.nodeapi.internal.network.NetworkBootstrapper -import picocli.CommandLine -import picocli.CommandLine.* +import picocli.CommandLine.Option import java.nio.file.Path import java.nio.file.Paths -import java.nio.file.StandardCopyOption.REPLACE_EXISTING -import kotlin.system.exitProcess fun main(args: Array) { - val main = Main() - try { - CommandLine.run(main, *args) - } catch (e: ExecutionException) { - val throwable = e.cause ?: e - if (main.verbose) { - throwable.printStackTrace() - } else { - System.err.println("*ERROR*: ${throwable.rootMessage ?: "Use --verbose for more details"}") - } - exitProcess(1) - } + NetworkBootstrapperRunner().start(*args) } -@Command( - name = "Network Bootstrapper", - versionProvider = CordaVersionProvider::class, - mixinStandardHelpOptions = true, - showDefaultValues = true, - description = ["Bootstrap a local test Corda network using a set of node configuration files and CorDapp JARs"] -) -class Main : Runnable { +class NetworkBootstrapperRunner : CordaCliWrapper("bootstrapper", "Bootstrap a local test Corda network using a set of node configuration files and CorDapp JARs") { @Option( names = ["--dir"], description = [ @@ -45,143 +24,7 @@ class Main : Runnable { @Option(names = ["--no-copy"], description = ["""Don't copy the CorDapp JARs into the nodes' "cordapps" directories."""]) private var noCopy: Boolean = false - @Option(names = ["--verbose"], description = ["Enable verbose output."]) - var verbose: Boolean = false - - @Option(names = ["--install-shell-extensions"], description = ["Install bootstrapper alias and autocompletion for bash and zsh"]) - var installShellExtensions: Boolean = false - - private class SettingsFile(val filePath: Path) { - private val lines: MutableList by lazy { getFileLines() } - var fileModified: Boolean = false - - // Return the lines in the file if it exists, else return an empty mutable list - private fun getFileLines(): MutableList { - return if (filePath.exists()) { - filePath.toFile().readLines().toMutableList() - } else { - emptyList().toMutableList() - } - } - - fun addOrReplaceIfStartsWith(startsWith: String, replaceWith: String) { - val index = lines.indexOfFirst { it.startsWith(startsWith) } - if (index >= 0) { - if (lines[index] != replaceWith) { - lines[index] = replaceWith - fileModified = true - } - } else { - lines.add(replaceWith) - fileModified = true - } - } - - fun addIfNotExists(line: String) { - if (!lines.contains(line)) { - lines.add(line) - fileModified = true - } - } - - fun updateAndBackupIfNecessary() { - if (fileModified) { - val backupFilePath = filePath.parent / "${filePath.fileName}.backup" - println("Updating settings in ${filePath.fileName} - existing settings file has been backed up to $backupFilePath") - if (filePath.exists()) filePath.copyTo(backupFilePath, REPLACE_EXISTING) - filePath.writeLines(lines) - } - } - } - - private val userHome: Path by lazy { Paths.get(System.getProperty("user.home")) } - private val jarLocation: Path by lazy { this.javaClass.location.toPath() } - - // If on Windows, Path.toString() returns a path with \ instead of /, but for bash Windows users we want to convert those back to /'s - private fun Path.toStringWithDeWindowsfication(): String = this.toAbsolutePath().toString().replace("\\", "/") - private fun jarVersion(alias: String) = "# $alias - Version: ${CordaVersionProvider.releaseVersion}, Revision: ${CordaVersionProvider.revision}" - private fun getAutoCompleteFileLocation(alias: String) = userHome / ".completion" / alias - - private fun generateAutoCompleteFile(alias: String) { - println("Generating $alias auto completion file") - val autoCompleteFile = getAutoCompleteFileLocation(alias) - autoCompleteFile.parent.createDirectories() - picocli.AutoComplete.main("-f", "-n", alias, this.javaClass.name, "-o", autoCompleteFile.toStringWithDeWindowsfication()) - - // Append hash of file to autocomplete file - autoCompleteFile.toFile().appendText(jarVersion(alias)) - } - - private fun installShellExtensions(alias: String) { - // Get jar location and generate alias command - val command = "alias $alias='java -jar \"${jarLocation.toStringWithDeWindowsfication()}\"'" - generateAutoCompleteFile(alias) - - // Get bash settings file - val bashSettingsFile = SettingsFile(userHome / ".bashrc") - // Replace any existing bootstrapper alias. There can be only one. - bashSettingsFile.addOrReplaceIfStartsWith("alias $alias", command) - val completionFileCommand = "for bcfile in ~/.completion/* ; do . \$bcfile; done" - bashSettingsFile.addIfNotExists(completionFileCommand) - bashSettingsFile.updateAndBackupIfNecessary() - - // Get zsh settings file - val zshSettingsFile = SettingsFile(userHome / ".zshrc") - zshSettingsFile.addIfNotExists("autoload -U +X compinit && compinit") - zshSettingsFile.addIfNotExists("autoload -U +X bashcompinit && bashcompinit") - zshSettingsFile.addOrReplaceIfStartsWith("alias $alias", command) - zshSettingsFile.addIfNotExists(completionFileCommand) - zshSettingsFile.updateAndBackupIfNecessary() - - println("Installation complete, $alias is available in bash with autocompletion. ") - println("Type `$alias ` from the commandline.") - println("Restart bash for this to take effect, or run `. ~/.bashrc` in bash or `. ~/.zshrc` in zsh to re-initialise your shell now") - } - - private fun checkForAutoCompleteUpdate(alias: String) { - val autoCompleteFile = getAutoCompleteFileLocation(alias) - - // If no autocomplete file, it hasn't been installed, so don't do anything - if (!autoCompleteFile.exists()) return - - var lastLine = "" - autoCompleteFile.toFile().forEachLine { lastLine = it } - - if (lastLine != jarVersion(alias)) { - println("Old auto completion file detected... regenerating") - generateAutoCompleteFile(alias) - println("Restart bash for this to take effect, or run `. ~/.bashrc` to re-initialise bash now") - } - } - - private fun installOrUpdateShellExtensions(alias: String) { - if (installShellExtensions) { - installShellExtensions(alias) - exitProcess(0) - } else { - checkForAutoCompleteUpdate(alias) - } - } - - override fun run() { - installOrUpdateShellExtensions("bootstrapper") - if (verbose) { - System.setProperty("logLevel", "trace") - } + override fun runProgram() { NetworkBootstrapper().bootstrap(dir.toAbsolutePath().normalize(), copyCordapps = !noCopy) } -} - -private class CordaVersionProvider : IVersionProvider { - companion object { - val releaseVersion: String by lazy { Manifests.read("Corda-Release-Version") } - val revision: String by lazy { Manifests.read("Corda-Revision") } - } - - override fun getVersion(): Array { - return arrayOf( - "Version: $releaseVersion", - "Revision: $revision" - ) - } -} +} \ No newline at end of file diff --git a/tools/cliutils/build.gradle b/tools/cliutils/build.gradle new file mode 100644 index 0000000000..87c7575f0c --- /dev/null +++ b/tools/cliutils/build.gradle @@ -0,0 +1,14 @@ +apply plugin: 'java' +apply plugin: 'kotlin' + +description 'CLI Utilities' + +dependencies { + compile project(":core") + + compile "info.picocli:picocli:$picocli_version" + compile "com.jcabi:jcabi-manifests:$jcabi_manifests_version" + compile "org.apache.logging.log4j:log4j-slf4j-impl:$log4j_version" + + compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version" +} diff --git a/tools/cliutils/src/main/kotlin/net/corda/cliutils/ConfigFilePathArgsParser.kt b/tools/cliutils/src/main/kotlin/net/corda/cliutils/ConfigFilePathArgsParser.kt new file mode 100644 index 0000000000..3d8c37829d --- /dev/null +++ b/tools/cliutils/src/main/kotlin/net/corda/cliutils/ConfigFilePathArgsParser.kt @@ -0,0 +1,25 @@ +package net.corda.cliutils + +import net.corda.core.internal.exists +import net.corda.core.internal.isReadable +import picocli.CommandLine +import java.nio.file.Path + +/** + * When a config file is required as part of setup, use this class to check that it exists and is formatted correctly. Add it as + * `@CommandLine.Mixin + * lateinit var configParser: ConfigFilePathArgsParser` + * in your command class and then call `validate()` + */ +@CommandLine.Command(description = ["Parse configuration file. Checks if given configuration file exists"]) +class ConfigFilePathArgsParser : Validated { + @CommandLine.Option(names = ["--config-file", "-f"], required = true, paramLabel = "FILE", description = ["The path to the config file"]) + lateinit var configFile: Path + + override fun validator(): List { + val res = mutableListOf() + if (!configFile.exists()) res += "Config file ${configFile.toAbsolutePath().normalize()} does not exist!" + if (!configFile.isReadable) res += "Config file ${configFile.toAbsolutePath().normalize()} is not readable" + return res + } +} \ No newline at end of file diff --git a/node/src/main/kotlin/net/corda/node/utilities/CLIUtils.kt b/tools/cliutils/src/main/kotlin/net/corda/cliutils/CordaCliWrapper.kt similarity index 52% rename from node/src/main/kotlin/net/corda/node/utilities/CLIUtils.kt rename to tools/cliutils/src/main/kotlin/net/corda/cliutils/CordaCliWrapper.kt index 62d6c4241c..317b1b4654 100644 --- a/node/src/main/kotlin/net/corda/node/utilities/CLIUtils.kt +++ b/tools/cliutils/src/main/kotlin/net/corda/cliutils/CordaCliWrapper.kt @@ -1,54 +1,17 @@ -package net.corda.node.utilities +package net.corda.cliutils -import com.jcabi.manifests.Manifests -import net.corda.core.internal.exists -import net.corda.core.internal.isReadable +import net.corda.core.internal.rootMessage import net.corda.core.utilities.contextLogger + import org.apache.logging.log4j.Level import picocli.CommandLine import picocli.CommandLine.* -import java.nio.file.Path import kotlin.system.exitProcess import java.util.* /** - * Something heavily used in network services, I am not sure it's of much use in corda, but who knows. Definitely it was the key to making DevOps happy. - * Add it as - * `@CommandLine.Mixin - * lateinit var configParser: ConfigFilePathArgsParser` - * - * in your command class and then validate() - */ -@Command(description = ["Parse configuration file. Checks if given configuration file exists"]) -class ConfigFilePathArgsParser : Validated { - @Option(names = ["--config-file", "-f"], required = true, paramLabel = "FILE", description = ["The path to the config file"]) - lateinit var configFile: Path - - override fun validator(): List { - val res = mutableListOf() - if(!configFile.exists()) res += "Config file ${configFile.toAbsolutePath().normalize()} does not exist!" - if(!configFile.isReadable) res += "Config file ${configFile.toAbsolutePath().normalize()} is not readable" - return res - } -} - -/** - * Simple version printing when command is called with --version or -V flag. Assuming that we reuse Corda-Release-Version and Corda-Revision - * in the manifest file. - */ -class CordaVersionProvider : IVersionProvider { - override fun getVersion(): Array { - return if (Manifests.exists("Corda-Release-Version") && Manifests.exists("Corda-Revision")) { - arrayOf("Version: ${Manifests.read("Corda-Release-Version")}", "Revision: ${Manifests.read("Corda-Revision")}") - } else { - arrayOf("No version data is available in the MANIFEST file.") - } - } -} - -/** - * Usually when we have errors in some command line flags that are not handled by picocli (e.g. non existing file). Error is thrown - * and no CommandLine help afterwards. This can be called from run() method. + * When we have errors in command line flags that are not handled by picocli (e.g. non existing files), an error is thrown + * without any command line help afterwards. This can be called from run() method. */ interface Validated { companion object { @@ -56,6 +19,7 @@ interface Validated { const val RED = "\u001B[31m" const val RESET = "\u001B[0m" } + /** * Check that provided command line parameters are valid, e.g. check file existence. Return list of error strings. */ @@ -75,6 +39,25 @@ interface Validated { } } +fun CordaCliWrapper.start(vararg args: String) { + val cmd = CommandLine(this) + cmd.commandSpec.name(alias) + cmd.commandSpec.usageMessage().description(description) + try { + cmd.parseWithHandlers(RunLast().useOut(System.out).useAnsi(Help.Ansi.AUTO), + DefaultExceptionHandler>().useErr(System.err).useAnsi(Help.Ansi.AUTO), + *args) + } catch (e: ExecutionException) { + val throwable = e.cause ?: e + if (this.verbose) { + throwable.printStackTrace() + } else { + System.err.println("*ERROR*: ${throwable.rootMessage ?: "Use --verbose for more details"}") + } + exitProcess(1) + } +} + /** * Simple base class for handling help, version, verbose and logging-level commands. * As versionProvider information from the MANIFEST file is used. It can be overwritten by custom version providers (see: Node) @@ -83,30 +66,44 @@ interface Validated { @Command(mixinStandardHelpOptions = true, versionProvider = CordaVersionProvider::class, sortOptions = false, + showDefaultValues = true, synopsisHeading = "%n@|bold,underline Usage|@:%n%n", descriptionHeading = "%n@|bold,underline Description|@:%n%n", parameterListHeading = "%n@|bold,underline Parameters|@:%n%n", optionListHeading = "%n@|bold,underline Options|@:%n%n", commandListHeading = "%n@|bold,underline Commands|@:%n%n") -abstract class ArgsParser { - @Option(names = [ "-v", "--verbose" ], description = ["If set, prints logging to the console as well as to a file."]) +abstract class CordaCliWrapper(val alias: String, val description: String) : Runnable { + @Option(names = ["-v", "--verbose"], description = ["If set, prints logging to the console as well as to a file."]) var verbose: Boolean = false @Option(names = ["--logging-level"], - // TODO For some reason I couldn't make picocli COMPLETION-CANDIDATES work - description = ["Enable logging at this level and higher. Defaults to INFO. Possible values: OFF, INFO, WARN, TRACE, DEBUG, ERROR, FATAL, ALL"], - converter = [LoggingLevelConverter::class]) + completionCandidates = LoggingLevelConverter.LoggingLevels::class, + description = ["Enable logging at this level and higher. Possible values: \${COMPLETION-CANDIDATES}"], + converter = [LoggingLevelConverter::class] + ) var loggingLevel: Level = Level.INFO + @Mixin + private lateinit var installShellExtensionsParser: InstallShellExtensionsParser + // This needs to be called before loggers (See: NodeStartup.kt:51 logger called by lazy, initLogging happens before). // Node's logging is more rich. In corda configurations two properties, defaultLoggingLevel and consoleLogLevel, are usually used. - protected open fun initLogging() { + private fun initLogging() { val loggingLevel = loggingLevel.name().toLowerCase(Locale.ENGLISH) System.setProperty("defaultLogLevel", loggingLevel) // These properties are referenced from the XML config file. if (verbose) { System.setProperty("consoleLogLevel", loggingLevel) } } + + // Override this function with the actual method to be run once all the arguments have been parsed + abstract fun runProgram() + + final override fun run() { + installShellExtensionsParser.installOrUpdateShellExtensions(alias, this.javaClass.name) + initLogging() + runProgram() + } } /** @@ -114,6 +111,9 @@ abstract class ArgsParser { */ class LoggingLevelConverter : ITypeConverter { override fun convert(value: String?): Level { - return value?.let { Level.getLevel(it) } ?: throw TypeConversionException("Unknown option for --logging-level: $value") + return value?.let { Level.getLevel(it) } + ?: throw TypeConversionException("Unknown option for --logging-level: $value") } + + class LoggingLevels : ArrayList(Level.values().map { it.toString() }) } diff --git a/tools/cliutils/src/main/kotlin/net/corda/cliutils/CordaVersionProvider.kt b/tools/cliutils/src/main/kotlin/net/corda/cliutils/CordaVersionProvider.kt new file mode 100644 index 0000000000..7158fa722b --- /dev/null +++ b/tools/cliutils/src/main/kotlin/net/corda/cliutils/CordaVersionProvider.kt @@ -0,0 +1,23 @@ +package net.corda.cliutils + +import com.jcabi.manifests.Manifests +import picocli.CommandLine + +/** + * Simple version printing when command is called with --version or -V flag. Assuming that we reuse Corda-Release-Version and Corda-Revision + * in the manifest file. + */ +class CordaVersionProvider : CommandLine.IVersionProvider { + companion object { + val releaseVersion: String by lazy { Manifests.read("Corda-Release-Version") } + val revision: String by lazy { Manifests.read("Corda-Revision") } + } + + override fun getVersion(): Array { + return if (Manifests.exists("Corda-Release-Version") && Manifests.exists("Corda-Revision")) { + arrayOf("Version: $releaseVersion", "Revision: $revision") + } else { + arrayOf("No version data is available in the MANIFEST file.") + } + } +} \ No newline at end of file diff --git a/tools/cliutils/src/main/kotlin/net/corda/cliutils/InstallShellExtensionsParser.kt b/tools/cliutils/src/main/kotlin/net/corda/cliutils/InstallShellExtensionsParser.kt new file mode 100644 index 0000000000..bfbf95ea44 --- /dev/null +++ b/tools/cliutils/src/main/kotlin/net/corda/cliutils/InstallShellExtensionsParser.kt @@ -0,0 +1,131 @@ +package net.corda.cliutils + +import net.corda.core.internal.* +import picocli.CommandLine +import java.nio.file.Path +import java.nio.file.Paths +import java.nio.file.StandardCopyOption +import java.util.* +import kotlin.system.exitProcess + +private class ShellExtensionsGenerator(val alias: String, val className: String) { + private class SettingsFile(val filePath: Path) { + private val lines: MutableList by lazy { getFileLines() } + var fileModified: Boolean = false + + // Return the lines in the file if it exists, else return an empty mutable list + private fun getFileLines(): MutableList { + return if (filePath.exists()) { + filePath.toFile().readLines().toMutableList() + } else { + Collections.emptyList().toMutableList() + } + } + + fun addOrReplaceIfStartsWith(startsWith: String, replaceWith: String) { + val index = lines.indexOfFirst { it.startsWith(startsWith) } + if (index >= 0) { + if (lines[index] != replaceWith) { + lines[index] = replaceWith + fileModified = true + } + } else { + lines.add(replaceWith) + fileModified = true + } + } + + fun addIfNotExists(line: String) { + if (!lines.contains(line)) { + lines.add(line) + fileModified = true + } + } + + fun updateAndBackupIfNecessary() { + if (fileModified) { + val backupFilePath = filePath.parent / "${filePath.fileName}.backup" + println("Updating settings in ${filePath.fileName} - existing settings file has been backed up to $backupFilePath") + if (filePath.exists()) filePath.copyTo(backupFilePath, StandardCopyOption.REPLACE_EXISTING) + filePath.writeLines(lines) + } + } + } + + private val userHome: Path by lazy { Paths.get(System.getProperty("user.home")) } + private val jarLocation: Path by lazy { this.javaClass.location.toPath() } + + // If on Windows, Path.toString() returns a path with \ instead of /, but for bash Windows users we want to convert those back to /'s + private fun Path.toStringWithDeWindowsfication(): String = this.toAbsolutePath().toString().replace("\\", "/") + + private fun jarVersion(alias: String) = "# $alias - Version: ${CordaVersionProvider.releaseVersion}, Revision: ${CordaVersionProvider.revision}" + private fun getAutoCompleteFileLocation(alias: String) = userHome / ".completion" / alias + + private fun generateAutoCompleteFile(alias: String, className: String) { + println("Generating $alias auto completion file") + val autoCompleteFile = getAutoCompleteFileLocation(alias) + autoCompleteFile.parent.createDirectories() + picocli.AutoComplete.main("-f", "-n", alias, className, "-o", autoCompleteFile.toStringWithDeWindowsfication()) + + // Append hash of file to autocomplete file + autoCompleteFile.toFile().appendText(jarVersion(alias)) + } + + fun installShellExtensions() { + // Get jar location and generate alias command + val command = "alias $alias='java -jar \"${jarLocation.toStringWithDeWindowsfication()}\"'" + generateAutoCompleteFile(alias, className) + + // Get bash settings file + val bashSettingsFile = SettingsFile(userHome / ".bashrc") + // Replace any existing alias. There can be only one. + bashSettingsFile.addOrReplaceIfStartsWith("alias $alias", command) + val completionFileCommand = "for bcfile in ~/.completion/* ; do . \$bcfile; done" + bashSettingsFile.addIfNotExists(completionFileCommand) + bashSettingsFile.updateAndBackupIfNecessary() + + // Get zsh settings file + val zshSettingsFile = SettingsFile(userHome / ".zshrc") + zshSettingsFile.addIfNotExists("autoload -U +X compinit && compinit") + zshSettingsFile.addIfNotExists("autoload -U +X bashcompinit && bashcompinit") + zshSettingsFile.addOrReplaceIfStartsWith("alias $alias", command) + zshSettingsFile.addIfNotExists(completionFileCommand) + zshSettingsFile.updateAndBackupIfNecessary() + + println("Installation complete, $alias is available in bash with autocompletion. ") + println("Type `$alias ` from the commandline.") + println("Restart bash for this to take effect, or run `. ~/.bashrc` in bash or `. ~/.zshrc` in zsh to re-initialise your shell now") + } + + fun checkForAutoCompleteUpdate() { + val autoCompleteFile = getAutoCompleteFileLocation(alias) + + // If no autocomplete file, it hasn't been installed, so don't do anything + if (!autoCompleteFile.exists()) return + + var lastLine = "" + autoCompleteFile.toFile().forEachLine { lastLine = it } + + if (lastLine != jarVersion(alias)) { + println("Old auto completion file detected... regenerating") + generateAutoCompleteFile(alias, className) + println("Restart bash for this to take effect, or run `. ~/.bashrc` to re-initialise bash now") + } + } +} + +@CommandLine.Command(description = [""]) +class InstallShellExtensionsParser { + @CommandLine.Option(names = ["--install-shell-extensions"], description = ["Install alias and autocompletion for bash and zsh"]) + var installShellExtensions: Boolean = false + + fun installOrUpdateShellExtensions(alias: String, className: String) { + val generator = ShellExtensionsGenerator(alias, className) + if (installShellExtensions) { + generator.installShellExtensions() + exitProcess(0) + } else { + generator.checkForAutoCompleteUpdate() + } + } +} \ No newline at end of file