Make ant task to build junit4 with jack for tests

Change-Id: Ie4f49fb6259e39c8515a71ebbe61c17e3da65abf

79 files changed, 1376 insertions, 0 deletions

diff --git a/core-stubs-mini/src/java/io/BufferedReader.java b/core-stubs-mini/src/java/io/BufferedReader.java
new file mode 100644
index 00000000..0ddc1b45
--- /dev/null
+++ b/core-stubs-mini/src/java/io/BufferedReader.java
@@ -0,0 +1,16 @@
+package java.io;
+public class BufferedReader
+  extends java.io.Reader
+{
+public  BufferedReader(java.io.Reader in) { throw new RuntimeException("Stub!"); }
+public  BufferedReader(java.io.Reader in, int size) { throw new RuntimeException("Stub!"); }
+public  void close() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void mark(int markLimit) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  boolean markSupported() { throw new RuntimeException("Stub!"); }
+public  int read() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  int read(char[] buffer, int offset, int length) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  java.lang.String readLine() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  boolean ready() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void reset() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  long skip(long charCount) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/ByteArrayOutputStream.java b/core-stubs-mini/src/java/io/ByteArrayOutputStream.java
new file mode 100644
index 00000000..9f934f6c
--- /dev/null
+++ b/core-stubs-mini/src/java/io/ByteArrayOutputStream.java
@@ -0,0 +1,20 @@
+package java.io;
+public class ByteArrayOutputStream
+  extends java.io.OutputStream
+{
+public  ByteArrayOutputStream() { throw new RuntimeException("Stub!"); }
+public  ByteArrayOutputStream(int size) { throw new RuntimeException("Stub!"); }
+public  void close() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public synchronized  void reset() { throw new RuntimeException("Stub!"); }
+public  int size() { throw new RuntimeException("Stub!"); }
+public synchronized  byte[] toByteArray() { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+@java.lang.Deprecated()
+public  java.lang.String toString(int hibyte) { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString(java.lang.String charsetName) throws java.io.UnsupportedEncodingException { throw new RuntimeException("Stub!"); }
+public synchronized  void write(byte[] buffer, int offset, int len) { throw new RuntimeException("Stub!"); }
+public synchronized  void write(int oneByte) { throw new RuntimeException("Stub!"); }
+public synchronized  void writeTo(java.io.OutputStream out) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected byte[] buf = null;
+protected int count;
+}
diff --git a/core-stubs-mini/src/java/io/DataInput.java b/core-stubs-mini/src/java/io/DataInput.java
new file mode 100644
index 00000000..149cafcc
--- /dev/null
+++ b/core-stubs-mini/src/java/io/DataInput.java
@@ -0,0 +1,19 @@
+package java.io;
+public interface DataInput
+{
+public abstract  boolean readBoolean() throws java.io.IOException;
+public abstract  byte readByte() throws java.io.IOException;
+public abstract  char readChar() throws java.io.IOException;
+public abstract  double readDouble() throws java.io.IOException;
+public abstract  float readFloat() throws java.io.IOException;
+public abstract  void readFully(byte[] dst) throws java.io.IOException;
+public abstract  void readFully(byte[] dst, int offset, int byteCount) throws java.io.IOException;
+public abstract  int readInt() throws java.io.IOException;
+public abstract  java.lang.String readLine() throws java.io.IOException;
+public abstract  long readLong() throws java.io.IOException;
+public abstract  short readShort() throws java.io.IOException;
+public abstract  int readUnsignedByte() throws java.io.IOException;
+public abstract  int readUnsignedShort() throws java.io.IOException;
+public abstract  java.lang.String readUTF() throws java.io.IOException;
+public abstract  int skipBytes(int count) throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/io/DataOutput.java b/core-stubs-mini/src/java/io/DataOutput.java
new file mode 100644
index 00000000..a55e5804
--- /dev/null
+++ b/core-stubs-mini/src/java/io/DataOutput.java
@@ -0,0 +1,18 @@
+package java.io;
+public interface DataOutput
+{
+public abstract  void write(byte[] buffer) throws java.io.IOException;
+public abstract  void write(byte[] buffer, int offset, int count) throws java.io.IOException;
+public abstract  void write(int oneByte) throws java.io.IOException;
+public abstract  void writeBoolean(boolean val) throws java.io.IOException;
+public abstract  void writeByte(int val) throws java.io.IOException;
+public abstract  void writeBytes(java.lang.String str) throws java.io.IOException;
+public abstract  void writeChar(int val) throws java.io.IOException;
+public abstract  void writeChars(java.lang.String str) throws java.io.IOException;
+public abstract  void writeDouble(double val) throws java.io.IOException;
+public abstract  void writeFloat(float val) throws java.io.IOException;
+public abstract  void writeInt(int val) throws java.io.IOException;
+public abstract  void writeLong(long val) throws java.io.IOException;
+public abstract  void writeShort(int val) throws java.io.IOException;
+public abstract  void writeUTF(java.lang.String str) throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/io/FileInputStream.java b/core-stubs-mini/src/java/io/FileInputStream.java
new file mode 100644
index 00000000..ea8b9bb5
--- /dev/null
+++ b/core-stubs-mini/src/java/io/FileInputStream.java
@@ -0,0 +1,16 @@
+package java.io;
+public class FileInputStream
+  extends java.io.InputStream
+{
+public  FileInputStream(java.io.File file) throws java.io.FileNotFoundException { throw new RuntimeException("Stub!"); }
+public  FileInputStream(java.io.FileDescriptor fd) { throw new RuntimeException("Stub!"); }
+public  FileInputStream(java.lang.String path) throws java.io.FileNotFoundException { throw new RuntimeException("Stub!"); }
+public  int available() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void close() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  void finalize() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  java.nio.channels.FileChannel getChannel() { throw new RuntimeException("Stub!"); }
+public final  java.io.FileDescriptor getFD() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  int read() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  int read(byte[] buffer, int byteOffset, int byteCount) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  long skip(long byteCount) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/FileOutputStream.java b/core-stubs-mini/src/java/io/FileOutputStream.java
new file mode 100644
index 00000000..2b32697d
--- /dev/null
+++ b/core-stubs-mini/src/java/io/FileOutputStream.java
@@ -0,0 +1,16 @@
+package java.io;
+public class FileOutputStream
+  extends java.io.OutputStream
+{
+public  FileOutputStream(java.io.File file) throws java.io.FileNotFoundException { throw new RuntimeException("Stub!"); }
+public  FileOutputStream(java.io.File file, boolean append) throws java.io.FileNotFoundException { throw new RuntimeException("Stub!"); }
+public  FileOutputStream(java.io.FileDescriptor fd) { throw new RuntimeException("Stub!"); }
+public  FileOutputStream(java.lang.String path) throws java.io.FileNotFoundException { throw new RuntimeException("Stub!"); }
+public  FileOutputStream(java.lang.String path, boolean append) throws java.io.FileNotFoundException { throw new RuntimeException("Stub!"); }
+public  void close() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  void finalize() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  java.nio.channels.FileChannel getChannel() { throw new RuntimeException("Stub!"); }
+public final  java.io.FileDescriptor getFD() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void write(byte[] buffer, int byteOffset, int byteCount) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void write(int oneByte) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/InvalidObjectException.java b/core-stubs-mini/src/java/io/InvalidObjectException.java
new file mode 100644
index 00000000..0a4d0c87
--- /dev/null
+++ b/core-stubs-mini/src/java/io/InvalidObjectException.java
@@ -0,0 +1,6 @@
+package java.io;
+public class InvalidObjectException
+  extends java.io.ObjectStreamException
+{
+public  InvalidObjectException(java.lang.String detailMessage) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/NotActiveException.java b/core-stubs-mini/src/java/io/NotActiveException.java
new file mode 100644
index 00000000..56bf1e6f
--- /dev/null
+++ b/core-stubs-mini/src/java/io/NotActiveException.java
@@ -0,0 +1,7 @@
+package java.io;
+public class NotActiveException
+  extends java.io.ObjectStreamException
+{
+public  NotActiveException() { throw new RuntimeException("Stub!"); }
+public  NotActiveException(java.lang.String detailMessage) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/ObjectInput.java b/core-stubs-mini/src/java/io/ObjectInput.java
new file mode 100644
index 00000000..c8a14d98
--- /dev/null
+++ b/core-stubs-mini/src/java/io/ObjectInput.java
@@ -0,0 +1,12 @@
+package java.io;
+public interface ObjectInput
+  extends java.io.DataInput, java.lang.AutoCloseable
+{
+public abstract  int available() throws java.io.IOException;
+public abstract  void close() throws java.io.IOException;
+public abstract  int read() throws java.io.IOException;
+public abstract  int read(byte[] buffer) throws java.io.IOException;
+public abstract  int read(byte[] buffer, int byteOffset, int byteCount) throws java.io.IOException;
+public abstract  java.lang.Object readObject() throws java.lang.ClassNotFoundException, java.io.IOException;
+public abstract  long skip(long byteCount) throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/io/ObjectInputStream.java b/core-stubs-mini/src/java/io/ObjectInputStream.java
new file mode 100644
index 00000000..244647ff
--- /dev/null
+++ b/core-stubs-mini/src/java/io/ObjectInputStream.java
@@ -0,0 +1,55 @@
+package java.io;
+public class ObjectInputStream
+  extends java.io.InputStream
+  implements java.io.ObjectInput, java.io.ObjectStreamConstants
+{
+public abstract static class GetField
+{
+public  GetField() { throw new RuntimeException("Stub!"); }
+public abstract  java.io.ObjectStreamClass getObjectStreamClass();
+public abstract  boolean defaulted(java.lang.String name) throws java.io.IOException, java.lang.IllegalArgumentException;
+public abstract  boolean get(java.lang.String name, boolean defaultValue) throws java.io.IOException, java.lang.IllegalArgumentException;
+public abstract  char get(java.lang.String name, char defaultValue) throws java.io.IOException, java.lang.IllegalArgumentException;
+public abstract  byte get(java.lang.String name, byte defaultValue) throws java.io.IOException, java.lang.IllegalArgumentException;
+public abstract  short get(java.lang.String name, short defaultValue) throws java.io.IOException, java.lang.IllegalArgumentException;
+public abstract  int get(java.lang.String name, int defaultValue) throws java.io.IOException, java.lang.IllegalArgumentException;
+public abstract  long get(java.lang.String name, long defaultValue) throws java.io.IOException, java.lang.IllegalArgumentException;
+public abstract  float get(java.lang.String name, float defaultValue) throws java.io.IOException, java.lang.IllegalArgumentException;
+public abstract  double get(java.lang.String name, double defaultValue) throws java.io.IOException, java.lang.IllegalArgumentException;
+public abstract  java.lang.Object get(java.lang.String name, java.lang.Object defaultValue) throws java.io.IOException, java.lang.IllegalArgumentException;
+}
+protected  ObjectInputStream() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  ObjectInputStream(java.io.InputStream input) throws java.io.StreamCorruptedException, java.io.IOException { throw new RuntimeException("Stub!"); }
+public  int available() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void close() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void defaultReadObject() throws java.io.IOException, java.lang.ClassNotFoundException, java.io.NotActiveException { throw new RuntimeException("Stub!"); }
+protected  boolean enableResolveObject(boolean enable) { throw new RuntimeException("Stub!"); }
+public  int read() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  int read(byte[] buffer, int byteOffset, int byteCount) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  boolean readBoolean() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  byte readByte() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  char readChar() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  double readDouble() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  java.io.ObjectInputStream.GetField readFields() throws java.io.IOException, java.lang.ClassNotFoundException, java.io.NotActiveException { throw new RuntimeException("Stub!"); }
+public  float readFloat() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void readFully(byte[] dst) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void readFully(byte[] dst, int offset, int byteCount) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  int readInt() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+@java.lang.Deprecated()
+public  java.lang.String readLine() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  long readLong() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  java.io.ObjectStreamClass readClassDescriptor() throws java.io.IOException, java.lang.ClassNotFoundException { throw new RuntimeException("Stub!"); }
+protected  java.lang.Class<?> resolveProxyClass(java.lang.String[] interfaceNames) throws java.io.IOException, java.lang.ClassNotFoundException { throw new RuntimeException("Stub!"); }
+public final  java.lang.Object readObject() throws java.io.OptionalDataException, java.lang.ClassNotFoundException, java.io.IOException { throw new RuntimeException("Stub!"); }
+public  java.lang.Object readUnshared() throws java.io.IOException, java.lang.ClassNotFoundException { throw new RuntimeException("Stub!"); }
+protected  java.lang.Object readObjectOverride() throws java.io.OptionalDataException, java.lang.ClassNotFoundException, java.io.IOException { throw new RuntimeException("Stub!"); }
+public  short readShort() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  void readStreamHeader() throws java.io.IOException, java.io.StreamCorruptedException { throw new RuntimeException("Stub!"); }
+public  int readUnsignedByte() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  int readUnsignedShort() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  java.lang.String readUTF() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public synchronized  void registerValidation(java.io.ObjectInputValidation object, int priority) throws java.io.NotActiveException, java.io.InvalidObjectException { throw new RuntimeException("Stub!"); }
+protected  java.lang.Class<?> resolveClass(java.io.ObjectStreamClass osClass) throws java.io.IOException, java.lang.ClassNotFoundException { throw new RuntimeException("Stub!"); }
+protected  java.lang.Object resolveObject(java.lang.Object object) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  int skipBytes(int length) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/ObjectInputValidation.java b/core-stubs-mini/src/java/io/ObjectInputValidation.java
new file mode 100644
index 00000000..e24d94d5
--- /dev/null
+++ b/core-stubs-mini/src/java/io/ObjectInputValidation.java
@@ -0,0 +1,5 @@
+package java.io;
+public interface ObjectInputValidation
+{
+public abstract  void validateObject() throws java.io.InvalidObjectException;
+}
diff --git a/core-stubs-mini/src/java/io/ObjectOutput.java b/core-stubs-mini/src/java/io/ObjectOutput.java
new file mode 100644
index 00000000..0fd77521
--- /dev/null
+++ b/core-stubs-mini/src/java/io/ObjectOutput.java
@@ -0,0 +1,11 @@
+package java.io;
+public interface ObjectOutput
+  extends java.io.DataOutput, java.lang.AutoCloseable
+{
+public abstract  void close() throws java.io.IOException;
+public abstract  void flush() throws java.io.IOException;
+public abstract  void write(byte[] buffer) throws java.io.IOException;
+public abstract  void write(byte[] buffer, int offset, int count) throws java.io.IOException;
+public abstract  void write(int value) throws java.io.IOException;
+public abstract  void writeObject(java.lang.Object obj) throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/io/ObjectOutputStream.java b/core-stubs-mini/src/java/io/ObjectOutputStream.java
new file mode 100644
index 00000000..fb934e96
--- /dev/null
+++ b/core-stubs-mini/src/java/io/ObjectOutputStream.java
@@ -0,0 +1,53 @@
+package java.io;
+public class ObjectOutputStream
+  extends java.io.OutputStream
+  implements java.io.ObjectOutput, java.io.ObjectStreamConstants
+{
+public abstract static class PutField
+{
+public  PutField() { throw new RuntimeException("Stub!"); }
+public abstract  void put(java.lang.String name, boolean value);
+public abstract  void put(java.lang.String name, char value);
+public abstract  void put(java.lang.String name, byte value);
+public abstract  void put(java.lang.String name, short value);
+public abstract  void put(java.lang.String name, int value);
+public abstract  void put(java.lang.String name, long value);
+public abstract  void put(java.lang.String name, float value);
+public abstract  void put(java.lang.String name, double value);
+public abstract  void put(java.lang.String name, java.lang.Object value);
+@java.lang.Deprecated()
+public abstract  void write(java.io.ObjectOutput out) throws java.io.IOException;
+}
+protected  ObjectOutputStream() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  ObjectOutputStream(java.io.OutputStream output) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  void annotateClass(java.lang.Class<?> aClass) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  void annotateProxyClass(java.lang.Class<?> aClass) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void close() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void defaultWriteObject() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  void drain() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  boolean enableReplaceObject(boolean enable) { throw new RuntimeException("Stub!"); }
+public  void flush() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  java.io.ObjectOutputStream.PutField putFields() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  java.lang.Object replaceObject(java.lang.Object object) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void reset() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void useProtocolVersion(int version) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void write(byte[] buffer, int offset, int length) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void write(int value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeBoolean(boolean value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeByte(int value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeBytes(java.lang.String value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeChar(int value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeChars(java.lang.String value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeDouble(double value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeFields() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeFloat(float value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeInt(int value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeLong(long value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  void writeClassDescriptor(java.io.ObjectStreamClass classDesc) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public final  void writeObject(java.lang.Object object) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeUnshared(java.lang.Object object) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  void writeObjectOverride(java.lang.Object object) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeShort(int value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected  void writeStreamHeader() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void writeUTF(java.lang.String value) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/ObjectStreamClass.java b/core-stubs-mini/src/java/io/ObjectStreamClass.java
new file mode 100644
index 00000000..984d610b
--- /dev/null
+++ b/core-stubs-mini/src/java/io/ObjectStreamClass.java
@@ -0,0 +1,15 @@
+package java.io;
+public class ObjectStreamClass
+  implements java.io.Serializable
+{
+ObjectStreamClass() { throw new RuntimeException("Stub!"); }
+public  java.lang.Class<?> forClass() { throw new RuntimeException("Stub!"); }
+public  java.io.ObjectStreamField getField(java.lang.String name) { throw new RuntimeException("Stub!"); }
+public  java.io.ObjectStreamField[] getFields() { throw new RuntimeException("Stub!"); }
+public  java.lang.String getName() { throw new RuntimeException("Stub!"); }
+public  long getSerialVersionUID() { throw new RuntimeException("Stub!"); }
+public static  java.io.ObjectStreamClass lookup(java.lang.Class<?> cl) { throw new RuntimeException("Stub!"); }
+public static  java.io.ObjectStreamClass lookupAny(java.lang.Class<?> cl) { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+public static final java.io.ObjectStreamField[] NO_FIELDS = null;
+}
diff --git a/core-stubs-mini/src/java/io/ObjectStreamConstants.java b/core-stubs-mini/src/java/io/ObjectStreamConstants.java
new file mode 100644
index 00000000..37b610ea
--- /dev/null
+++ b/core-stubs-mini/src/java/io/ObjectStreamConstants.java
@@ -0,0 +1,33 @@
+package java.io;
+public interface ObjectStreamConstants
+{
+public static final int PROTOCOL_VERSION_1 = 1;
+public static final int PROTOCOL_VERSION_2 = 2;
+public static final byte SC_BLOCK_DATA = 8;
+public static final byte SC_ENUM = 16;
+public static final byte SC_EXTERNALIZABLE = 4;
+public static final byte SC_SERIALIZABLE = 2;
+public static final byte SC_WRITE_METHOD = 1;
+public static final short STREAM_MAGIC = -21267;
+public static final short STREAM_VERSION = 5;
+public static final java.io.SerializablePermission SUBCLASS_IMPLEMENTATION_PERMISSION = null;
+public static final java.io.SerializablePermission SUBSTITUTION_PERMISSION = null;
+public static final byte TC_ARRAY = 117;
+public static final byte TC_BASE = 112;
+public static final byte TC_BLOCKDATA = 119;
+public static final byte TC_BLOCKDATALONG = 122;
+public static final byte TC_CLASS = 118;
+public static final byte TC_CLASSDESC = 114;
+public static final byte TC_ENDBLOCKDATA = 120;
+public static final byte TC_ENUM = 126;
+public static final byte TC_EXCEPTION = 123;
+public static final byte TC_LONGSTRING = 124;
+public static final byte TC_MAX = 126;
+public static final byte TC_NULL = 112;
+public static final byte TC_OBJECT = 115;
+public static final byte TC_PROXYCLASSDESC = 125;
+public static final byte TC_REFERENCE = 113;
+public static final byte TC_RESET = 121;
+public static final byte TC_STRING = 116;
+public static final int baseWireHandle = 8257536;
+}
diff --git a/core-stubs-mini/src/java/io/ObjectStreamField.java b/core-stubs-mini/src/java/io/ObjectStreamField.java
new file mode 100644
index 00000000..54523d3c
--- /dev/null
+++ b/core-stubs-mini/src/java/io/ObjectStreamField.java
@@ -0,0 +1,17 @@
+package java.io;
+public class ObjectStreamField
+  implements java.lang.Comparable<java.lang.Object>
+{
+public  ObjectStreamField(java.lang.String name, java.lang.Class<?> cl) { throw new RuntimeException("Stub!"); }
+public  ObjectStreamField(java.lang.String name, java.lang.Class<?> cl, boolean unshared) { throw new RuntimeException("Stub!"); }
+public  int compareTo(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+public  java.lang.String getName() { throw new RuntimeException("Stub!"); }
+public  int getOffset() { throw new RuntimeException("Stub!"); }
+public  java.lang.Class<?> getType() { throw new RuntimeException("Stub!"); }
+public  char getTypeCode() { throw new RuntimeException("Stub!"); }
+public  java.lang.String getTypeString() { throw new RuntimeException("Stub!"); }
+public  boolean isPrimitive() { throw new RuntimeException("Stub!"); }
+protected  void setOffset(int newValue) { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+public  boolean isUnshared() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/OptionalDataException.java b/core-stubs-mini/src/java/io/OptionalDataException.java
new file mode 100644
index 00000000..46a0dda0
--- /dev/null
+++ b/core-stubs-mini/src/java/io/OptionalDataException.java
@@ -0,0 +1,8 @@
+package java.io;
+public class OptionalDataException
+  extends java.io.ObjectStreamException
+{
+OptionalDataException() { throw new RuntimeException("Stub!"); }
+public boolean eof;
+public int length;
+}
diff --git a/core-stubs-mini/src/java/io/SerializablePermission.java b/core-stubs-mini/src/java/io/SerializablePermission.java
new file mode 100644
index 00000000..ec251381
--- /dev/null
+++ b/core-stubs-mini/src/java/io/SerializablePermission.java
@@ -0,0 +1,9 @@
+package java.io;
+public final class SerializablePermission
+  extends java.security.BasicPermission
+{
+public  SerializablePermission(java.lang.String permissionName) { super((java.lang.String)null,(java.lang.String)null); throw new RuntimeException("Stub!"); }
+public  SerializablePermission(java.lang.String name, java.lang.String actions) { super((java.lang.String)null,(java.lang.String)null); throw new RuntimeException("Stub!"); }
+public  java.lang.String getActions() { throw new RuntimeException("Stub!"); }
+public  boolean implies(java.security.Permission permission) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/StreamCorruptedException.java b/core-stubs-mini/src/java/io/StreamCorruptedException.java
new file mode 100644
index 00000000..a57351c1
--- /dev/null
+++ b/core-stubs-mini/src/java/io/StreamCorruptedException.java
@@ -0,0 +1,7 @@
+package java.io;
+public class StreamCorruptedException
+  extends java.io.ObjectStreamException
+{
+public  StreamCorruptedException() { throw new RuntimeException("Stub!"); }
+public  StreamCorruptedException(java.lang.String detailMessage) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/StringReader.java b/core-stubs-mini/src/java/io/StringReader.java
new file mode 100644
index 00000000..7e948a25
--- /dev/null
+++ b/core-stubs-mini/src/java/io/StringReader.java
@@ -0,0 +1,14 @@
+package java.io;
+public class StringReader
+  extends java.io.Reader
+{
+public  StringReader(java.lang.String str) { throw new RuntimeException("Stub!"); }
+public  void close() { throw new RuntimeException("Stub!"); }
+public  void mark(int readLimit) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  boolean markSupported() { throw new RuntimeException("Stub!"); }
+public  int read() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  int read(char[] buffer, int offset, int count) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  boolean ready() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void reset() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  long skip(long charCount) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/io/StringWriter.java b/core-stubs-mini/src/java/io/StringWriter.java
new file mode 100644
index 00000000..84c43023
--- /dev/null
+++ b/core-stubs-mini/src/java/io/StringWriter.java
@@ -0,0 +1,18 @@
+package java.io;
+public class StringWriter
+  extends java.io.Writer
+{
+public  StringWriter() { throw new RuntimeException("Stub!"); }
+public  StringWriter(int initialSize) { throw new RuntimeException("Stub!"); }
+public  void close() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public  void flush() { throw new RuntimeException("Stub!"); }
+public  java.lang.StringBuffer getBuffer() { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+public  void write(char[] chars, int offset, int count) { throw new RuntimeException("Stub!"); }
+public  void write(int oneChar) { throw new RuntimeException("Stub!"); }
+public  void write(java.lang.String str) { throw new RuntimeException("Stub!"); }
+public  void write(java.lang.String str, int offset, int count) { throw new RuntimeException("Stub!"); }
+public  java.io.StringWriter append(char c) { throw new RuntimeException("Stub!"); }
+public  java.io.StringWriter append(java.lang.CharSequence csq) { throw new RuntimeException("Stub!"); }
+public  java.io.StringWriter append(java.lang.CharSequence csq, int start, int end) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/lang/IllegalStateException.java b/core-stubs-mini/src/java/lang/IllegalStateException.java
new file mode 100644
index 00000000..5399f41d
--- /dev/null
+++ b/core-stubs-mini/src/java/lang/IllegalStateException.java
@@ -0,0 +1,9 @@
+package java.lang;
+public class IllegalStateException
+  extends java.lang.RuntimeException
+{
+public  IllegalStateException() { throw new RuntimeException("Stub!"); }
+public  IllegalStateException(java.lang.String detailMessage) { throw new RuntimeException("Stub!"); }
+public  IllegalStateException(java.lang.String message, java.lang.Throwable cause) { throw new RuntimeException("Stub!"); }
+public  IllegalStateException(java.lang.Throwable cause) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/lang/NegativeArraySizeException.java b/core-stubs-mini/src/java/lang/NegativeArraySizeException.java
new file mode 100644
index 00000000..0aa92998
--- /dev/null
+++ b/core-stubs-mini/src/java/lang/NegativeArraySizeException.java
@@ -0,0 +1,7 @@
+package java.lang;
+public class NegativeArraySizeException
+  extends java.lang.RuntimeException
+{
+public  NegativeArraySizeException() { throw new RuntimeException("Stub!"); }
+public  NegativeArraySizeException(java.lang.String detailMessage) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/lang/SafeVarargs.java b/core-stubs-mini/src/java/lang/SafeVarargs.java
new file mode 100644
index 00000000..607a6e6b
--- /dev/null
+++ b/core-stubs-mini/src/java/lang/SafeVarargs.java
@@ -0,0 +1,7 @@
+package java.lang;
+@java.lang.annotation.Documented()
+@java.lang.annotation.Retention(value=java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value={java.lang.annotation.ElementType.CONSTRUCTOR,java.lang.annotation.ElementType.METHOD})
+public @interface SafeVarargs
+{
+}
diff --git a/core-stubs-mini/src/java/lang/ThreadDeath.java b/core-stubs-mini/src/java/lang/ThreadDeath.java
new file mode 100644
index 00000000..0b75cc94
--- /dev/null
+++ b/core-stubs-mini/src/java/lang/ThreadDeath.java
@@ -0,0 +1,6 @@
+package java.lang;
+public class ThreadDeath
+  extends java.lang.Error
+{
+public  ThreadDeath() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/lang/annotation/Inherited.java b/core-stubs-mini/src/java/lang/annotation/Inherited.java
new file mode 100644
index 00000000..1fed805a
--- /dev/null
+++ b/core-stubs-mini/src/java/lang/annotation/Inherited.java
@@ -0,0 +1,7 @@
+package java.lang.annotation;
+@java.lang.annotation.Documented()
+@java.lang.annotation.Retention(value=java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value={java.lang.annotation.ElementType.ANNOTATION_TYPE})
+public @interface Inherited
+{
+}
diff --git a/core-stubs-mini/src/java/lang/reflect/Array.java b/core-stubs-mini/src/java/lang/reflect/Array.java
new file mode 100644
index 00000000..3fd80a00
--- /dev/null
+++ b/core-stubs-mini/src/java/lang/reflect/Array.java
@@ -0,0 +1,26 @@
+package java.lang.reflect;
+public final class Array
+{
+Array() { throw new RuntimeException("Stub!"); }
+public static  java.lang.Object get(java.lang.Object array, int index) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  boolean getBoolean(java.lang.Object array, int index) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  byte getByte(java.lang.Object array, int index) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  char getChar(java.lang.Object array, int index) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  double getDouble(java.lang.Object array, int index) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  float getFloat(java.lang.Object array, int index) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  int getInt(java.lang.Object array, int index) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  int getLength(java.lang.Object array) { throw new RuntimeException("Stub!"); }
+public static  long getLong(java.lang.Object array, int index) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  short getShort(java.lang.Object array, int index) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  java.lang.Object newInstance(java.lang.Class<?> componentType, int... dimensions) throws java.lang.NegativeArraySizeException, java.lang.IllegalArgumentException { throw new RuntimeException("Stub!"); }
+public static  java.lang.Object newInstance(java.lang.Class<?> componentType, int size) throws java.lang.NegativeArraySizeException { throw new RuntimeException("Stub!"); }
+public static  void set(java.lang.Object array, int index, java.lang.Object value) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  void setBoolean(java.lang.Object array, int index, boolean value) { throw new RuntimeException("Stub!"); }
+public static  void setByte(java.lang.Object array, int index, byte value) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  void setChar(java.lang.Object array, int index, char value) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  void setDouble(java.lang.Object array, int index, double value) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  void setFloat(java.lang.Object array, int index, float value) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  void setInt(java.lang.Object array, int index, int value) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  void setLong(java.lang.Object array, int index, long value) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+public static  void setShort(java.lang.Object array, int index, short value) throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/lang/reflect/GenericArrayType.java b/core-stubs-mini/src/java/lang/reflect/GenericArrayType.java
new file mode 100644
index 00000000..1c4bfd62
--- /dev/null
+++ b/core-stubs-mini/src/java/lang/reflect/GenericArrayType.java
@@ -0,0 +1,6 @@
+package java.lang.reflect;
+public interface GenericArrayType
+  extends java.lang.reflect.Type
+{
+public abstract  java.lang.reflect.Type getGenericComponentType();
+}
diff --git a/core-stubs-mini/src/java/lang/reflect/Modifier.java b/core-stubs-mini/src/java/lang/reflect/Modifier.java
new file mode 100644
index 00000000..e5160771
--- /dev/null
+++ b/core-stubs-mini/src/java/lang/reflect/Modifier.java
@@ -0,0 +1,35 @@
+package java.lang.reflect;
+public class Modifier
+{
+public  Modifier() { throw new RuntimeException("Stub!"); }
+public static  int classModifiers() { throw new RuntimeException("Stub!"); }
+public static  int constructorModifiers() { throw new RuntimeException("Stub!"); }
+public static  int fieldModifiers() { throw new RuntimeException("Stub!"); }
+public static  int interfaceModifiers() { throw new RuntimeException("Stub!"); }
+public static  int methodModifiers() { throw new RuntimeException("Stub!"); }
+public static  boolean isAbstract(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isFinal(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isInterface(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isNative(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isPrivate(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isProtected(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isPublic(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isStatic(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isStrict(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isSynchronized(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isTransient(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  boolean isVolatile(int modifiers) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String toString(int modifiers) { throw new RuntimeException("Stub!"); }
+public static final int ABSTRACT = 1024;
+public static final int FINAL = 16;
+public static final int INTERFACE = 512;
+public static final int NATIVE = 256;
+public static final int PRIVATE = 2;
+public static final int PROTECTED = 4;
+public static final int PUBLIC = 1;
+public static final int STATIC = 8;
+public static final int STRICT = 2048;
+public static final int SYNCHRONIZED = 32;
+public static final int TRANSIENT = 128;
+public static final int VOLATILE = 64;
+}
diff --git a/core-stubs-mini/src/java/lang/reflect/ParameterizedType.java b/core-stubs-mini/src/java/lang/reflect/ParameterizedType.java
new file mode 100644
index 00000000..5c8ba0d8
--- /dev/null
+++ b/core-stubs-mini/src/java/lang/reflect/ParameterizedType.java
@@ -0,0 +1,8 @@
+package java.lang.reflect;
+public interface ParameterizedType
+  extends java.lang.reflect.Type
+{
+public abstract  java.lang.reflect.Type[] getActualTypeArguments();
+public abstract  java.lang.reflect.Type getOwnerType();
+public abstract  java.lang.reflect.Type getRawType();
+}
diff --git a/core-stubs-mini/src/java/lang/reflect/WildcardType.java b/core-stubs-mini/src/java/lang/reflect/WildcardType.java
new file mode 100644
index 00000000..265fad76
--- /dev/null
+++ b/core-stubs-mini/src/java/lang/reflect/WildcardType.java
@@ -0,0 +1,7 @@
+package java.lang.reflect;
+public interface WildcardType
+  extends java.lang.reflect.Type
+{
+public abstract  java.lang.reflect.Type[] getUpperBounds();
+public abstract  java.lang.reflect.Type[] getLowerBounds();
+}
diff --git a/core-stubs-mini/src/java/math/RoundingMode.java b/core-stubs-mini/src/java/math/RoundingMode.java
new file mode 100644
index 00000000..3c05e643
--- /dev/null
+++ b/core-stubs-mini/src/java/math/RoundingMode.java
@@ -0,0 +1,13 @@
+package java.math;
+public enum RoundingMode
+{
+CEILING(),
+DOWN(),
+FLOOR(),
+HALF_DOWN(),
+HALF_EVEN(),
+HALF_UP(),
+UNNECESSARY(),
+UP();
+public static  java.math.RoundingMode valueOf(int mode) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/nio/MappedByteBuffer.java b/core-stubs-mini/src/java/nio/MappedByteBuffer.java
new file mode 100644
index 00000000..97ce6371
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/MappedByteBuffer.java
@@ -0,0 +1,9 @@
+package java.nio;
+public abstract class MappedByteBuffer
+  extends java.nio.ByteBuffer
+{
+MappedByteBuffer() { throw new RuntimeException("Stub!"); }
+public final  boolean isLoaded() { throw new RuntimeException("Stub!"); }
+public final  java.nio.MappedByteBuffer load() { throw new RuntimeException("Stub!"); }
+public final  java.nio.MappedByteBuffer force() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/nio/channels/AsynchronousCloseException.java b/core-stubs-mini/src/java/nio/channels/AsynchronousCloseException.java
new file mode 100644
index 00000000..748dcc5b
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/AsynchronousCloseException.java
@@ -0,0 +1,6 @@
+package java.nio.channels;
+public class AsynchronousCloseException
+  extends java.nio.channels.ClosedChannelException
+{
+public  AsynchronousCloseException() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/nio/channels/ByteChannel.java b/core-stubs-mini/src/java/nio/channels/ByteChannel.java
new file mode 100644
index 00000000..bb2b9283
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/ByteChannel.java
@@ -0,0 +1,5 @@
+package java.nio.channels;
+public interface ByteChannel
+  extends java.nio.channels.ReadableByteChannel, java.nio.channels.WritableByteChannel
+{
+}
diff --git a/core-stubs-mini/src/java/nio/channels/ClosedChannelException.java b/core-stubs-mini/src/java/nio/channels/ClosedChannelException.java
new file mode 100644
index 00000000..05efa232
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/ClosedChannelException.java
@@ -0,0 +1,6 @@
+package java.nio.channels;
+public class ClosedChannelException
+  extends java.io.IOException
+{
+public  ClosedChannelException() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/nio/channels/FileChannel.java b/core-stubs-mini/src/java/nio/channels/FileChannel.java
new file mode 100644
index 00000000..a90f5ce0
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/FileChannel.java
@@ -0,0 +1,36 @@
+package java.nio.channels;
+public abstract class FileChannel
+  extends java.nio.channels.spi.AbstractInterruptibleChannel
+  implements java.nio.channels.ByteChannel, java.nio.channels.GatheringByteChannel, java.nio.channels.ScatteringByteChannel
+{
+public static class MapMode
+{
+MapMode() { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+public static final java.nio.channels.FileChannel.MapMode PRIVATE;
+public static final java.nio.channels.FileChannel.MapMode READ_ONLY;
+public static final java.nio.channels.FileChannel.MapMode READ_WRITE;
+static { PRIVATE = null; READ_ONLY = null; READ_WRITE = null; }
+}
+protected  FileChannel() { throw new RuntimeException("Stub!"); }
+public abstract  void force(boolean metadata) throws java.io.IOException;
+public final  java.nio.channels.FileLock lock() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public abstract  java.nio.channels.FileLock lock(long position, long size, boolean shared) throws java.io.IOException;
+public abstract  java.nio.MappedByteBuffer map(java.nio.channels.FileChannel.MapMode mode, long position, long size) throws java.io.IOException;
+public abstract  long position() throws java.io.IOException;
+public abstract  java.nio.channels.FileChannel position(long newPosition) throws java.io.IOException;
+public abstract  int read(java.nio.ByteBuffer buffer) throws java.io.IOException;
+public abstract  int read(java.nio.ByteBuffer buffer, long position) throws java.io.IOException;
+public final  long read(java.nio.ByteBuffer[] buffers) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public abstract  long read(java.nio.ByteBuffer[] buffers, int start, int number) throws java.io.IOException;
+public abstract  long size() throws java.io.IOException;
+public abstract  long transferFrom(java.nio.channels.ReadableByteChannel src, long position, long count) throws java.io.IOException;
+public abstract  long transferTo(long position, long count, java.nio.channels.WritableByteChannel target) throws java.io.IOException;
+public abstract  java.nio.channels.FileChannel truncate(long size) throws java.io.IOException;
+public final  java.nio.channels.FileLock tryLock() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public abstract  java.nio.channels.FileLock tryLock(long position, long size, boolean shared) throws java.io.IOException;
+public abstract  int write(java.nio.ByteBuffer src) throws java.io.IOException;
+public abstract  int write(java.nio.ByteBuffer buffer, long position) throws java.io.IOException;
+public final  long write(java.nio.ByteBuffer[] buffers) throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public abstract  long write(java.nio.ByteBuffer[] buffers, int offset, int length) throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/nio/channels/FileLock.java b/core-stubs-mini/src/java/nio/channels/FileLock.java
new file mode 100644
index 00000000..f3ec6412
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/FileLock.java
@@ -0,0 +1,15 @@
+package java.nio.channels;
+public abstract class FileLock
+  implements java.lang.AutoCloseable
+{
+protected  FileLock(java.nio.channels.FileChannel channel, long position, long size, boolean shared) { throw new RuntimeException("Stub!"); }
+public final  java.nio.channels.FileChannel channel() { throw new RuntimeException("Stub!"); }
+public final  long position() { throw new RuntimeException("Stub!"); }
+public final  long size() { throw new RuntimeException("Stub!"); }
+public final  boolean isShared() { throw new RuntimeException("Stub!"); }
+public final  boolean overlaps(long start, long length) { throw new RuntimeException("Stub!"); }
+public abstract  boolean isValid();
+public abstract  void release() throws java.io.IOException;
+public final  void close() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+public final  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/nio/channels/GatheringByteChannel.java b/core-stubs-mini/src/java/nio/channels/GatheringByteChannel.java
new file mode 100644
index 00000000..7f0b8bc3
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/GatheringByteChannel.java
@@ -0,0 +1,7 @@
+package java.nio.channels;
+public interface GatheringByteChannel
+  extends java.nio.channels.WritableByteChannel
+{
+public abstract  long write(java.nio.ByteBuffer[] buffers) throws java.io.IOException;
+public abstract  long write(java.nio.ByteBuffer[] buffers, int offset, int length) throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/nio/channels/InterruptibleChannel.java b/core-stubs-mini/src/java/nio/channels/InterruptibleChannel.java
new file mode 100644
index 00000000..1236c5bd
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/InterruptibleChannel.java
@@ -0,0 +1,6 @@
+package java.nio.channels;
+public interface InterruptibleChannel
+  extends java.nio.channels.Channel
+{
+public abstract  void close() throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/nio/channels/ReadableByteChannel.java b/core-stubs-mini/src/java/nio/channels/ReadableByteChannel.java
new file mode 100644
index 00000000..ad090b8a
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/ReadableByteChannel.java
@@ -0,0 +1,6 @@
+package java.nio.channels;
+public interface ReadableByteChannel
+  extends java.nio.channels.Channel
+{
+public abstract  int read(java.nio.ByteBuffer buffer) throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/nio/channels/ScatteringByteChannel.java b/core-stubs-mini/src/java/nio/channels/ScatteringByteChannel.java
new file mode 100644
index 00000000..67520802
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/ScatteringByteChannel.java
@@ -0,0 +1,7 @@
+package java.nio.channels;
+public interface ScatteringByteChannel
+  extends java.nio.channels.ReadableByteChannel
+{
+public abstract  long read(java.nio.ByteBuffer[] buffers) throws java.io.IOException;
+public abstract  long read(java.nio.ByteBuffer[] buffers, int offset, int length) throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/nio/channels/WritableByteChannel.java b/core-stubs-mini/src/java/nio/channels/WritableByteChannel.java
new file mode 100644
index 00000000..fb8e5705
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/WritableByteChannel.java
@@ -0,0 +1,6 @@
+package java.nio.channels;
+public interface WritableByteChannel
+  extends java.nio.channels.Channel
+{
+public abstract  int write(java.nio.ByteBuffer buffer) throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/nio/channels/spi/AbstractInterruptibleChannel.java b/core-stubs-mini/src/java/nio/channels/spi/AbstractInterruptibleChannel.java
new file mode 100644
index 00000000..3b73a48e
--- /dev/null
+++ b/core-stubs-mini/src/java/nio/channels/spi/AbstractInterruptibleChannel.java
@@ -0,0 +1,11 @@
+package java.nio.channels.spi;
+public abstract class AbstractInterruptibleChannel
+  implements java.nio.channels.Channel, java.nio.channels.InterruptibleChannel
+{
+protected  AbstractInterruptibleChannel() { throw new RuntimeException("Stub!"); }
+public final synchronized  boolean isOpen() { throw new RuntimeException("Stub!"); }
+public final  void close() throws java.io.IOException { throw new RuntimeException("Stub!"); }
+protected final  void begin() { throw new RuntimeException("Stub!"); }
+protected final  void end(boolean success) throws java.nio.channels.AsynchronousCloseException { throw new RuntimeException("Stub!"); }
+protected abstract  void implCloseChannel() throws java.io.IOException;
+}
diff --git a/core-stubs-mini/src/java/security/BasicPermission.java b/core-stubs-mini/src/java/security/BasicPermission.java
new file mode 100644
index 00000000..66cd36f9
--- /dev/null
+++ b/core-stubs-mini/src/java/security/BasicPermission.java
@@ -0,0 +1,10 @@
+package java.security;
+public abstract class BasicPermission
+  extends java.security.Permission
+  implements java.io.Serializable
+{
+public  BasicPermission(java.lang.String name) { super((java.lang.String)null); throw new RuntimeException("Stub!"); }
+public  BasicPermission(java.lang.String name, java.lang.String action) { super((java.lang.String)null); throw new RuntimeException("Stub!"); }
+public  java.lang.String getActions() { throw new RuntimeException("Stub!"); }
+public  boolean implies(java.security.Permission permission) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/security/PrivilegedAction.java b/core-stubs-mini/src/java/security/PrivilegedAction.java
new file mode 100644
index 00000000..1c47b499
--- /dev/null
+++ b/core-stubs-mini/src/java/security/PrivilegedAction.java
@@ -0,0 +1,5 @@
+package java.security;
+public interface PrivilegedAction<T>
+{
+public abstract  T run();
+}
diff --git a/core-stubs-mini/src/java/security/PrivilegedExceptionAction.java b/core-stubs-mini/src/java/security/PrivilegedExceptionAction.java
new file mode 100644
index 00000000..fffa85ee
--- /dev/null
+++ b/core-stubs-mini/src/java/security/PrivilegedExceptionAction.java
@@ -0,0 +1,5 @@
+package java.security;
+public interface PrivilegedExceptionAction<T>
+{
+public abstract  T run() throws java.lang.Exception;
+}
diff --git a/core-stubs-mini/src/java/text/AttributedCharacterIterator.java b/core-stubs-mini/src/java/text/AttributedCharacterIterator.java
new file mode 100644
index 00000000..61720666
--- /dev/null
+++ b/core-stubs-mini/src/java/text/AttributedCharacterIterator.java
@@ -0,0 +1,28 @@
+package java.text;
+public interface AttributedCharacterIterator
+  extends java.text.CharacterIterator
+{
+public static class Attribute
+  implements java.io.Serializable
+{
+protected  Attribute(java.lang.String name) { throw new RuntimeException("Stub!"); }
+public final  boolean equals(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+protected  java.lang.String getName() { throw new RuntimeException("Stub!"); }
+public final  int hashCode() { throw new RuntimeException("Stub!"); }
+protected  java.lang.Object readResolve() throws java.io.InvalidObjectException { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+public static final java.text.AttributedCharacterIterator.Attribute INPUT_METHOD_SEGMENT;
+public static final java.text.AttributedCharacterIterator.Attribute LANGUAGE;
+public static final java.text.AttributedCharacterIterator.Attribute READING;
+static { INPUT_METHOD_SEGMENT = null; LANGUAGE = null; READING = null; }
+}
+public abstract  java.util.Set<java.text.AttributedCharacterIterator.Attribute> getAllAttributeKeys();
+public abstract  java.lang.Object getAttribute(java.text.AttributedCharacterIterator.Attribute attribute);
+public abstract  java.util.Map<java.text.AttributedCharacterIterator.Attribute, java.lang.Object> getAttributes();
+public abstract  int getRunLimit();
+public abstract  int getRunLimit(java.text.AttributedCharacterIterator.Attribute attribute);
+public abstract  int getRunLimit(java.util.Set<? extends java.text.AttributedCharacterIterator.Attribute> attributes);
+public abstract  int getRunStart();
+public abstract  int getRunStart(java.text.AttributedCharacterIterator.Attribute attribute);
+public abstract  int getRunStart(java.util.Set<? extends java.text.AttributedCharacterIterator.Attribute> attributes);
+}
diff --git a/core-stubs-mini/src/java/text/FieldPosition.java b/core-stubs-mini/src/java/text/FieldPosition.java
new file mode 100644
index 00000000..297131fb
--- /dev/null
+++ b/core-stubs-mini/src/java/text/FieldPosition.java
@@ -0,0 +1,16 @@
+package java.text;
+public class FieldPosition
+{
+public  FieldPosition(int field) { throw new RuntimeException("Stub!"); }
+public  FieldPosition(java.text.Format.Field attribute) { throw new RuntimeException("Stub!"); }
+public  FieldPosition(java.text.Format.Field attribute, int field) { throw new RuntimeException("Stub!"); }
+public  boolean equals(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public  int getBeginIndex() { throw new RuntimeException("Stub!"); }
+public  int getEndIndex() { throw new RuntimeException("Stub!"); }
+public  int getField() { throw new RuntimeException("Stub!"); }
+public  java.text.Format.Field getFieldAttribute() { throw new RuntimeException("Stub!"); }
+public  int hashCode() { throw new RuntimeException("Stub!"); }
+public  void setBeginIndex(int index) { throw new RuntimeException("Stub!"); }
+public  void setEndIndex(int index) { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/text/Format.java b/core-stubs-mini/src/java/text/Format.java
new file mode 100644
index 00000000..ad0fa749
--- /dev/null
+++ b/core-stubs-mini/src/java/text/Format.java
@@ -0,0 +1,17 @@
+package java.text;
+public abstract class Format
+  implements java.io.Serializable, java.lang.Cloneable
+{
+public static class Field
+  extends java.text.AttributedCharacterIterator.Attribute
+{
+protected  Field(java.lang.String fieldName) { super((java.lang.String)null); throw new RuntimeException("Stub!"); }
+}
+protected  Format() { throw new RuntimeException("Stub!"); }
+public  java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+public final  java.lang.String format(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public abstract  java.lang.StringBuffer format(java.lang.Object object, java.lang.StringBuffer buffer, java.text.FieldPosition field);
+public  java.text.AttributedCharacterIterator formatToCharacterIterator(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public  java.lang.Object parseObject(java.lang.String string) throws java.text.ParseException { throw new RuntimeException("Stub!"); }
+public abstract  java.lang.Object parseObject(java.lang.String string, java.text.ParsePosition position);
+}
diff --git a/core-stubs-mini/src/java/text/NumberFormat.java b/core-stubs-mini/src/java/text/NumberFormat.java
new file mode 100644
index 00000000..3849f68c
--- /dev/null
+++ b/core-stubs-mini/src/java/text/NumberFormat.java
@@ -0,0 +1,63 @@
+package java.text;
+public abstract class NumberFormat
+  extends java.text.Format
+{
+public static class Field
+  extends java.text.Format.Field
+{
+protected  Field(java.lang.String fieldName) { super((java.lang.String)null); throw new RuntimeException("Stub!"); }
+public static final java.text.NumberFormat.Field CURRENCY;
+public static final java.text.NumberFormat.Field DECIMAL_SEPARATOR;
+public static final java.text.NumberFormat.Field EXPONENT;
+public static final java.text.NumberFormat.Field EXPONENT_SIGN;
+public static final java.text.NumberFormat.Field EXPONENT_SYMBOL;
+public static final java.text.NumberFormat.Field FRACTION;
+public static final java.text.NumberFormat.Field GROUPING_SEPARATOR;
+public static final java.text.NumberFormat.Field INTEGER;
+public static final java.text.NumberFormat.Field PERCENT;
+public static final java.text.NumberFormat.Field PERMILLE;
+public static final java.text.NumberFormat.Field SIGN;
+static { CURRENCY = null; DECIMAL_SEPARATOR = null; EXPONENT = null; EXPONENT_SIGN = null; EXPONENT_SYMBOL = null; FRACTION = null; GROUPING_SEPARATOR = null; INTEGER = null; PERCENT = null; PERMILLE = null; SIGN = null; }
+}
+protected  NumberFormat() { throw new RuntimeException("Stub!"); }
+public  java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+public  boolean equals(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public final  java.lang.String format(double value) { throw new RuntimeException("Stub!"); }
+public abstract  java.lang.StringBuffer format(double value, java.lang.StringBuffer buffer, java.text.FieldPosition field);
+public final  java.lang.String format(long value) { throw new RuntimeException("Stub!"); }
+public abstract  java.lang.StringBuffer format(long value, java.lang.StringBuffer buffer, java.text.FieldPosition field);
+public  java.lang.StringBuffer format(java.lang.Object object, java.lang.StringBuffer buffer, java.text.FieldPosition field) { throw new RuntimeException("Stub!"); }
+public static  java.util.Locale[] getAvailableLocales() { throw new RuntimeException("Stub!"); }
+public  java.util.Currency getCurrency() { throw new RuntimeException("Stub!"); }
+public static final  java.text.NumberFormat getCurrencyInstance() { throw new RuntimeException("Stub!"); }
+public static  java.text.NumberFormat getCurrencyInstance(java.util.Locale locale) { throw new RuntimeException("Stub!"); }
+public static final  java.text.NumberFormat getIntegerInstance() { throw new RuntimeException("Stub!"); }
+public static  java.text.NumberFormat getIntegerInstance(java.util.Locale locale) { throw new RuntimeException("Stub!"); }
+public static final  java.text.NumberFormat getInstance() { throw new RuntimeException("Stub!"); }
+public static  java.text.NumberFormat getInstance(java.util.Locale locale) { throw new RuntimeException("Stub!"); }
+public  int getMaximumFractionDigits() { throw new RuntimeException("Stub!"); }
+public  int getMaximumIntegerDigits() { throw new RuntimeException("Stub!"); }
+public  int getMinimumFractionDigits() { throw new RuntimeException("Stub!"); }
+public  int getMinimumIntegerDigits() { throw new RuntimeException("Stub!"); }
+public static final  java.text.NumberFormat getNumberInstance() { throw new RuntimeException("Stub!"); }
+public static  java.text.NumberFormat getNumberInstance(java.util.Locale locale) { throw new RuntimeException("Stub!"); }
+public static final  java.text.NumberFormat getPercentInstance() { throw new RuntimeException("Stub!"); }
+public static  java.text.NumberFormat getPercentInstance(java.util.Locale locale) { throw new RuntimeException("Stub!"); }
+public  int hashCode() { throw new RuntimeException("Stub!"); }
+public  boolean isGroupingUsed() { throw new RuntimeException("Stub!"); }
+public  boolean isParseIntegerOnly() { throw new RuntimeException("Stub!"); }
+public  java.lang.Number parse(java.lang.String string) throws java.text.ParseException { throw new RuntimeException("Stub!"); }
+public abstract  java.lang.Number parse(java.lang.String string, java.text.ParsePosition position);
+public final  java.lang.Object parseObject(java.lang.String string, java.text.ParsePosition position) { throw new RuntimeException("Stub!"); }
+public  void setCurrency(java.util.Currency currency) { throw new RuntimeException("Stub!"); }
+public  void setGroupingUsed(boolean value) { throw new RuntimeException("Stub!"); }
+public  void setMaximumFractionDigits(int value) { throw new RuntimeException("Stub!"); }
+public  void setMaximumIntegerDigits(int value) { throw new RuntimeException("Stub!"); }
+public  void setMinimumFractionDigits(int value) { throw new RuntimeException("Stub!"); }
+public  void setMinimumIntegerDigits(int value) { throw new RuntimeException("Stub!"); }
+public  void setParseIntegerOnly(boolean value) { throw new RuntimeException("Stub!"); }
+public  java.math.RoundingMode getRoundingMode() { throw new RuntimeException("Stub!"); }
+public  void setRoundingMode(java.math.RoundingMode roundingMode) { throw new RuntimeException("Stub!"); }
+public static final int FRACTION_FIELD = 1;
+public static final int INTEGER_FIELD = 0;
+}
diff --git a/core-stubs-mini/src/java/text/ParseException.java b/core-stubs-mini/src/java/text/ParseException.java
new file mode 100644
index 00000000..f25665a8
--- /dev/null
+++ b/core-stubs-mini/src/java/text/ParseException.java
@@ -0,0 +1,7 @@
+package java.text;
+public class ParseException
+  extends java.lang.Exception
+{
+public  ParseException(java.lang.String detailMessage, int location) { throw new RuntimeException("Stub!"); }
+public  int getErrorOffset() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/text/ParsePosition.java b/core-stubs-mini/src/java/text/ParsePosition.java
new file mode 100644
index 00000000..672b9195
--- /dev/null
+++ b/core-stubs-mini/src/java/text/ParsePosition.java
@@ -0,0 +1,12 @@
+package java.text;
+public class ParsePosition
+{
+public  ParsePosition(int index) { throw new RuntimeException("Stub!"); }
+public  boolean equals(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public  int getErrorIndex() { throw new RuntimeException("Stub!"); }
+public  int getIndex() { throw new RuntimeException("Stub!"); }
+public  int hashCode() { throw new RuntimeException("Stub!"); }
+public  void setErrorIndex(int index) { throw new RuntimeException("Stub!"); }
+public  void setIndex(int index) { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/AbstractSet.java b/core-stubs-mini/src/java/util/AbstractSet.java
new file mode 100644
index 00000000..54c4cb1c
--- /dev/null
+++ b/core-stubs-mini/src/java/util/AbstractSet.java
@@ -0,0 +1,10 @@
+package java.util;
+public abstract class AbstractSet<E>
+  extends java.util.AbstractCollection<E>
+  implements java.util.Set<E>
+{
+protected  AbstractSet() { throw new RuntimeException("Stub!"); }
+public  boolean equals(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public  int hashCode() { throw new RuntimeException("Stub!"); }
+public  boolean removeAll(java.util.Collection<?> collection) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/ArrayList.java b/core-stubs-mini/src/java/util/ArrayList.java
new file mode 100644
index 00000000..396854bc
--- /dev/null
+++ b/core-stubs-mini/src/java/util/ArrayList.java
@@ -0,0 +1,33 @@
+package java.util;
+public class ArrayList<E>
+  extends java.util.AbstractList<E>
+  implements java.lang.Cloneable, java.io.Serializable, java.util.RandomAccess
+{
+public  ArrayList(int capacity) { throw new RuntimeException("Stub!"); }
+public  ArrayList() { throw new RuntimeException("Stub!"); }
+public  ArrayList(java.util.Collection<? extends E> collection) { throw new RuntimeException("Stub!"); }
+public  boolean add(E object) { throw new RuntimeException("Stub!"); }
+public  void add(int index, E object) { throw new RuntimeException("Stub!"); }
+public  boolean addAll(java.util.Collection<? extends E> collection) { throw new RuntimeException("Stub!"); }
+public  boolean addAll(int index, java.util.Collection<? extends E> collection) { throw new RuntimeException("Stub!"); }
+public  void clear() { throw new RuntimeException("Stub!"); }
+public  java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+public  void ensureCapacity(int minimumCapacity) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public  E get(int index) { throw new RuntimeException("Stub!"); }
+public  int size() { throw new RuntimeException("Stub!"); }
+public  boolean isEmpty() { throw new RuntimeException("Stub!"); }
+public  boolean contains(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public  int indexOf(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public  int lastIndexOf(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public  E remove(int index) { throw new RuntimeException("Stub!"); }
+public  boolean remove(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+protected  void removeRange(int fromIndex, int toIndex) { throw new RuntimeException("Stub!"); }
+public  E set(int index, E object) { throw new RuntimeException("Stub!"); }
+public  java.lang.Object[] toArray() { throw new RuntimeException("Stub!"); }
+public <T> T[] toArray(T[] contents) { throw new RuntimeException("Stub!"); }
+public  void trimToSize() { throw new RuntimeException("Stub!"); }
+public  java.util.Iterator<E> iterator() { throw new RuntimeException("Stub!"); }
+public  int hashCode() { throw new RuntimeException("Stub!"); }
+public  boolean equals(java.lang.Object o) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/Arrays.java b/core-stubs-mini/src/java/util/Arrays.java
new file mode 100644
index 00000000..0fb0fa53
--- /dev/null
+++ b/core-stubs-mini/src/java/util/Arrays.java
@@ -0,0 +1,113 @@
+package java.util;
+public class Arrays
+{
+Arrays() { throw new RuntimeException("Stub!"); }
+@java.lang.SafeVarargs()
+public static <T> java.util.List<T> asList(T... array) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(byte[] array, byte value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(byte[] array, int startIndex, int endIndex, byte value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(char[] array, char value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(char[] array, int startIndex, int endIndex, char value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(double[] array, double value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(double[] array, int startIndex, int endIndex, double value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(float[] array, float value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(float[] array, int startIndex, int endIndex, float value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(int[] array, int value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(int[] array, int startIndex, int endIndex, int value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(long[] array, long value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(long[] array, int startIndex, int endIndex, long value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(java.lang.Object[] array, java.lang.Object value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(java.lang.Object[] array, int startIndex, int endIndex, java.lang.Object value) { throw new RuntimeException("Stub!"); }
+public static <T> int binarySearch(T[] array, T value, java.util.Comparator<? super T> comparator) { throw new RuntimeException("Stub!"); }
+public static <T> int binarySearch(T[] array, int startIndex, int endIndex, T value, java.util.Comparator<? super T> comparator) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(short[] array, short value) { throw new RuntimeException("Stub!"); }
+public static  int binarySearch(short[] array, int startIndex, int endIndex, short value) { throw new RuntimeException("Stub!"); }
+public static  void fill(byte[] array, byte value) { throw new RuntimeException("Stub!"); }
+public static  void fill(byte[] array, int start, int end, byte value) { throw new RuntimeException("Stub!"); }
+public static  void fill(short[] array, short value) { throw new RuntimeException("Stub!"); }
+public static  void fill(short[] array, int start, int end, short value) { throw new RuntimeException("Stub!"); }
+public static  void fill(char[] array, char value) { throw new RuntimeException("Stub!"); }
+public static  void fill(char[] array, int start, int end, char value) { throw new RuntimeException("Stub!"); }
+public static  void fill(int[] array, int value) { throw new RuntimeException("Stub!"); }
+public static  void fill(int[] array, int start, int end, int value) { throw new RuntimeException("Stub!"); }
+public static  void fill(long[] array, long value) { throw new RuntimeException("Stub!"); }
+public static  void fill(long[] array, int start, int end, long value) { throw new RuntimeException("Stub!"); }
+public static  void fill(float[] array, float value) { throw new RuntimeException("Stub!"); }
+public static  void fill(float[] array, int start, int end, float value) { throw new RuntimeException("Stub!"); }
+public static  void fill(double[] array, double value) { throw new RuntimeException("Stub!"); }
+public static  void fill(double[] array, int start, int end, double value) { throw new RuntimeException("Stub!"); }
+public static  void fill(boolean[] array, boolean value) { throw new RuntimeException("Stub!"); }
+public static  void fill(boolean[] array, int start, int end, boolean value) { throw new RuntimeException("Stub!"); }
+public static  void fill(java.lang.Object[] array, java.lang.Object value) { throw new RuntimeException("Stub!"); }
+public static  void fill(java.lang.Object[] array, int start, int end, java.lang.Object value) { throw new RuntimeException("Stub!"); }
+public static  int hashCode(boolean[] array) { throw new RuntimeException("Stub!"); }
+public static  int hashCode(int[] array) { throw new RuntimeException("Stub!"); }
+public static  int hashCode(short[] array) { throw new RuntimeException("Stub!"); }
+public static  int hashCode(char[] array) { throw new RuntimeException("Stub!"); }
+public static  int hashCode(byte[] array) { throw new RuntimeException("Stub!"); }
+public static  int hashCode(long[] array) { throw new RuntimeException("Stub!"); }
+public static  int hashCode(float[] array) { throw new RuntimeException("Stub!"); }
+public static  int hashCode(double[] array) { throw new RuntimeException("Stub!"); }
+public static  int hashCode(java.lang.Object[] array) { throw new RuntimeException("Stub!"); }
+public static  int deepHashCode(java.lang.Object[] array) { throw new RuntimeException("Stub!"); }
+public static  boolean equals(byte[] array1, byte[] array2) { throw new RuntimeException("Stub!"); }
+public static  boolean equals(short[] array1, short[] array2) { throw new RuntimeException("Stub!"); }
+public static  boolean equals(char[] array1, char[] array2) { throw new RuntimeException("Stub!"); }
+public static  boolean equals(int[] array1, int[] array2) { throw new RuntimeException("Stub!"); }
+public static  boolean equals(long[] array1, long[] array2) { throw new RuntimeException("Stub!"); }
+public static  boolean equals(float[] array1, float[] array2) { throw new RuntimeException("Stub!"); }
+public static  boolean equals(double[] array1, double[] array2) { throw new RuntimeException("Stub!"); }
+public static  boolean equals(boolean[] array1, boolean[] array2) { throw new RuntimeException("Stub!"); }
+public static  boolean equals(java.lang.Object[] array1, java.lang.Object[] array2) { throw new RuntimeException("Stub!"); }
+public static  boolean deepEquals(java.lang.Object[] array1, java.lang.Object[] array2) { throw new RuntimeException("Stub!"); }
+public static  void sort(byte[] array) { throw new RuntimeException("Stub!"); }
+public static  void sort(byte[] array, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  void sort(char[] array) { throw new RuntimeException("Stub!"); }
+public static  void sort(char[] array, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  void sort(double[] array) { throw new RuntimeException("Stub!"); }
+public static  void sort(double[] array, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  void sort(float[] array) { throw new RuntimeException("Stub!"); }
+public static  void sort(float[] array, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  void sort(int[] array) { throw new RuntimeException("Stub!"); }
+public static  void sort(int[] array, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  void sort(long[] array) { throw new RuntimeException("Stub!"); }
+public static  void sort(long[] array, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  void sort(short[] array) { throw new RuntimeException("Stub!"); }
+public static  void sort(short[] array, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  void sort(java.lang.Object[] array) { throw new RuntimeException("Stub!"); }
+public static  void sort(java.lang.Object[] array, int start, int end) { throw new RuntimeException("Stub!"); }
+public static <T> void sort(T[] array, int start, int end, java.util.Comparator<? super T> comparator) { throw new RuntimeException("Stub!"); }
+public static <T> void sort(T[] array, java.util.Comparator<? super T> comparator) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String toString(boolean[] array) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String toString(byte[] array) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String toString(char[] array) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String toString(double[] array) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String toString(float[] array) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String toString(int[] array) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String toString(long[] array) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String toString(short[] array) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String toString(java.lang.Object[] array) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String deepToString(java.lang.Object[] array) { throw new RuntimeException("Stub!"); }
+public static  boolean[] copyOf(boolean[] original, int newLength) { throw new RuntimeException("Stub!"); }
+public static  byte[] copyOf(byte[] original, int newLength) { throw new RuntimeException("Stub!"); }
+public static  char[] copyOf(char[] original, int newLength) { throw new RuntimeException("Stub!"); }
+public static  double[] copyOf(double[] original, int newLength) { throw new RuntimeException("Stub!"); }
+public static  float[] copyOf(float[] original, int newLength) { throw new RuntimeException("Stub!"); }
+public static  int[] copyOf(int[] original, int newLength) { throw new RuntimeException("Stub!"); }
+public static  long[] copyOf(long[] original, int newLength) { throw new RuntimeException("Stub!"); }
+public static  short[] copyOf(short[] original, int newLength) { throw new RuntimeException("Stub!"); }
+public static <T> T[] copyOf(T[] original, int newLength) { throw new RuntimeException("Stub!"); }
+public static <T, U> T[] copyOf(U[] original, int newLength, java.lang.Class<? extends T[]> newType) { throw new RuntimeException("Stub!"); }
+public static  boolean[] copyOfRange(boolean[] original, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  byte[] copyOfRange(byte[] original, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  char[] copyOfRange(char[] original, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  double[] copyOfRange(double[] original, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  float[] copyOfRange(float[] original, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  int[] copyOfRange(int[] original, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  long[] copyOfRange(long[] original, int start, int end) { throw new RuntimeException("Stub!"); }
+public static  short[] copyOfRange(short[] original, int start, int end) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <T> T[] copyOfRange(T[] original, int start, int end) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <T, U> T[] copyOfRange(U[] original, int start, int end, java.lang.Class<? extends T[]> newType) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/Collections.java b/core-stubs-mini/src/java/util/Collections.java
new file mode 100644
index 00000000..3010cbe4
--- /dev/null
+++ b/core-stubs-mini/src/java/util/Collections.java
@@ -0,0 +1,86 @@
+package java.util;
+public class Collections
+{
+Collections() { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <T> int binarySearch(java.util.List<? extends java.lang.Comparable<? super T>> list, T object) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <T> int binarySearch(java.util.List<? extends T> list, T object, java.util.Comparator<? super T> comparator) { throw new RuntimeException("Stub!"); }
+public static <T> void copy(java.util.List<? super T> destination, java.util.List<? extends T> source) { throw new RuntimeException("Stub!"); }
+public static <T> java.util.Enumeration<T> enumeration(java.util.Collection<T> collection) { throw new RuntimeException("Stub!"); }
+public static <T> void fill(java.util.List<? super T> list, T object) { throw new RuntimeException("Stub!"); }
+public static <T extends java.lang.Object & java.lang.Comparable<? super T>> T max(java.util.Collection<? extends T> collection) { throw new RuntimeException("Stub!"); }
+public static <T> T max(java.util.Collection<? extends T> collection, java.util.Comparator<? super T> comparator) { throw new RuntimeException("Stub!"); }
+public static <T extends java.lang.Object & java.lang.Comparable<? super T>> T min(java.util.Collection<? extends T> collection) { throw new RuntimeException("Stub!"); }
+public static <T> T min(java.util.Collection<? extends T> collection, java.util.Comparator<? super T> comparator) { throw new RuntimeException("Stub!"); }
+public static <T> java.util.List<T> nCopies(int length, T object) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static  void reverse(java.util.List<?> list) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <T> java.util.Comparator<T> reverseOrder() { throw new RuntimeException("Stub!"); }
+public static <T> java.util.Comparator<T> reverseOrder(java.util.Comparator<T> c) { throw new RuntimeException("Stub!"); }
+public static  void shuffle(java.util.List<?> list) { throw new RuntimeException("Stub!"); }
+public static  void shuffle(java.util.List<?> list, java.util.Random random) { throw new RuntimeException("Stub!"); }
+public static <E> java.util.Set<E> singleton(E object) { throw new RuntimeException("Stub!"); }
+public static <E> java.util.List<E> singletonList(E object) { throw new RuntimeException("Stub!"); }
+public static <K, V> java.util.Map<K, V> singletonMap(K key, V value) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <T extends java.lang.Comparable<? super T>> void sort(java.util.List<T> list) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <T> void sort(java.util.List<T> list, java.util.Comparator<? super T> comparator) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static  void swap(java.util.List<?> list, int index1, int index2) { throw new RuntimeException("Stub!"); }
+public static <T> boolean replaceAll(java.util.List<T> list, T obj, T obj2) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static  void rotate(java.util.List<?> lst, int dist) { throw new RuntimeException("Stub!"); }
+public static  int indexOfSubList(java.util.List<?> list, java.util.List<?> sublist) { throw new RuntimeException("Stub!"); }
+public static  int lastIndexOfSubList(java.util.List<?> list, java.util.List<?> sublist) { throw new RuntimeException("Stub!"); }
+public static <T> java.util.ArrayList<T> list(java.util.Enumeration<T> enumeration) { throw new RuntimeException("Stub!"); }
+public static <T> java.util.Collection<T> synchronizedCollection(java.util.Collection<T> collection) { throw new RuntimeException("Stub!"); }
+public static <T> java.util.List<T> synchronizedList(java.util.List<T> list) { throw new RuntimeException("Stub!"); }
+public static <K, V> java.util.Map<K, V> synchronizedMap(java.util.Map<K, V> map) { throw new RuntimeException("Stub!"); }
+public static <E> java.util.Set<E> synchronizedSet(java.util.Set<E> set) { throw new RuntimeException("Stub!"); }
+public static <K, V> java.util.SortedMap<K, V> synchronizedSortedMap(java.util.SortedMap<K, V> map) { throw new RuntimeException("Stub!"); }
+public static <E> java.util.SortedSet<E> synchronizedSortedSet(java.util.SortedSet<E> set) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <E> java.util.Collection<E> unmodifiableCollection(java.util.Collection<? extends E> collection) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <E> java.util.List<E> unmodifiableList(java.util.List<? extends E> list) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <K, V> java.util.Map<K, V> unmodifiableMap(java.util.Map<? extends K, ? extends V> map) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <E> java.util.Set<E> unmodifiableSet(java.util.Set<? extends E> set) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <K, V> java.util.SortedMap<K, V> unmodifiableSortedMap(java.util.SortedMap<K, ? extends V> map) { throw new RuntimeException("Stub!"); }
+public static <E> java.util.SortedSet<E> unmodifiableSortedSet(java.util.SortedSet<E> set) { throw new RuntimeException("Stub!"); }
+public static  int frequency(java.util.Collection<?> c, java.lang.Object o) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static final <T> java.util.List<T> emptyList() { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static final <T> java.util.Set<T> emptySet() { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static final <K, V> java.util.Map<K, V> emptyMap() { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <T> java.util.Enumeration<T> emptyEnumeration() { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static <T> java.util.Iterator<T> emptyIterator() { throw new RuntimeException("Stub!"); }
+public static <T> java.util.ListIterator<T> emptyListIterator() { throw new RuntimeException("Stub!"); }
+public static <E> java.util.Collection<E> checkedCollection(java.util.Collection<E> c, java.lang.Class<E> type) { throw new RuntimeException("Stub!"); }
+public static <K, V> java.util.Map<K, V> checkedMap(java.util.Map<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) { throw new RuntimeException("Stub!"); }
+public static <E> java.util.List<E> checkedList(java.util.List<E> list, java.lang.Class<E> type) { throw new RuntimeException("Stub!"); }
+public static <E> java.util.Set<E> checkedSet(java.util.Set<E> s, java.lang.Class<E> type) { throw new RuntimeException("Stub!"); }
+public static <K, V> java.util.SortedMap<K, V> checkedSortedMap(java.util.SortedMap<K, V> m, java.lang.Class<K> keyType, java.lang.Class<V> valueType) { throw new RuntimeException("Stub!"); }
+public static <E> java.util.SortedSet<E> checkedSortedSet(java.util.SortedSet<E> s, java.lang.Class<E> type) { throw new RuntimeException("Stub!"); }
+@java.lang.SafeVarargs()
+public static <T> boolean addAll(java.util.Collection<? super T> c, T... a) { throw new RuntimeException("Stub!"); }
+public static  boolean disjoint(java.util.Collection<?> c1, java.util.Collection<?> c2) { throw new RuntimeException("Stub!"); }
+public static <E> java.util.Set<E> newSetFromMap(java.util.Map<E, java.lang.Boolean> map) { throw new RuntimeException("Stub!"); }
+public static <T> java.util.Queue<T> asLifoQueue(java.util.Deque<T> deque) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static final java.util.List EMPTY_LIST;
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static final java.util.Map EMPTY_MAP;
+@java.lang.SuppressWarnings(value={"unchecked"})
+public static final java.util.Set EMPTY_SET;
+static { EMPTY_LIST = null; EMPTY_MAP = null; EMPTY_SET = null; }
+}
diff --git a/core-stubs-mini/src/java/util/Currency.java b/core-stubs-mini/src/java/util/Currency.java
new file mode 100644
index 00000000..f6ead5b7
--- /dev/null
+++ b/core-stubs-mini/src/java/util/Currency.java
@@ -0,0 +1,16 @@
+package java.util;
+public final class Currency
+  implements java.io.Serializable
+{
+Currency() { throw new RuntimeException("Stub!"); }
+public static  java.util.Currency getInstance(java.lang.String currencyCode) { throw new RuntimeException("Stub!"); }
+public static  java.util.Currency getInstance(java.util.Locale locale) { throw new RuntimeException("Stub!"); }
+public static  java.util.Set<java.util.Currency> getAvailableCurrencies() { throw new RuntimeException("Stub!"); }
+public  java.lang.String getCurrencyCode() { throw new RuntimeException("Stub!"); }
+public  java.lang.String getDisplayName() { throw new RuntimeException("Stub!"); }
+public  java.lang.String getDisplayName(java.util.Locale locale) { throw new RuntimeException("Stub!"); }
+public  java.lang.String getSymbol() { throw new RuntimeException("Stub!"); }
+public  java.lang.String getSymbol(java.util.Locale locale) { throw new RuntimeException("Stub!"); }
+public  int getDefaultFractionDigits() { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/HashSet.java b/core-stubs-mini/src/java/util/HashSet.java
new file mode 100644
index 00000000..68fa5599
--- /dev/null
+++ b/core-stubs-mini/src/java/util/HashSet.java
@@ -0,0 +1,19 @@
+package java.util;
+public class HashSet<E>
+  extends java.util.AbstractSet<E>
+  implements java.util.Set<E>, java.lang.Cloneable, java.io.Serializable
+{
+public  HashSet() { throw new RuntimeException("Stub!"); }
+public  HashSet(int capacity) { throw new RuntimeException("Stub!"); }
+public  HashSet(int capacity, float loadFactor) { throw new RuntimeException("Stub!"); }
+public  HashSet(java.util.Collection<? extends E> collection) { throw new RuntimeException("Stub!"); }
+public  boolean add(E object) { throw new RuntimeException("Stub!"); }
+public  void clear() { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public  java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+public  boolean contains(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public  boolean isEmpty() { throw new RuntimeException("Stub!"); }
+public  java.util.Iterator<E> iterator() { throw new RuntimeException("Stub!"); }
+public  boolean remove(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public  int size() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/RandomAccess.java b/core-stubs-mini/src/java/util/RandomAccess.java
new file mode 100644
index 00000000..6aa9a6ce
--- /dev/null
+++ b/core-stubs-mini/src/java/util/RandomAccess.java
@@ -0,0 +1,4 @@
+package java.util;
+public interface RandomAccess
+{
+}
diff --git a/core-stubs-mini/src/java/util/SortedSet.java b/core-stubs-mini/src/java/util/SortedSet.java
new file mode 100644
index 00000000..34133955
--- /dev/null
+++ b/core-stubs-mini/src/java/util/SortedSet.java
@@ -0,0 +1,11 @@
+package java.util;
+public interface SortedSet<E>
+  extends java.util.Set<E>
+{
+public abstract  java.util.Comparator<? super E> comparator();
+public abstract  E first();
+public abstract  java.util.SortedSet<E> headSet(E end);
+public abstract  E last();
+public abstract  java.util.SortedSet<E> subSet(E start, E end);
+public abstract  java.util.SortedSet<E> tailSet(E start);
+}
diff --git a/core-stubs-mini/src/java/util/Vector.java b/core-stubs-mini/src/java/util/Vector.java
new file mode 100644
index 00000000..5be45c25
--- /dev/null
+++ b/core-stubs-mini/src/java/util/Vector.java
@@ -0,0 +1,62 @@
+package java.util;
+public class Vector<E>
+  extends java.util.AbstractList<E>
+  implements java.util.List<E>, java.util.RandomAccess, java.lang.Cloneable, java.io.Serializable
+{
+public  Vector() { throw new RuntimeException("Stub!"); }
+public  Vector(int capacity) { throw new RuntimeException("Stub!"); }
+public  Vector(int capacity, int capacityIncrement) { throw new RuntimeException("Stub!"); }
+public  Vector(java.util.Collection<? extends E> collection) { throw new RuntimeException("Stub!"); }
+public  void add(int location, E object) { throw new RuntimeException("Stub!"); }
+public synchronized  boolean add(E object) { throw new RuntimeException("Stub!"); }
+public synchronized  boolean addAll(int location, java.util.Collection<? extends E> collection) { throw new RuntimeException("Stub!"); }
+public synchronized  boolean addAll(java.util.Collection<? extends E> collection) { throw new RuntimeException("Stub!"); }
+public synchronized  void addElement(E object) { throw new RuntimeException("Stub!"); }
+public synchronized  int capacity() { throw new RuntimeException("Stub!"); }
+public  void clear() { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public synchronized  java.lang.Object clone() { throw new RuntimeException("Stub!"); }
+public  boolean contains(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public synchronized  boolean containsAll(java.util.Collection<?> collection) { throw new RuntimeException("Stub!"); }
+public synchronized  void copyInto(java.lang.Object[] elements) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public synchronized  E elementAt(int location) { throw new RuntimeException("Stub!"); }
+public  java.util.Enumeration<E> elements() { throw new RuntimeException("Stub!"); }
+public synchronized  void ensureCapacity(int minimumCapacity) { throw new RuntimeException("Stub!"); }
+public synchronized  boolean equals(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public synchronized  E firstElement() { throw new RuntimeException("Stub!"); }
+public  E get(int location) { throw new RuntimeException("Stub!"); }
+public synchronized  int hashCode() { throw new RuntimeException("Stub!"); }
+public  int indexOf(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public synchronized  int indexOf(java.lang.Object object, int location) { throw new RuntimeException("Stub!"); }
+public synchronized  void insertElementAt(E object, int location) { throw new RuntimeException("Stub!"); }
+public synchronized  boolean isEmpty() { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public synchronized  E lastElement() { throw new RuntimeException("Stub!"); }
+public synchronized  int lastIndexOf(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public synchronized  int lastIndexOf(java.lang.Object object, int location) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public synchronized  E remove(int location) { throw new RuntimeException("Stub!"); }
+public  boolean remove(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public synchronized  boolean removeAll(java.util.Collection<?> collection) { throw new RuntimeException("Stub!"); }
+public synchronized  void removeAllElements() { throw new RuntimeException("Stub!"); }
+public synchronized  boolean removeElement(java.lang.Object object) { throw new RuntimeException("Stub!"); }
+public synchronized  void removeElementAt(int location) { throw new RuntimeException("Stub!"); }
+protected  void removeRange(int start, int end) { throw new RuntimeException("Stub!"); }
+public synchronized  boolean retainAll(java.util.Collection<?> collection) { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public synchronized  E set(int location, E object) { throw new RuntimeException("Stub!"); }
+public synchronized  void setElementAt(E object, int location) { throw new RuntimeException("Stub!"); }
+public synchronized  void setSize(int length) { throw new RuntimeException("Stub!"); }
+public synchronized  int size() { throw new RuntimeException("Stub!"); }
+public synchronized  java.util.List<E> subList(int start, int end) { throw new RuntimeException("Stub!"); }
+public synchronized  java.lang.Object[] toArray() { throw new RuntimeException("Stub!"); }
+@java.lang.SuppressWarnings(value={"unchecked"})
+public synchronized <T> T[] toArray(T[] contents) { throw new RuntimeException("Stub!"); }
+public synchronized  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+public synchronized  void trimToSize() { throw new RuntimeException("Stub!"); }
+protected int capacityIncrement;
+protected int elementCount;
+protected java.lang.Object[] elementData = null;
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/Callable.java b/core-stubs-mini/src/java/util/concurrent/Callable.java
new file mode 100644
index 00000000..2acc4162
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/Callable.java
@@ -0,0 +1,5 @@
+package java.util.concurrent;
+public interface Callable<V>
+{
+public abstract  V call() throws java.lang.Exception;
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/Delayed.java b/core-stubs-mini/src/java/util/concurrent/Delayed.java
new file mode 100644
index 00000000..82771210
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/Delayed.java
@@ -0,0 +1,6 @@
+package java.util.concurrent;
+public interface Delayed
+  extends java.lang.Comparable<java.util.concurrent.Delayed>
+{
+public abstract  long getDelay(java.util.concurrent.TimeUnit unit);
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/ExecutionException.java b/core-stubs-mini/src/java/util/concurrent/ExecutionException.java
new file mode 100644
index 00000000..241a486b
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/ExecutionException.java
@@ -0,0 +1,9 @@
+package java.util.concurrent;
+public class ExecutionException
+  extends java.lang.Exception
+{
+protected  ExecutionException() { throw new RuntimeException("Stub!"); }
+protected  ExecutionException(java.lang.String message) { throw new RuntimeException("Stub!"); }
+public  ExecutionException(java.lang.String message, java.lang.Throwable cause) { throw new RuntimeException("Stub!"); }
+public  ExecutionException(java.lang.Throwable cause) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/Executor.java b/core-stubs-mini/src/java/util/concurrent/Executor.java
new file mode 100644
index 00000000..234d0279
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/Executor.java
@@ -0,0 +1,5 @@
+package java.util.concurrent;
+public interface Executor
+{
+public abstract  void execute(java.lang.Runnable command);
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/ExecutorService.java b/core-stubs-mini/src/java/util/concurrent/ExecutorService.java
new file mode 100644
index 00000000..f8fbf990
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/ExecutorService.java
@@ -0,0 +1,17 @@
+package java.util.concurrent;
+public interface ExecutorService
+  extends java.util.concurrent.Executor
+{
+public abstract  void shutdown();
+public abstract  java.util.List<java.lang.Runnable> shutdownNow();
+public abstract  boolean isShutdown();
+public abstract  boolean isTerminated();
+public abstract  boolean awaitTermination(long timeout, java.util.concurrent.TimeUnit unit) throws java.lang.InterruptedException;
+public abstract <T> java.util.concurrent.Future<T> submit(java.util.concurrent.Callable<T> task);
+public abstract <T> java.util.concurrent.Future<T> submit(java.lang.Runnable task, T result);
+public abstract  java.util.concurrent.Future<?> submit(java.lang.Runnable task);
+public abstract <T> java.util.List<java.util.concurrent.Future<T>> invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks) throws java.lang.InterruptedException;
+public abstract <T> java.util.List<java.util.concurrent.Future<T>> invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks, long timeout, java.util.concurrent.TimeUnit unit) throws java.lang.InterruptedException;
+public abstract <T> T invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks) throws java.lang.InterruptedException, java.util.concurrent.ExecutionException;
+public abstract <T> T invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks, long timeout, java.util.concurrent.TimeUnit unit) throws java.lang.InterruptedException, java.util.concurrent.ExecutionException, java.util.concurrent.TimeoutException;
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/Executors.java b/core-stubs-mini/src/java/util/concurrent/Executors.java
new file mode 100644
index 00000000..884a3f39
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/Executors.java
@@ -0,0 +1,25 @@
+package java.util.concurrent;
+public class Executors
+{
+Executors() { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ExecutorService newFixedThreadPool(int nThreads) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ExecutorService newFixedThreadPool(int nThreads, java.util.concurrent.ThreadFactory threadFactory) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ExecutorService newSingleThreadExecutor() { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ExecutorService newSingleThreadExecutor(java.util.concurrent.ThreadFactory threadFactory) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ExecutorService newCachedThreadPool() { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ExecutorService newCachedThreadPool(java.util.concurrent.ThreadFactory threadFactory) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ScheduledExecutorService newSingleThreadScheduledExecutor() { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ScheduledExecutorService newSingleThreadScheduledExecutor(java.util.concurrent.ThreadFactory threadFactory) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ScheduledExecutorService newScheduledThreadPool(int corePoolSize, java.util.concurrent.ThreadFactory threadFactory) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ExecutorService unconfigurableExecutorService(java.util.concurrent.ExecutorService executor) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ScheduledExecutorService unconfigurableScheduledExecutorService(java.util.concurrent.ScheduledExecutorService executor) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ThreadFactory defaultThreadFactory() { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.ThreadFactory privilegedThreadFactory() { throw new RuntimeException("Stub!"); }
+public static <T> java.util.concurrent.Callable<T> callable(java.lang.Runnable task, T result) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.Callable<java.lang.Object> callable(java.lang.Runnable task) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.Callable<java.lang.Object> callable(java.security.PrivilegedAction<?> action) { throw new RuntimeException("Stub!"); }
+public static  java.util.concurrent.Callable<java.lang.Object> callable(java.security.PrivilegedExceptionAction<?> action) { throw new RuntimeException("Stub!"); }
+public static <T> java.util.concurrent.Callable<T> privilegedCallable(java.util.concurrent.Callable<T> callable) { throw new RuntimeException("Stub!"); }
+public static <T> java.util.concurrent.Callable<T> privilegedCallableUsingCurrentClassLoader(java.util.concurrent.Callable<T> callable) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/Future.java b/core-stubs-mini/src/java/util/concurrent/Future.java
new file mode 100644
index 00000000..4d9ad688
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/Future.java
@@ -0,0 +1,9 @@
+package java.util.concurrent;
+public interface Future<V>
+{
+public abstract  boolean cancel(boolean mayInterruptIfRunning);
+public abstract  boolean isCancelled();
+public abstract  boolean isDone();
+public abstract  V get() throws java.lang.InterruptedException, java.util.concurrent.ExecutionException;
+public abstract  V get(long timeout, java.util.concurrent.TimeUnit unit) throws java.lang.InterruptedException, java.util.concurrent.ExecutionException, java.util.concurrent.TimeoutException;
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/ScheduledExecutorService.java b/core-stubs-mini/src/java/util/concurrent/ScheduledExecutorService.java
new file mode 100644
index 00000000..c70f77ac
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/ScheduledExecutorService.java
@@ -0,0 +1,9 @@
+package java.util.concurrent;
+public interface ScheduledExecutorService
+  extends java.util.concurrent.ExecutorService
+{
+public abstract  java.util.concurrent.ScheduledFuture<?> schedule(java.lang.Runnable command, long delay, java.util.concurrent.TimeUnit unit);
+public abstract <V> java.util.concurrent.ScheduledFuture<V> schedule(java.util.concurrent.Callable<V> callable, long delay, java.util.concurrent.TimeUnit unit);
+public abstract  java.util.concurrent.ScheduledFuture<?> scheduleAtFixedRate(java.lang.Runnable command, long initialDelay, long period, java.util.concurrent.TimeUnit unit);
+public abstract  java.util.concurrent.ScheduledFuture<?> scheduleWithFixedDelay(java.lang.Runnable command, long initialDelay, long delay, java.util.concurrent.TimeUnit unit);
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/ScheduledFuture.java b/core-stubs-mini/src/java/util/concurrent/ScheduledFuture.java
new file mode 100644
index 00000000..24d22a53
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/ScheduledFuture.java
@@ -0,0 +1,5 @@
+package java.util.concurrent;
+public interface ScheduledFuture<V>
+  extends java.util.concurrent.Delayed, java.util.concurrent.Future<V>
+{
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/ThreadFactory.java b/core-stubs-mini/src/java/util/concurrent/ThreadFactory.java
new file mode 100644
index 00000000..6cb7f72c
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/ThreadFactory.java
@@ -0,0 +1,5 @@
+package java.util.concurrent;
+public interface ThreadFactory
+{
+public abstract  java.lang.Thread newThread(java.lang.Runnable r);
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/TimeUnit.java b/core-stubs-mini/src/java/util/concurrent/TimeUnit.java
new file mode 100644
index 00000000..89c2b0a6
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/TimeUnit.java
@@ -0,0 +1,22 @@
+package java.util.concurrent;
+public enum TimeUnit
+{
+DAYS(),
+HOURS(),
+MICROSECONDS(),
+MILLISECONDS(),
+MINUTES(),
+NANOSECONDS(),
+SECONDS();
+public  long convert(long sourceDuration, java.util.concurrent.TimeUnit sourceUnit) { throw new RuntimeException("Stub!"); }
+public  long toNanos(long duration) { throw new RuntimeException("Stub!"); }
+public  long toMicros(long duration) { throw new RuntimeException("Stub!"); }
+public  long toMillis(long duration) { throw new RuntimeException("Stub!"); }
+public  long toSeconds(long duration) { throw new RuntimeException("Stub!"); }
+public  long toMinutes(long duration) { throw new RuntimeException("Stub!"); }
+public  long toHours(long duration) { throw new RuntimeException("Stub!"); }
+public  long toDays(long duration) { throw new RuntimeException("Stub!"); }
+public  void timedWait(java.lang.Object obj, long timeout) throws java.lang.InterruptedException { throw new RuntimeException("Stub!"); }
+public  void timedJoin(java.lang.Thread thread, long timeout) throws java.lang.InterruptedException { throw new RuntimeException("Stub!"); }
+public  void sleep(long timeout) throws java.lang.InterruptedException { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/TimeoutException.java b/core-stubs-mini/src/java/util/concurrent/TimeoutException.java
new file mode 100644
index 00000000..c284256d
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/TimeoutException.java
@@ -0,0 +1,7 @@
+package java.util.concurrent;
+public class TimeoutException
+  extends java.lang.Exception
+{
+public  TimeoutException() { throw new RuntimeException("Stub!"); }
+public  TimeoutException(java.lang.String message) { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/concurrent/atomic/AtomicInteger.java b/core-stubs-mini/src/java/util/concurrent/atomic/AtomicInteger.java
new file mode 100644
index 00000000..40807083
--- /dev/null
+++ b/core-stubs-mini/src/java/util/concurrent/atomic/AtomicInteger.java
@@ -0,0 +1,25 @@
+package java.util.concurrent.atomic;
+public class AtomicInteger
+  extends java.lang.Number
+  implements java.io.Serializable
+{
+public  AtomicInteger(int initialValue) { throw new RuntimeException("Stub!"); }
+public  AtomicInteger() { throw new RuntimeException("Stub!"); }
+public final  int get() { throw new RuntimeException("Stub!"); }
+public final  void set(int newValue) { throw new RuntimeException("Stub!"); }
+public final  void lazySet(int newValue) { throw new RuntimeException("Stub!"); }
+public final  int getAndSet(int newValue) { throw new RuntimeException("Stub!"); }
+public final  boolean compareAndSet(int expect, int update) { throw new RuntimeException("Stub!"); }
+public final  boolean weakCompareAndSet(int expect, int update) { throw new RuntimeException("Stub!"); }
+public final  int getAndIncrement() { throw new RuntimeException("Stub!"); }
+public final  int getAndDecrement() { throw new RuntimeException("Stub!"); }
+public final  int getAndAdd(int delta) { throw new RuntimeException("Stub!"); }
+public final  int incrementAndGet() { throw new RuntimeException("Stub!"); }
+public final  int decrementAndGet() { throw new RuntimeException("Stub!"); }
+public final  int addAndGet(int delta) { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+public  int intValue() { throw new RuntimeException("Stub!"); }
+public  long longValue() { throw new RuntimeException("Stub!"); }
+public  float floatValue() { throw new RuntimeException("Stub!"); }
+public  double doubleValue() { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/regex/MatchResult.java b/core-stubs-mini/src/java/util/regex/MatchResult.java
new file mode 100644
index 00000000..dbe4c743
--- /dev/null
+++ b/core-stubs-mini/src/java/util/regex/MatchResult.java
@@ -0,0 +1,11 @@
+package java.util.regex;
+public interface MatchResult
+{
+public abstract  int end();
+public abstract  int end(int group);
+public abstract  java.lang.String group();
+public abstract  java.lang.String group(int group);
+public abstract  int groupCount();
+public abstract  int start();
+public abstract  int start(int group);
+}
diff --git a/core-stubs-mini/src/java/util/regex/Matcher.java b/core-stubs-mini/src/java/util/regex/Matcher.java
new file mode 100644
index 00000000..19b25019
--- /dev/null
+++ b/core-stubs-mini/src/java/util/regex/Matcher.java
@@ -0,0 +1,38 @@
+package java.util.regex;
+public final class Matcher
+  implements java.util.regex.MatchResult
+{
+Matcher() { throw new RuntimeException("Stub!"); }
+public  java.util.regex.Matcher appendReplacement(java.lang.StringBuffer buffer, java.lang.String replacement) { throw new RuntimeException("Stub!"); }
+public  java.util.regex.Matcher reset() { throw new RuntimeException("Stub!"); }
+public  java.util.regex.Matcher reset(java.lang.CharSequence input) { throw new RuntimeException("Stub!"); }
+public  java.util.regex.Matcher usePattern(java.util.regex.Pattern pattern) { throw new RuntimeException("Stub!"); }
+public  java.util.regex.Matcher region(int start, int end) { throw new RuntimeException("Stub!"); }
+public  java.lang.StringBuffer appendTail(java.lang.StringBuffer buffer) { throw new RuntimeException("Stub!"); }
+public  java.lang.String replaceFirst(java.lang.String replacement) { throw new RuntimeException("Stub!"); }
+public  java.lang.String replaceAll(java.lang.String replacement) { throw new RuntimeException("Stub!"); }
+public  java.util.regex.Pattern pattern() { throw new RuntimeException("Stub!"); }
+public  boolean find(int start) { throw new RuntimeException("Stub!"); }
+public  boolean find() { throw new RuntimeException("Stub!"); }
+public  boolean lookingAt() { throw new RuntimeException("Stub!"); }
+public  boolean matches() { throw new RuntimeException("Stub!"); }
+public static  java.lang.String quoteReplacement(java.lang.String s) { throw new RuntimeException("Stub!"); }
+public  java.util.regex.MatchResult toMatchResult() { throw new RuntimeException("Stub!"); }
+public  java.util.regex.Matcher useAnchoringBounds(boolean value) { throw new RuntimeException("Stub!"); }
+public  boolean hasAnchoringBounds() { throw new RuntimeException("Stub!"); }
+public  java.util.regex.Matcher useTransparentBounds(boolean value) { throw new RuntimeException("Stub!"); }
+public  boolean hasTransparentBounds() { throw new RuntimeException("Stub!"); }
+public  int regionStart() { throw new RuntimeException("Stub!"); }
+public  int regionEnd() { throw new RuntimeException("Stub!"); }
+public  boolean requireEnd() { throw new RuntimeException("Stub!"); }
+public  boolean hitEnd() { throw new RuntimeException("Stub!"); }
+protected  void finalize() throws java.lang.Throwable { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+public  int end() { throw new RuntimeException("Stub!"); }
+public  int end(int group) { throw new RuntimeException("Stub!"); }
+public  java.lang.String group() { throw new RuntimeException("Stub!"); }
+public  java.lang.String group(int group) { throw new RuntimeException("Stub!"); }
+public  int groupCount() { throw new RuntimeException("Stub!"); }
+public  int start() { throw new RuntimeException("Stub!"); }
+public  int start(int group) throws java.lang.IllegalStateException { throw new RuntimeException("Stub!"); }
+}
diff --git a/core-stubs-mini/src/java/util/regex/Pattern.java b/core-stubs-mini/src/java/util/regex/Pattern.java
new file mode 100644
index 00000000..64a550a9
--- /dev/null
+++ b/core-stubs-mini/src/java/util/regex/Pattern.java
@@ -0,0 +1,25 @@
+package java.util.regex;
+public final class Pattern
+  implements java.io.Serializable
+{
+Pattern() { throw new RuntimeException("Stub!"); }
+public  java.util.regex.Matcher matcher(java.lang.CharSequence input) { throw new RuntimeException("Stub!"); }
+public  java.lang.String[] split(java.lang.CharSequence input, int limit) { throw new RuntimeException("Stub!"); }
+public  java.lang.String[] split(java.lang.CharSequence input) { throw new RuntimeException("Stub!"); }
+public  java.lang.String pattern() { throw new RuntimeException("Stub!"); }
+public  java.lang.String toString() { throw new RuntimeException("Stub!"); }
+public  int flags() { throw new RuntimeException("Stub!"); }
+public static  java.util.regex.Pattern compile(java.lang.String regularExpression, int flags) throws java.util.regex.PatternSyntaxException { throw new RuntimeException("Stub!"); }
+public static  java.util.regex.Pattern compile(java.lang.String pattern) { throw new RuntimeException("Stub!"); }
+public static  boolean matches(java.lang.String regularExpression, java.lang.CharSequence input) { throw new RuntimeException("Stub!"); }
+public static  java.lang.String quote(java.lang.String string) { throw new RuntimeException("Stub!"); }
+protected  void finalize() throws java.lang.Throwable { throw new RuntimeException("Stub!"); }
+public static final int CANON_EQ = 128;
+public static final int CASE_INSENSITIVE = 2;
+public static final int COMMENTS = 4;
+public static final int DOTALL = 32;
+public static final int LITERAL = 16;
+public static final int MULTILINE = 8;
+public static final int UNICODE_CASE = 64;
+public static final int UNIX_LINES = 1;
+}
diff --git a/core-stubs-mini/src/java/util/regex/PatternSyntaxException.java b/core-stubs-mini/src/java/util/regex/PatternSyntaxException.java
new file mode 100644
index 00000000..3cc0dba3
--- /dev/null
+++ b/core-stubs-mini/src/java/util/regex/PatternSyntaxException.java
@@ -0,0 +1,10 @@
+package java.util.regex;
+public class PatternSyntaxException
+  extends java.lang.IllegalArgumentException
+{
+public  PatternSyntaxException(java.lang.String description, java.lang.String pattern, int index) { throw new RuntimeException("Stub!"); }
+public  java.lang.String getPattern() { throw new RuntimeException("Stub!"); }
+public  java.lang.String getMessage() { throw new RuntimeException("Stub!"); }
+public  java.lang.String getDescription() { throw new RuntimeException("Stub!"); }
+public  int getIndex() { throw new RuntimeException("Stub!"); }
+}