separate lib from compiler

162 files changed, 4761 insertions, 0 deletions

diff --git a/library/src/dotty/DottyPredef.scala b/library/src/dotty/DottyPredef.scala
new file mode 100644
index 000000000..cd90c4882
--- /dev/null
+++ b/library/src/dotty/DottyPredef.scala
@@ -0,0 +1,45 @@
+package dotty
+
+import scala.reflect.runtime.universe.TypeTag
+import scala.reflect.ClassTag
+import scala.Predef.???
+import scala.collection.Seq
+
+/** unimplemented implicit for TypeTag */
+object DottyPredef {
+  implicit def typeTag[T]: TypeTag[T] = ???
+
+  implicit def arrayTag[T](implicit ctag: ClassTag[T]): ClassTag[Array[T]] =
+    ctag.wrap
+
+  /** A fall-back implicit to compare values of any types.
+   *  The compiler will restrict implicit instances of `eqAny`. An instance
+   *  `eqAny[T, U]` is _valid_ if `T <: U` or `U <: T` or both `T` and `U` are
+   *  Eq-free. A type `S` is Eq-free if there is no implicit instance of `Eq[S, S]`.
+   *  An implicit search will fail instead of returning an invalid `eqAny` instance.
+   */
+  implicit def eqAny[L, R]: Eq[L, R] = Eq
+
+  implicit def eqNumber   : Eq[Number, Number] = Eq
+  implicit def eqString   : Eq[String, String] = Eq
+
+  // true asymmetry, modeling the (somewhat problematic) nature of equals on Proxies
+  implicit def eqProxy    : Eq[Proxy, Any]     = Eq
+
+  implicit def eqSeq[T, U](implicit eq: Eq[T, U]): Eq[Seq[T], Seq[U]] = Eq
+
+  implicit def eqByteNum  : Eq[Byte, Number]   = Eq
+  implicit def eqNumByte  : Eq[Number, Byte]   = Eq
+  implicit def eqCharNum  : Eq[Char, Number]   = Eq
+  implicit def eqNumChar  : Eq[Number, Char]   = Eq
+  implicit def eqShortNum : Eq[Short, Number]  = Eq
+  implicit def eqNumShort : Eq[Number, Short]  = Eq
+  implicit def eqIntNum   : Eq[Int, Number]    = Eq
+  implicit def eqNumInt   : Eq[Number, Int]    = Eq
+  implicit def eqLongNum  : Eq[Long, Number]   = Eq
+  implicit def eqNumLong  : Eq[Number, Long]   = Eq
+  implicit def eqFloatNum : Eq[Float, Number]  = Eq
+  implicit def eqNumFloat : Eq[Number, Float]  = Eq
+  implicit def eqDoubleNum: Eq[Double, Number] = Eq
+  implicit def eqNumDouble: Eq[Number, Double] = Eq
+}
diff --git a/library/src/dotty/runtime/Arrays.scala b/library/src/dotty/runtime/Arrays.scala
new file mode 100644
index 000000000..9ec5512ad
--- /dev/null
+++ b/library/src/dotty/runtime/Arrays.scala
@@ -0,0 +1,31 @@
+package dotty.runtime
+
+import scala.reflect.ClassTag
+
+import java.lang.{reflect => jlr}
+
+/** All but the first two operations should be short-circuited and implemented specially by
+ *  the backend.
+ */
+object Arrays {
+
+  // note: this class is magical. Do not touch it unless you know what you are doing.`
+
+  /** Creates an array of some element type determined by the given `ClassTag`
+   *  argument. The erased type of applications of this method is `Object`.
+   */
+  def newGenericArray[T](length: Int)(implicit tag: ClassTag[T]): Array[T] =
+    tag.newArray(length)
+
+  /** Convert a sequence to a Java array with element type given by `clazz`. */
+  def seqToArray[T](xs: Seq[T], clazz: Class[_]): Array[T] = {
+    val arr = java.lang.reflect.Array.newInstance(clazz, xs.length).asInstanceOf[Array[T]]
+    xs.copyToArray(arr)
+    arr
+  }
+
+  /** Create an array of a reference type T.
+   */
+  def newArray[Arr](componentType: Class[_], returnType: Class[Arr], dimensions: Array[Int]): Arr =
+    jlr.Array.newInstance(componentType, dimensions: _*).asInstanceOf[Arr]
+}
diff --git a/library/src/dotty/runtime/LazyHolders.scala b/library/src/dotty/runtime/LazyHolders.scala
new file mode 100644
index 000000000..1e31cda66
--- /dev/null
+++ b/library/src/dotty/runtime/LazyHolders.scala
@@ -0,0 +1,44 @@
+package dotty.runtime
+
+/**
+ * Classes used as holders for local lazy vals
+ */
+class LazyInt {
+  var value: Int = _
+  @volatile var initialized: Boolean = false
+}
+
+class LazyLong {
+  var value: Long = _
+  @volatile var initialized: Boolean = false
+}
+
+class LazyBoolean {
+  var value: Boolean = _
+  @volatile var initialized: Boolean = false
+}
+
+class LazyDouble {
+  var value: Double = _
+  @volatile var initialized: Boolean = false
+}
+
+class LazyByte {
+  var value: Byte = _
+  @volatile var initialized: Boolean = false
+}
+
+class LazyRef {
+  var value: AnyRef = _
+  @volatile var initialized: Boolean = false
+}
+
+class LazyShort {
+  var value: Short = _
+  @volatile var initialized: Boolean = false
+}
+
+class LazyChar {
+  var value: Char = _
+  @volatile var initialized: Boolean = false
+}
diff --git a/library/src/dotty/runtime/LazyVals.scala b/library/src/dotty/runtime/LazyVals.scala
new file mode 100644
index 000000000..4dea0d34d
--- /dev/null
+++ b/library/src/dotty/runtime/LazyVals.scala
@@ -0,0 +1,103 @@
+package dotty.runtime
+
+import scala.annotation.tailrec
+
+/**
+ * Helper methods used in thread-safe lazy vals.
+ */
+object LazyVals {
+  private val unsafe = scala.concurrent.util.Unsafe.instance
+
+  final val BITS_PER_LAZY_VAL = 2L
+  final val LAZY_VAL_MASK = 3L
+  final val debug = false
+
+  @inline def STATE(cur: Long, ord: Int) = {
+    val r = (cur >> (ord * BITS_PER_LAZY_VAL)) & LAZY_VAL_MASK
+    if (debug)
+      println(s"STATE($cur, $ord) = $r")
+    r
+  }
+  @inline def CAS(t: Object, offset: Long, e: Long, v: Int, ord: Int) = {
+    if (debug)
+      println(s"CAS($t, $offset, $e, $v, $ord)")
+    val mask = ~(LAZY_VAL_MASK << ord * BITS_PER_LAZY_VAL)
+    val n = (e & mask) | (v << (ord * BITS_PER_LAZY_VAL))
+    compareAndSet(t, offset, e, n)
+  }
+  @inline def setFlag(t: Object, offset: Long, v: Int, ord: Int) = {
+    if (debug)
+      println(s"setFlag($t, $offset, $v, $ord)")
+    var retry = true
+    while (retry) {
+      val cur = get(t, offset)
+      if (STATE(cur, ord) == 1) retry = CAS(t, offset, cur, v, ord)
+      else {
+        // cur == 2, somebody is waiting on monitor
+        if (CAS(t, offset, cur, v, ord)) {
+          val monitor = getMonitor(t, ord)
+          monitor.synchronized {
+            monitor.notifyAll()
+          }
+          retry = false
+        }
+      }
+    }
+  }
+  @inline def wait4Notification(t: Object, offset: Long, cur: Long, ord: Int) = {
+    if (debug)
+      println(s"wait4Notification($t, $offset, $cur, $ord)")
+    var retry = true
+    while (retry) {
+      val cur = get(t, offset)
+      val state = STATE(cur, ord)
+      if (state == 1) CAS(t, offset, cur, 2, ord)
+      else if (state == 2) {
+        val monitor = getMonitor(t, ord)
+        monitor.synchronized {
+          monitor.wait()
+        }
+      }
+      else retry = false
+    }
+  }
+
+  @inline def compareAndSet(t: Object, off: Long, e: Long, v: Long) = unsafe.compareAndSwapLong(t, off, e, v)
+  @inline def get(t: Object, off: Long) = {
+    if (debug)
+      println(s"get($t, $off)")
+    unsafe.getLongVolatile(t, off)
+  }
+
+  val processors: Int = java.lang.Runtime.getRuntime.availableProcessors()
+  val base: Int = 8 * processors * processors
+  val monitors: Array[Object] = (0 to base).map {
+    x => new Object()
+  }.toArray
+
+  @inline def getMonitor(obj: Object, fieldId: Int = 0) = {
+    var id = (
+      /*java.lang.System.identityHashCode(obj) + */ // should be here, but #548
+      fieldId) % base
+
+    if (id < 0) id += base
+    monitors(id)
+  }
+
+  @inline def getOffset(clz: Class[_], name: String) = {
+    val r = unsafe.objectFieldOffset(clz.getDeclaredField(name))
+    if (debug)
+      println(s"getOffset($clz, $name) = $r")
+    r
+  }
+
+  object Names {
+    final val state = "STATE"
+    final val cas = "CAS"
+    final val setFlag = "setFlag"
+    final val wait4Notification = "wait4Notification"
+    final val compareAndSet = "compareAndSet"
+    final val get = "get"
+    final val getOffset = "getOffset"
+  }
+}
diff --git a/library/src/dotty/runtime/LegacyApp.scala b/library/src/dotty/runtime/LegacyApp.scala
new file mode 100644
index 000000000..2c4b295d0
--- /dev/null
+++ b/library/src/dotty/runtime/LegacyApp.scala
@@ -0,0 +1,9 @@
+package dotty.runtime
+
+
+/**
+ * replaces the `scala.App` class which relies on `DelayedInit` functionality, not supported by Dotty.
+ */
+class LegacyApp {
+  def main(args: Array[String]): Unit = ()
+}
diff --git a/library/src/dotty/runtime/vc/VCPrototype.scala b/library/src/dotty/runtime/vc/VCPrototype.scala
new file mode 100644
index 000000000..212046ef8
--- /dev/null
+++ b/library/src/dotty/runtime/vc/VCPrototype.scala
@@ -0,0 +1,486 @@
+package dotty.runtime.vc
+
+import scala.reflect.ClassTag
+
+abstract class VCPrototype {
+}
+
+
+abstract class VCArrayPrototype[T <: VCPrototype] extends Object with Cloneable {
+  def apply(idx: Int): Object
+  def update(idx: Int, el: T): Unit
+  def length: Int
+  override def clone(): Object = super.clone()
+}
+
+
+abstract class VCFloatPrototype(val underlying: Float) extends VCPrototype {}
+
+abstract class VCFloatCasePrototype(underlying: Float) extends VCFloatPrototype(underlying) with Product1[Float] {
+
+  final def _1: Float = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCFloatCompanion[T <: VCFloatPrototype] extends ClassTag[T] {
+  def box(underlying: Float): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCFloatArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Float)       = underlying
+  final def hashCode$extension(underlying: Float) = underlying.hashCode()
+  final def toString$extension(underlying: Float) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Float): String
+}
+
+final class VCFloatArray[T <: VCFloatPrototype] private (val arr: Array[Float], val ct: VCFloatCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCFloatCompanion[T], sz: Int) =
+    this(new Array[Float](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+  def length: Int = arr.length
+
+  override def clone(): VCFloatArray[T] = {
+    new VCFloatArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCObjectPrototype(val underlying: Object) extends VCPrototype {}
+
+abstract class VCObjectCasePrototype(underlying: Object) extends VCObjectPrototype(underlying) with Product1[Object] {
+
+  final def _1: Object = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCObjectCompanion[T <: VCObjectPrototype] extends ClassTag[T] {
+  def box(underlying: Object): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCObjectArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Object)       = underlying
+  final def hashCode$extension(underlying: Object) = underlying.hashCode()
+  final def toString$extension(underlying: Object) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Object): String
+}
+
+final class VCObjectArray[T <: VCObjectPrototype] private (val arr: Array[Object], val ct: VCObjectCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCObjectCompanion[T], sz: Int) =
+    this(new Array[Object](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+
+  def length: Int = arr.length
+
+  override def clone(): VCObjectArray[T] = {
+    new VCObjectArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCShortPrototype(val underlying: Short) extends VCPrototype {}
+
+abstract class VCShortCasePrototype(underlying: Short) extends VCShortPrototype(underlying) with Product1[Short] {
+
+  final def _1: Short = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCShortCompanion[T <: VCShortPrototype] extends ClassTag[T] {
+  def box(underlying: Short): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCShortArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Short)       = underlying
+  final def hashCode$extension(underlying: Short) = underlying.hashCode()
+  final def toString$extension(underlying: Short) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Short): String
+}
+
+final class VCShortArray[T <: VCShortPrototype] private (val arr: Array[Short], val ct: VCShortCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCShortCompanion[T], sz: Int) =
+    this(new Array[Short](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+
+  def length: Int = arr.length
+
+  override def clone(): VCShortArray[T] = {
+    new VCShortArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+
+}
+
+
+abstract class VCLongPrototype(val underlying: Long) extends VCPrototype {}
+
+abstract class VCLongCasePrototype(underlying: Long) extends VCLongPrototype(underlying) with Product1[Long] {
+
+  final def _1: Long = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCLongCompanion[T <: VCLongPrototype] extends ClassTag[T] {
+  def box(underlying: Long): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCLongArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Long)       = underlying
+  final def hashCode$extension(underlying: Long) = underlying.hashCode()
+  final def toString$extension(underlying: Long) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Long): String
+}
+
+final class VCLongArray[T <: VCLongPrototype] private (val arr: Array[Long], val ct: VCLongCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCLongCompanion[T], sz: Int) =
+    this(new Array[Long](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+
+  def length: Int = arr.length
+
+  override def clone(): VCLongArray[T] = {
+    new VCLongArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCIntPrototype(val underlying: Int) extends VCPrototype {}
+
+abstract class VCIntCasePrototype(underlying: Int) extends VCIntPrototype(underlying) with Product1[Int] {
+
+  final def _1: Int = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCIntCompanion[T <: VCIntPrototype] extends ClassTag[T] {
+  def box(underlying: Int): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCIntArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Int)       = underlying
+  final def hashCode$extension(underlying: Int) = underlying.hashCode()
+  final def toString$extension(underlying: Int) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Int): String
+}
+
+final class VCIntArray[T <: VCIntPrototype] private (val arr: Array[Int], val ct: VCIntCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCIntCompanion[T], sz: Int) =
+    this(new Array[Int](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+  def length: Int = arr.length
+
+  override def clone(): VCIntArray[T] = {
+    new VCIntArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCDoublePrototype(val underlying: Double) extends VCPrototype {}
+
+abstract class VCDoubleCasePrototype(underlying: Double) extends VCDoublePrototype(underlying) with Product1[Double] {
+
+  final def _1: Double = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCDoubleCompanion[T <: VCDoublePrototype] extends ClassTag[T] {
+  def box(underlying: Double): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCDoubleArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Double)       = underlying
+  final def hashCode$extension(underlying: Double) = underlying.hashCode()
+  final def toString$extension(underlying: Double) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Double): String
+}
+
+final class VCDoubleArray[T <: VCDoublePrototype] private (val arr: Array[Double], val ct: VCDoubleCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCDoubleCompanion[T], sz: Int) =
+    this(new Array[Double](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+  def length: Int = arr.length
+
+  override def clone(): VCDoubleArray[T] = {
+    new VCDoubleArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCBooleanPrototype(val underlying: Boolean) extends VCPrototype {}
+
+abstract class VCBooleanCasePrototype(underlying: Boolean) extends VCBooleanPrototype(underlying) with Product1[Boolean] {
+
+  final def _1: Boolean = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCBooleanCompanion[T <: VCBooleanPrototype] extends ClassTag[T] {
+  def box(underlying: Boolean): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCBooleanArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Boolean)       = underlying
+  final def hashCode$extension(underlying: Boolean) = underlying.hashCode()
+  final def toString$extension(underlying: Boolean) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Boolean): String
+}
+
+final class VCBooleanArray[T <: VCBooleanPrototype] private (val arr: Array[Boolean], val ct: VCBooleanCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCBooleanCompanion[T], sz: Int) =
+    this(new Array[Boolean](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+
+  def length: Int = arr.length
+
+  override def clone(): VCBooleanArray[T] = {
+    new VCBooleanArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCCharPrototype(val underlying: Char) extends VCPrototype {}
+
+abstract class VCCharCasePrototype(underlying: Char) extends VCCharPrototype(underlying) with Product1[Char] {
+
+  final def _1: Char = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+
+  // subclasses are expected to implement equals, productPrefix, and canEqual
+}
+
+abstract class VCCharCompanion[T <: VCCharPrototype] extends ClassTag[T] {
+  def box(underlying: Char): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCCharArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Char)       = underlying
+  final def hashCode$extension(underlying: Char) = underlying.hashCode()
+  final def toString$extension(underlying: Char) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Char): String
+}
+
+final class VCCharArray[T <: VCCharPrototype] private (val arr: Array[Char], val ct: VCCharCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCCharCompanion[T], sz: Int) =
+    this(new Array[Char](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+  def length: Int = arr.length
+
+  override def clone(): VCCharArray[T] = {
+    new VCCharArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+}
+
+
+abstract class VCBytePrototype(val underlying: Byte) extends VCPrototype {}
+
+abstract class VCByteCasePrototype(underlying: Byte) extends VCBytePrototype(underlying) with Product1[Byte] {
+
+  final def _1: Byte = underlying
+
+  override final def hashCode(): Int = {
+    underlying.hashCode()
+  }
+
+  override final def toString: String = {
+    s"$productPrefix($underlying)"
+  }
+}
+
+abstract class VCByteCompanion[T <: VCBytePrototype] extends ClassTag[T] {
+  def box(underlying: Byte): T
+  final def unbox(boxed: T) = boxed.underlying
+
+  implicit def classTag: this.type = this
+  override def newArray(len: Int): Array[T] =
+    new VCByteArray(this, len).asInstanceOf[Array[T]]
+
+
+  final def _1$extension(underlying: Byte)       = underlying
+  final def hashCode$extension(underlying: Byte) = underlying.hashCode()
+  final def toString$extension(underlying: Byte) = s"${productPrefix$extension(underlying)}($underlying)"
+  def productPrefix$extension(underlying: Byte): String
+}
+
+final class VCByteArray[T <: VCBytePrototype] private (val arr: Array[Byte], val ct: VCByteCompanion[T])
+  extends VCArrayPrototype[T] {
+  def this(ct: VCByteCompanion[T], sz: Int) =
+    this(new Array[Byte](sz), ct)
+
+  def apply(idx: Int) =
+    ct.box(arr(idx))
+  def update(idx: Int, elem: T) =
+    arr(idx) = ct.unbox(elem)
+  def length: Int = arr.length
+
+  override def clone(): VCByteArray[T] = {
+    new VCByteArray[T](arr.clone(), ct)
+  }
+
+  override def toString: String = {
+    "[" + ct.runtimeClass
+  }
+
+}
+
diff --git a/library/src/scala/Eq.scala b/library/src/scala/Eq.scala
new file mode 100644
index 000000000..d6d617cab
--- /dev/null
+++ b/library/src/scala/Eq.scala
@@ -0,0 +1,14 @@
+package scala
+
+import annotation.implicitNotFound
+
+/** A marker trait indicating that values of type `L` can be compared to values of type `R`. */
+@implicitNotFound("Values of types ${L} and ${R} cannot be compared with == or !=")
+sealed trait Eq[-L, -R]
+
+/** Besides being a companion object, this object
+ *  can also be used as a value that's compatible with
+ *  any instance of `Eq`.
+ */
+object Eq extends Eq[Any, Any]
+
diff --git a/library/src/scala/Function23.scala b/library/src/scala/Function23.scala
new file mode 100644
index 000000000..254772d53
--- /dev/null
+++ b/library/src/scala/Function23.scala
@@ -0,0 +1,21 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala
+
+
+/** A function of 23 parameters. Used as a temporary fix until arity limit is dropped.
+ *
+ */
+trait Function23[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, -T23, +R] extends AnyRef { self =>
+  /** Apply the body of this function to the arguments.
+   *  @return   the result of function application.
+   */
+  def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22, v23: T23): R
+
+  override def toString() = "<function23>"
+}
diff --git a/library/src/scala/Function24.scala b/library/src/scala/Function24.scala
new file mode 100644
index 000000000..8af8ed995
--- /dev/null
+++ b/library/src/scala/Function24.scala
@@ -0,0 +1,21 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala
+
+
+/** A function of 24 parameters. Used as a temporary fix until arity limit is dropped.
+ *
+ */
+trait Function24[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, -T23, -T24, +R] extends AnyRef { self =>
+  /** Apply the body of this function to the arguments.
+   *  @return   the result of function application.
+   */
+  def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22, v23: T23, v24: T24): R
+
+  override def toString() = "<function24>"
+}
diff --git a/library/src/scala/Function25.scala b/library/src/scala/Function25.scala
new file mode 100644
index 000000000..6df740b5b
--- /dev/null
+++ b/library/src/scala/Function25.scala
@@ -0,0 +1,21 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala
+
+
+/** A function of 25 parameters. Used as a temporary fix until arity limit is dropped.
+ *
+ */
+trait Function25[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, -T23, -T24, -T25, +R] extends AnyRef { self =>
+  /** Apply the body of this function to the arguments.
+   *  @return   the result of function application.
+   */
+  def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22, v23: T23, v24: T24, v25: T25): R
+
+  override def toString() = "<function25>"
+}
diff --git a/library/src/scala/Function26.scala b/library/src/scala/Function26.scala
new file mode 100644
index 000000000..5daccb6f0
--- /dev/null
+++ b/library/src/scala/Function26.scala
@@ -0,0 +1,20 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala
+
+/** A function of 26 parameters. Used as a temporary fix until arity limit is dropped.
+ *
+ */
+trait Function26[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, -T23, -T24, -T25, -T26, +R] extends AnyRef { self =>
+  /** Apply the body of this function to the arguments.
+   *  @return   the result of function application.
+   */
+  def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22, v23: T23, v24: T24, v25: T25, v26: T26): R
+
+  override def toString() = "<function26>"
+}
diff --git a/library/src/scala/Function27.scala b/library/src/scala/Function27.scala
new file mode 100644
index 000000000..daebd3ed4
--- /dev/null
+++ b/library/src/scala/Function27.scala
@@ -0,0 +1,20 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala
+
+/** A function of 27 parameters. Used as a temporary fix until arity limit is dropped.
+ *
+ */
+trait Function27[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, -T23, -T24, -T25, -T26, -T27, +R] extends AnyRef { self =>
+  /** Apply the body of this function to the arguments.
+   *  @return   the result of function application.
+   */
+  def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22, v23: T23, v24: T24, v25: T25, v26: T26, v27: T27): R
+
+  override def toString() = "<function27>"
+}
diff --git a/library/src/scala/Function28.scala b/library/src/scala/Function28.scala
new file mode 100644
index 000000000..82912caea
--- /dev/null
+++ b/library/src/scala/Function28.scala
@@ -0,0 +1,20 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala
+
+/** A function of 28 parameters. Used as a temporary fix until arity limit is dropped.
+ *
+ */
+trait Function28[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, -T23, -T24, -T25, -T26, -T27, -T28, +R] extends AnyRef { self =>
+  /** Apply the body of this function to the arguments.
+   *  @return   the result of function application.
+   */
+  def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22, v23: T23, v24: T24, v25: T25, v26: T26, v27: T27, v28: T28): R
+
+  override def toString() = "<function28>"
+}
diff --git a/library/src/scala/Function29.scala b/library/src/scala/Function29.scala
new file mode 100644
index 000000000..6dabf2051
--- /dev/null
+++ b/library/src/scala/Function29.scala
@@ -0,0 +1,20 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala
+
+/** A function of 29 parameters. Used as a temporary fix until arity limit is dropped.
+ *
+ */
+trait Function29[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, -T23, -T24, -T25, -T26, -T27, -T28, -T29, +R] extends AnyRef { self =>
+  /** Apply the body of this function to the arguments.
+   *  @return   the result of function application.
+   */
+  def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22, v23: T23, v24: T24, v25: T25, v26: T26, v27: T27, v28: T28, v29: T29): R
+
+  override def toString() = "<function29>"
+}
diff --git a/library/src/scala/Function30.scala b/library/src/scala/Function30.scala
new file mode 100644
index 000000000..20fd970dd
--- /dev/null
+++ b/library/src/scala/Function30.scala
@@ -0,0 +1,20 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala
+
+/** A function of 30 parameters. Used as a temporary fix until arity limit is dropped.
+ *
+ */
+trait Function30[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, -T23, -T24, -T25, -T26, -T27, -T28, -T29, -T30, +R] extends AnyRef { self =>
+  /** Apply the body of this function to the arguments.
+   *  @return   the result of function application.
+   */
+  def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22, v23: T23, v24: T24, v25: T25, v26: T26, v27: T27, v28: T28, v29: T29, v30: T30): R
+
+  override def toString() = "<function30>"
+}
diff --git a/library/src/scala/Product0.scala b/library/src/scala/Product0.scala
new file mode 100644
index 000000000..d50721d02
--- /dev/null
+++ b/library/src/scala/Product0.scala
@@ -0,0 +1,23 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+package scala
+
+/** A class for Product0 which was missing from the scala distribution. */
+object Product0 {
+  def unapply(x: Product0): Option[Product0] =
+    Some(x)
+}
+
+trait Product0 extends Any with Product {
+
+  override def productArity = 0
+
+  @throws(classOf[IndexOutOfBoundsException])
+  override def productElement(n: Int) =
+    throw new IndexOutOfBoundsException(n.toString())
+}
diff --git a/library/src/scala/annotation/internal/Alias.scala b/library/src/scala/annotation/internal/Alias.scala
new file mode 100644
index 000000000..e3f56e70c
--- /dev/null
+++ b/library/src/scala/annotation/internal/Alias.scala
@@ -0,0 +1,10 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** An annotation to record a Scala2 pickled alias.
+ *  @param aliased  A TermRef pointing to the aliased field.
+ */
+class Alias(aliased: Any) extends Annotation {
+
+}
diff --git a/library/src/scala/annotation/internal/AnnotationDefault.scala b/library/src/scala/annotation/internal/AnnotationDefault.scala
new file mode 100644
index 000000000..5280d091c
--- /dev/null
+++ b/library/src/scala/annotation/internal/AnnotationDefault.scala
@@ -0,0 +1,8 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** An annotation to tag Java annotation default values */
+class AnnotationDefault extends Annotation {
+
+}
diff --git a/library/src/scala/annotation/internal/Body.scala b/library/src/scala/annotation/internal/Body.scala
new file mode 100644
index 000000000..b6aa0c0fb
--- /dev/null
+++ b/library/src/scala/annotation/internal/Body.scala
@@ -0,0 +1,8 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** The class associated with a `BodyAnnotation`, which indicates
+ *  an inline method's right hand side
+ */
+final class Body() extends Annotation
diff --git a/library/src/scala/annotation/internal/Child.scala b/library/src/scala/annotation/internal/Child.scala
new file mode 100644
index 000000000..c90871945
--- /dev/null
+++ b/library/src/scala/annotation/internal/Child.scala
@@ -0,0 +1,16 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** An annotation to indicate a child class or object of the annotated class.
+ *  E.g. if we have
+ *
+ *    sealed class A
+ *    case class B() extends A
+ *    case class C() extends A
+ *
+ *  Then the class symbol `A` would carry the annotations
+ *  `@Child[Bref] @Child[Cref]` where `Bref`, `Cref` are TypeRefs
+ *  referring to the class symbols of `B` and `C`
+ */
+class Child[T] extends Annotation
diff --git a/library/src/scala/annotation/internal/InlineParam.scala b/library/src/scala/annotation/internal/InlineParam.scala
new file mode 100644
index 000000000..0b3649e89
--- /dev/null
+++ b/library/src/scala/annotation/internal/InlineParam.scala
@@ -0,0 +1,6 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** An annotation produced by Namer to indicate an inline parameter */
+final class InlineParam() extends Annotation
diff --git a/library/src/scala/annotation/internal/Repeated.scala b/library/src/scala/annotation/internal/Repeated.scala
new file mode 100644
index 000000000..75eb3bc25
--- /dev/null
+++ b/library/src/scala/annotation/internal/Repeated.scala
@@ -0,0 +1,10 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** An annotation produced by desugaring to indicate that a
+ *  sequence is a repeated parameter. I.e.
+ *
+ *      T*  is expanded by Desugar to    Seq[T] @Repeated
+ */
+final class Repeated() extends Annotation
diff --git a/library/src/scala/annotation/internal/SourceFile.scala b/library/src/scala/annotation/internal/SourceFile.scala
new file mode 100644
index 000000000..b203869cf
--- /dev/null
+++ b/library/src/scala/annotation/internal/SourceFile.scala
@@ -0,0 +1,10 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** An annotation to record a Scala2 pickled alias.
+ *  @param aliased  A TermRef pointing to the aliased field.
+ */
+class SourceFile(path: String) extends Annotation {
+
+}
diff --git a/library/src/scala/annotation/internal/TASTYLongSignature.java b/library/src/scala/annotation/internal/TASTYLongSignature.java
new file mode 100644
index 000000000..2278da258
--- /dev/null
+++ b/library/src/scala/annotation/internal/TASTYLongSignature.java
@@ -0,0 +1,12 @@
+package scala.annotation.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface TASTYLongSignature {
+    public String[] bytes();
+}
diff --git a/library/src/scala/annotation/internal/TASTYSignature.java b/library/src/scala/annotation/internal/TASTYSignature.java
new file mode 100644
index 000000000..a6372f008
--- /dev/null
+++ b/library/src/scala/annotation/internal/TASTYSignature.java
@@ -0,0 +1,12 @@
+package scala.annotation.internal;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface TASTYSignature {
+    public String bytes();
+}
diff --git a/library/src/scala/annotation/internal/UnsafeNonvariant.scala b/library/src/scala/annotation/internal/UnsafeNonvariant.scala
new file mode 100644
index 000000000..b33df65d6
--- /dev/null
+++ b/library/src/scala/annotation/internal/UnsafeNonvariant.scala
@@ -0,0 +1,8 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** This annotation is used as a marker for unsafe
+ *  instantiations in asSeenFrom. See TypeOps.asSeenfrom for an explanation.
+ */
+class UnsafeNonvariant extends Annotation
diff --git a/library/src/scala/annotation/static.scala b/library/src/scala/annotation/static.scala
new file mode 100644
index 000000000..b00072b18
--- /dev/null
+++ b/library/src/scala/annotation/static.scala
@@ -0,0 +1,13 @@
+package scala.annotation
+
+import scala.annotation.meta._
+
+/** https://github.com/scala/scala.github.com/pull/491 */
+
+@field
+@getter
+@beanGetter
+@beanSetter
+@param
+@setter
+final class static extends StaticAnnotation
diff --git a/library/src/scala/compat/java8/JFunction.java b/library/src/scala/compat/java8/JFunction.java
new file mode 100644
index 000000000..d68805d08
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction.java
@@ -0,0 +1,233 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+public final class JFunction {
+    private JFunction() {}
+    public static <R> scala.Function0<R> func(JFunction0<R> f) { return f; }
+    public static scala.Function0<BoxedUnit> proc(JProcedure0 p) { return p; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function0<BoxedUnit> procSpecialized(JFunction0$mcV$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function0<Byte> funcSpecialized(JFunction0$mcB$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function0<Short> funcSpecialized(JFunction0$mcS$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function0<Integer> funcSpecialized(JFunction0$mcI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function0<Long> funcSpecialized(JFunction0$mcJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function0<Character> funcSpecialized(JFunction0$mcC$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function0<Float> funcSpecialized(JFunction0$mcF$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function0<Double> funcSpecialized(JFunction0$mcD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function0<Boolean> funcSpecialized(JFunction0$mcZ$sp f) { return f; }
+    public static <T1, R> scala.Function1<T1, R> func(JFunction1<T1, R> f) { return f; }
+    public static <T1> scala.Function1<T1, BoxedUnit> proc(JProcedure1<T1> p) { return p; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Integer, BoxedUnit> procSpecialized(JFunction1$mcVI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Integer, Boolean> funcSpecialized(JFunction1$mcZI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Integer, Integer> funcSpecialized(JFunction1$mcII$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Integer, Float> funcSpecialized(JFunction1$mcFI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Integer, Long> funcSpecialized(JFunction1$mcJI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Integer, Double> funcSpecialized(JFunction1$mcDI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Long, BoxedUnit> procSpecialized(JFunction1$mcVJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Long, Boolean> funcSpecialized(JFunction1$mcZJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Long, Integer> funcSpecialized(JFunction1$mcIJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Long, Float> funcSpecialized(JFunction1$mcFJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Long, Long> funcSpecialized(JFunction1$mcJJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Long, Double> funcSpecialized(JFunction1$mcDJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Float, BoxedUnit> procSpecialized(JFunction1$mcVF$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Float, Boolean> funcSpecialized(JFunction1$mcZF$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Float, Integer> funcSpecialized(JFunction1$mcIF$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Float, Float> funcSpecialized(JFunction1$mcFF$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Float, Long> funcSpecialized(JFunction1$mcJF$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Float, Double> funcSpecialized(JFunction1$mcDF$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Double, BoxedUnit> procSpecialized(JFunction1$mcVD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Double, Boolean> funcSpecialized(JFunction1$mcZD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Double, Integer> funcSpecialized(JFunction1$mcID$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Double, Float> funcSpecialized(JFunction1$mcFD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Double, Long> funcSpecialized(JFunction1$mcJD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function1<Double, Double> funcSpecialized(JFunction1$mcDD$sp f) { return f; }
+    public static <T1, T2, R> scala.Function2<T1, T2, R> func(JFunction2<T1, T2, R> f) { return f; }
+    public static <T1, T2> scala.Function2<T1, T2, BoxedUnit> proc(JProcedure2<T1, T2> p) { return p; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Integer, BoxedUnit> procSpecialized(JFunction2$mcVII$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Integer, Boolean> funcSpecialized(JFunction2$mcZII$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Integer, Integer> funcSpecialized(JFunction2$mcIII$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Integer, Float> funcSpecialized(JFunction2$mcFII$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Integer, Long> funcSpecialized(JFunction2$mcJII$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Integer, Double> funcSpecialized(JFunction2$mcDII$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Long, BoxedUnit> procSpecialized(JFunction2$mcVIJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Long, Boolean> funcSpecialized(JFunction2$mcZIJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Long, Integer> funcSpecialized(JFunction2$mcIIJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Long, Float> funcSpecialized(JFunction2$mcFIJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Long, Long> funcSpecialized(JFunction2$mcJIJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Long, Double> funcSpecialized(JFunction2$mcDIJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Double, BoxedUnit> procSpecialized(JFunction2$mcVID$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Double, Boolean> funcSpecialized(JFunction2$mcZID$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Double, Integer> funcSpecialized(JFunction2$mcIID$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Double, Float> funcSpecialized(JFunction2$mcFID$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Double, Long> funcSpecialized(JFunction2$mcJID$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Integer, Double, Double> funcSpecialized(JFunction2$mcDID$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Integer, BoxedUnit> procSpecialized(JFunction2$mcVJI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Integer, Boolean> funcSpecialized(JFunction2$mcZJI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Integer, Integer> funcSpecialized(JFunction2$mcIJI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Integer, Float> funcSpecialized(JFunction2$mcFJI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Integer, Long> funcSpecialized(JFunction2$mcJJI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Integer, Double> funcSpecialized(JFunction2$mcDJI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Long, BoxedUnit> procSpecialized(JFunction2$mcVJJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Long, Boolean> funcSpecialized(JFunction2$mcZJJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Long, Integer> funcSpecialized(JFunction2$mcIJJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Long, Float> funcSpecialized(JFunction2$mcFJJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Long, Long> funcSpecialized(JFunction2$mcJJJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Long, Double> funcSpecialized(JFunction2$mcDJJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Double, BoxedUnit> procSpecialized(JFunction2$mcVJD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Double, Boolean> funcSpecialized(JFunction2$mcZJD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Double, Integer> funcSpecialized(JFunction2$mcIJD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Double, Float> funcSpecialized(JFunction2$mcFJD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Double, Long> funcSpecialized(JFunction2$mcJJD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Long, Double, Double> funcSpecialized(JFunction2$mcDJD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Integer, BoxedUnit> procSpecialized(JFunction2$mcVDI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Integer, Boolean> funcSpecialized(JFunction2$mcZDI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Integer, Integer> funcSpecialized(JFunction2$mcIDI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Integer, Float> funcSpecialized(JFunction2$mcFDI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Integer, Long> funcSpecialized(JFunction2$mcJDI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Integer, Double> funcSpecialized(JFunction2$mcDDI$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Long, BoxedUnit> procSpecialized(JFunction2$mcVDJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Long, Boolean> funcSpecialized(JFunction2$mcZDJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Long, Integer> funcSpecialized(JFunction2$mcIDJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Long, Float> funcSpecialized(JFunction2$mcFDJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Long, Long> funcSpecialized(JFunction2$mcJDJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Long, Double> funcSpecialized(JFunction2$mcDDJ$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Double, BoxedUnit> procSpecialized(JFunction2$mcVDD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Double, Boolean> funcSpecialized(JFunction2$mcZDD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Double, Integer> funcSpecialized(JFunction2$mcIDD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Double, Float> funcSpecialized(JFunction2$mcFDD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Double, Long> funcSpecialized(JFunction2$mcJDD$sp f) { return f; }
+    @SuppressWarnings("unchecked")
+    public static scala.Function2<Double, Double, Double> funcSpecialized(JFunction2$mcDDD$sp f) { return f; }
+    public static <T1, T2, T3, R> scala.Function3<T1, T2, T3, R> func(JFunction3<T1, T2, T3, R> f) { return f; }
+    public static <T1, T2, T3> scala.Function3<T1, T2, T3, BoxedUnit> proc(JProcedure3<T1, T2, T3> p) { return p; }
+    public static <T1, T2, T3, T4, R> scala.Function4<T1, T2, T3, T4, R> func(JFunction4<T1, T2, T3, T4, R> f) { return f; }
+    public static <T1, T2, T3, T4> scala.Function4<T1, T2, T3, T4, BoxedUnit> proc(JProcedure4<T1, T2, T3, T4> p) { return p; }
+    public static <T1, T2, T3, T4, T5, R> scala.Function5<T1, T2, T3, T4, T5, R> func(JFunction5<T1, T2, T3, T4, T5, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5> scala.Function5<T1, T2, T3, T4, T5, BoxedUnit> proc(JProcedure5<T1, T2, T3, T4, T5> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, R> scala.Function6<T1, T2, T3, T4, T5, T6, R> func(JFunction6<T1, T2, T3, T4, T5, T6, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6> scala.Function6<T1, T2, T3, T4, T5, T6, BoxedUnit> proc(JProcedure6<T1, T2, T3, T4, T5, T6> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, R> scala.Function7<T1, T2, T3, T4, T5, T6, T7, R> func(JFunction7<T1, T2, T3, T4, T5, T6, T7, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7> scala.Function7<T1, T2, T3, T4, T5, T6, T7, BoxedUnit> proc(JProcedure7<T1, T2, T3, T4, T5, T6, T7> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, R> scala.Function8<T1, T2, T3, T4, T5, T6, T7, T8, R> func(JFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8> scala.Function8<T1, T2, T3, T4, T5, T6, T7, T8, BoxedUnit> proc(JProcedure8<T1, T2, T3, T4, T5, T6, T7, T8> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, R> scala.Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> func(JFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9> scala.Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, BoxedUnit> proc(JProcedure9<T1, T2, T3, T4, T5, T6, T7, T8, T9> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> scala.Function10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> func(JFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> scala.Function10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, BoxedUnit> proc(JProcedure10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> scala.Function11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> func(JFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> scala.Function11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, BoxedUnit> proc(JProcedure11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> scala.Function12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> func(JFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> scala.Function12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, BoxedUnit> proc(JProcedure12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> scala.Function13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> func(JFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> scala.Function13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, BoxedUnit> proc(JProcedure13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> scala.Function14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> func(JFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> scala.Function14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, BoxedUnit> proc(JProcedure14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> scala.Function15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> func(JFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> scala.Function15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, BoxedUnit> proc(JProcedure15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> scala.Function16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> func(JFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> scala.Function16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, BoxedUnit> proc(JProcedure16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> scala.Function17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> func(JFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> scala.Function17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, BoxedUnit> proc(JProcedure17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> scala.Function18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> func(JFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> scala.Function18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, BoxedUnit> proc(JProcedure18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> scala.Function19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> func(JFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> scala.Function19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, BoxedUnit> proc(JProcedure19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> scala.Function20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> func(JFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> scala.Function20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, BoxedUnit> proc(JProcedure20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> scala.Function21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> func(JFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> scala.Function21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, BoxedUnit> proc(JProcedure21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> p) { return p; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> scala.Function22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> func(JFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> f) { return f; }
+    public static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> scala.Function22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, BoxedUnit> proc(JProcedure22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> p) { return p; }
+}
+
diff --git a/library/src/scala/compat/java8/JFunction0$mcB$sp.java b/library/src/scala/compat/java8/JFunction0$mcB$sp.java
new file mode 100644
index 000000000..354667b63
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction0$mcB$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction0$mcB$sp extends JFunction0 {
+    abstract byte apply$mcB$sp();
+
+    default Object apply() { return (Byte) apply$mcB$sp(); }
+}
diff --git a/library/src/scala/compat/java8/JFunction0$mcC$sp.java b/library/src/scala/compat/java8/JFunction0$mcC$sp.java
new file mode 100644
index 000000000..85c1d25e8
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction0$mcC$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction0$mcC$sp extends JFunction0 {
+    abstract char apply$mcC$sp();
+
+    default Object apply() { return (Character) apply$mcC$sp(); }
+}
diff --git a/library/src/scala/compat/java8/JFunction0$mcD$sp.java b/library/src/scala/compat/java8/JFunction0$mcD$sp.java
new file mode 100644
index 000000000..e430cddd7
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction0$mcD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction0$mcD$sp extends JFunction0 {
+    abstract double apply$mcD$sp();
+
+    default Object apply() { return (Double) apply$mcD$sp(); }
+}
diff --git a/library/src/scala/compat/java8/JFunction0$mcF$sp.java b/library/src/scala/compat/java8/JFunction0$mcF$sp.java
new file mode 100644
index 000000000..e839d1edf
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction0$mcF$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction0$mcF$sp extends JFunction0 {
+    abstract float apply$mcF$sp();
+
+    default Object apply() { return (Float) apply$mcF$sp(); }
+}
diff --git a/library/src/scala/compat/java8/JFunction0$mcI$sp.java b/library/src/scala/compat/java8/JFunction0$mcI$sp.java
new file mode 100644
index 000000000..6d592a41e
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction0$mcI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction0$mcI$sp extends JFunction0 {
+    abstract int apply$mcI$sp();
+
+    default Object apply() { return (Integer) apply$mcI$sp(); }
+}
diff --git a/library/src/scala/compat/java8/JFunction0$mcJ$sp.java b/library/src/scala/compat/java8/JFunction0$mcJ$sp.java
new file mode 100644
index 000000000..8347b0df1
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction0$mcJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction0$mcJ$sp extends JFunction0 {
+    abstract long apply$mcJ$sp();
+
+    default Object apply() { return (Long) apply$mcJ$sp(); }
+}
diff --git a/library/src/scala/compat/java8/JFunction0$mcS$sp.java b/library/src/scala/compat/java8/JFunction0$mcS$sp.java
new file mode 100644
index 000000000..dede12cf1
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction0$mcS$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction0$mcS$sp extends JFunction0 {
+    abstract short apply$mcS$sp();
+
+    default Object apply() { return (Short) apply$mcS$sp(); }
+}
diff --git a/library/src/scala/compat/java8/JFunction0$mcV$sp.java b/library/src/scala/compat/java8/JFunction0$mcV$sp.java
new file mode 100644
index 000000000..933c9a28a
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction0$mcV$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction0$mcV$sp extends JFunction0 {
+    abstract void apply$mcV$sp();
+
+    default Object apply() { apply$mcV$sp(); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction0$mcZ$sp.java b/library/src/scala/compat/java8/JFunction0$mcZ$sp.java
new file mode 100644
index 000000000..c51141b00
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction0$mcZ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction0$mcZ$sp extends JFunction0 {
+    abstract boolean apply$mcZ$sp();
+
+    default Object apply() { return (Boolean) apply$mcZ$sp(); }
+}
diff --git a/library/src/scala/compat/java8/JFunction0.java b/library/src/scala/compat/java8/JFunction0.java
new file mode 100644
index 000000000..e1c6f364a
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction0.java
@@ -0,0 +1,39 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction0<R> extends scala.Function0<R> {
+    default void $init$() {
+    };
+    default void apply$mcV$sp() {
+        apply();
+    }
+    default byte apply$mcB$sp() {
+        return (Byte) apply();
+    }
+    default short apply$mcS$sp() {
+        return (Short) apply();
+    }
+    default int apply$mcI$sp() {
+        return (Integer) apply();
+    }
+    default long apply$mcJ$sp() {
+        return (Long) apply();
+    }
+    default char apply$mcC$sp() {
+        return (Character) apply();
+    }
+    default float apply$mcF$sp() {
+        return (Float) apply();
+    }
+    default double apply$mcD$sp() {
+        return (Double) apply();
+    }
+    default boolean apply$mcZ$sp() {
+        return (Boolean) apply();
+    }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcDD$sp.java b/library/src/scala/compat/java8/JFunction1$mcDD$sp.java
new file mode 100644
index 000000000..cccdd3a44
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcDD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcDD$sp extends JFunction1 {
+    abstract double apply$mcDD$sp(double v1);
+
+    default Object apply(Object t) { return (Double) apply$mcDD$sp((Double) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcDF$sp.java b/library/src/scala/compat/java8/JFunction1$mcDF$sp.java
new file mode 100644
index 000000000..8c86f3585
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcDF$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcDF$sp extends JFunction1 {
+    abstract double apply$mcDF$sp(float v1);
+
+    default Object apply(Object t) { return (Double) apply$mcDF$sp((Float) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcDI$sp.java b/library/src/scala/compat/java8/JFunction1$mcDI$sp.java
new file mode 100644
index 000000000..4b2cf185b
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcDI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcDI$sp extends JFunction1 {
+    abstract double apply$mcDI$sp(int v1);
+
+    default Object apply(Object t) { return (Double) apply$mcDI$sp((Integer) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcDJ$sp.java b/library/src/scala/compat/java8/JFunction1$mcDJ$sp.java
new file mode 100644
index 000000000..24deff2dc
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcDJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcDJ$sp extends JFunction1 {
+    abstract double apply$mcDJ$sp(long v1);
+
+    default Object apply(Object t) { return (Double) apply$mcDJ$sp((Long) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcFD$sp.java b/library/src/scala/compat/java8/JFunction1$mcFD$sp.java
new file mode 100644
index 000000000..138120dbf
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcFD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcFD$sp extends JFunction1 {
+    abstract float apply$mcFD$sp(double v1);
+
+    default Object apply(Object t) { return (Float) apply$mcFD$sp((Double) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcFF$sp.java b/library/src/scala/compat/java8/JFunction1$mcFF$sp.java
new file mode 100644
index 000000000..ba6ef5e7e
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcFF$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcFF$sp extends JFunction1 {
+    abstract float apply$mcFF$sp(float v1);
+
+    default Object apply(Object t) { return (Float) apply$mcFF$sp((Float) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcFI$sp.java b/library/src/scala/compat/java8/JFunction1$mcFI$sp.java
new file mode 100644
index 000000000..f37b26527
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcFI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcFI$sp extends JFunction1 {
+    abstract float apply$mcFI$sp(int v1);
+
+    default Object apply(Object t) { return (Float) apply$mcFI$sp((Integer) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcFJ$sp.java b/library/src/scala/compat/java8/JFunction1$mcFJ$sp.java
new file mode 100644
index 000000000..fe697df45
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcFJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcFJ$sp extends JFunction1 {
+    abstract float apply$mcFJ$sp(long v1);
+
+    default Object apply(Object t) { return (Float) apply$mcFJ$sp((Long) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcID$sp.java b/library/src/scala/compat/java8/JFunction1$mcID$sp.java
new file mode 100644
index 000000000..4a8cae858
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcID$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcID$sp extends JFunction1 {
+    abstract int apply$mcID$sp(double v1);
+
+    default Object apply(Object t) { return (Integer) apply$mcID$sp((Double) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcIF$sp.java b/library/src/scala/compat/java8/JFunction1$mcIF$sp.java
new file mode 100644
index 000000000..38a262377
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcIF$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcIF$sp extends JFunction1 {
+    abstract int apply$mcIF$sp(float v1);
+
+    default Object apply(Object t) { return (Integer) apply$mcIF$sp((Float) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcII$sp.java b/library/src/scala/compat/java8/JFunction1$mcII$sp.java
new file mode 100644
index 000000000..14fce8afc
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcII$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcII$sp extends JFunction1 {
+    abstract int apply$mcII$sp(int v1);
+
+    default Object apply(Object t) { return (Integer) apply$mcII$sp((Integer) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcIJ$sp.java b/library/src/scala/compat/java8/JFunction1$mcIJ$sp.java
new file mode 100644
index 000000000..dd033736b
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcIJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcIJ$sp extends JFunction1 {
+    abstract int apply$mcIJ$sp(long v1);
+
+    default Object apply(Object t) { return (Integer) apply$mcIJ$sp((Long) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcJD$sp.java b/library/src/scala/compat/java8/JFunction1$mcJD$sp.java
new file mode 100644
index 000000000..9a9e37fca
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcJD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcJD$sp extends JFunction1 {
+    abstract long apply$mcJD$sp(double v1);
+
+    default Object apply(Object t) { return (Long) apply$mcJD$sp((Double) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcJF$sp.java b/library/src/scala/compat/java8/JFunction1$mcJF$sp.java
new file mode 100644
index 000000000..1dac4d5f2
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcJF$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcJF$sp extends JFunction1 {
+    abstract long apply$mcJF$sp(float v1);
+
+    default Object apply(Object t) { return (Long) apply$mcJF$sp((Float) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcJI$sp.java b/library/src/scala/compat/java8/JFunction1$mcJI$sp.java
new file mode 100644
index 000000000..a9dcc859d
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcJI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcJI$sp extends JFunction1 {
+    abstract long apply$mcJI$sp(int v1);
+
+    default Object apply(Object t) { return (Long) apply$mcJI$sp((Integer) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcJJ$sp.java b/library/src/scala/compat/java8/JFunction1$mcJJ$sp.java
new file mode 100644
index 000000000..8dfcdcd84
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcJJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcJJ$sp extends JFunction1 {
+    abstract long apply$mcJJ$sp(long v1);
+
+    default Object apply(Object t) { return (Long) apply$mcJJ$sp((Long) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcVD$sp.java b/library/src/scala/compat/java8/JFunction1$mcVD$sp.java
new file mode 100644
index 000000000..9ebd8cb12
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcVD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcVD$sp extends JFunction1 {
+    abstract void apply$mcVD$sp(double v1);
+
+    default Object apply(Object t) { apply$mcVD$sp((Double) t); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcVF$sp.java b/library/src/scala/compat/java8/JFunction1$mcVF$sp.java
new file mode 100644
index 000000000..663f16a10
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcVF$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcVF$sp extends JFunction1 {
+    abstract void apply$mcVF$sp(float v1);
+
+    default Object apply(Object t) { apply$mcVF$sp((Float) t); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcVI$sp.java b/library/src/scala/compat/java8/JFunction1$mcVI$sp.java
new file mode 100644
index 000000000..657973eb1
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcVI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcVI$sp extends JFunction1 {
+    abstract void apply$mcVI$sp(int v1);
+
+    default Object apply(Object t) { apply$mcVI$sp((Integer) t); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcVJ$sp.java b/library/src/scala/compat/java8/JFunction1$mcVJ$sp.java
new file mode 100644
index 000000000..123e8907f
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcVJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcVJ$sp extends JFunction1 {
+    abstract void apply$mcVJ$sp(long v1);
+
+    default Object apply(Object t) { apply$mcVJ$sp((Long) t); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcZD$sp.java b/library/src/scala/compat/java8/JFunction1$mcZD$sp.java
new file mode 100644
index 000000000..6928c3742
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcZD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcZD$sp extends JFunction1 {
+    abstract boolean apply$mcZD$sp(double v1);
+
+    default Object apply(Object t) { return (Boolean) apply$mcZD$sp((Double) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcZF$sp.java b/library/src/scala/compat/java8/JFunction1$mcZF$sp.java
new file mode 100644
index 000000000..2abc0a158
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcZF$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcZF$sp extends JFunction1 {
+    abstract boolean apply$mcZF$sp(float v1);
+
+    default Object apply(Object t) { return (Boolean) apply$mcZF$sp((Float) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcZI$sp.java b/library/src/scala/compat/java8/JFunction1$mcZI$sp.java
new file mode 100644
index 000000000..cdde336a4
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcZI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcZI$sp extends JFunction1 {
+    abstract boolean apply$mcZI$sp(int v1);
+
+    default Object apply(Object t) { return (Boolean) apply$mcZI$sp((Integer) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1$mcZJ$sp.java b/library/src/scala/compat/java8/JFunction1$mcZJ$sp.java
new file mode 100644
index 000000000..ce784542e
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1$mcZJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1$mcZJ$sp extends JFunction1 {
+    abstract boolean apply$mcZJ$sp(long v1);
+
+    default Object apply(Object t) { return (Boolean) apply$mcZJ$sp((Long) t); }
+}
diff --git a/library/src/scala/compat/java8/JFunction1.java b/library/src/scala/compat/java8/JFunction1.java
new file mode 100644
index 000000000..69176cdea
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction1.java
@@ -0,0 +1,314 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction1<T1, R> extends scala.Function1<T1, R> {
+    default void $init$() {
+    };
+
+    @Override
+    @SuppressWarnings("unchecked")
+    default <A> scala.Function1<T1, A> andThen(scala.Function1<R, A> g) {
+        return scala.Function1$class.andThen(this, g);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    default <A> scala.Function1<A, R> compose(scala.Function1<A, T1> g) {
+        return scala.Function1$class.compose(this, g);
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVI$sp(int v1) {
+        apply((T1) ((Integer) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZI$sp(int v1) {
+        return (Boolean) apply((T1) ((Integer) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcII$sp(int v1) {
+        return (Integer) apply((T1) ((Integer) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFI$sp(int v1) {
+        return (Float) apply((T1) ((Integer) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJI$sp(int v1) {
+        return (Long) apply((T1) ((Integer) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDI$sp(int v1) {
+        return (Double) apply((T1) ((Integer) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVJ$sp(long v1) {
+        apply((T1) ((Long) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZJ$sp(long v1) {
+        return (Boolean) apply((T1) ((Long) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIJ$sp(long v1) {
+        return (Integer) apply((T1) ((Long) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFJ$sp(long v1) {
+        return (Float) apply((T1) ((Long) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJJ$sp(long v1) {
+        return (Long) apply((T1) ((Long) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDJ$sp(long v1) {
+        return (Double) apply((T1) ((Long) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVF$sp(float v1) {
+        apply((T1) ((Float) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZF$sp(float v1) {
+        return (Boolean) apply((T1) ((Float) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIF$sp(float v1) {
+        return (Integer) apply((T1) ((Float) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFF$sp(float v1) {
+        return (Float) apply((T1) ((Float) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJF$sp(float v1) {
+        return (Long) apply((T1) ((Float) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDF$sp(float v1) {
+        return (Double) apply((T1) ((Float) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVD$sp(double v1) {
+        apply((T1) ((Double) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZD$sp(double v1) {
+        return (Boolean) apply((T1) ((Double) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcID$sp(double v1) {
+        return (Integer) apply((T1) ((Double) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFD$sp(double v1) {
+        return (Float) apply((T1) ((Double) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJD$sp(double v1) {
+        return (Long) apply((T1) ((Double) v1));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDD$sp(double v1) {
+        return (Double) apply((T1) ((Double) v1));
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcVI$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcZI$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcII$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcFI$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcJI$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcDI$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcVJ$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcZJ$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcIJ$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcFJ$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcJJ$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcDJ$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcVF$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcZF$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcIF$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcFF$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcJF$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcDF$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcVD$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcZD$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcID$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcFD$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcJD$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 compose$mcDD$sp(scala.Function1 g) {
+        return compose(g);
+    }
+    
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcVI$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcZI$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcII$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcFI$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcJI$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcDI$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcVJ$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcZJ$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcIJ$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcFJ$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcJJ$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcDJ$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcVF$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcZF$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcIF$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcFF$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcJF$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcDF$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcVD$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcZD$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcID$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcFD$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcJD$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 andThen$mcDD$sp(scala.Function1 g) {
+        return andThen(g);
+    }
+}
diff --git a/library/src/scala/compat/java8/JFunction10.java b/library/src/scala/compat/java8/JFunction10.java
new file mode 100644
index 000000000..8519ac223
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction10.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> extends scala.Function10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, R>>>>>>>>>> curried() {
+      return scala.Function10$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, R> tupled() {
+      return scala.Function10$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction11.java b/library/src/scala/compat/java8/JFunction11.java
new file mode 100644
index 000000000..032ee40af
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction11.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> extends scala.Function11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, R>>>>>>>>>>> curried() {
+      return scala.Function11$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, R> tupled() {
+      return scala.Function11$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction12.java b/library/src/scala/compat/java8/JFunction12.java
new file mode 100644
index 000000000..3f3eff492
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction12.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> extends scala.Function12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, R>>>>>>>>>>>> curried() {
+      return scala.Function12$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, R> tupled() {
+      return scala.Function12$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction13.java b/library/src/scala/compat/java8/JFunction13.java
new file mode 100644
index 000000000..2bed6ee97
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction13.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> extends scala.Function13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, scala.Function1<T13, R>>>>>>>>>>>>> curried() {
+      return scala.Function13$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, R> tupled() {
+      return scala.Function13$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction14.java b/library/src/scala/compat/java8/JFunction14.java
new file mode 100644
index 000000000..77fac237d
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction14.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> extends scala.Function14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, scala.Function1<T13, scala.Function1<T14, R>>>>>>>>>>>>>> curried() {
+      return scala.Function14$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>, R> tupled() {
+      return scala.Function14$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction15.java b/library/src/scala/compat/java8/JFunction15.java
new file mode 100644
index 000000000..25adc1679
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction15.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> extends scala.Function15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, scala.Function1<T13, scala.Function1<T14, scala.Function1<T15, R>>>>>>>>>>>>>>> curried() {
+      return scala.Function15$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>, R> tupled() {
+      return scala.Function15$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction16.java b/library/src/scala/compat/java8/JFunction16.java
new file mode 100644
index 000000000..fda1ea0c7
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction16.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> extends scala.Function16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, scala.Function1<T13, scala.Function1<T14, scala.Function1<T15, scala.Function1<T16, R>>>>>>>>>>>>>>>> curried() {
+      return scala.Function16$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>, R> tupled() {
+      return scala.Function16$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction17.java b/library/src/scala/compat/java8/JFunction17.java
new file mode 100644
index 000000000..89cb1b312
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction17.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> extends scala.Function17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, scala.Function1<T13, scala.Function1<T14, scala.Function1<T15, scala.Function1<T16, scala.Function1<T17, R>>>>>>>>>>>>>>>>> curried() {
+      return scala.Function17$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>, R> tupled() {
+      return scala.Function17$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction18.java b/library/src/scala/compat/java8/JFunction18.java
new file mode 100644
index 000000000..428cee961
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction18.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> extends scala.Function18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, scala.Function1<T13, scala.Function1<T14, scala.Function1<T15, scala.Function1<T16, scala.Function1<T17, scala.Function1<T18, R>>>>>>>>>>>>>>>>>> curried() {
+      return scala.Function18$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>, R> tupled() {
+      return scala.Function18$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction19.java b/library/src/scala/compat/java8/JFunction19.java
new file mode 100644
index 000000000..95e47df7e
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction19.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> extends scala.Function19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, scala.Function1<T13, scala.Function1<T14, scala.Function1<T15, scala.Function1<T16, scala.Function1<T17, scala.Function1<T18, scala.Function1<T19, R>>>>>>>>>>>>>>>>>>> curried() {
+      return scala.Function19$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>, R> tupled() {
+      return scala.Function19$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcDDD$sp.java b/library/src/scala/compat/java8/JFunction2$mcDDD$sp.java
new file mode 100644
index 000000000..2bb68e698
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcDDD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcDDD$sp extends JFunction2 {
+    abstract double apply$mcDDD$sp(double v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Double) apply$mcDDD$sp((Double) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcDDI$sp.java b/library/src/scala/compat/java8/JFunction2$mcDDI$sp.java
new file mode 100644
index 000000000..61e4d1b17
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcDDI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcDDI$sp extends JFunction2 {
+    abstract double apply$mcDDI$sp(double v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Double) apply$mcDDI$sp((Double) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcDDJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcDDJ$sp.java
new file mode 100644
index 000000000..aa8564960
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcDDJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcDDJ$sp extends JFunction2 {
+    abstract double apply$mcDDJ$sp(double v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Double) apply$mcDDJ$sp((Double) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcDID$sp.java b/library/src/scala/compat/java8/JFunction2$mcDID$sp.java
new file mode 100644
index 000000000..ba56c080c
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcDID$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcDID$sp extends JFunction2 {
+    abstract double apply$mcDID$sp(int v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Double) apply$mcDID$sp((Integer) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcDII$sp.java b/library/src/scala/compat/java8/JFunction2$mcDII$sp.java
new file mode 100644
index 000000000..ec7bc956b
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcDII$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcDII$sp extends JFunction2 {
+    abstract double apply$mcDII$sp(int v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Double) apply$mcDII$sp((Integer) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcDIJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcDIJ$sp.java
new file mode 100644
index 000000000..152e067e0
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcDIJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcDIJ$sp extends JFunction2 {
+    abstract double apply$mcDIJ$sp(int v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Double) apply$mcDIJ$sp((Integer) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcDJD$sp.java b/library/src/scala/compat/java8/JFunction2$mcDJD$sp.java
new file mode 100644
index 000000000..27b5b6567
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcDJD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcDJD$sp extends JFunction2 {
+    abstract double apply$mcDJD$sp(long v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Double) apply$mcDJD$sp((Long) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcDJI$sp.java b/library/src/scala/compat/java8/JFunction2$mcDJI$sp.java
new file mode 100644
index 000000000..c8130a78d
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcDJI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcDJI$sp extends JFunction2 {
+    abstract double apply$mcDJI$sp(long v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Double) apply$mcDJI$sp((Long) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcDJJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcDJJ$sp.java
new file mode 100644
index 000000000..48705ca6f
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcDJJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcDJJ$sp extends JFunction2 {
+    abstract double apply$mcDJJ$sp(long v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Double) apply$mcDJJ$sp((Long) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcFDD$sp.java b/library/src/scala/compat/java8/JFunction2$mcFDD$sp.java
new file mode 100644
index 000000000..b9d39f3cd
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcFDD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcFDD$sp extends JFunction2 {
+    abstract float apply$mcFDD$sp(double v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Float) apply$mcFDD$sp((Double) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcFDI$sp.java b/library/src/scala/compat/java8/JFunction2$mcFDI$sp.java
new file mode 100644
index 000000000..a1a887bfe
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcFDI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcFDI$sp extends JFunction2 {
+    abstract float apply$mcFDI$sp(double v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Float) apply$mcFDI$sp((Double) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcFDJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcFDJ$sp.java
new file mode 100644
index 000000000..2a864db0f
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcFDJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcFDJ$sp extends JFunction2 {
+    abstract float apply$mcFDJ$sp(double v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Float) apply$mcFDJ$sp((Double) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcFID$sp.java b/library/src/scala/compat/java8/JFunction2$mcFID$sp.java
new file mode 100644
index 000000000..502836254
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcFID$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcFID$sp extends JFunction2 {
+    abstract float apply$mcFID$sp(int v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Float) apply$mcFID$sp((Integer) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcFII$sp.java b/library/src/scala/compat/java8/JFunction2$mcFII$sp.java
new file mode 100644
index 000000000..a9dded128
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcFII$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcFII$sp extends JFunction2 {
+    abstract float apply$mcFII$sp(int v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Float) apply$mcFII$sp((Integer) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcFIJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcFIJ$sp.java
new file mode 100644
index 000000000..c3070f196
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcFIJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcFIJ$sp extends JFunction2 {
+    abstract float apply$mcFIJ$sp(int v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Float) apply$mcFIJ$sp((Integer) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcFJD$sp.java b/library/src/scala/compat/java8/JFunction2$mcFJD$sp.java
new file mode 100644
index 000000000..686b67468
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcFJD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcFJD$sp extends JFunction2 {
+    abstract float apply$mcFJD$sp(long v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Float) apply$mcFJD$sp((Long) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcFJI$sp.java b/library/src/scala/compat/java8/JFunction2$mcFJI$sp.java
new file mode 100644
index 000000000..bc8971fb1
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcFJI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcFJI$sp extends JFunction2 {
+    abstract float apply$mcFJI$sp(long v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Float) apply$mcFJI$sp((Long) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcFJJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcFJJ$sp.java
new file mode 100644
index 000000000..25d7057a6
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcFJJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcFJJ$sp extends JFunction2 {
+    abstract float apply$mcFJJ$sp(long v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Float) apply$mcFJJ$sp((Long) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcIDD$sp.java b/library/src/scala/compat/java8/JFunction2$mcIDD$sp.java
new file mode 100644
index 000000000..3fbec6839
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcIDD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcIDD$sp extends JFunction2 {
+    abstract int apply$mcIDD$sp(double v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Integer) apply$mcIDD$sp((Double) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcIDI$sp.java b/library/src/scala/compat/java8/JFunction2$mcIDI$sp.java
new file mode 100644
index 000000000..02ba78f56
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcIDI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcIDI$sp extends JFunction2 {
+    abstract int apply$mcIDI$sp(double v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Integer) apply$mcIDI$sp((Double) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcIDJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcIDJ$sp.java
new file mode 100644
index 000000000..1d954bb0b
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcIDJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcIDJ$sp extends JFunction2 {
+    abstract int apply$mcIDJ$sp(double v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Integer) apply$mcIDJ$sp((Double) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcIID$sp.java b/library/src/scala/compat/java8/JFunction2$mcIID$sp.java
new file mode 100644
index 000000000..473284a6b
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcIID$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcIID$sp extends JFunction2 {
+    abstract int apply$mcIID$sp(int v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Integer) apply$mcIID$sp((Integer) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcIII$sp.java b/library/src/scala/compat/java8/JFunction2$mcIII$sp.java
new file mode 100644
index 000000000..61f5ac97a
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcIII$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcIII$sp extends JFunction2 {
+    abstract int apply$mcIII$sp(int v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Integer) apply$mcIII$sp((Integer) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcIIJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcIIJ$sp.java
new file mode 100644
index 000000000..2091156ef
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcIIJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcIIJ$sp extends JFunction2 {
+    abstract int apply$mcIIJ$sp(int v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Integer) apply$mcIIJ$sp((Integer) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcIJD$sp.java b/library/src/scala/compat/java8/JFunction2$mcIJD$sp.java
new file mode 100644
index 000000000..93473e694
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcIJD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcIJD$sp extends JFunction2 {
+    abstract int apply$mcIJD$sp(long v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Integer) apply$mcIJD$sp((Long) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcIJI$sp.java b/library/src/scala/compat/java8/JFunction2$mcIJI$sp.java
new file mode 100644
index 000000000..638dea436
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcIJI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcIJI$sp extends JFunction2 {
+    abstract int apply$mcIJI$sp(long v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Integer) apply$mcIJI$sp((Long) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcIJJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcIJJ$sp.java
new file mode 100644
index 000000000..d90bbf8ed
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcIJJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcIJJ$sp extends JFunction2 {
+    abstract int apply$mcIJJ$sp(long v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Integer) apply$mcIJJ$sp((Long) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcJDD$sp.java b/library/src/scala/compat/java8/JFunction2$mcJDD$sp.java
new file mode 100644
index 000000000..8116b017a
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcJDD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcJDD$sp extends JFunction2 {
+    abstract long apply$mcJDD$sp(double v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Long) apply$mcJDD$sp((Double) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcJDI$sp.java b/library/src/scala/compat/java8/JFunction2$mcJDI$sp.java
new file mode 100644
index 000000000..bc72f4771
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcJDI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcJDI$sp extends JFunction2 {
+    abstract long apply$mcJDI$sp(double v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Long) apply$mcJDI$sp((Double) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcJDJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcJDJ$sp.java
new file mode 100644
index 000000000..360ca0596
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcJDJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcJDJ$sp extends JFunction2 {
+    abstract long apply$mcJDJ$sp(double v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Long) apply$mcJDJ$sp((Double) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcJID$sp.java b/library/src/scala/compat/java8/JFunction2$mcJID$sp.java
new file mode 100644
index 000000000..d7257a43f
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcJID$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcJID$sp extends JFunction2 {
+    abstract long apply$mcJID$sp(int v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Long) apply$mcJID$sp((Integer) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcJII$sp.java b/library/src/scala/compat/java8/JFunction2$mcJII$sp.java
new file mode 100644
index 000000000..c7bce849f
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcJII$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcJII$sp extends JFunction2 {
+    abstract long apply$mcJII$sp(int v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Long) apply$mcJII$sp((Integer) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcJIJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcJIJ$sp.java
new file mode 100644
index 000000000..083ea1f85
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcJIJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcJIJ$sp extends JFunction2 {
+    abstract long apply$mcJIJ$sp(int v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Long) apply$mcJIJ$sp((Integer) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcJJD$sp.java b/library/src/scala/compat/java8/JFunction2$mcJJD$sp.java
new file mode 100644
index 000000000..06940bb25
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcJJD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcJJD$sp extends JFunction2 {
+    abstract long apply$mcJJD$sp(long v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Long) apply$mcJJD$sp((Long) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcJJI$sp.java b/library/src/scala/compat/java8/JFunction2$mcJJI$sp.java
new file mode 100644
index 000000000..8ecc1f4ef
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcJJI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcJJI$sp extends JFunction2 {
+    abstract long apply$mcJJI$sp(long v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Long) apply$mcJJI$sp((Long) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcJJJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcJJJ$sp.java
new file mode 100644
index 000000000..2046292c7
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcJJJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcJJJ$sp extends JFunction2 {
+    abstract long apply$mcJJJ$sp(long v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Long) apply$mcJJJ$sp((Long) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcVDD$sp.java b/library/src/scala/compat/java8/JFunction2$mcVDD$sp.java
new file mode 100644
index 000000000..22bc2c1ce
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcVDD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcVDD$sp extends JFunction2 {
+    abstract void apply$mcVDD$sp(double v1, double v2);
+
+    default Object apply(Object v1, Object v2) { apply$mcVDD$sp((Double) v1, (Double) v2); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcVDI$sp.java b/library/src/scala/compat/java8/JFunction2$mcVDI$sp.java
new file mode 100644
index 000000000..75b17c326
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcVDI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcVDI$sp extends JFunction2 {
+    abstract void apply$mcVDI$sp(double v1, int v2);
+
+    default Object apply(Object v1, Object v2) { apply$mcVDI$sp((Double) v1, (Integer) v2); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcVDJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcVDJ$sp.java
new file mode 100644
index 000000000..e649163f6
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcVDJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcVDJ$sp extends JFunction2 {
+    abstract void apply$mcVDJ$sp(double v1, long v2);
+
+    default Object apply(Object v1, Object v2) { apply$mcVDJ$sp((Double) v1, (Long) v2); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcVID$sp.java b/library/src/scala/compat/java8/JFunction2$mcVID$sp.java
new file mode 100644
index 000000000..334f4aeed
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcVID$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcVID$sp extends JFunction2 {
+    abstract void apply$mcVID$sp(int v1, double v2);
+
+    default Object apply(Object v1, Object v2) { apply$mcVID$sp((Integer) v1, (Double) v2); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcVII$sp.java b/library/src/scala/compat/java8/JFunction2$mcVII$sp.java
new file mode 100644
index 000000000..1d2d8ca94
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcVII$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcVII$sp extends JFunction2 {
+    abstract void apply$mcVII$sp(int v1, int v2);
+
+    default Object apply(Object v1, Object v2) { apply$mcVII$sp((Integer) v1, (Integer) v2); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcVIJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcVIJ$sp.java
new file mode 100644
index 000000000..0345e6df7
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcVIJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcVIJ$sp extends JFunction2 {
+    abstract void apply$mcVIJ$sp(int v1, long v2);
+
+    default Object apply(Object v1, Object v2) { apply$mcVIJ$sp((Integer) v1, (Long) v2); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcVJD$sp.java b/library/src/scala/compat/java8/JFunction2$mcVJD$sp.java
new file mode 100644
index 000000000..f277a8b24
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcVJD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcVJD$sp extends JFunction2 {
+    abstract void apply$mcVJD$sp(long v1, double v2);
+
+    default Object apply(Object v1, Object v2) { apply$mcVJD$sp((Long) v1, (Double) v2); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcVJI$sp.java b/library/src/scala/compat/java8/JFunction2$mcVJI$sp.java
new file mode 100644
index 000000000..8209b82c0
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcVJI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcVJI$sp extends JFunction2 {
+    abstract void apply$mcVJI$sp(long v1, int v2);
+
+    default Object apply(Object v1, Object v2) { apply$mcVJI$sp((Long) v1, (Integer) v2); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcVJJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcVJJ$sp.java
new file mode 100644
index 000000000..9b7e7d68e
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcVJJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcVJJ$sp extends JFunction2 {
+    abstract void apply$mcVJJ$sp(long v1, long v2);
+
+    default Object apply(Object v1, Object v2) { apply$mcVJJ$sp((Long) v1, (Long) v2); return scala.runtime.BoxedUnit.UNIT; }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcZDD$sp.java b/library/src/scala/compat/java8/JFunction2$mcZDD$sp.java
new file mode 100644
index 000000000..a921b50ec
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcZDD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcZDD$sp extends JFunction2 {
+    abstract boolean apply$mcZDD$sp(double v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZDD$sp((Double) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcZDI$sp.java b/library/src/scala/compat/java8/JFunction2$mcZDI$sp.java
new file mode 100644
index 000000000..1c902b5e6
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcZDI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcZDI$sp extends JFunction2 {
+    abstract boolean apply$mcZDI$sp(double v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZDI$sp((Double) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcZDJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcZDJ$sp.java
new file mode 100644
index 000000000..a210da17a
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcZDJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcZDJ$sp extends JFunction2 {
+    abstract boolean apply$mcZDJ$sp(double v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZDJ$sp((Double) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcZID$sp.java b/library/src/scala/compat/java8/JFunction2$mcZID$sp.java
new file mode 100644
index 000000000..ec2309c35
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcZID$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcZID$sp extends JFunction2 {
+    abstract boolean apply$mcZID$sp(int v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZID$sp((Integer) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcZII$sp.java b/library/src/scala/compat/java8/JFunction2$mcZII$sp.java
new file mode 100644
index 000000000..91fe9c689
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcZII$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcZII$sp extends JFunction2 {
+    abstract boolean apply$mcZII$sp(int v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZII$sp((Integer) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcZIJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcZIJ$sp.java
new file mode 100644
index 000000000..024522a20
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcZIJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcZIJ$sp extends JFunction2 {
+    abstract boolean apply$mcZIJ$sp(int v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZIJ$sp((Integer) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcZJD$sp.java b/library/src/scala/compat/java8/JFunction2$mcZJD$sp.java
new file mode 100644
index 000000000..e510eccda
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcZJD$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcZJD$sp extends JFunction2 {
+    abstract boolean apply$mcZJD$sp(long v1, double v2);
+
+    default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZJD$sp((Long) v1, (Double) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcZJI$sp.java b/library/src/scala/compat/java8/JFunction2$mcZJI$sp.java
new file mode 100644
index 000000000..0a251ba12
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcZJI$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcZJI$sp extends JFunction2 {
+    abstract boolean apply$mcZJI$sp(long v1, int v2);
+
+    default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZJI$sp((Long) v1, (Integer) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2$mcZJJ$sp.java b/library/src/scala/compat/java8/JFunction2$mcZJJ$sp.java
new file mode 100644
index 000000000..12e3a896a
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2$mcZJJ$sp.java
@@ -0,0 +1,13 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2$mcZJJ$sp extends JFunction2 {
+    abstract boolean apply$mcZJJ$sp(long v1, long v2);
+
+    default Object apply(Object v1, Object v2) { return (Boolean) apply$mcZJJ$sp((Long) v1, (Long) v2); }
+}
diff --git a/library/src/scala/compat/java8/JFunction2.java b/library/src/scala/compat/java8/JFunction2.java
new file mode 100644
index 000000000..bad1493bb
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction2.java
@@ -0,0 +1,673 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction2<T1, T2, R> extends scala.Function2<T1, T2, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, R>> curried() {
+      return scala.Function2$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple2<T1, T2>, R> tupled() {
+      return scala.Function2$class.tupled(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default void apply$mcVII$sp(int v1, int v2) {
+        apply((T1) ((Integer) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZII$sp(int v1, int v2) {
+        return (Boolean) apply((T1) ((Integer) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIII$sp(int v1, int v2) {
+        return (Integer) apply((T1) ((Integer) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFII$sp(int v1, int v2) {
+        return (Float) apply((T1) ((Integer) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJII$sp(int v1, int v2) {
+        return (Long) apply((T1) ((Integer) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDII$sp(int v1, int v2) {
+        return (Double) apply((T1) ((Integer) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVIJ$sp(int v1, long v2) {
+        apply((T1) ((Integer) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZIJ$sp(int v1, long v2) {
+        return (Boolean) apply((T1) ((Integer) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIIJ$sp(int v1, long v2) {
+        return (Integer) apply((T1) ((Integer) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFIJ$sp(int v1, long v2) {
+        return (Float) apply((T1) ((Integer) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJIJ$sp(int v1, long v2) {
+        return (Long) apply((T1) ((Integer) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDIJ$sp(int v1, long v2) {
+        return (Double) apply((T1) ((Integer) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVID$sp(int v1, double v2) {
+        apply((T1) ((Integer) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZID$sp(int v1, double v2) {
+        return (Boolean) apply((T1) ((Integer) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIID$sp(int v1, double v2) {
+        return (Integer) apply((T1) ((Integer) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFID$sp(int v1, double v2) {
+        return (Float) apply((T1) ((Integer) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJID$sp(int v1, double v2) {
+        return (Long) apply((T1) ((Integer) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDID$sp(int v1, double v2) {
+        return (Double) apply((T1) ((Integer) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVJI$sp(long v1, int v2) {
+        apply((T1) ((Long) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZJI$sp(long v1, int v2) {
+        return (Boolean) apply((T1) ((Long) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIJI$sp(long v1, int v2) {
+        return (Integer) apply((T1) ((Long) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFJI$sp(long v1, int v2) {
+        return (Float) apply((T1) ((Long) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJJI$sp(long v1, int v2) {
+        return (Long) apply((T1) ((Long) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDJI$sp(long v1, int v2) {
+        return (Double) apply((T1) ((Long) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVJJ$sp(long v1, long v2) {
+        apply((T1) ((Long) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZJJ$sp(long v1, long v2) {
+        return (Boolean) apply((T1) ((Long) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIJJ$sp(long v1, long v2) {
+        return (Integer) apply((T1) ((Long) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFJJ$sp(long v1, long v2) {
+        return (Float) apply((T1) ((Long) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJJJ$sp(long v1, long v2) {
+        return (Long) apply((T1) ((Long) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDJJ$sp(long v1, long v2) {
+        return (Double) apply((T1) ((Long) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVJD$sp(long v1, double v2) {
+        apply((T1) ((Long) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZJD$sp(long v1, double v2) {
+        return (Boolean) apply((T1) ((Long) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIJD$sp(long v1, double v2) {
+        return (Integer) apply((T1) ((Long) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFJD$sp(long v1, double v2) {
+        return (Float) apply((T1) ((Long) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJJD$sp(long v1, double v2) {
+        return (Long) apply((T1) ((Long) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDJD$sp(long v1, double v2) {
+        return (Double) apply((T1) ((Long) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVDI$sp(double v1, int v2) {
+        apply((T1) ((Double) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZDI$sp(double v1, int v2) {
+        return (Boolean) apply((T1) ((Double) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIDI$sp(double v1, int v2) {
+        return (Integer) apply((T1) ((Double) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFDI$sp(double v1, int v2) {
+        return (Float) apply((T1) ((Double) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJDI$sp(double v1, int v2) {
+        return (Long) apply((T1) ((Double) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDDI$sp(double v1, int v2) {
+        return (Double) apply((T1) ((Double) v1), (T2) ((Integer) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVDJ$sp(double v1, long v2) {
+        apply((T1) ((Double) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZDJ$sp(double v1, long v2) {
+        return (Boolean) apply((T1) ((Double) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIDJ$sp(double v1, long v2) {
+        return (Integer) apply((T1) ((Double) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFDJ$sp(double v1, long v2) {
+        return (Float) apply((T1) ((Double) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJDJ$sp(double v1, long v2) {
+        return (Long) apply((T1) ((Double) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDDJ$sp(double v1, long v2) {
+        return (Double) apply((T1) ((Double) v1), (T2) ((Long) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default void apply$mcVDD$sp(double v1, double v2) {
+        apply((T1) ((Double) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default boolean apply$mcZDD$sp(double v1, double v2) {
+        return (Boolean) apply((T1) ((Double) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default int apply$mcIDD$sp(double v1, double v2) {
+        return (Integer) apply((T1) ((Double) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default float apply$mcFDD$sp(double v1, double v2) {
+        return (Float) apply((T1) ((Double) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default long apply$mcJDD$sp(double v1, double v2) {
+        return (Long) apply((T1) ((Double) v1), (T2) ((Double) v2));
+    }
+    @SuppressWarnings("unchecked")
+    default double apply$mcDDD$sp(double v1, double v2) {
+        return (Double) apply((T1) ((Double) v1), (T2) ((Double) v2));
+    }
+    
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcVII$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcZII$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcIII$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcFII$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcJII$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcDII$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcVIJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcZIJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcIIJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcFIJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcJIJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcDIJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcVID$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcZID$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcIID$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcFID$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcJID$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcDID$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcVJI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcZJI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcIJI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcFJI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcJJI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcDJI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcVJJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcZJJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcIJJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcFJJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcJJJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcDJJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcVJD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcZJD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcIJD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcFJD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcJJD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcDJD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcVDI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcZDI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcIDI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcFDI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcJDI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcDDI$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcVDJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcZDJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcIDJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcFDJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcJDJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcDDJ$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcVDD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcZDD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcIDD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcFDD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcJDD$sp() {
+        return curried();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 curried$mcDDD$sp() {
+        return curried();
+    }
+    
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcVII$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcZII$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcIII$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcFII$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcJII$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcDII$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcVIJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcZIJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcIIJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcFIJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcJIJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcDIJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcVID$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcZID$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcIID$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcFID$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcJID$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcDID$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcVJI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcZJI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcIJI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcFJI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcJJI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcDJI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcVJJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcZJJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcIJJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcFJJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcJJJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcDJJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcVJD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcZJD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcIJD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcFJD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcJJD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcDJD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcVDI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcZDI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcIDI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcFDI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcJDI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcDDI$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcVDJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcZDJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcIDJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcFDJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcJDJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcDDJ$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcVDD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcZDD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcIDD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcFDD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcJDD$sp() {
+        return tupled();
+    }
+    @SuppressWarnings("unchecked")
+    default scala.Function1 tupled$mcDDD$sp() {
+        return tupled();
+    }
+}
diff --git a/library/src/scala/compat/java8/JFunction20.java b/library/src/scala/compat/java8/JFunction20.java
new file mode 100644
index 000000000..ed30b41ef
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction20.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> extends scala.Function20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, scala.Function1<T13, scala.Function1<T14, scala.Function1<T15, scala.Function1<T16, scala.Function1<T17, scala.Function1<T18, scala.Function1<T19, scala.Function1<T20, R>>>>>>>>>>>>>>>>>>>> curried() {
+      return scala.Function20$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>, R> tupled() {
+      return scala.Function20$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction21.java b/library/src/scala/compat/java8/JFunction21.java
new file mode 100644
index 000000000..aa6da8084
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction21.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> extends scala.Function21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, scala.Function1<T13, scala.Function1<T14, scala.Function1<T15, scala.Function1<T16, scala.Function1<T17, scala.Function1<T18, scala.Function1<T19, scala.Function1<T20, scala.Function1<T21, R>>>>>>>>>>>>>>>>>>>>> curried() {
+      return scala.Function21$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>, R> tupled() {
+      return scala.Function21$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction22.java b/library/src/scala/compat/java8/JFunction22.java
new file mode 100644
index 000000000..532145157
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction22.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> extends scala.Function22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, scala.Function1<T10, scala.Function1<T11, scala.Function1<T12, scala.Function1<T13, scala.Function1<T14, scala.Function1<T15, scala.Function1<T16, scala.Function1<T17, scala.Function1<T18, scala.Function1<T19, scala.Function1<T20, scala.Function1<T21, scala.Function1<T22, R>>>>>>>>>>>>>>>>>>>>>> curried() {
+      return scala.Function22$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>, R> tupled() {
+      return scala.Function22$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction3.java b/library/src/scala/compat/java8/JFunction3.java
new file mode 100644
index 000000000..731608b2e
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction3.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction3<T1, T2, T3, R> extends scala.Function3<T1, T2, T3, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, R>>> curried() {
+      return scala.Function3$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple3<T1, T2, T3>, R> tupled() {
+      return scala.Function3$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction4.java b/library/src/scala/compat/java8/JFunction4.java
new file mode 100644
index 000000000..9bff4c835
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction4.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction4<T1, T2, T3, T4, R> extends scala.Function4<T1, T2, T3, T4, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, R>>>> curried() {
+      return scala.Function4$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple4<T1, T2, T3, T4>, R> tupled() {
+      return scala.Function4$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction5.java b/library/src/scala/compat/java8/JFunction5.java
new file mode 100644
index 000000000..a5566a5ba
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction5.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction5<T1, T2, T3, T4, T5, R> extends scala.Function5<T1, T2, T3, T4, T5, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, R>>>>> curried() {
+      return scala.Function5$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple5<T1, T2, T3, T4, T5>, R> tupled() {
+      return scala.Function5$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction6.java b/library/src/scala/compat/java8/JFunction6.java
new file mode 100644
index 000000000..b30fb5f47
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction6.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction6<T1, T2, T3, T4, T5, T6, R> extends scala.Function6<T1, T2, T3, T4, T5, T6, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, R>>>>>> curried() {
+      return scala.Function6$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple6<T1, T2, T3, T4, T5, T6>, R> tupled() {
+      return scala.Function6$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction7.java b/library/src/scala/compat/java8/JFunction7.java
new file mode 100644
index 000000000..4a4a92cba
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction7.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction7<T1, T2, T3, T4, T5, T6, T7, R> extends scala.Function7<T1, T2, T3, T4, T5, T6, T7, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, R>>>>>>> curried() {
+      return scala.Function7$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple7<T1, T2, T3, T4, T5, T6, T7>, R> tupled() {
+      return scala.Function7$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction8.java b/library/src/scala/compat/java8/JFunction8.java
new file mode 100644
index 000000000..825236e48
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction8.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction8<T1, T2, T3, T4, T5, T6, T7, T8, R> extends scala.Function8<T1, T2, T3, T4, T5, T6, T7, T8, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, R>>>>>>>> curried() {
+      return scala.Function8$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>, R> tupled() {
+      return scala.Function8$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JFunction9.java b/library/src/scala/compat/java8/JFunction9.java
new file mode 100644
index 000000000..d0e40c316
--- /dev/null
+++ b/library/src/scala/compat/java8/JFunction9.java
@@ -0,0 +1,24 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+@FunctionalInterface
+public interface JFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> extends scala.Function9<T1, T2, T3, T4, T5, T6, T7, T8, T9, R> {
+    default void $init$() {
+    };
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<T1, scala.Function1<T2, scala.Function1<T3, scala.Function1<T4, scala.Function1<T5, scala.Function1<T6, scala.Function1<T7, scala.Function1<T8, scala.Function1<T9, R>>>>>>>>> curried() {
+      return scala.Function9$class.curried(this);
+    }
+
+    @SuppressWarnings("unchecked")
+    default scala.Function1<scala.Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>, R> tupled() {
+      return scala.Function9$class.tupled(this);
+    }
+
+
+}
diff --git a/library/src/scala/compat/java8/JProcedure0.java b/library/src/scala/compat/java8/JProcedure0.java
new file mode 100644
index 000000000..8361252c6
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure0.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure0 extends JFunction0<BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid();
+
+    default BoxedUnit apply() {
+        applyVoid();
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure1.java b/library/src/scala/compat/java8/JProcedure1.java
new file mode 100644
index 000000000..189e451cd
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure1.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure1<T1> extends JFunction1<T1, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1);
+
+    default BoxedUnit apply(T1 t1) {
+        applyVoid(t1);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure10.java b/library/src/scala/compat/java8/JProcedure10.java
new file mode 100644
index 000000000..63a7543c5
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure10.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> extends JFunction10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure11.java b/library/src/scala/compat/java8/JProcedure11.java
new file mode 100644
index 000000000..1f530fba9
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure11.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> extends JFunction11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure12.java b/library/src/scala/compat/java8/JProcedure12.java
new file mode 100644
index 000000000..454868e66
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure12.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> extends JFunction12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure13.java b/library/src/scala/compat/java8/JProcedure13.java
new file mode 100644
index 000000000..4db2cd866
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure13.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> extends JFunction13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure14.java b/library/src/scala/compat/java8/JProcedure14.java
new file mode 100644
index 000000000..9d1c4b89f
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure14.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> extends JFunction14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure15.java b/library/src/scala/compat/java8/JProcedure15.java
new file mode 100644
index 000000000..c49f042e7
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure15.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> extends JFunction15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure16.java b/library/src/scala/compat/java8/JProcedure16.java
new file mode 100644
index 000000000..aad602dfa
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure16.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> extends JFunction16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure17.java b/library/src/scala/compat/java8/JProcedure17.java
new file mode 100644
index 000000000..cdc30b9ee
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure17.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> extends JFunction17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure18.java b/library/src/scala/compat/java8/JProcedure18.java
new file mode 100644
index 000000000..2e03d8f80
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure18.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> extends JFunction18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure19.java b/library/src/scala/compat/java8/JProcedure19.java
new file mode 100644
index 000000000..5e4fcb9aa
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure19.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> extends JFunction19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure2.java b/library/src/scala/compat/java8/JProcedure2.java
new file mode 100644
index 000000000..36e84d8dd
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure2.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure2<T1, T2> extends JFunction2<T1, T2, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2);
+
+    default BoxedUnit apply(T1 t1, T2 t2) {
+        applyVoid(t1, t2);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure20.java b/library/src/scala/compat/java8/JProcedure20.java
new file mode 100644
index 000000000..d6598c312
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure20.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> extends JFunction20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure21.java b/library/src/scala/compat/java8/JProcedure21.java
new file mode 100644
index 000000000..c85cb540c
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure21.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> extends JFunction21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure22.java b/library/src/scala/compat/java8/JProcedure22.java
new file mode 100644
index 000000000..a1653ae61
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure22.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> extends JFunction22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T11 t11, T12 t12, T13 t13, T14 t14, T15 t15, T16 t16, T17 t17, T18 t18, T19 t19, T20 t20, T21 t21, T22 t22) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure3.java b/library/src/scala/compat/java8/JProcedure3.java
new file mode 100644
index 000000000..f2b1e498a
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure3.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure3<T1, T2, T3> extends JFunction3<T1, T2, T3, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3) {
+        applyVoid(t1, t2, t3);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure4.java b/library/src/scala/compat/java8/JProcedure4.java
new file mode 100644
index 000000000..7a3457b57
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure4.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure4<T1, T2, T3, T4> extends JFunction4<T1, T2, T3, T4, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4) {
+        applyVoid(t1, t2, t3, t4);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure5.java b/library/src/scala/compat/java8/JProcedure5.java
new file mode 100644
index 000000000..e9d25854a
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure5.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure5<T1, T2, T3, T4, T5> extends JFunction5<T1, T2, T3, T4, T5, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) {
+        applyVoid(t1, t2, t3, t4, t5);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure6.java b/library/src/scala/compat/java8/JProcedure6.java
new file mode 100644
index 000000000..d1675bd24
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure6.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure6<T1, T2, T3, T4, T5, T6> extends JFunction6<T1, T2, T3, T4, T5, T6, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) {
+        applyVoid(t1, t2, t3, t4, t5, t6);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure7.java b/library/src/scala/compat/java8/JProcedure7.java
new file mode 100644
index 000000000..1348e051b
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure7.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure7<T1, T2, T3, T4, T5, T6, T7> extends JFunction7<T1, T2, T3, T4, T5, T6, T7, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure8.java b/library/src/scala/compat/java8/JProcedure8.java
new file mode 100644
index 000000000..df944ca6e
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure8.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure8<T1, T2, T3, T4, T5, T6, T7, T8> extends JFunction8<T1, T2, T3, T4, T5, T6, T7, T8, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/compat/java8/JProcedure9.java b/library/src/scala/compat/java8/JProcedure9.java
new file mode 100644
index 000000000..47ad5d234
--- /dev/null
+++ b/library/src/scala/compat/java8/JProcedure9.java
@@ -0,0 +1,21 @@
+
+/*
+ * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.compat.java8;
+
+import scala.runtime.BoxedUnit;
+
+@FunctionalInterface
+public interface JProcedure9<T1, T2, T3, T4, T5, T6, T7, T8, T9> extends JFunction9<T1, T2, T3, T4, T5, T6, T7, T8, T9, BoxedUnit> {
+    default void $init$() {
+    }
+
+    void applyVoid(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9);
+
+    default BoxedUnit apply(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9) {
+        applyVoid(t1, t2, t3, t4, t5, t6, t7, t8, t9);
+        return BoxedUnit.UNIT;
+    }
+}
diff --git a/library/src/scala/runtime/ScalaRunTime.scala b/library/src/scala/runtime/ScalaRunTime.scala
new file mode 100644
index 000000000..ed1eb82b1
--- /dev/null
+++ b/library/src/scala/runtime/ScalaRunTime.scala
@@ -0,0 +1,377 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala
+package runtime
+
+import dotty.runtime.vc.VCArrayPrototype
+
+import scala.collection.{ Seq, IndexedSeq, TraversableView, AbstractIterator }
+import scala.collection.mutable.WrappedArray
+import scala.collection.immutable.{ StringLike, NumericRange, List, Stream, Nil, :: }
+import scala.collection.generic.{ Sorted, IsTraversableLike }
+import scala.reflect.{ ClassTag, classTag }
+import scala.util.control.ControlThrowable
+import java.lang.{ Class => jClass }
+
+import java.lang.Double.doubleToLongBits
+import java.lang.reflect.{ Modifier, Method => JMethod }
+
+/** The object ScalaRunTime provides support methods required by
+  *  the scala runtime.  All these methods should be considered
+  *  outside the API and subject to change or removal without notice.
+  */
+object ScalaRunTime {
+  def isArray(x: Any, atLevel: Int = 1): Boolean =
+    x != null && isArrayClass(x.getClass, atLevel)
+
+  private def isArrayClass(clazz: jClass[_], atLevel: Int): Boolean =
+    (clazz.isArray || classOf[VCArrayPrototype[_]].isAssignableFrom(clazz)) &&
+      (atLevel == 1 || isArrayClass(clazz.getComponentType, atLevel - 1))
+
+  def isValueClass(clazz: jClass[_]) = clazz.isPrimitive()
+
+  // includes specialized subclasses and future proofed against hypothetical TupleN (for N > 22)
+  def isTuple(x: Any) = x != null && x.getClass.getName.startsWith("scala.Tuple")
+  def isAnyVal(x: Any) = x match {
+    case _: Byte | _: Short | _: Char | _: Int | _: Long | _: Float | _: Double | _: Boolean | _: Unit => true
+    case _                                                                                             => false
+  }
+
+  // A helper method to make my life in the pattern matcher a lot easier.
+  def drop[Repr](coll: Repr, num: Int)(implicit traversable: IsTraversableLike[Repr]): Repr =
+    traversable conversion coll drop num
+
+  /** Return the class object representing an array with element class `clazz`.
+    */
+  def arrayClass(clazz: jClass[_]): jClass[_] = {
+    // Dmitry: I want to see where this method is used to know how to fix it
+    // [Martin] Here's a stacktrace
+    // Exception in thread "main" scala.NotImplementedError: an implementation is missing
+    //  at scala.Predef$.$qmark$qmark$qmark(Predef.scala:225)
+    //  at scala.runtime.ScalaRunTime$.arrayClass(ScalaRunTime.scala:53)
+    //  at scala.Array$.fill(Array.scala:281)
+    //  at dotty.tools.dotc.core.Flags$.<init>(Flags.scala:139)
+    // newInstance throws an exception if the erasure is Void.TYPE. see SI-5680
+    if (clazz == java.lang.Void.TYPE) classOf[Array[Unit]]
+    else java.lang.reflect.Array.newInstance(clazz, 0).getClass
+  }
+
+  /** Return the class object representing elements in arrays described by a given schematic.
+    */
+  def arrayElementClass(schematic: Any): jClass[_] = schematic match {
+    case cls: jClass[_]   => cls.getComponentType
+    case tag: ClassTag[_] => tag.runtimeClass
+    case _                =>
+      throw new UnsupportedOperationException(s"unsupported schematic $schematic (${schematic.getClass})")
+  }
+
+  /** Return the class object representing an unboxed value type,
+    *  e.g., classOf[int], not classOf[java.lang.Integer].  The compiler
+    *  rewrites expressions like 5.getClass to come here.
+    */
+  def anyValClass[T <: AnyVal : ClassTag](value: T): jClass[T] =
+    classTag[T].runtimeClass.asInstanceOf[jClass[T]]
+
+  /** Retrieve generic array element */
+  def array_apply(xs: AnyRef, idx: Int): Any = {
+    xs match {
+      case x: Array[AnyRef]  => x(idx).asInstanceOf[Any]
+      case x: Array[Int]     => x(idx).asInstanceOf[Any]
+      case x: Array[Double]  => x(idx).asInstanceOf[Any]
+      case x: Array[Long]    => x(idx).asInstanceOf[Any]
+      case x: Array[Float]   => x(idx).asInstanceOf[Any]
+      case x: Array[Char]    => x(idx).asInstanceOf[Any]
+      case x: Array[Byte]    => x(idx).asInstanceOf[Any]
+      case x: Array[Short]   => x(idx).asInstanceOf[Any]
+      case x: Array[Boolean] => x(idx).asInstanceOf[Any]
+      case x: Array[Unit]    => x(idx).asInstanceOf[Any]
+      case x: VCArrayPrototype[_] => x.apply(idx)
+      case null => throw new NullPointerException
+    }
+  }
+
+  /** update generic array element */
+  def array_update(xs: AnyRef, idx: Int, value: Any): Unit = {
+    xs match {
+      case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
+      case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
+      case x: Array[Double]  => x(idx) = value.asInstanceOf[Double]
+      case x: Array[Long]    => x(idx) = value.asInstanceOf[Long]
+      case x: Array[Float]   => x(idx) = value.asInstanceOf[Float]
+      case x: Array[Char]    => x(idx) = value.asInstanceOf[Char]
+      case x: Array[Byte]    => x(idx) = value.asInstanceOf[Byte]
+      case x: Array[Short]   => x(idx) = value.asInstanceOf[Short]
+      case x: Array[Boolean] => x(idx) = value.asInstanceOf[Boolean]
+      case x: Array[Unit]    => x(idx) = value.asInstanceOf[Unit]
+      case x: VCArrayPrototype[t] => x.update(idx, value.asInstanceOf[t])
+      case null => throw new NullPointerException
+    }
+  }
+
+  /** Get generic array length */
+  def array_length(xs: AnyRef): Int = xs match {
+    case x: Array[AnyRef]  => x.length
+    case x: Array[Int]     => x.length
+    case x: Array[Double]  => x.length
+    case x: Array[Long]    => x.length
+    case x: Array[Float]   => x.length
+    case x: Array[Char]    => x.length
+    case x: Array[Byte]    => x.length
+    case x: Array[Short]   => x.length
+    case x: Array[Boolean] => x.length
+    case x: Array[Unit]    => x.length
+    case x: VCArrayPrototype[_] => x.length
+    case null => throw new NullPointerException
+  }
+
+  def array_clone(xs: AnyRef): AnyRef = xs match {
+    case x: Array[AnyRef]  => ArrayRuntime.cloneArray(x)
+    case x: Array[Int]     => ArrayRuntime.cloneArray(x)
+    case x: Array[Double]  => ArrayRuntime.cloneArray(x)
+    case x: Array[Long]    => ArrayRuntime.cloneArray(x)
+    case x: Array[Float]   => ArrayRuntime.cloneArray(x)
+    case x: Array[Char]    => ArrayRuntime.cloneArray(x)
+    case x: Array[Byte]    => ArrayRuntime.cloneArray(x)
+    case x: Array[Short]   => ArrayRuntime.cloneArray(x)
+    case x: Array[Boolean] => ArrayRuntime.cloneArray(x)
+    case x: Array[Unit]    => x
+    case x: VCArrayPrototype[_] => x.clone()
+    case null => throw new NullPointerException
+  }
+
+  /** Convert an array to an object array.
+    *  Needed to deal with vararg arguments of primitive types that are passed
+    *  to a generic Java vararg parameter T ...
+    */
+  def toObjectArray(src: AnyRef): Array[Object] = src match {
+    case x: Array[AnyRef] => x
+    case _ =>
+      val length = array_length(src)
+      val dest = new Array[Object](length)
+      for (i <- 0 until length)
+        array_update(dest, i, array_apply(src, i))
+      dest
+  }
+
+  def toArray[T](xs: scala.collection.Seq[T]) = {
+    val arr = new Array[AnyRef](xs.length)
+    var i = 0
+    for (x <- xs) {
+      arr(i) = x.asInstanceOf[AnyRef]
+      i += 1
+    }
+    arr
+  }
+
+  // Java bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071957
+  // More background at ticket #2318.
+  def ensureAccessible(m: JMethod): JMethod = scala.reflect.ensureAccessible(m)
+
+  def checkInitialized[T <: AnyRef](x: T): T =
+    if (x == null) throw new UninitializedError else x
+
+  def _toString(x: Product): String =
+    x.productIterator.mkString(x.productPrefix + "(", ",", ")")
+
+  def _hashCode(x: Product): Int = scala.util.hashing.MurmurHash3.productHash(x)
+
+  /** A helper for case classes. */
+  def typedProductIterator[T](x: Product): Iterator[T] = {
+    new AbstractIterator[T] {
+      private var c: Int = 0
+      private val cmax = x.productArity
+      def hasNext = c < cmax
+      def next() = {
+        val result = x.productElement(c)
+        c += 1
+        result.asInstanceOf[T]
+      }
+    }
+  }
+
+  /** Fast path equality method for inlining; used when -optimise is set.
+    */
+  @inline def inlinedEquals(x: Object, y: Object): Boolean =
+    if (x eq y) true
+    else if (x eq null) false
+    else if (x.isInstanceOf[java.lang.Number]) BoxesRunTime.equalsNumObject(x.asInstanceOf[java.lang.Number], y)
+    else if (x.isInstanceOf[java.lang.Character]) BoxesRunTime.equalsCharObject(x.asInstanceOf[java.lang.Character], y)
+    else x.equals(y)
+
+  def _equals(x: Product, y: Any): Boolean = y match {
+    case y: Product if x.productArity == y.productArity => x.productIterator sameElements y.productIterator
+    case _                                              => false
+  }
+
+  // hashcode -----------------------------------------------------------
+  //
+  // Note that these are the implementations called by ##, so they
+  // must not call ## themselves.
+
+  def hash(x: Any): Int =
+    if (x == null) 0
+    else if (x.isInstanceOf[java.lang.Number]) BoxesRunTime.hashFromNumber(x.asInstanceOf[java.lang.Number])
+    else x.hashCode
+
+  def hash(dv: Double): Int = {
+    val iv = dv.toInt
+    if (iv == dv) return iv
+
+    val lv = dv.toLong
+    if (lv == dv) return lv.hashCode
+
+    val fv = dv.toFloat
+    if (fv == dv) fv.hashCode else dv.hashCode
+  }
+  def hash(fv: Float): Int = {
+    val iv = fv.toInt
+    if (iv == fv) return iv
+
+    val lv = fv.toLong
+    if (lv == fv) hash(lv)
+    else fv.hashCode
+  }
+  def hash(lv: Long): Int = {
+    val low = lv.toInt
+    val lowSign = low >>> 31
+    val high = (lv >>> 32).toInt
+    low ^ (high + lowSign)
+  }
+  def hash(x: Number): Int  = runtime.BoxesRunTime.hashFromNumber(x)
+
+  // The remaining overloads are here for completeness, but the compiler
+  // inlines these definitions directly so they're not generally used.
+  def hash(x: Int): Int = x
+  def hash(x: Short): Int = x.toInt
+  def hash(x: Byte): Int = x.toInt
+  def hash(x: Char): Int = x.toInt
+  def hash(x: Boolean): Int = if (x) true.hashCode else false.hashCode
+  def hash(x: Unit): Int = 0
+
+  /** A helper method for constructing case class equality methods,
+    *  because existential types get in the way of a clean outcome and
+    *  it's performing a series of Any/Any equals comparisons anyway.
+    *  See ticket #2867 for specifics.
+    */
+  def sameElements(xs1: scala.collection.Seq[Any], xs2: scala.collection.Seq[Any]) = xs1 sameElements xs2
+
+  /** Given any Scala value, convert it to a String.
+    *
+    * The primary motivation for this method is to provide a means for
+    * correctly obtaining a String representation of a value, while
+    * avoiding the pitfalls of naïvely calling toString on said value.
+    * In particular, it addresses the fact that (a) toString cannot be
+    * called on null and (b) depending on the apparent type of an
+    * array, toString may or may not print it in a human-readable form.
+    *
+    * @param   arg   the value to stringify
+    * @return        a string representation of arg.
+    */
+  def stringOf(arg: Any): String = stringOf(arg, scala.Int.MaxValue)
+  def stringOf(arg: Any, maxElements: Int): String = {
+    def packageOf(x: AnyRef) = x.getClass.getPackage match {
+      case null   => ""
+      case p      => p.getName
+    }
+    def isScalaClass(x: AnyRef)         = packageOf(x) startsWith "scala."
+    def isScalaCompilerClass(x: AnyRef) = packageOf(x) startsWith "scala.tools.nsc."
+
+    // We use reflection because the scala.xml package might not be available
+    def isSubClassOf(potentialSubClass: Class[_], ofClass: String) =
+      try {
+        val classLoader = potentialSubClass.getClassLoader
+        val clazz = Class.forName(ofClass, /*initialize =*/ false, classLoader)
+        clazz.isAssignableFrom(potentialSubClass)
+      } catch {
+        case cnfe: ClassNotFoundException => false
+      }
+    def isXmlNode(potentialSubClass: Class[_])     = isSubClassOf(potentialSubClass, "scala.xml.Node")
+    def isXmlMetaData(potentialSubClass: Class[_]) = isSubClassOf(potentialSubClass, "scala.xml.MetaData")
+
+    // When doing our own iteration is dangerous
+    def useOwnToString(x: Any) = x match {
+      // Range/NumericRange have a custom toString to avoid walking a gazillion elements
+      case _: Range | _: NumericRange[_] => true
+      // Sorted collections to the wrong thing (for us) on iteration - ticket #3493
+      case _: Sorted[_, _]  => true
+      // StringBuilder(a, b, c) and similar not so attractive
+      case _: StringLike[_] => true
+      // Don't want to evaluate any elements in a view
+      case _: TraversableView[_, _] => true
+      // Node extends NodeSeq extends Seq[Node] and MetaData extends Iterable[MetaData]
+      // -> catch those by isXmlNode and isXmlMetaData.
+      // Don't want to a) traverse infinity or b) be overly helpful with peoples' custom
+      // collections which may have useful toString methods - ticket #3710
+      // or c) print AbstractFiles which are somehow also Iterable[AbstractFile]s.
+      case x: Traversable[_] => !x.hasDefiniteSize || !isScalaClass(x) || isScalaCompilerClass(x) || isXmlNode(x.getClass) || isXmlMetaData(x.getClass)
+      // Otherwise, nothing could possibly go wrong
+      case _ => false
+    }
+
+    // A variation on inner for maps so they print -> instead of bare tuples
+    def mapInner(arg: Any): String = arg match {
+      case (k, v)   => inner(k) + " -> " + inner(v)
+      case _        => inner(arg)
+    }
+
+    // Special casing Unit arrays, the value class which uses a reference array type.
+    def arrayToString(x: AnyRef) = {
+      if (x.getClass.getComponentType == classOf[BoxedUnit])
+        0 until (array_length(x) min maxElements) map (_ => "()") mkString ("Array(", ", ", ")")
+      else
+        WrappedArray make x take maxElements map inner mkString ("Array(", ", ", ")")
+    }
+
+    // The recursively applied attempt to prettify Array printing.
+    // Note that iterator is used if possible and foreach is used as a
+    // last resort, because the parallel collections "foreach" in a
+    // random order even on sequences.
+    def inner(arg: Any): String = arg match {
+      case null                         => "null"
+      case ""                           => "\"\""
+      case x: String                    => if (x.head.isWhitespace || x.last.isWhitespace) "\"" + x + "\"" else x
+      case x if useOwnToString(x)       => x.toString
+      case x: AnyRef if isArray(x)      => arrayToString(x)
+      case x: scala.collection.Map[_, _]      => x.iterator take maxElements map mapInner mkString (x.stringPrefix + "(", ", ", ")")
+      case x: Iterable[_]               => x.iterator take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")")
+      case x: Traversable[_]            => x take maxElements map inner mkString (x.stringPrefix + "(", ", ", ")")
+      case x: Product1[_] if isTuple(x) => "(" + inner(x._1) + ",)" // that special trailing comma
+      case x: Product if isTuple(x)     => x.productIterator map inner mkString ("(", ",", ")")
+      case x                            => x.toString
+    }
+
+    // The try/catch is defense against iterables which aren't actually designed
+    // to be iterated, such as some scala.tools.nsc.io.AbstractFile derived classes.
+    try inner(arg)
+    catch {
+      case _: UnsupportedOperationException | _: AssertionError => "" + arg
+    }
+  }
+
+  /** stringOf formatted for use in a repl result. */
+  def replStringOf(arg: Any, maxElements: Int): String = {
+    val s  = stringOf(arg, maxElements)
+    val nl = if (s contains "\n") "\n" else ""
+
+    nl + s + "\n"
+  }
+
+  def box[T](clazz: jClass[T]): jClass[_] = clazz match {
+    case java.lang.Byte.TYPE => classOf[java.lang.Byte]
+    case java.lang.Short.TYPE => classOf[java.lang.Short]
+    case java.lang.Character.TYPE => classOf[java.lang.Character]
+    case java.lang.Integer.TYPE => classOf[java.lang.Integer]
+    case java.lang.Long.TYPE => classOf[java.lang.Long]
+    case java.lang.Float.TYPE => classOf[java.lang.Float]
+    case java.lang.Double.TYPE => classOf[java.lang.Double]
+    case java.lang.Void.TYPE => classOf[scala.runtime.BoxedUnit]
+    case java.lang.Boolean.TYPE => classOf[java.lang.Boolean]
+    case _ => clazz
+  }
+}