Merge remote-tracking branch 'upstream/2.12.x' into opt/elimBoxes

572 files changed, 5443 insertions, 24515 deletions

diff --git a/README.md b/README.md
index ea61d72122..ce232758dc 100644
--- a/README.md
+++ b/README.md
@@ -40,16 +40,12 @@ P.S.: If you have some spare time to help out around here, we would be delighted
 
 # Handy Links
   - [A wealth of documentation](http://docs.scala-lang.org)
+  - [mailing lists](http://www.scala-lang.org/community/)
+  - [Gitter room for Scala contributors](https://gitter.im/scala/contributors)
   - [Scala CI](https://scala-ci.typesafe.com/)
-  - [Download the latest nightly](http://www.scala-lang.org/files/archive/nightly/2.11.x/)
-  - [(Deprecated) Scala CI at EPFL](https://scala-webapps.epfl.ch/jenkins/)
-  - Scala mailing lists:
-    - [Compiler and standard library development](https://groups.google.com/group/scala-internals)
-    - [Users of Scala](https://groups.google.com/group/scala-user)
-    - [Scala language discussion](https://groups.google.com/group/scala-language)
-    - [Scala Improvement Process](https://groups.google.com/group/scala-sips)
-    - [Debate](https://groups.google.com/group/scala-debate)
-    - [Announcements](https://groups.google.com/group/scala-announce)
+  - download the latest nightlies:
+      - [2.11.x](http://www.scala-lang.org/files/archive/nightly/2.11.x/)
+      - [2.12.x](http://www.scala-lang.org/files/archive/nightly/2.12.x/)
 
 # Repository structure
 
@@ -74,7 +70,13 @@ scala/
 
 ## Requirements
 
-You'll need a Java SDK (8 or newer), Apache Ant (version 1.9.3 or above), and curl (for `./pull-binary-libs.sh`).
+You'll need a Java SDK.  The baseline version is 6 for 2.11.x, 8 for
+2.12.x. (It's also possible to use a later SDK for local development,
+but the CI will verify against the baseline version.)
+
+You'll also need Apache Ant (version 1.9.3 or above) and curl (for `./pull-binary-libs.sh`).
+
+Mac OS X and Linux work. Windows may work if you use Cygwin. (Community help with keeping the build working on Windows is appreciated.)
 
 ## Git Hygiene
 
@@ -129,25 +131,10 @@ Here, `<milestone>` is the milestone targeted by the PR (e.g., 2.11.6), and `<sh
 
 ## IDE Setup
 ### Eclipse
-Download the [Scala IDE bundle](http://scala-ide.org/download/sdk.html). It comes preconfigured for optimal performance.
-
-  - Run `ant init` to download some necessary jars.
-  - Import the project (in `src/eclipse`) via `File` → `Import Existing Projects into Workspace`. Check all projects and click ok.
-
-For important details on building, debugging and file encodings, please see [the excellent tutorial on scala-ide.org](http://scala-ide.org/docs/tutorials/scalac-trunk/index.html) and the included README.md in src/eclipse.
+See `src/eclipse/README.md`.
 
 ### IntelliJ 14
-Use the latest IntelliJ IDEA release and install the Scala plugin from within the IDE.
-
-The following steps are required to use IntelliJ IDEA on Scala trunk
- - Run `ant init`. This will download some JARs to `./build/deps`, which are included in IntelliJ's classpath.
- - Run `./src/intellij/setup.sh`.
- - Open `./src/intellij/scala.ipr` in IntelliJ.
- - `File` → `Project Structure` → `Project` → `Project SDK`. Create an SDK entry named "1.6" containing the Java 1.6 SDK.
-   (You may use a later SDK for local development, but the CI will verify against Java 6.)
-
-Compilation within IDEA is performed in `-Dlocker.skip=1` mode: the sources are built
-directly using the STARR compiler (which is downloaded from [the Central Repository](http://central.sonatype.org/), according to `starr.version` in `versions.properties`).
+See `src/intellij/README.md`.
 
 ## Building with sbt (EXPERIMENTAL)
 
diff --git a/build.sbt b/build.sbt
index c36b0bd42a..fb5849a2d1 100644
--- a/build.sbt
+++ b/build.sbt
@@ -1,10 +1,13 @@
 /*
  * The new, sbt-based build definition for Scala.
  *
- * What you see below is very much work-in-progress. Basics like compiling and packaging jars
- * (into right location) work. Everything else is missing:
- *    building docs, placing shell scripts in right locations (so you can run compiler easily),
- *    running partest test, compiling and running JUnit test, and many, many other things.
+ * What you see below is very much work-in-progress. The following features are implemented:
+ *   - Compiling all classses for the compiler and library ("compile" in the respective subprojects)
+ *   - Running JUnit tests ("test") and partest ("test/it:test")
+ *   - Creating build-sbt/quick with all compiled classes and launcher scripts ("dist/mkQuick")
+ *   - Creating build-sbt/pack with all JARs and launcher scripts ("dist/mkPack")
+ *   - Building all scaladoc sets ("doc")
+ *   - Publishing ("publishDists" and standard sbt tasks like "publish" and "publishLocal")
  *
  * You'll notice that this build definition is much more complicated than your typical sbt build.
  * The main reason is that we are not benefiting from sbt's conventions when it comes project
@@ -50,12 +53,15 @@
  *     https://groups.google.com/d/topic/scala-internals/gp5JsM1E0Fo/discussion
  */
 
+import VersionUtil.{versionProps, versionNumber, generatePropertiesFileSettings, versionProperties, versionPropertiesSettings}
+
 val bootstrapScalaVersion = versionProps("starr.version")
 
 def withoutScalaLang(moduleId: ModuleID): ModuleID = moduleId exclude("org.scala-lang", "*")
 
 // exclusion of the scala-library transitive dependency avoids eviction warnings during `update`.
 val scalaParserCombinatorsDep = withoutScalaLang("org.scala-lang.modules" %% "scala-parser-combinators" % versionNumber("scala-parser-combinators"))
+val scalaSwingDep = withoutScalaLang("org.scala-lang.modules" %% "scala-swing" % versionNumber("scala-swing"))
 val scalaXmlDep = withoutScalaLang("org.scala-lang.modules" %% "scala-xml" % versionNumber("scala-xml"))
 val partestDep = withoutScalaLang("org.scala-lang.modules" %% "scala-partest" % versionNumber("partest"))
 val partestInterfaceDep = withoutScalaLang("org.scala-lang.modules" %% "scala-partest-interface" % "0.5.0")
@@ -66,9 +72,35 @@ val jlineDep = "jline" % "jline" % versionProps("jline.version")
 val antDep = "org.apache.ant" % "ant" % "1.9.4"
 val scalacheckDep = withoutScalaLang("org.scalacheck" %% "scalacheck" % versionNumber("scalacheck") % "it")
 
-lazy val commonSettings = clearSourceAndResourceDirectories ++ Seq[Setting[_]](
+/** Publish to ./dists/maven-sbt, similar to the ANT build which publishes to ./dists/maven. This
+  * can be used to compare the output of the sbt and ANT builds during the transition period. Any
+  * real publishing should be done with sbt's standard `publish` task. */
+lazy val publishDists = taskKey[Unit]("Publish to ./dists/maven-sbt.")
+
+lazy val publishSettings : Seq[Setting[_]] = Seq(
+  publishDists := {
+    val artifacts = (packagedArtifacts in publish).value
+    val ver = VersionUtil.versionProperties.value.canonicalVersion
+    val log = streams.value.log
+    val mappings = artifacts.toSeq.map { case (a, f) =>
+      val typeSuffix = a.`type` match {
+        case "pom" => "-pom.xml"
+        case "bundle" | "jar" => ".jar"
+        case "doc" => "-docs.jar"
+        case tpe => s"-$tpe.${a.extension}"
+      }
+      val to = file("dists/maven-sbt") / ver / a.name / (a.name + typeSuffix)
+      log.info(s"Publishing $f to $to")
+      (f, to)
+    }
+    IO.copy(mappings)
+  }
+)
+
+lazy val commonSettings = clearSourceAndResourceDirectories ++ versionPropertiesSettings ++ publishSettings ++ Seq[Setting[_]](
   organization := "org.scala-lang",
-  version := "2.11.8-SNAPSHOT",
+  // The ANT build uses the file "build.number" and the property "build.release" to compute the version
+  version := "2.12.0-SNAPSHOT",
   scalaVersion := bootstrapScalaVersion,
   // we don't cross build Scala itself
   crossPaths := false,
@@ -90,6 +122,7 @@ lazy val commonSettings = clearSourceAndResourceDirectories ++ Seq[Setting[_]](
   unmanagedJars in Compile := Seq.empty,
   sourceDirectory in Compile := baseDirectory.value,
   unmanagedSourceDirectories in Compile := List(baseDirectory.value),
+  unmanagedResourceDirectories in Compile += (baseDirectory in ThisBuild).value / "src" / thisProject.value.id,
   scalaSource in Compile := (sourceDirectory in Compile).value,
   javaSource in Compile := (sourceDirectory in Compile).value,
   // resources are stored along source files in our current layout
@@ -97,26 +130,113 @@ lazy val commonSettings = clearSourceAndResourceDirectories ++ Seq[Setting[_]](
   // each subproject has to ask specifically for files they want to include
   includeFilter in unmanagedResources in Compile := NothingFilter,
   target := (baseDirectory in ThisBuild).value / "target" / thisProject.value.id,
-  target in Compile in doc := buildDirectory.value / "scaladoc" / thisProject.value.id,
   classDirectory in Compile := buildDirectory.value / "quick/classes" / thisProject.value.id,
-  // given that classDirectory is overriden to be _outside_ of target directory, we have
-  // to make sure its being cleaned properly
+  target in Compile in doc := buildDirectory.value / "scaladoc" / thisProject.value.id,
+  // given that classDirectory and doc target are overriden to be _outside_ of target directory, we have
+  // to make sure they are being cleaned properly
   cleanFiles += (classDirectory in Compile).value,
-  fork in run := true
+  cleanFiles += (target in Compile in doc).value,
+  fork in run := true,
+  scalacOptions in Compile in doc ++= Seq(
+    "-doc-footer", "epfl",
+    "-diagrams",
+    "-implicits",
+    "-groups",
+    "-doc-version", versionProperties.value.canonicalVersion,
+    "-doc-title", description.value,
+    "-sourcepath", (baseDirectory in ThisBuild).value.toString,
+    "-doc-source-url", s"https://github.com/scala/scala/tree/${versionProperties.value.githubTree}€{FILE_PATH}.scala#L1"
+  ),
+  homepage := Some(url("http://www.scala-lang.org")),
+  startYear := Some(2002),
+  licenses += ("BSD 3-Clause", url("http://www.scala-lang.org/license.html")),
+  apiURL := Some(url("http://www.scala-lang.org/api/" + versionProperties.value.mavenVersion + "/")),
+  pomIncludeRepository := { _ => false },
+  pomExtra := {
+    val base =
+      <scm>
+        <connection>scm:git:git://github.com/scala/scala.git</connection>
+        <url>https://github.com/scala/scala.git</url>
+      </scm>
+        <issueManagement>
+          <system>JIRA</system>
+          <url>https://issues.scala-lang.org/</url>
+        </issueManagement>
+        <developers>
+          <developer>
+            <id>lamp</id>
+            <name>EPFL LAMP</name>
+          </developer>
+          <developer>
+            <id>Typesafe</id>
+            <name>Typesafe, Inc.</name>
+          </developer>
+        </developers>
+    apiURL.value match {
+      case Some(url) => base ++
+        <properties>
+          <info.apiURL>{url.toString}</info.apiURL>
+        </properties>
+      case None => base
+    }
+  },
+  // Remove auto-generated manifest attributes
+  packageOptions in Compile in packageBin := Seq.empty,
+  packageOptions in Compile in packageSrc := Seq.empty
 )
 
-// disable various tasks that are not needed for projects that are used
-// only for compiling code and not publishing it as a standalone artifact
-// we disable those tasks by overriding them and returning bogus files when
-// needed. This is a bit sketchy but I haven't found any better way.
-val disableDocsAndPublishingTasks = Seq[Setting[_]](
-  doc := file("!!! NO DOCS !!!"),
-  publishLocal := {},
-  publish := {},
-  packageBin in Compile := file("!!! NO PACKAGING !!!")
+/** Extra post-processing for the published POM files. These are needed to create POMs that
+  * are equivalent to the ones from the ANT build. In the long term this should be removed and
+  * POMs, scaladocs, OSGi manifests, etc. should all use the same metadata. */
+def fixPom(extra: (String, scala.xml.Node)*): Setting[_] = {
+  /** Find elements in an XML document by a simple XPath and replace them */
+  def fixXML(n: scala.xml.Node, repl: Map[String, scala.xml.Node]): scala.xml.Node = {
+    def f(n: scala.xml.Node, p: String): scala.xml.Node = n match {
+      case e: scala.xml.Elem =>
+        val pp = p + "/" + e.label
+        repl.get(pp) match {
+          case Some(xml) => xml
+          case None => e.copy(child = e.child.map(ch => f(ch, pp)))
+        }
+      case n => n
+    }
+    f(n, "")
+  }
+  pomPostProcess := { n => fixXML(pomPostProcess.value.apply(n), Map(
+    "/project/organization" ->
+      <organization>
+        <name>LAMP/EPFL</name>
+        <url>http://lamp.epfl.ch/</url>
+      </organization>,
+    "/project/url" -> <url>http://www.scala-lang.org/</url>
+  ) ++ extra) }
+}
+
+/** Remove unwanted dependencies from the POM. */
+def removePomDependencies(deps: (String, String)*): Setting[_] = {
+  pomPostProcess := { n =>
+    val n2 = pomPostProcess.value.apply(n)
+    import scala.xml._
+    import scala.xml.transform._
+    (new RuleTransformer(new RewriteRule {
+      override def transform(node: Node) = node match {
+        case e: Elem if e.label == "dependency" &&
+            deps.exists { case (g, a) =>
+              e.child.contains(<groupId>{g}</groupId>) &&
+                (e.child.contains(<artifactId>{a}</artifactId>) || e.child.contains(<artifactId>{a + "_" + scalaBinaryVersion.value}</artifactId>))
+            } => Seq.empty
+        case n => Seq(n)
+      }
+    })).transform(Seq(n2)).head
+  }
+}
+
+val disableDocs = Seq[Setting[_]](
+  sources in (Compile, doc) := Seq.empty,
+  publishArtifact in (Compile, packageDoc) := false
 )
 
-lazy val setJarLocation: Setting[_] = 
+lazy val setJarLocation: Setting[_] =
   artifactPath in packageBin in Compile := {
     // two lines below are copied over from sbt's sources:
     // https://github.com/sbt/sbt/blob/0.13/main/src/main/scala/sbt/Defaults.scala#L628
@@ -130,92 +250,234 @@ lazy val setJarLocation: Setting[_] =
   }
 lazy val scalaSubprojectSettings: Seq[Setting[_]] = commonSettings :+ setJarLocation
 
-lazy val generatePropertiesFileSettings = Seq[Setting[_]](
-  copyrightString := "Copyright 2002-2015, LAMP/EPFL",
-  resourceGenerators in Compile += generateVersionPropertiesFile.map(file => Seq(file)).taskValue,
-  generateVersionPropertiesFile := generateVersionPropertiesFileImpl.value
+def filterDocSources(ff: FileFilter): Seq[Setting[_]] = Seq(
+  sources in (Compile, doc) ~= (_.filter(ff.accept _)),
+  // Excluded sources may still be referenced by the included sources, so we add the compiler
+  // output to the scaladoc classpath to resolve them. For the `library` project this is
+  // always required because otherwise the compiler cannot even initialize Definitions without
+  // binaries of the library on the classpath. Specifically, we get this error:
+  // (library/compile:doc) scala.reflect.internal.FatalError: package class scala does not have a member Int
+  // Ant build does the same thing always: it puts binaries for documented classes on the classpath
+  // sbt never does this by default (which seems like a good default)
+  dependencyClasspath in (Compile, doc) += (classDirectory in Compile).value,
+  doc in Compile <<= doc in Compile dependsOn (compile in Compile)
 )
 
-val libIncludes: FileFilter = "*.tmpl" | "*.xml" | "*.js" | "*.css" | "rootdoc.txt"
+def regexFileFilter(s: String): FileFilter = new FileFilter {
+  val pat = s.r.pattern
+  def accept(f: File) = pat.matcher(f.getAbsolutePath.replace('\\', '/')).matches()
+}
 
 lazy val library = configureAsSubproject(project)
   .settings(generatePropertiesFileSettings: _*)
+  .settings(Osgi.settings: _*)
   .settings(
     name := "scala-library",
+    description := "Scala Standard Library",
     compileOrder := CompileOrder.Mixed, // needed for JFunction classes in scala.runtime.java8
     scalacOptions in Compile ++= Seq[String]("-sourcepath", (scalaSource in Compile).value.toString),
-    // Workaround for a bug in `scaladoc` that it seems to not respect the `-sourcepath` option
-    // as a result of this bug, the compiler cannot even initialize Definitions without
-    // binaries of the library on the classpath. Specifically, we get this error:
-    // (library/compile:doc) scala.reflect.internal.FatalError: package class scala does not have a member Int
-    // Ant build does the same thing always: it puts binaries for documented classes on the classpath
-    // sbt never does this by default (which seems like a good default)
-    dependencyClasspath in Compile in doc += (classDirectory in Compile).value,
     scalacOptions in Compile in doc ++= {
       val libraryAuxDir = (baseDirectory in ThisBuild).value / "src/library-aux"
-      Seq("-doc-no-compile", libraryAuxDir.toString)
+      Seq(
+        "-doc-no-compile", libraryAuxDir.toString,
+        "-skip-packages", "scala.concurrent.impl",
+        "-doc-root-content", (sourceDirectory in Compile).value + "/rootdoc.txt"
+      )
+    },
+    includeFilter in unmanagedResources in Compile := "*.tmpl" | "*.xml" | "*.js" | "*.css" | "rootdoc.txt",
+    // Include *.txt files in source JAR:
+    mappings in Compile in packageSrc ++= {
+      val base = (unmanagedResourceDirectories in Compile).value
+      base ** "*.txt" pair relativeTo(base)
     },
-    includeFilter in unmanagedResources in Compile := libIncludes)
+    Osgi.headers += "Import-Package" -> "sun.misc;resolution:=optional, *",
+    fixPom(
+      "/project/name" -> <name>Scala Library</name>,
+      "/project/description" -> <description>Standard library for the Scala Programming Language</description>,
+      "/project/packaging" -> <packaging>jar</packaging>
+    )
+  )
+  .settings(filterDocSources("*.scala" -- (regexFileFilter(".*/runtime/.*\\$\\.scala") ||
+                                           regexFileFilter(".*/runtime/ScalaRunTime\\.scala") ||
+                                           regexFileFilter(".*/runtime/StringAdd\\.scala"))): _*)
 
 lazy val reflect = configureAsSubproject(project)
   .settings(generatePropertiesFileSettings: _*)
-  .settings(name := "scala-reflect")
+  .settings(Osgi.settings: _*)
+  .settings(
+    name := "scala-reflect",
+    description := "Scala Reflection Library",
+    Osgi.bundleName := "Scala Reflect",
+    scalacOptions in Compile in doc ++= Seq(
+      "-skip-packages", "scala.reflect.macros.internal:scala.reflect.internal:scala.reflect.io"
+    ),
+    Osgi.headers +=
+      "Import-Package" -> ("scala.*;version=\"${range;[==,=+);${ver}}\","+
+                           "scala.tools.nsc;resolution:=optional;version=\"${range;[==,=+);${ver}}\","+
+                           "*"),
+    fixPom(
+      "/project/name" -> <name>Scala Compiler</name>,
+      "/project/description" -> <description>Compiler for the Scala Programming Language</description>,
+      "/project/packaging" -> <packaging>jar</packaging>
+    )
+  )
   .dependsOn(library)
 
-val compilerIncludes: FileFilter =
-  "*.tmpl" | "*.xml" | "*.js" | "*.css" | "*.html" | "*.properties" | "*.swf" |
-  "*.png" | "*.gif" | "*.gif" | "*.txt"
-
 lazy val compiler = configureAsSubproject(project)
   .settings(generatePropertiesFileSettings: _*)
+  .settings(Osgi.settings: _*)
   .settings(
     name := "scala-compiler",
+    description := "Scala Compiler",
     libraryDependencies ++= Seq(antDep, asmDep),
+    // These are only needed for the POM:
+    libraryDependencies ++= Seq(scalaXmlDep, scalaParserCombinatorsDep, jlineDep % "optional"),
     // this a way to make sure that classes from interactive and scaladoc projects
     // end up in compiler jar (that's what Ant build does)
     // we need to use LocalProject references (with strings) to deal with mutual recursion
-    mappings in Compile in packageBin :=
-      (mappings in Compile in packageBin).value ++
-      dependencyClasses(
-        (externalDependencyClasspath in Compile).value,
-        modules = Set(asmDep),
-        keep = "*.class" || "scala-asm.properties",
-        streams.value.cacheDirectory) ++
-      (mappings in Compile in packageBin in LocalProject("interactive")).value ++
-      (mappings in Compile in packageBin in LocalProject("scaladoc")).value ++
-      (mappings in Compile in packageBin in LocalProject("repl")).value,
-    includeFilter in unmanagedResources in Compile := compilerIncludes)
+    products in Compile in packageBin :=
+      (products in Compile in packageBin).value ++
+        Seq((dependencyClasspath in Compile).value.find(_.get(moduleID.key) == Some(asmDep)).get.data) ++
+        (products in Compile in packageBin in LocalProject("interactive")).value ++
+        (products in Compile in packageBin in LocalProject("scaladoc")).value ++
+        (products in Compile in packageBin in LocalProject("repl")).value ++
+        (products in Compile in packageBin in LocalProject("repl-jline")).value ++
+        (products in Compile in packageBin in LocalProject("repl-jline-embedded")).value,
+    includeFilter in unmanagedResources in Compile :=
+      "*.tmpl" | "*.xml" | "*.js" | "*.css" | "*.html" | "*.properties" | "*.swf" |
+      "*.png" | "*.gif" | "*.gif" | "*.txt",
+    // Also include the selected unmanaged resources and source files from the additional projects in the source JAR:
+    mappings in Compile in packageSrc ++= {
+      val base = (unmanagedResourceDirectories in Compile).value ++
+        (unmanagedResourceDirectories in Compile in LocalProject("interactive")).value ++
+        (unmanagedResourceDirectories in Compile in LocalProject("scaladoc")).value ++
+        (unmanagedResourceDirectories in Compile in LocalProject("repl")).value
+      base ** ((includeFilter in unmanagedResources in Compile).value || "*.scala" || "*.psd" || "*.ai" || "*.java") pair relativeTo(base)
+    },
+    scalacOptions in Compile in doc ++= Seq(
+      "-doc-root-content", (sourceDirectory in Compile).value + "/rootdoc.txt"
+    ),
+    Osgi.headers +=
+      "Import-Package" -> ("jline.*;resolution:=optional," +
+                           "org.apache.tools.ant.*;resolution:=optional," +
+                           "scala.util.parsing.*;version=\"${range;[====,====];"+versionNumber("scala-parser-combinators")+"}\";resolution:=optional," +
+                           "scala.xml.*;version=\"${range;[====,====];"+versionNumber("scala-xml")+"}\";resolution:=optional," +
+                           "scala.*;version=\"${range;[==,=+);${ver}}\"," +
+                           "*"),
+    // Generate the ScriptEngineFactory service definition. The ant build does this when building
+    // the JAR but sbt has no support for it and it is easier to do as a resource generator:
+    generateServiceProviderResources("javax.script.ScriptEngineFactory" -> "scala.tools.nsc.interpreter.IMain$Factory"),
+    managedResourceDirectories in Compile := Seq((resourceManaged in Compile).value),
+    fixPom(
+      "/project/name" -> <name>Scala Compiler</name>,
+      "/project/description" -> <description>Compiler for the Scala Programming Language</description>,
+      "/project/packaging" -> <packaging>jar</packaging>
+    ),
+    apiURL := None,
+    removePomDependencies(
+      ("org.apache.ant", "ant"),
+      ("org.scala-lang.modules", "scala-asm")
+    )
+  )
   .dependsOn(library, reflect)
 
 lazy val interactive = configureAsSubproject(project)
-  .settings(disableDocsAndPublishingTasks: _*)
+  .settings(disableDocs: _*)
+  .settings(
+    name := "scala-compiler-interactive",
+    description := "Scala Interactive Compiler",
+    publishArtifact := false
+  )
   .dependsOn(compiler)
 
-// TODO: SI-9339 embed shaded copy of jline & its interface (see #4563)
 lazy val repl = configureAsSubproject(project)
+  .settings(disableDocs: _*)
   .settings(
-    libraryDependencies += jlineDep,
     connectInput in run := true,
+    publishArtifact := false,
     outputStrategy in run := Some(StdoutOutput),
     run <<= (run in Compile).partialInput(" -usejavacp") // Automatically add this so that `repl/run` works without additional arguments.
   )
-  .settings(disableDocsAndPublishingTasks: _*)
   .dependsOn(compiler, interactive)
 
+lazy val replJline = configureAsSubproject(Project("repl-jline", file(".") / "src" / "repl-jline"))
+  .settings(disableDocs: _*)
+  .settings(
+    libraryDependencies += jlineDep,
+    name := "scala-repl-jline",
+    publishArtifact := false
+  )
+  .dependsOn(repl)
+
+lazy val replJlineEmbedded = Project("repl-jline-embedded", file(".") / "target" / "repl-jline-embedded-src-dummy")
+  .settings(scalaSubprojectSettings: _*)
+  .settings(
+    name := "scala-repl-jline-embedded",
+    // There is nothing to compile for this project. Instead we use the compile task to create
+    // shaded versions of repl-jline and jline.jar. dist/mkBin puts all of quick/repl,
+    // quick/repl-jline and quick/repl-jline-shaded on the classpath for quick/bin scripts.
+    // This is different from the ant build where all parts are combined into quick/repl, but
+    // it is cleaner because it avoids circular dependencies.
+    compile in Compile <<= (compile in Compile).dependsOn(Def.task {
+      import java.util.jar._
+      import collection.JavaConverters._
+      val inputs: Iterator[JarJar.Entry] = {
+        val repljlineClasses = (products in Compile in replJline).value.flatMap(base => Path.allSubpaths(base).map(x => (base, x._1)))
+        val jlineJAR = (dependencyClasspath in Compile).value.find(_.get(moduleID.key) == Some(jlineDep)).get.data
+        val jarFile = new JarFile(jlineJAR)
+        val jarEntries = jarFile.entries.asScala.filterNot(_.isDirectory).map(entry => JarJar.JarEntryInput(jarFile, entry))
+        def compiledClasses = repljlineClasses.iterator.map { case (base, file) => JarJar.FileInput(base, file) }
+        (jarEntries ++ compiledClasses).filter(x =>
+          x.name.endsWith(".class") || x.name.endsWith(".properties") || x.name.startsWith("META-INF/native") || x.name.startsWith("META-INF/maven")
+        )
+      }
+      //println(inputs.map(_.name).mkString("\n"))
+      import JarJar.JarJarConfig._
+      val config: Seq[JarJar.JarJarConfig] = Seq(
+        Rule("org.fusesource.**", "scala.tools.fusesource_embedded.@1"),
+        Rule("jline.**", "scala.tools.jline_embedded.@1"),
+        Rule("scala.tools.nsc.interpreter.jline.**", "scala.tools.nsc.interpreter.jline_embedded.@1"),
+        Keep("scala.tools.**")
+      )
+      val outdir = (classDirectory in Compile).value
+      JarJar(inputs, outdir, config)
+    }),
+    publishArtifact := false
+  )
+  .dependsOn(replJline)
+
 lazy val scaladoc = configureAsSubproject(project)
+  .settings(disableDocs: _*)
   .settings(
-    libraryDependencies ++= Seq(scalaXmlDep, scalaParserCombinatorsDep, partestDep)
+    name := "scala-compiler-doc",
+    description := "Scala Documentation Generator",
+    libraryDependencies ++= Seq(scalaXmlDep, scalaParserCombinatorsDep, partestDep),
+    publishArtifact := false,
+    includeFilter in unmanagedResources in Compile := "*.html" | "*.css" | "*.gif" | "*.png" | "*.js" | "*.txt"
   )
-  .settings(disableDocsAndPublishingTasks: _*)
   .dependsOn(compiler)
 
-lazy val scalap = configureAsSubproject(project).
-  dependsOn(compiler)
+lazy val scalap = configureAsSubproject(project)
+  .settings(
+    description := "Scala Bytecode Parser",
+    // Include decoder.properties
+    includeFilter in unmanagedResources in Compile := "*.properties",
+    fixPom(
+      "/project/name" -> <name>Scalap</name>,
+      "/project/description" -> <description>bytecode analysis tool</description>,
+      "/project/properties" -> scala.xml.Text("")
+    )
+  )
+  .dependsOn(compiler)
 
 lazy val partestExtras = configureAsSubproject(Project("partest-extras", file(".") / "src" / "partest-extras"))
-  .dependsOn(repl)
+  .dependsOn(replJlineEmbedded)
   .settings(clearSourceAndResourceDirectories: _*)
+  .settings(disableDocs: _*)
   .settings(
+    name := "scala-partest-extras",
+    description := "Scala Compiler Testing Tool (compiler-specific extras)",
+    publishArtifact := false,
     libraryDependencies += partestDep,
     unmanagedSourceDirectories in Compile := List(baseDirectory.value)
   )
@@ -224,22 +486,26 @@ lazy val junit = project.in(file("test") / "junit")
   .dependsOn(library, reflect, compiler, partestExtras, scaladoc)
   .settings(clearSourceAndResourceDirectories: _*)
   .settings(commonSettings: _*)
+  .settings(disableDocs: _*)
   .settings(
+    publishArtifact := false,
     fork in Test := true,
     libraryDependencies ++= Seq(junitDep, junitIntefaceDep),
     testOptions += Tests.Argument(TestFrameworks.JUnit, "-a", "-v"),
     unmanagedSourceDirectories in Test := List(baseDirectory.value)
   )
 
-lazy val partestJavaAgent = (project in file(".") / "src" / "partest-javaagent").
-  settings(commonSettings: _*).
-  settings(
+lazy val partestJavaAgent = Project("partest-javaagent", file(".") / "src" / "partest-javaagent")
+  .settings(commonSettings: _*)
+  .settings(generatePropertiesFileSettings: _*)
+  .settings(disableDocs: _*)
+  .settings(
     libraryDependencies += asmDep,
-    doc := file("!!! NO DOCS !!!"),
     publishLocal := {},
     publish := {},
     // Setting name to "scala-partest-javaagent" so that the jar file gets that name, which the Runner relies on
     name := "scala-partest-javaagent",
+    description := "Scala Compiler Testing Tool (compiler-specific java agent)",
     // writing jar file to $buildDirectory/pack/lib because that's where it's expected to be found
     setJarLocation,
     // add required manifest entry - previously included from file
@@ -249,13 +515,14 @@ lazy val partestJavaAgent = (project in file(".") / "src" / "partest-javaagent")
     exportJars := true
   )
 
-lazy val test = project.
-  dependsOn(compiler, interactive, repl, scalap, partestExtras, partestJavaAgent, scaladoc).
-  configs(IntegrationTest).
-  settings(disableDocsAndPublishingTasks: _*).
-  settings(commonSettings: _*).
-  settings(Defaults.itSettings: _*).
-  settings(
+lazy val test = project
+  .dependsOn(compiler, interactive, replJlineEmbedded, scalap, partestExtras, partestJavaAgent, scaladoc)
+  .configs(IntegrationTest)
+  .settings(commonSettings: _*)
+  .settings(disableDocs: _*)
+  .settings(Defaults.itSettings: _*)
+  .settings(
+    publishArtifact := false,
     libraryDependencies ++= Seq(asmDep, partestDep, scalaXmlDep, partestInterfaceDep, scalacheckDep),
     unmanagedBase in Test := baseDirectory.value / "files" / "lib",
     unmanagedJars in Test <+= (unmanagedBase) (j => Attributed.blank(j)) map(identity),
@@ -279,9 +546,82 @@ lazy val test = project.
      )
   )
 
-lazy val root = (project in file(".")).
-  aggregate(library, reflect, compiler, interactive, repl,
-    scaladoc, scalap, partestExtras, junit).settings(
+lazy val manual = configureAsSubproject(project)
+  .settings(disableDocs: _*)
+  .settings(
+    publishArtifact := false,
+    libraryDependencies ++= Seq(scalaXmlDep, antDep),
+    classDirectory in Compile := (target in Compile).value / "classes"
+  )
+  .dependsOn(library)
+
+lazy val libraryAll = Project("library-all", file(".") / "target" / "library-all-src-dummy")
+  .settings(commonSettings: _*)
+  .settings(disableDocs: _*)
+  .settings(
+    name := "scala-library-all",
+    publishArtifact in (Compile, packageBin) := false,
+    publishArtifact in (Compile, packageSrc) := false,
+    libraryDependencies ++= Seq(scalaXmlDep, scalaParserCombinatorsDep, scalaSwingDep),
+    apiURL := None,
+    fixPom(
+      "/project/name" -> <name>Scala Library Powerpack</name>,
+      "/project/description" -> <description>The Scala Standard Library and Official Modules</description>
+    )
+  )
+  .dependsOn(library, reflect)
+
+lazy val scalaDist = Project("scala-dist", file(".") / "target" / "scala-dist-dist-src-dummy")
+  .settings(commonSettings: _*)
+  .settings(disableDocs: _*)
+  .settings(
+    mappings in Compile in packageBin ++= {
+      val binBaseDir = buildDirectory.value / "pack"
+      val binMappings = (mkBin in dist).value.pair(relativeTo(binBaseDir), errorIfNone = false)
+      // With the way the resource files are spread out over the project sources we can't just add
+      // an unmanagedResourceDirectory, so we generate the mappings manually:
+      val docBaseDir = (baseDirectory in ThisBuild).value
+      val docMappings = (docBaseDir / "doc").*** pair relativeTo(docBaseDir)
+      val resBaseDir = (baseDirectory in ThisBuild).value / "src/manual/scala/tools/docutil/resources"
+      val resMappings = resBaseDir ** ("*.html" | "*.css" | "*.gif" | "*.png") pair (p => relativeTo(resBaseDir)(p).map("doc/tools/" + _))
+      docMappings ++ resMappings ++ binMappings
+    },
+    resourceGenerators in Compile += Def.task {
+      val command = "fsc, scala, scalac, scaladoc, scalap"
+      val htmlOut = (resourceManaged in Compile).value / "doc/tools"
+      val manOut = (resourceManaged in Compile).value / "genman"
+      val fixedManOut = (resourceManaged in Compile).value / "man"
+      IO.createDirectory(htmlOut)
+      IO.createDirectory(manOut / "man1")
+      toError(runner.value.run("scala.tools.docutil.ManMaker",
+        (fullClasspath in Compile in manual).value.files,
+        Seq(command, htmlOut.getAbsolutePath, manOut.getAbsolutePath),
+        streams.value.log))
+      (manOut ** "*.1" pair rebase(manOut, fixedManOut)).foreach { case (in, out) =>
+        // Generated manpages should always use LF only. There doesn't seem to be a good reason
+        // for generating them with the platform EOL first and then converting them but that's
+        // what the ant build does.
+        IO.write(out, IO.readBytes(in).filterNot(_ == '\r'))
+      }
+      (htmlOut ** "*.html").get ++ (fixedManOut ** "*.1").get
+    }.taskValue,
+    managedResourceDirectories in Compile := Seq((resourceManaged in Compile).value),
+    libraryDependencies += jlineDep,
+    apiURL := None,
+    fixPom(
+      "/project/name" -> <name>Scala Distribution Artifacts</name>,
+      "/project/description" -> <description>The Artifacts Distributed with Scala</description>,
+      "/project/packaging" -> <packaging>jar</packaging>
+    ),
+    publishArtifact in (Compile, packageSrc) := false
+  )
+  .dependsOn(libraryAll, compiler, scalap)
+
+lazy val root = (project in file("."))
+  .settings(disableDocs: _*)
+  .settings(publishArtifact := false)
+  .aggregate(library, reflect, compiler, interactive, repl, replJline, replJlineEmbedded,
+    scaladoc, scalap, partestExtras, junit, libraryAll, scalaDist).settings(
     sources in Compile := Seq.empty,
     onLoadMessage := """|*** Welcome to the sbt build definition for Scala! ***
       |This build definition has an EXPERIMENTAL status. If you are not
@@ -289,9 +629,35 @@ lazy val root = (project in file(".")).
       |the Ant build definition for now. Check README.md for more information.""".stripMargin
   )
 
-lazy val dist = (project in file("dist")).settings(
-  mkBin := mkBinImpl.value
-)
+// The following subprojects' binaries are required for building "pack":
+lazy val distDependencies = Seq(replJline, replJlineEmbedded, compiler, library, partestExtras, partestJavaAgent, reflect, scalap, scaladoc)
+
+lazy val dist = (project in file("dist"))
+  .settings(commonSettings)
+  .settings(
+    libraryDependencies ++= Seq(scalaSwingDep, jlineDep),
+    mkBin := mkBinImpl.value,
+    mkQuick <<= Def.task {} dependsOn ((distDependencies.map(products in Runtime in _) :+ mkBin): _*),
+    mkPack <<= Def.task {} dependsOn (packageBin in Compile, mkBin),
+    target := (baseDirectory in ThisBuild).value / "target" / thisProject.value.id,
+    packageBin in Compile := {
+      val extraDeps = Set(scalaSwingDep, scalaParserCombinatorsDep, scalaXmlDep)
+      val targetDir = (buildDirectory in ThisBuild).value / "pack" / "lib"
+      def uniqueModule(m: ModuleID) = (m.organization, m.name.replaceFirst("_.*", ""))
+      val extraModules = extraDeps.map(uniqueModule)
+      val extraJars = (externalDependencyClasspath in Compile).value.map(a => (a.get(moduleID.key), a.data)).collect {
+        case (Some(m), f) if extraModules contains uniqueModule(m) => f
+      }
+      val jlineJAR = (dependencyClasspath in Compile).value.find(_.get(moduleID.key) == Some(jlineDep)).get.data
+      val mappings = extraJars.map(f => (f, targetDir / f.getName)) :+ (jlineJAR, targetDir / "jline.jar")
+      IO.copy(mappings, overwrite = true)
+      targetDir
+    },
+    cleanFiles += (buildDirectory in ThisBuild).value / "quick",
+    cleanFiles += (buildDirectory in ThisBuild).value / "pack",
+    packageBin in Compile <<= (packageBin in Compile).dependsOn(distDependencies.map(packageBin in Compile in _): _*)
+  )
+  .dependsOn(distDependencies.map(p => p: ClasspathDep[ProjectReference]): _*)
 
 /**
  * Configures passed project as a subproject (e.g. compiler or repl)
@@ -306,105 +672,15 @@ lazy val dist = (project in file("dist")).settings(
  */
 def configureAsSubproject(project: Project): Project = {
   val base = file(".") / "src" / project.id
-  (project in base).settings(scalaSubprojectSettings: _*)
+  (project in base)
+    .settings(scalaSubprojectSettings: _*)
+    .settings(generatePropertiesFileSettings: _*)
 }
 
-
 lazy val buildDirectory = settingKey[File]("The directory where all build products go. By default ./build")
-lazy val copyrightString = settingKey[String]("Copyright string.")
-lazy val generateVersionPropertiesFile = taskKey[File]("Generating version properties file.")
 lazy val mkBin = taskKey[Seq[File]]("Generate shell script (bash or Windows batch).")
-
-lazy val generateVersionPropertiesFileImpl: Def.Initialize[Task[File]] = Def.task {
-  val propFile = (resourceManaged in Compile).value / s"${thisProject.value.id}.properties"
-  val props = new java.util.Properties
-
-  /**
-   * Regexp that splits version number split into two parts: version and suffix.
-   * Examples of how the split is performed:
-   *
-   *  "2.11.5": ("2.11.5", null)
-   *  "2.11.5-acda7a": ("2.11.5", "-acda7a")
-   *  "2.11.5-SNAPSHOT": ("2.11.5", "-SNAPSHOT")
-   *
-   */
-  val versionSplitted = """([\w+\.]+)(-[\w+\.]+)??""".r
-
-  val versionSplitted(ver, suffixOrNull) = version.value
-  val osgiSuffix = suffixOrNull match {
-    case null => "-VFINAL"
-    case "-SNAPSHOT" => ""
-    case suffixStr => suffixStr
-  }
-
-  def executeTool(tool: String) = {
-      val cmd =
-        if (System.getProperty("os.name").toLowerCase.contains("windows"))
-          s"cmd.exe /c tools\\$tool.bat -p"
-        else s"tools/$tool"
-      Process(cmd).lines.head
-  }
-
-  val commitDate = executeTool("get-scala-commit-date")
-  val commitSha = executeTool("get-scala-commit-sha")
-
-  props.put("version.number", s"${version.value}-$commitDate-$commitSha")
-  props.put("maven.version.number", s"${version.value}")
-  props.put("osgi.version.number", s"$ver.v$commitDate$osgiSuffix-$commitSha")
-  props.put("copyright.string", copyrightString.value)
-
-  // unfortunately, this will write properties in arbitrary order
-  // this makes it harder to test for stability of generated artifacts
-  // consider using https://github.com/etiennestuder/java-ordered-properties
-  // instead of java.util.Properties
-  IO.write(props, null, propFile)
-
-  propFile
-}
-
-/**
- * Extract selected dependencies to the `cacheDirectory` and return a mapping for the content.
- * Heavily inspired by sbt-assembly (https://github.com/sbt/sbt-assembly/blob/0.13.0/src/main/scala/sbtassembly/Assembly.scala#L157)
- */
-def dependencyClasses(dependencies: Classpath, modules: Set[ModuleID], keep: FileFilter, cacheDirectory: File): Seq[(File, String)] = {
-  val dependencyFiles: Seq[File] = dependencies.map(_.data).toSeq
-  val toInclude = dependencyFiles.filter(f => {
-    val p = f.getCanonicalPath
-    modules.exists(m => {
-      // works for both .m2 (org/scala-lang/modules/scala-asm/5.0.3-scala-3/scala-asm-5.0.3-scala-3.jar)
-      // and .ivy2 (org.scala-lang.modules/scala-asm/5.0.3-scala-3/bundles/scala-asm.jar)
-      val nameParts = m.organization.split('.').toSet + m.name + m.revision
-      nameParts.forall(p.contains)
-    })
-  })
-  assert(toInclude.forall(sbt.classpath.ClasspathUtilities.isArchive), s"Expected JAR files as dependencies: $toInclude")
-
-  val tempDir = cacheDirectory / "unpackedDependencies"
-
-  def sha1name(f: File): String     = bytesToSha1String(f.getCanonicalPath.getBytes("UTF-8"))
-  def sha1content(f: File): String  = bytesToSha1String(IO.readBytes(f))
-  def bytesToSha1String(bytes: Array[Byte]): String = {
-    val sha1 = java.security.MessageDigest.getInstance("SHA-1")
-    val hash = sha1.digest(bytes)
-    hash map {"%02x".format(_)} mkString
-  }
-
-  val jarDirs: Seq[File] = for (jar <- toInclude) yield {
-    val jarName = jar.getName
-    val hash = sha1name(jar) + "_" + sha1content(jar)
-    val jarNamePath = tempDir / (hash + ".jarName")
-    val dest = tempDir / hash
-    if (!jarNamePath.exists || IO.read(jarNamePath) != jar.getCanonicalPath) {
-      IO.delete(dest)
-      dest.mkdir()
-      IO.unzip(jar, dest)
-      IO.write(jarNamePath, jar.getCanonicalPath, IO.utf8, append = false)
-    }
-    dest
-  }
-
-  jarDirs.flatMap(dir => dir ** keep --- dir pair relativeTo(dir))
-}
+lazy val mkQuick = taskKey[Unit]("Generate a full build, including scripts, in build-sbt/quick")
+lazy val mkPack = taskKey[Unit]("Generate a full build, including scripts, in build-sbt/pack")
 
 // Defining these settings is somewhat redundant as we also redefine settings that depend on them.
 // However, IntelliJ's project import works better when these are set correctly.
@@ -416,6 +692,7 @@ def clearSourceAndResourceDirectories = Seq(Compile, Test).flatMap(config => inC
 )))
 
 lazy val mkBinImpl: Def.Initialize[Task[Seq[File]]] = Def.task {
+  import java.io.IOException
   def mkScalaTool(mainCls: String, classpath: Seq[Attributed[File]]): ScalaTool =
     ScalaTool(mainClass  = mainCls,
       classpath  = classpath.toList.map(_.data.getAbsolutePath),
@@ -423,45 +700,42 @@ lazy val mkBinImpl: Def.Initialize[Task[Seq[File]]] = Def.task {
       javaOpts   = "-Xmx256M -Xms32M",
       toolFlags  = "")
   val rootDir = (classDirectory in Compile in compiler).value
-  def writeScripts(scalaTool: ScalaTool, file: String, outDir: File): Seq[File] =
-    Seq(
+  val quickOutDir = buildDirectory.value / "quick/bin"
+  val packOutDir = buildDirectory.value / "pack/bin"
+  def writeScripts(scalaTool: ScalaTool, file: String, outDir: File): Seq[File] = {
+    val res = Seq(
       scalaTool.writeScript(file, "unix", rootDir, outDir),
       scalaTool.writeScript(file, "windows", rootDir, outDir)
     )
-  def mkQuickBin(file: String, mainCls: String, classpath: Seq[Attributed[File]]): Seq[File] = {
-    val scalaTool = mkScalaTool(mainCls, classpath)
-    val outDir = buildDirectory.value / "quick/bin"
-    writeScripts(scalaTool, file, outDir)
-  }
-
-  def mkPackBin(file: String, mainCls: String): Seq[File] = {
-    val scalaTool = mkScalaTool(mainCls, classpath = Nil)
-    val outDir = buildDirectory.value / "pack/bin"
-    writeScripts(scalaTool, file, outDir)
+    res.foreach { f =>
+      //TODO 2.12: Use Files.setPosixFilePermissions() (Java 7+) instead of calling out to chmod
+      if(Process(List("chmod", "ugo+rx", f.getAbsolutePath())).! > 0)
+        throw new IOException("chmod failed")
+    }
+    res
   }
 
   def mkBin(file: String, mainCls: String, classpath: Seq[Attributed[File]]): Seq[File] =
-    mkQuickBin(file, mainCls, classpath) ++ mkPackBin(file, mainCls)
+    writeScripts(mkScalaTool(mainCls, classpath), file, quickOutDir) ++
+    writeScripts(mkScalaTool(mainCls, Nil      ), file, packOutDir)
 
-  mkBin("scala"    , "scala.tools.nsc.MainGenericRunner", (fullClasspath in Compile in repl).value) ++
+  streams.value.log.info(s"Creating scripts in $quickOutDir and $packOutDir")
+
+  mkBin("scala"    , "scala.tools.nsc.MainGenericRunner", (fullClasspath in Compile in replJlineEmbedded).value) ++
   mkBin("scalac"   , "scala.tools.nsc.Main",              (fullClasspath in Compile in compiler).value) ++
   mkBin("fsc"      , "scala.tools.nsc.CompileClient",     (fullClasspath in Compile in compiler).value) ++
   mkBin("scaladoc" , "scala.tools.nsc.ScalaDoc",          (fullClasspath in Compile in scaladoc).value) ++
   mkBin("scalap"   , "scala.tools.scalap.Main",           (fullClasspath in Compile in scalap).value)
 }
 
-buildDirectory in ThisBuild := (baseDirectory in ThisBuild).value / "build-sbt"
-
-lazy val versionProps: Map[String, String] = {
-  import java.io.FileInputStream
-  import java.util.Properties
-  val props = new Properties()
-  val in = new FileInputStream(file("versions.properties"))
-  try props.load(in)
-  finally in.close()
-  import scala.collection.JavaConverters._
-  props.asScala.toMap
-}
+/** Generate service provider definition files under META-INF/services */
+def generateServiceProviderResources(services: (String, String)*): Setting[_] =
+  resourceGenerators in Compile += Def.task {
+    services.map { case (k, v) =>
+      val f = (resourceManaged in Compile).value / "META-INF/services" / k
+      IO.write(f, v + "\n")
+      f
+    }
+  }.taskValue
 
-def versionNumber(name: String): String =
-  versionProps(s"$name.version.number")
+buildDirectory in ThisBuild := (baseDirectory in ThisBuild).value / "build-sbt"
diff --git a/build.xml b/build.xml
index 9f42afb20d..0a41870b21 100644
--- a/build.xml
+++ b/build.xml
@@ -270,7 +270,7 @@ TODO:
       </artifact:dependencies>
 
       <artifact:dependencies pathId="jarjar.classpath">
-        <dependency groupId="com.googlecode.jarjar" artifactId="jarjar" version="1.3"/>
+        <dependency groupId="org.pantsbuild" artifactId="jarjar" version="1.6.0"/>
       </artifact:dependencies>
 
       <!-- JUnit -->
@@ -996,10 +996,14 @@ TODO:
       <include name="**/*.png"/>
       <include name="**/*.gif"/>
       <include name="**/*.txt"/>
+      <include name="**/*.eot"/>
+      <include name="**/*.ttf"/>
+      <include name="**/*.woff"/>
+      <include name="**/*.svg"/>
     </patternset>
 
     <taskdef resource="scala/tools/ant/sabbus/antlib.xml" classpathref="starr.compiler.path"/>
-    <taskdef name="jarjar" classname="com.tonicsystems.jarjar.JarJarTask" classpathref="jarjar.classpath" />
+    <taskdef name="jarjar" classname="org.pantsbuild.jarjar.JarJarTask" classpathref="jarjar.classpath" />
   </target>
 
 <!-- ===========================================================================
@@ -1537,7 +1541,7 @@ TODO:
     <mkdir dir="${bc-build.dir}"/>
     <!-- Pull down MIMA -->
     <artifact:dependencies pathId="mima.classpath">
-      <dependency groupId="com.typesafe" artifactId="mima-reporter_2.10" version="0.1.6"/>
+      <dependency groupId="com.typesafe" artifactId="mima-reporter_2.10" version="0.1.8"/>
     </artifact:dependencies>
     <artifact:dependencies pathId="old.bc.classpath">
       <dependency groupId="org.scala-lang" artifactId="scala-library" version="${bc-reference-version}"/>
@@ -1580,20 +1584,15 @@ TODO:
   <target name="docs.lib" depends="docs.start" unless="docs.skip">
     <staged-docs project="library">
       <include name="**/*.scala"/>
-      <exclude name="runtime/*$.scala"/>
-      <exclude name="runtime/ScalaRunTime.scala"/>
-      <exclude name="runtime/StringAdd.scala"/>
+      <exclude name="**/runtime/*$.scala"/>
+      <exclude name="**/runtime/ScalaRunTime.scala"/>
+      <exclude name="**/runtime/StringAdd.scala"/>
     </staged-docs>
   </target>
 
   <target name="docs.reflect" depends="docs.start" unless="docs.skip">
     <staged-docs project="reflect">
       <include name="**/*.scala"/>
-      <exclude name="reflect/Code.scala"/>
-      <exclude name="reflect/Print.scala"/>
-      <exclude name="reflect/Symbol.scala"/>
-      <exclude name="reflect/Tree.scala"/>
-      <exclude name="reflect/Type.scala"/>
     </staged-docs>
   </target>
 
@@ -1667,6 +1666,10 @@ TODO:
         <include name="**/*.css"/>
         <include name="**/*.gif"/>
         <include name="**/*.png"/>
+        <include name="**/*.eot"/>
+        <include name="**/*.ttf"/>
+        <include name="**/*.woff"/>
+        <include name="**/*.svg"/>
       </fileset>
     </copy>
   </target>
diff --git a/doc/LICENSE.md b/doc/LICENSE.md
index f38bf4c519..5c9310a8db 100644
--- a/doc/LICENSE.md
+++ b/doc/LICENSE.md
@@ -56,9 +56,5 @@ This license is used by the following third-party libraries:
 This license is used by the following third-party libraries:
 
   * jquery
-  * jquery-ui
-  * jquery-layout
   * sizzle
   * tools tooltip
-
-
diff --git a/doc/License.rtf b/doc/License.rtf
index 35ff645feb..d2f37a4bf9 100644
--- a/doc/License.rtf
+++ b/doc/License.rtf
@@ -53,7 +53,5 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \'93AS IS\'9
 
 \fs26 This license is used by the following third-party libraries:\
 	\'95	jquery\
-	\'95	jquery-ui\
-	\'95	jquery-layout\
 	\'95	sizzle\
 	\'95	tools tooltip\
diff --git a/doc/licenses/mit_jquery-layout.txt b/doc/licenses/mit_jquery-layout.txt
deleted file mode 100644
index 4af6a0a4b0..0000000000
--- a/doc/licenses/mit_jquery-layout.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License
-
-Copyright (c) 2010 Fabrizio Balliano, Kevin Dalman
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/doc/licenses/mit_jquery-ui.txt b/doc/licenses/mit_jquery-ui.txt
deleted file mode 100644
index be226805d3..0000000000
--- a/doc/licenses/mit_jquery-ui.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2011 Paul Bakaus, http://jqueryui.com/
-
-This software consists of voluntary contributions made by many
-individuals (AUTHORS.txt, http://jqueryui.com/about) For exact
-contribution history, see the revision history and logs, available
-at http://jquery-ui.googlecode.com/svn/
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/project/JarJar.scala b/project/JarJar.scala
new file mode 100644
index 0000000000..2eec0e9033
--- /dev/null
+++ b/project/JarJar.scala
@@ -0,0 +1,92 @@
+import org.pantsbuild.jarjar
+import org.pantsbuild.jarjar._
+import org.pantsbuild.jarjar.util._
+import scala.collection.JavaConverters._
+import java.util.jar._
+import java.io._
+import sbt._
+
+object JarJar {
+  sealed abstract class JarJarConfig {
+    def toPatternElement: PatternElement
+  }
+  object JarJarConfig {
+    case class Rule(pattern: String, result: String) extends JarJarConfig {
+      def toPatternElement: PatternElement = {
+        val rule = new jarjar.Rule
+        rule.setPattern(pattern)
+        rule.setResult(result)
+        rule
+      }
+    }
+    case class Keep(pattern: String) extends JarJarConfig {
+      def toPatternElement: PatternElement = {
+        val keep = new jarjar.Keep
+        keep.setPattern(pattern)
+        keep
+      }
+    }
+  }
+
+  sealed abstract class Entry {
+    def name: String
+    def time: Long
+    def data: Array[Byte]
+  }
+
+  case class JarEntryInput(jarFile: JarFile, entry: JarEntry) extends Entry {
+    def name = entry.getName
+    def time = entry.getTime
+    def data = sbt.IO.readBytes(jarFile.getInputStream(entry))
+  }
+  case class FileInput(base: File, file: File) extends Entry {
+    def name = file.relativeTo(base).get.getPath
+    def time = file.lastModified
+    def data = sbt.IO.readBytes(file)
+  }
+
+  private def newMainProcessor(patterns: java.util.List[PatternElement], verbose: Boolean, skipManifest: Boolean): JarProcessor = {
+    val cls = Class.forName("org.pantsbuild.jarjar.MainProcessor")
+    val constructor = cls.getConstructor(classOf[java.util.List[_]], java.lang.Boolean.TYPE, java.lang.Boolean.TYPE)
+    constructor.setAccessible(true)
+    constructor.newInstance(patterns, Boolean.box(verbose), Boolean.box(skipManifest)).asInstanceOf[JarProcessor]
+  }
+
+  def apply(in: Iterator[Entry], outdir: File,
+            config: Seq[JarJarConfig], verbose: Boolean = false): Seq[File] = {
+    val patterns = config.map(_.toPatternElement).asJava
+    val processor = newMainProcessor(patterns, verbose, false)
+    def process(e: Entry): Option[File] = {
+      val struct = new EntryStruct()
+      struct.name = e.name
+      struct.time = e.time
+      struct.data = e.data
+      if (processor.process(struct)) {
+        if (struct.name.endsWith("/")) None
+        else {
+          val f = outdir / struct.name
+          try {
+            f.getParentFile.mkdirs()
+            sbt.IO.write(f, struct.data)
+          } catch {
+            case ex: Exception =>
+              throw new IOException(s"Failed to write ${e.name} / ${f.getParentFile} / ${f.getParentFile.exists}", ex)
+          }
+          Some(f)
+        }
+      }
+      else None
+    }
+    val processed = in.flatMap(entry => process(entry)).toSet
+    val getter = processor.getClass.getDeclaredMethod("getExcludes")
+    getter.setAccessible(true)
+    val excludes = getter.invoke(processor).asInstanceOf[java.util.Set[String]].asScala
+    val excluded = excludes.map { name =>
+      val f: File = outdir / name
+      if(f.exists && !f.delete())
+        throw new IOException("Failed to delete excluded file $f")
+      f
+    }
+    (processed -- excluded).toSeq
+  }
+}
diff --git a/project/Osgi.scala b/project/Osgi.scala
new file mode 100644
index 0000000000..78370b695b
--- /dev/null
+++ b/project/Osgi.scala
@@ -0,0 +1,69 @@
+import aQute.bnd.osgi.Builder
+import aQute.bnd.osgi.Constants._
+import java.util.Properties
+import sbt._
+import sbt.Keys._
+import scala.collection.JavaConversions._
+import VersionUtil.versionProperties
+
+/** OSGi packaging for the Scala build, distilled from sbt-osgi. We do not use sbt-osgi because it
+  * depends on a newer version of BND which gives slightly different output (probably OK to upgrade
+  * in the future but for now it would make comparing the sbt and ant build output harder) and does
+  * not allow a crucial bit of configuration that we need: Setting the classpath for BND. In sbt-osgi
+  * this is always `fullClasspath in Compile` whereas we want `products in Compile in packageBin`. */
+object Osgi {
+  val bundle = TaskKey[File]("osgiBundle", "Create an OSGi bundle.")
+  val bundleName = SettingKey[String]("osgiBundleName", "The Bundle-Name for the manifest.")
+  val bundleSymbolicName = SettingKey[String]("osgiBundleSymbolicName", "The Bundle-SymbolicName for the manifest.")
+  val headers = SettingKey[Seq[(String, String)]]("osgiHeaders", "Headers and processing instructions for BND.")
+
+  def settings: Seq[Setting[_]] = Seq(
+    bundleName := description.value,
+    bundleSymbolicName := organization.value + "." + name.value,
+    headers := {
+      val v = VersionUtil.versionProperties.value.osgiVersion
+      Seq(
+        "Bundle-Name" -> bundleName.value,
+        "Bundle-SymbolicName" -> bundleSymbolicName.value,
+        "ver" -> v,
+        "Export-Package" -> ("*;version=${ver}"),
+        "Import-Package" -> ("scala.*;version=\"${range;[==,=+);${ver}}\",*"),
+        "Bundle-Version" -> v,
+        "Bundle-RequiredExecutionEnvironment" -> "JavaSE-1.8",
+        "-eclipse" -> "false"
+      )
+    },
+    bundle <<= Def.task {
+      val res = (products in Compile in packageBin).value
+      bundleTask(headers.value.toMap, (products in Compile in packageBin).value,
+        (artifactPath in (Compile, packageBin)).value, res, streams.value)
+    },
+    packagedArtifact in (Compile, packageBin) <<= (artifact in (Compile, packageBin), bundle).identityMap,
+    // Also create OSGi source bundles:
+    artifact in (Compile, packageBin) ~= (_.copy(`type` = "bundle")),
+    packageOptions in (Compile, packageSrc) += Package.ManifestAttributes(
+      "Bundle-Name" -> (description.value + " Sources"),
+      "Bundle-SymbolicName" -> (bundleSymbolicName.value + ".source"),
+      "Bundle-Version" -> versionProperties.value.osgiVersion,
+      "Eclipse-SourceBundle" -> (bundleSymbolicName.value + ";version=\"" + versionProperties.value.osgiVersion + "\";roots:=\".\"")
+    )
+  )
+
+  def bundleTask(headers: Map[String, String], fullClasspath: Seq[File], artifactPath: File,
+                 resourceDirectories: Seq[File], streams: TaskStreams): File = {
+    val log = streams.log
+    val builder = new Builder
+    builder.setClasspath(fullClasspath.toArray)
+    headers foreach { case (k, v) => builder.setProperty(k, v) }
+    val includeRes = resourceDirectories.filter(_.exists).map(_.getAbsolutePath).mkString(",")
+    if(!includeRes.isEmpty) builder.setProperty(INCLUDERESOURCE, includeRes)
+    builder.getProperties.foreach { case (k, v) => log.debug(s"bnd: $k: $v") }
+    // builder.build is not thread-safe because it uses a static SimpleDateFormat.  This ensures
+    // that all calls to builder.build are serialized.
+    val jar = synchronized { builder.build }
+    builder.getWarnings.foreach(s => log.warn(s"bnd: $s"))
+    builder.getErrors.foreach(s => log.error(s"bnd: $s"))
+    jar.write(artifactPath)
+    artifactPath
+  }
+}
diff --git a/project/VersionUtil.scala b/project/VersionUtil.scala
new file mode 100644
index 0000000000..71de772b08
--- /dev/null
+++ b/project/VersionUtil.scala
@@ -0,0 +1,103 @@
+import sbt._
+import Keys._
+import java.util.Properties
+import java.io.FileInputStream
+import scala.collection.JavaConverters._
+
+object VersionUtil {
+  lazy val copyrightString = settingKey[String]("Copyright string.")
+  lazy val versionProperties = settingKey[Versions]("Version properties.")
+  lazy val generateVersionPropertiesFile = taskKey[File]("Generating version properties file.")
+
+  lazy val versionPropertiesSettings = Seq[Setting[_]](
+    versionProperties := versionPropertiesImpl.value
+  )
+
+  lazy val generatePropertiesFileSettings = Seq[Setting[_]](
+    copyrightString := "Copyright 2002-2015, LAMP/EPFL",
+    resourceGenerators in Compile += generateVersionPropertiesFile.map(file => Seq(file)).taskValue,
+    versionProperties := versionPropertiesImpl.value,
+    generateVersionPropertiesFile := generateVersionPropertiesFileImpl.value
+  )
+
+  case class Versions(canonicalVersion: String, mavenVersion: String, osgiVersion: String, commitSha: String, commitDate: String, isRelease: Boolean) {
+    val githubTree =
+      if(isRelease) "v" + mavenVersion
+      else if(commitSha != "unknown") commitSha
+      else "master"
+
+    override def toString = s"Canonical: $canonicalVersion, Maven: $mavenVersion, OSGi: $osgiVersion, github: $githubTree"
+
+    def toProperties: Properties = {
+      val props = new Properties
+      props.put("version.number", canonicalVersion)
+      props.put("maven.version.number", mavenVersion)
+      props.put("osgi.version.number", osgiVersion)
+      props
+    }
+  }
+
+  lazy val versionPropertiesImpl: Def.Initialize[Versions] = Def.setting {
+    /** Regexp that splits version number split into two parts: version and suffix.
+      * Examples of how the split is performed:
+      *
+      *  "2.11.5": ("2.11.5", null)
+      *  "2.11.5-acda7a": ("2.11.5", "-acda7a")
+      *  "2.11.5-SNAPSHOT": ("2.11.5", "-SNAPSHOT") */
+    val versionSplitted = """([\w+\.]+)(-[\w+\.]+)??""".r
+
+    val versionSplitted(ver, suffixOrNull) = version.value
+
+    val osgiSuffix = suffixOrNull match {
+      case null => "-VFINAL"
+      case "-SNAPSHOT" => ""
+      case suffixStr => suffixStr
+    }
+
+    def executeTool(tool: String) = {
+      val cmd =
+        if (System.getProperty("os.name").toLowerCase.contains("windows"))
+          s"cmd.exe /c tools\\$tool.bat -p"
+        else s"tools/$tool"
+      Process(cmd).lines.head
+    }
+
+    val commitDate = executeTool("get-scala-commit-date")
+    val commitSha = executeTool("get-scala-commit-sha")
+
+    Versions(
+      canonicalVersion = s"$ver-$commitDate-$commitSha",
+      mavenVersion = s"${version.value}",
+      osgiVersion = s"$ver.v$commitDate$osgiSuffix-$commitSha",
+      commitSha = commitSha,
+      commitDate = commitDate,
+      isRelease = !osgiSuffix.isEmpty
+    )
+  }
+
+  lazy val generateVersionPropertiesFileImpl: Def.Initialize[Task[File]] = Def.task {
+    val props = versionProperties.value.toProperties
+    val propFile = (resourceManaged in Compile).value / s"${thisProject.value.id}.properties"
+    props.put("copyright.string", copyrightString.value)
+
+    // unfortunately, this will write properties in arbitrary order
+    // this makes it harder to test for stability of generated artifacts
+    // consider using https://github.com/etiennestuder/java-ordered-properties
+    // instead of java.util.Properties
+    IO.write(props, null, propFile)
+    propFile
+  }
+
+  /** The global versions.properties data */
+  lazy val versionProps: Map[String, String] = {
+    val props = new Properties()
+    val in = new FileInputStream(file("versions.properties"))
+    try props.load(in)
+    finally in.close()
+    props.asScala.toMap
+  }
+
+  /** Get a subproject version number from `versionProps` */
+  def versionNumber(name: String): String =
+    versionProps(s"$name.version.number")
+}
diff --git a/project/plugins.sbt b/project/plugins.sbt
index dc266a8db1..02d66a16dd 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1 +1,5 @@
-libraryDependencies += "org.apache.commons" % "commons-lang3" % "3.3.2"
\ No newline at end of file
+libraryDependencies += "org.apache.commons" % "commons-lang3" % "3.3.2"
+
+libraryDependencies += "org.pantsbuild" % "jarjar" % "1.6.0"
+
+libraryDependencies += "biz.aQute.bnd" % "biz.aQute.bnd" % "2.4.1"
diff --git a/scripts/jobs/integrate/windows b/scripts/jobs/integrate/windows
new file mode 100755
index 0000000000..be68a826f7
--- /dev/null
+++ b/scripts/jobs/integrate/windows
@@ -0,0 +1,15 @@
+#!/bin/bash -x
+
+./pull-binary-libs.sh
+
+export ANT_OPTS="-Dfile.encoding=UTF-8 -server -XX:+AggressiveOpts -XX:+UseParNewGC -Xmx2G -Xss1M -XX:MaxPermSize=512M -XX:ReservedCodeCacheSize=128M"
+
+# TODO: don't hardcode this path, which is just where we currently have
+# ant manually installed on jenkins-worker-windows-publish.
+PATH=/cygdrive/c/apache-ant-1.9.6/bin:$PATH
+
+ant \
+  -Dstarr.version=2.11.7 \
+  -Dscalac.args.optimise=-optimise \
+  -Dlocker.skip=1 \
+  test
diff --git a/spec/01-lexical-syntax.md b/spec/01-lexical-syntax.md
index 72ae6e8794..0232ed9a34 100644
--- a/spec/01-lexical-syntax.md
+++ b/spec/01-lexical-syntax.md
@@ -90,11 +90,11 @@ syntactic class `id` of lexical identifiers.
 abstract    case        catch       class       def
 do          else        extends     false       final
 finally     for         forSome     if          implicit
-import      lazy        match       new         null
-object      override    package     private     protected
-return      sealed      super       this        throw
-trait       try         true        type        val
-var         while       with        yield
+import      lazy        macro       match       new
+null        object      override    package     private
+protected   return      sealed      super       this
+throw       trait       try         true        type
+val         var         while       with        yield
 _    :    =    =>    <-    <:    <%     >:    #    @
 ```
 
diff --git a/spec/06-expressions.md b/spec/06-expressions.md
index 9cd58ea346..c24ca01c3b 100644
--- a/spec/06-expressions.md
+++ b/spec/06-expressions.md
@@ -1341,7 +1341,7 @@ to $U$ after applying [eta-expansion](#eta-expansion) and
 
 ### Value Conversions
 
-The following five implicit conversions can be applied to an
+The following seven implicit conversions can be applied to an
 expression $e$ which has some value type $T$ and which is type-checked with
 some expected type $\mathit{pt}$.
 
diff --git a/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala b/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
index b8384851da..a3bf894b25 100644
--- a/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
+++ b/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala
@@ -12,7 +12,6 @@ abstract class DefaultMacroCompiler extends Resolvers
   import treeInfo._
   import definitions._
   val runDefinitions = currentRun.runDefinitions
-  import runDefinitions.Predef_???
 
   val typer: global.analyzer.Typer
   val context = typer.context
@@ -92,4 +91,4 @@ abstract class DefaultMacroCompiler extends Resolvers
         EmptyTree
     }
   }
-}
\ No newline at end of file
+}
diff --git a/src/compiler/scala/reflect/quasiquotes/Holes.scala b/src/compiler/scala/reflect/quasiquotes/Holes.scala
index 47084fc317..63be500061 100644
--- a/src/compiler/scala/reflect/quasiquotes/Holes.scala
+++ b/src/compiler/scala/reflect/quasiquotes/Holes.scala
@@ -1,7 +1,6 @@
 package scala.reflect
 package quasiquotes
 
-import scala.collection.{immutable, mutable}
 import scala.reflect.internal.Flags._
 import scala.reflect.macros.TypecheckException
 
@@ -222,7 +221,7 @@ trait Holes { self: Quasiquotes =>
       else if (rank == NoDot) Some(unlifter)
       else {
         val idx = records.indexWhere { p => p._1 =:= tpe && p._2 == rank }
-        val resIdx = if (idx != -1) idx else { records +:= (tpe, rank); records.length - 1}
+        val resIdx = if (idx != -1) idx else { records +:= ((tpe, rank)); records.length - 1}
         Some(Ident(TermName(nme.QUASIQUOTE_UNLIFT_HELPER + resIdx)))
       }
     }
diff --git a/src/compiler/scala/reflect/quasiquotes/Parsers.scala b/src/compiler/scala/reflect/quasiquotes/Parsers.scala
index 97ec7dbfc3..6972c4070c 100644
--- a/src/compiler/scala/reflect/quasiquotes/Parsers.scala
+++ b/src/compiler/scala/reflect/quasiquotes/Parsers.scala
@@ -3,10 +3,7 @@ package quasiquotes
 
 import scala.tools.nsc.ast.parser.{Parsers => ScalaParser}
 import scala.tools.nsc.ast.parser.Tokens._
-import scala.compat.Platform.EOL
 import scala.reflect.internal.util.{BatchSourceFile, SourceFile, FreshNameCreator}
-import scala.collection.mutable.ListBuffer
-import scala.util.Try
 
 /** Builds upon the vanilla Scala parser and teams up together with Placeholders.scala to emulate holes.
  *  A principled solution to splicing into Scala syntax would be a parser that natively supports holes.
diff --git a/src/compiler/scala/reflect/quasiquotes/Placeholders.scala b/src/compiler/scala/reflect/quasiquotes/Placeholders.scala
index a5b42f8a1f..bc4f954275 100644
--- a/src/compiler/scala/reflect/quasiquotes/Placeholders.scala
+++ b/src/compiler/scala/reflect/quasiquotes/Placeholders.scala
@@ -2,7 +2,7 @@ package scala.reflect
 package quasiquotes
 
 import java.util.UUID.randomUUID
-import scala.collection.{immutable, mutable}
+import scala.collection.mutable
 
 /** Emulates hole support (see Holes.scala) in the quasiquote parser (see Parsers.scala).
  *  A principled solution to splicing into Scala syntax would be a parser that natively supports holes.
diff --git a/src/compiler/scala/tools/ant/FastScalac.scala b/src/compiler/scala/tools/ant/FastScalac.scala
index 6f0a30aa9d..e0b7be8004 100644
--- a/src/compiler/scala/tools/ant/FastScalac.scala
+++ b/src/compiler/scala/tools/ant/FastScalac.scala
@@ -8,7 +8,7 @@
 
 package scala.tools.ant
 
-import org.apache.tools.ant.{AntClassLoader, Project}
+import org.apache.tools.ant.AntClassLoader
 import org.apache.tools.ant.taskdefs.Java
 import org.apache.tools.ant.types.Path
 
diff --git a/src/compiler/scala/tools/ant/Pack200Task.scala b/src/compiler/scala/tools/ant/Pack200Task.scala
index 3c1bc8cad9..df162d734a 100644
--- a/src/compiler/scala/tools/ant/Pack200Task.scala
+++ b/src/compiler/scala/tools/ant/Pack200Task.scala
@@ -8,14 +8,10 @@
 
 package scala.tools.ant
 
-import java.io.{BufferedOutputStream, File, FileInputStream,
-       FileOutputStream, PipedInputStream, PipedOutputStream}
-import java.util.jar.{JarFile, JarInputStream, JarOutputStream, Pack200}
+import java.io.{BufferedOutputStream, File, FileOutputStream}
+import java.util.jar.{JarFile, JarOutputStream, Pack200}
 import java.util.jar.Pack200.Packer._
 
-import org.apache.tools.ant.{BuildException, DirectoryScanner}
-import org.apache.tools.ant.types.FileSet
-
 /** An [[http://ant.apache.org Ant]] task that applies the pack200 encoding
  *  to a JAR file.
  *
diff --git a/src/compiler/scala/tools/ant/ScalaMatchingTask.scala b/src/compiler/scala/tools/ant/ScalaMatchingTask.scala
index 68a84bed0c..43b9010509 100644
--- a/src/compiler/scala/tools/ant/ScalaMatchingTask.scala
+++ b/src/compiler/scala/tools/ant/ScalaMatchingTask.scala
@@ -8,11 +8,8 @@
 
 package scala.tools.ant
 
-import java.io.{ File, InputStream, FileWriter }
-
 import org.apache.tools.ant.{ Task, BuildException }
 import org.apache.tools.ant.taskdefs.MatchingTask
-import org.apache.tools.ant.types.{ Path, Reference }
 
 trait ScalaTask {
   self: Task =>
@@ -27,5 +24,4 @@ trait ScalaTask {
      throw new BuildException(message, getLocation())
 }
 
-abstract class ScalaMatchingTask extends MatchingTask with ScalaTask {
-}
+abstract class ScalaMatchingTask extends MatchingTask with ScalaTask
diff --git a/src/compiler/scala/tools/ant/ScalaTool.scala b/src/compiler/scala/tools/ant/ScalaTool.scala
index bb6a933d3f..67879d6de3 100644
--- a/src/compiler/scala/tools/ant/ScalaTool.scala
+++ b/src/compiler/scala/tools/ant/ScalaTool.scala
@@ -8,8 +8,7 @@
 
 package scala.tools.ant
 
-import java.io.{File, InputStream, FileWriter}
-import org.apache.tools.ant.BuildException
+import java.io.{File, FileWriter}
 import org.apache.tools.ant.types.{Path, Reference}
 
 /** An Ant task that generates a shell or batch script to execute a
diff --git a/src/compiler/scala/tools/ant/Scalac.scala b/src/compiler/scala/tools/ant/Scalac.scala
index f46f014096..fe9815be20 100644
--- a/src/compiler/scala/tools/ant/Scalac.scala
+++ b/src/compiler/scala/tools/ant/Scalac.scala
@@ -10,13 +10,11 @@ package scala.tools.ant
 
 import java.io.{File, PrintWriter, BufferedWriter, FileWriter}
 
-import org.apache.tools.ant.{ BuildException, Project, AntClassLoader }
+import org.apache.tools.ant.{ Project, AntClassLoader}
 import org.apache.tools.ant.taskdefs.Java
 import org.apache.tools.ant.types.{Path, Reference}
-import org.apache.tools.ant.util.{FileUtils, GlobPatternMapper,
-                                  SourceFileScanner, facade}
-import org.apache.tools.ant.util.facade.{FacadeTaskHelper,
-                                  ImplementationSpecificArgument}
+import org.apache.tools.ant.util.{FileUtils, GlobPatternMapper, SourceFileScanner}
+import org.apache.tools.ant.util.facade.{FacadeTaskHelper, ImplementationSpecificArgument}
 
 import scala.tools.nsc.{Global, Settings, CompilerCommand}
 import scala.tools.nsc.io.{Path => SPath}
@@ -91,8 +89,8 @@ class Scalac extends ScalaMatchingTask with ScalacShared {
     val values = List("namer", "typer", "pickler", "refchecks",
                       "uncurry", "tailcalls", "specialize", "explicitouter",
                       "erasure", "lazyvals", "lambdalift", "constructors",
-                      "flatten", "mixin", "delambdafy", "cleanup", "icode", "inliner",
-                      "closelim", "dce", "jvm", "terminal")
+                      "flatten", "mixin", "delambdafy", "cleanup",
+                      "jvm", "terminal")
   }
 
   /** Defines valid values for the `target` property. */
diff --git a/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala b/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala
index cde827ba54..c31f55c9b6 100644
--- a/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala
+++ b/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala
@@ -10,7 +10,7 @@ package scala
 package tools.ant
 package sabbus
 
-import java.io.{ File, FileWriter }
+import java.io.File
 import org.apache.tools.ant.Project
 import org.apache.tools.ant.taskdefs.Java
 import org.apache.tools.ant.util.{ GlobPatternMapper, SourceFileScanner }
diff --git a/src/compiler/scala/tools/ant/sabbus/Use.scala b/src/compiler/scala/tools/ant/sabbus/Use.scala
index a8736f228b..cb514e35b3 100644
--- a/src/compiler/scala/tools/ant/sabbus/Use.scala
+++ b/src/compiler/scala/tools/ant/sabbus/Use.scala
@@ -13,7 +13,6 @@ package sabbus
 
 import java.io.File
 
-import org.apache.tools.ant.types.{Path, Reference}
 import org.apache.tools.ant.util.{GlobPatternMapper, SourceFileScanner}
 
 class Use extends ScalaMatchingTask {
diff --git a/src/compiler/scala/tools/cmd/FromString.scala b/src/compiler/scala/tools/cmd/FromString.scala
index 0b074efc0f..ab49c7507c 100644
--- a/src/compiler/scala/tools/cmd/FromString.scala
+++ b/src/compiler/scala/tools/cmd/FromString.scala
@@ -6,7 +6,7 @@
 package scala.tools
 package cmd
 
-import nsc.io.{ Path, File, Directory }
+import nsc.io.Directory
 import scala.reflect.OptManifest
 
 /** A general mechanism for defining how a command line argument
diff --git a/src/compiler/scala/tools/cmd/Spec.scala b/src/compiler/scala/tools/cmd/Spec.scala
index a1cb31f911..069a7a89a1 100644
--- a/src/compiler/scala/tools/cmd/Spec.scala
+++ b/src/compiler/scala/tools/cmd/Spec.scala
@@ -47,6 +47,6 @@ object Spec {
   }
 
   class EnvironmentVar(val name: String) {
-    override def toString = "${%s}" format name
+    override def toString = s"$${$name}"
   }
 }
diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala
index 6be1fda1b5..34b07a2651 100644
--- a/src/compiler/scala/tools/nsc/CompilationUnits.scala
+++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala
@@ -117,9 +117,7 @@ trait CompilationUnits { global: Global =>
      */
     def targetPos: Position = NoPosition
 
-    /** The icode representation of classes in this compilation unit.
-     *  It is empty up to phase 'icode'.
-     */
+    /** For sbt compatibility (https://github.com/scala/scala/pull/4588) */
     val icode: LinkedHashSet[icodes.IClass] = new LinkedHashSet
 
     @deprecated("Call global.reporter.echo directly instead.", "2.11.2")
diff --git a/src/compiler/scala/tools/nsc/CompileServer.scala b/src/compiler/scala/tools/nsc/CompileServer.scala
index aa02957a6c..9cac497a85 100644
--- a/src/compiler/scala/tools/nsc/CompileServer.scala
+++ b/src/compiler/scala/tools/nsc/CompileServer.scala
@@ -8,7 +8,7 @@ package scala.tools.nsc
 import java.io.PrintStream
 import io.Directory
 import scala.tools.nsc.reporters.{Reporter, ConsoleReporter}
-import scala.reflect.internal.util.{FakePos, Position}
+import scala.reflect.internal.util.FakePos
 import scala.tools.util.SocketServer
 import settings.FscSettings
 
@@ -193,14 +193,14 @@ object CompileServer {
     val i = args.indexOf("-p")
     if (i >= 0 && args.length > i + 1) {
     	scala.util.control.Exception.ignoring(classOf[NumberFormatException]) {
-    		port = args(i + 1).toInt 
+		port = args(i + 1).toInt
     	}
     }
-    
+
     // Create instance rather than extend to pass a port parameter.
     val server = new StandardCompileServer(port)
     val redirectDir = (server.compileSocket.tmpDir / "output-redirects").createDirectory()
-    
+
     if (debug) {
       server.echo("Starting CompileServer on port " + server.port)
       server.echo("Redirect dir is " + redirectDir)
diff --git a/src/compiler/scala/tools/nsc/CompileSocket.scala b/src/compiler/scala/tools/nsc/CompileSocket.scala
index 27a14141fa..01c7d72d4f 100644
--- a/src/compiler/scala/tools/nsc/CompileSocket.scala
+++ b/src/compiler/scala/tools/nsc/CompileSocket.scala
@@ -5,9 +5,9 @@
 
 package scala.tools.nsc
 
-import java.io.{ FileNotFoundException, PrintWriter, FileOutputStream }
+import java.io.FileNotFoundException
 import java.security.SecureRandom
-import io.{ File, Path, Directory, Socket }
+import io.{ File, Path, Socket }
 import scala.tools.util.CompileOutputCommon
 import scala.reflect.internal.util.StringOps.splitWhere
 import scala.sys.process._
@@ -46,7 +46,7 @@ trait HasCompileSocket {
 class CompileSocket extends CompileOutputCommon {
   protected lazy val compileClient: StandardCompileClient = CompileClient
   def verbose = compileClient.verbose
-  
+
   /* Fixes the port where to start the server, 0 yields some free port */
   var fixPort = 0
 
@@ -67,7 +67,7 @@ class CompileSocket extends CompileOutputCommon {
 
   /** The class name of the scala compile server */
   protected val serverClass     = "scala.tools.nsc.CompileServer"
-  protected def serverClassArgs = (if (verbose) List("-v") else Nil) ::: (if (fixPort > 0) List("-p", fixPort.toString) else Nil) 
+  protected def serverClassArgs = (if (verbose) List("-v") else Nil) ::: (if (fixPort > 0) List("-p", fixPort.toString) else Nil)
 
   /** A temporary directory to use */
   val tmpDir = {
@@ -196,7 +196,7 @@ class CompileSocket extends CompileOutputCommon {
     catch { case _: NumberFormatException => None }
 
   def getSocket(serverAdr: String): Option[Socket] = (
-    for ((name, portStr) <- splitWhere(serverAdr, _ == ':', doDropIndex = true) ; port <- parseInt(portStr)) yield    	
+    for ((name, portStr) <- splitWhere(serverAdr, _ == ':', doDropIndex = true) ; port <- parseInt(portStr)) yield
       getSocket(name, port)
   ) getOrElse fatal("Malformed server address: %s; exiting" format serverAdr)
 
@@ -205,7 +205,7 @@ class CompileSocket extends CompileOutputCommon {
     if (sock.isEmpty) warn("Unable to establish connection to server %s:%d".format(hostName, port))
     sock
   }
-  
+
   def getPassword(port: Int): String = {
     val ff  = portFile(port)
     val f   = ff.bufferedReader()
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index c6124e7177..c1d7176d0c 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -7,12 +7,12 @@ package scala
 package tools
 package nsc
 
-import java.io.{ File, FileOutputStream, PrintWriter, IOException, FileNotFoundException }
+import java.io.{ File, IOException, FileNotFoundException }
 import java.net.URL
 import java.nio.charset.{ Charset, CharsetDecoder, IllegalCharsetNameException, UnsupportedCharsetException }
 import scala.collection.{ mutable, immutable }
 import io.{ SourceReader, AbstractFile, Path }
-import reporters.{ Reporter, ConsoleReporter }
+import reporters.Reporter
 import util.{ ClassFileLookup, ClassPath, MergedClassPath, StatisticsInfo, returning }
 import scala.reflect.ClassTag
 import scala.reflect.internal.util.{ ScalaClassLoader, SourceFile, NoSourceFile, BatchSourceFile, ScriptSourceFile }
@@ -25,12 +25,8 @@ import ast.parser._
 import typechecker._
 import transform.patmat.PatternMatching
 import transform._
-import backend.icode.{ ICodes, GenICode, ICodeCheckers }
 import backend.{ ScalaPrimitives, JavaPlatform }
 import backend.jvm.GenBCode
-import backend.jvm.GenASM
-import backend.opt.{ Inliners, InlineExceptionHandlers, ConstantOptimization, ClosureElimination, DeadCodeElimination }
-import backend.icode.analysis._
 import scala.language.postfixOps
 import scala.tools.nsc.ast.{TreeGen => AstTreeGen}
 import scala.tools.nsc.classpath.FlatClassPath
@@ -140,12 +136,12 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     val global: Global.this.type = Global.this
   } with ConstantFolder
 
-  /** ICode generator */
-  object icodes extends {
-    val global: Global.this.type = Global.this
-  } with ICodes
+  /** For sbt compatibility (https://github.com/scala/scala/pull/4588) */
+  object icodes {
+    class IClass(val symbol: Symbol)
+  }
 
-  /** Scala primitives, used in genicode */
+  /** Scala primitives, used the backend */
   object scalaPrimitives extends {
     val global: Global.this.type = Global.this
   } with ScalaPrimitives
@@ -157,18 +153,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
   type SymbolPair = overridingPairs.SymbolPair
 
-  // Optimizer components
-
-  /** ICode analysis for optimization */
-  object analysis extends {
-    val global: Global.this.type = Global.this
-  } with TypeFlowAnalysis
-
-  /** Copy propagation for optimization */
-  object copyPropagation extends {
-    val global: Global.this.type = Global.this
-  } with CopyPropagation
-
   // Components for collecting and generating output
 
   /** Some statistics (normally disabled) set with -Ystatistics */
@@ -231,7 +215,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   /** Called from parser, which signals hereby that a method definition has been parsed. */
   def signalParseProgress(pos: Position) {}
 
-  /** Called by ScalaDocAnalyzer when a doc comment has been parsed. */
+  /** Called by ScaladocAnalyzer when a doc comment has been parsed. */
   def signalParsedDocComment(comment: String, pos: Position) = {
     // TODO: this is all very broken (only works for scaladoc comments, not regular ones)
     //       --> add hooks to parser and refactor Interactive global to handle comments directly
@@ -400,15 +384,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
     def apply(unit: CompilationUnit): Unit
 
-    private val isErased = prev.name == "erasure" || prev.erasedTypes
-    override def erasedTypes: Boolean = isErased
-    private val isFlat = prev.name == "flatten" || prev.flatClasses
-    override def flatClasses: Boolean = isFlat
-    private val isSpecialized = prev.name == "specialize" || prev.specialized
-    override def specialized: Boolean = isSpecialized
-    private val isRefChecked = prev.name == "refchecks" || prev.refChecked
-    override def refChecked: Boolean = isRefChecked
-
     /** Is current phase cancelled on this unit? */
     def cancelled(unit: CompilationUnit) = {
       // run the typer only if in `createJavadoc` mode
@@ -591,59 +566,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     val runsRightAfter = None
   } with Delambdafy
 
-  // phaseName = "icode"
-  object genicode extends {
-    val global: Global.this.type = Global.this
-    val runsAfter = List("cleanup")
-    val runsRightAfter = None
-  } with GenICode
-
-  // phaseName = "inliner"
-  object inliner extends {
-    val global: Global.this.type = Global.this
-    val runsAfter = List("icode")
-    val runsRightAfter = None
-  } with Inliners
-
-  // phaseName = "inlinehandlers"
-  object inlineExceptionHandlers extends {
-    val global: Global.this.type = Global.this
-    val runsAfter = List("inliner")
-    val runsRightAfter = None
-  } with InlineExceptionHandlers
-
-  // phaseName = "closelim"
-  object closureElimination extends {
-    val global: Global.this.type = Global.this
-    val runsAfter = List("inlinehandlers")
-    val runsRightAfter = None
-  } with ClosureElimination
-
-  // phaseName = "constopt"
-  object constantOptimization extends {
-    val global: Global.this.type = Global.this
-    val runsAfter = List("closelim")
-    val runsRightAfter = None
-  } with ConstantOptimization
-
-  // phaseName = "dce"
-  object deadCode extends {
-    val global: Global.this.type = Global.this
-    val runsAfter = List("closelim")
-    val runsRightAfter = None
-  } with DeadCodeElimination
-
-  // phaseName = "jvm", ASM-based version
-  object genASM extends {
-    val global: Global.this.type = Global.this
-    val runsAfter = List("dce")
-    val runsRightAfter = None
-  } with GenASM
-
   // phaseName = "bcode"
   object genBCode extends {
     val global: Global.this.type = Global.this
-    val runsAfter = List("dce")
+    val runsAfter = List("cleanup")
     val runsRightAfter = None
   } with GenBCode
 
@@ -674,13 +600,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     val global: Global.this.type = Global.this
   } with TreeCheckers
 
-  /** Icode verification */
-  object icodeCheckers extends {
-    val global: Global.this.type = Global.this
-  } with ICodeCheckers
-
-  object icodeChecker extends icodeCheckers.ICodeChecker()
-
   object typer extends analyzer.Typer(
     analyzer.NoContext.make(EmptyTree, RootClass, newScope)
   )
@@ -713,12 +632,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       mixer                   -> "mixin composition",
       delambdafy              -> "remove lambdas",
       cleanup                 -> "platform-specific cleanups, generate reflective calls",
-      genicode                -> "generate portable intermediate code",
-      inliner                 -> "optimization: do inlining",
-      inlineExceptionHandlers -> "optimization: inline exception handlers",
-      closureElimination      -> "optimization: eliminate uncalled closures",
-      constantOptimization    -> "optimization: optimize null and other constants",
-      deadCode                -> "optimization: eliminate dead code",
       terminal                -> "the last phase during a compilation run"
     )
 
@@ -1057,9 +970,9 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   @inline final def enteringErasure[T](op: => T): T       = enteringPhase(currentRun.erasurePhase)(op)
   @inline final def enteringExplicitOuter[T](op: => T): T = enteringPhase(currentRun.explicitouterPhase)(op)
   @inline final def enteringFlatten[T](op: => T): T       = enteringPhase(currentRun.flattenPhase)(op)
-  @inline final def enteringIcode[T](op: => T): T         = enteringPhase(currentRun.icodePhase)(op)
   @inline final def enteringMixin[T](op: => T): T         = enteringPhase(currentRun.mixinPhase)(op)
   @inline final def enteringDelambdafy[T](op: => T): T    = enteringPhase(currentRun.delambdafyPhase)(op)
+  @inline final def enteringJVM[T](op: => T): T           = enteringPhase(currentRun.jvmPhase)(op)
   @inline final def enteringPickler[T](op: => T): T       = enteringPhase(currentRun.picklerPhase)(op)
   @inline final def enteringSpecialize[T](op: => T): T    = enteringPhase(currentRun.specializePhase)(op)
   @inline final def enteringTyper[T](op: => T): T         = enteringPhase(currentRun.typerPhase)(op)
@@ -1333,8 +1246,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     // val superaccessorsPhase          = phaseNamed("superaccessors")
     val picklerPhase                 = phaseNamed("pickler")
     val refchecksPhase               = phaseNamed("refchecks")
-    // val selectiveanfPhase            = phaseNamed("selectiveanf")
-    // val selectivecpsPhase            = phaseNamed("selectivecps")
     val uncurryPhase                 = phaseNamed("uncurry")
     // val tailcallsPhase               = phaseNamed("tailcalls")
     val specializePhase              = phaseNamed("specialize")
@@ -1348,20 +1259,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     val mixinPhase                   = phaseNamed("mixin")
     val delambdafyPhase              = phaseNamed("delambdafy")
     val cleanupPhase                 = phaseNamed("cleanup")
-    val icodePhase                   = phaseNamed("icode")
-    val inlinerPhase                 = phaseNamed("inliner")
-    val inlineExceptionHandlersPhase = phaseNamed("inlinehandlers")
-    val closelimPhase                = phaseNamed("closelim")
-    val dcePhase                     = phaseNamed("dce")
     val jvmPhase                     = phaseNamed("jvm")
 
     def runIsAt(ph: Phase)   = globalPhase.id == ph.id
-    def runIsAtOptimiz       = {
-      runIsAt(inlinerPhase)                 || // listing phases in full for robustness when -Ystop-after has been given.
-      runIsAt(inlineExceptionHandlersPhase) ||
-      runIsAt(closelimPhase)                ||
-      runIsAt(dcePhase)
-    }
+    def runIsAtOptimiz       = runIsAt(jvmPhase)
 
     isDefined = true
 
@@ -1424,8 +1325,8 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
       if (canCheck) {
         phase = globalPhase
-        if (globalPhase.id >= icodePhase.id) icodeChecker.checkICodes()
-        else treeChecker.checkTrees()
+        if (globalPhase.id <= cleanupPhase.id)
+          treeChecker.checkTrees()
       }
     }
 
@@ -1506,14 +1407,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
 
         // progress update
         informTime(globalPhase.description, startTime)
-        val shouldWriteIcode = (
-             (settings.writeICode.isSetByUser && (settings.writeICode containsPhase globalPhase))
-          || (!settings.Xprint.doAllPhases && (settings.Xprint containsPhase globalPhase) && runIsAtOptimiz)
-        )
-        if (shouldWriteIcode) {
-          // Write *.icode files when -Xprint-icode or -Xprint:<some-optimiz-phase> was given.
-          writeICode()
-        } else if ((settings.Xprint containsPhase globalPhase) || settings.printLate && runIsAt(cleanupPhase)) {
+        if ((settings.Xprint containsPhase globalPhase) || settings.printLate && runIsAt(cleanupPhase)) {
           // print trees
           if (settings.Xshowtrees || settings.XshowtreesCompact || settings.XshowtreesStringified) nodePrinters.printAll()
           else printAllUnits()
@@ -1534,7 +1428,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
         // move the pointer
         globalPhase = globalPhase.next
 
-        // run tree/icode checkers
+        // run tree checkers
         if (settings.check containsPhase globalPhase.prev)
           runCheckers()
 
@@ -1678,30 +1572,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   /** Returns the file with the given suffix for the given class. Used for icode writing. */
   def getFile(clazz: Symbol, suffix: String): File = getFile(clazz.sourceFile, clazz.fullName split '.', suffix)
 
-  private def writeICode() {
-    val printer = new icodes.TextPrinter(writer = null, icodes.linearizer)
-    icodes.classes.values foreach { cls =>
-      val file = {
-        val module = if (cls.symbol.hasModuleFlag) "$" else ""
-        val faze   = if (settings.debug) phase.name else f"${phase.id}%02d" // avoid breaking windows build with long filename
-        getFile(cls.symbol, s"$module-$faze.icode")
-      }
-
-      try {
-        val stream = new FileOutputStream(file)
-        printer.setWriter(new PrintWriter(stream, true))
-        try
-          printer.printClass(cls)
-        finally
-          stream.close()
-        informProgress(s"wrote $file")
-      } catch {
-        case e: IOException =>
-          if (settings.debug) e.printStackTrace()
-          globalError(s"could not write file $file")
-      }
-    }
-  }
   def createJavadoc    = false
 }
 
diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala
index 4e7a527a5a..e11cba466e 100644
--- a/src/compiler/scala/tools/nsc/Reporting.scala
+++ b/src/compiler/scala/tools/nsc/Reporting.scala
@@ -7,7 +7,7 @@ package scala
 package tools
 package nsc
 
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import scala.reflect.internal.util.StringOps.countElementsAsString
 
 /** Provides delegates to the reporter doing the actual work.
@@ -78,7 +78,7 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w
         s"""|
             |This can be achieved by adding the import clause 'import $fqname'
             |or by setting the compiler option -language:$featureName.
-            |See the Scala docs for value $fqname for a discussion
+            |See the Scaladoc for value $fqname for a discussion
             |why the feature $req be explicitly enabled.""".stripMargin
       )
       reportedFeature += featureTrait
diff --git a/src/compiler/scala/tools/nsc/ast/Printers.scala b/src/compiler/scala/tools/nsc/ast/Printers.scala
index f3def3c80c..8b37948e9b 100644
--- a/src/compiler/scala/tools/nsc/ast/Printers.scala
+++ b/src/compiler/scala/tools/nsc/ast/Printers.scala
@@ -6,7 +6,7 @@
 package scala.tools.nsc
 package ast
 
-import java.io.{ OutputStream, PrintWriter, StringWriter, Writer }
+import java.io.{ OutputStream, PrintWriter }
 
 trait Printers extends scala.reflect.internal.Printers { this: Global =>
 
diff --git a/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala b/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala
index eafecf9462..105bdee256 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeBrowsers.scala
@@ -7,7 +7,9 @@ package scala
 package tools.nsc
 package ast
 
-import java.awt.{List => awtList, _}
+import scala.language.implicitConversions
+
+import java.awt.{List => _, _}
 import java.awt.event._
 import java.io.StringWriter
 
@@ -17,7 +19,6 @@ import javax.swing.tree._
 
 import scala.concurrent.Lock
 import scala.text._
-import scala.language.implicitConversions
 
 /**
  * Tree browsers can show the AST in a graphical and interactive
diff --git a/src/compiler/scala/tools/nsc/ast/TreeDSL.scala b/src/compiler/scala/tools/nsc/ast/TreeDSL.scala
index 6dda30b5e7..9e1498cf3e 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeDSL.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeDSL.scala
@@ -7,7 +7,6 @@
 package scala.tools.nsc
 package ast
 
-import symtab.Flags
 import scala.language.implicitConversions
 
 /** A DSL for generating scala code.  The goal is that the
diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
index 332acf4a26..3167f87383 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -242,11 +242,14 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
   def mkSynchronizedCheck(clazz: Symbol, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree =
     mkSynchronizedCheck(mkAttributedThis(clazz), cond, syncBody, stats)
 
-  def mkSynchronizedCheck(attrThis: Tree, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree =
-    Block(mkSynchronized(
-      attrThis,
-      If(cond, Block(syncBody: _*), EmptyTree)) ::
-      stats: _*)
+  def mkSynchronizedCheck(attrThis: Tree, cond: Tree, syncBody: List[Tree], stats: List[Tree]): Tree = {
+    def blockOrStat(stats: List[Tree]): Tree = stats match {
+      case head :: Nil => head
+      case _ => Block(stats : _*)
+    }
+    val sync = mkSynchronized(attrThis, If(cond, blockOrStat(syncBody), EmptyTree))
+    blockOrStat(sync :: stats)
+  }
 
   /** Creates a tree representing new Object { stats }.
    *  To make sure an anonymous subclass of Object is created,
diff --git a/src/compiler/scala/tools/nsc/ast/Trees.scala b/src/compiler/scala/tools/nsc/ast/Trees.scala
index 934257092f..2d47e254e5 100644
--- a/src/compiler/scala/tools/nsc/ast/Trees.scala
+++ b/src/compiler/scala/tools/nsc/ast/Trees.scala
@@ -7,13 +7,6 @@ package scala.tools.nsc
 package ast
 
 import scala.reflect.ClassTag
-import scala.reflect.internal.Flags.BYNAMEPARAM
-import scala.reflect.internal.Flags.DEFAULTPARAM
-import scala.reflect.internal.Flags.IMPLICIT
-import scala.reflect.internal.Flags.PARAM
-import scala.reflect.internal.Flags.PARAMACCESSOR
-import scala.reflect.internal.Flags.PRESUPER
-import scala.reflect.internal.Flags.TRAIT
 import scala.compat.Platform.EOL
 
 trait Trees extends scala.reflect.internal.Trees { self: Global =>
diff --git a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
index 52b8a51a79..46d533b037 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
@@ -12,7 +12,7 @@ import mutable.{ Buffer, ArrayBuffer, ListBuffer }
 import scala.util.control.ControlThrowable
 import scala.tools.nsc.util.CharArrayReader
 import scala.tools.nsc.ast.parser.xml.{MarkupParserCommon, Utility}
-import scala.reflect.internal.Chars.{ SU, LF }
+import scala.reflect.internal.Chars.SU
 
 // XXX/Note: many/most of the functions in here are almost direct cut and pastes
 // from another file - scala.xml.parsing.MarkupParser, it looks like.
@@ -261,7 +261,7 @@ trait MarkupParsers {
       def coalesce(): ArrayBuffer[Tree] = {
         def copy() = {
           val buf = new ArrayBuffer[Tree]
-          var acc = new StringBuilder
+          val acc = new StringBuilder
           var pos: Position = NoPosition
           def emit() = if (acc.nonEmpty) {
             appendText(pos, buf, acc.toString)
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index dac3c7a285..1d96b940ae 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -9,10 +9,9 @@
 package scala.tools.nsc
 package ast.parser
 
-import scala.collection.{ mutable, immutable }
-import mutable.{ ListBuffer, StringBuilder }
+import scala.collection.mutable
+import mutable.ListBuffer
 import scala.reflect.internal.{ Precedence, ModifierFlags => Flags }
-import scala.reflect.internal.Chars.{ isScalaLetter }
 import scala.reflect.internal.util.{ SourceFile, Position, FreshNameCreator, ListOfNil }
 import Tokens._
 
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala
index 51bb0d3c5b..3d8f5a2dd3 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala
@@ -10,7 +10,7 @@ import scala.reflect.internal.util._
 import scala.reflect.internal.Chars._
 import Tokens._
 import scala.annotation.{ switch, tailrec }
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import mutable.{ ListBuffer, ArrayBuffer }
 import scala.tools.nsc.ast.parser.xml.Utility.isNameStart
 import scala.language.postfixOps
diff --git a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
index 67241ef639..c3c3ee9d47 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
@@ -6,7 +6,7 @@
 package scala.tools.nsc
 package ast.parser
 
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import symtab.Flags.MUTABLE
 import scala.reflect.internal.util.ListOfNil
 import scala.reflect.internal.util.StringOps.splitWhere
diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 6e5a3f6ef7..6b564197a1 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -7,7 +7,6 @@ package scala.tools.nsc
 package ast.parser
 
 import symtab.Flags._
-import scala.collection.mutable.ListBuffer
 import scala.reflect.internal.util.{Position, SourceFile, FreshNameCreator}
 
 /** Methods for building trees, used in the parser.  All the trees
diff --git a/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala b/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala
index 6bd123c51f..16f086e9e7 100644
--- a/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala
+++ b/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala
@@ -40,13 +40,9 @@ trait JavaPlatform extends Platform {
   def updateClassPath(subst: Map[ClassPath[AbstractFile], ClassPath[AbstractFile]]) =
     currentClassPath = Some(new DeltaClassPath(currentClassPath.get, subst))
 
-  private def classEmitPhase =
-    if (settings.isBCodeActive) genBCode
-    else genASM
-
   def platformPhases = List(
-    flatten,        // get rid of inner classes
-    classEmitPhase  // generate .class files
+    flatten,  // get rid of inner classes
+    genBCode  // generate .class files
   )
 
   lazy val externalEquals          = getDecl(BoxesRunTimeClass, nme.equals_)
diff --git a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala
index b8ddb65de9..9a53737554 100644
--- a/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala
+++ b/src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala
@@ -31,7 +31,6 @@ abstract class ScalaPrimitives {
 
   import global._
   import definitions._
-  import global.icodes._
 
   // Arithmetic unary operations
   final val POS = 1                            // +x
@@ -457,18 +456,6 @@ abstract class ScalaPrimitives {
 
   def isCoercion(code: Int): Boolean = (code >= B2B) && (code <= D2D)
 
-  final val typeOfArrayOp: Map[Int, TypeKind] = Map(
-    (List(ZARRAY_LENGTH, ZARRAY_GET, ZARRAY_SET) map (_ -> BOOL)) ++
-    (List(BARRAY_LENGTH, BARRAY_GET, BARRAY_SET) map (_ -> BYTE)) ++
-    (List(SARRAY_LENGTH, SARRAY_GET, SARRAY_SET) map (_ -> SHORT)) ++
-    (List(CARRAY_LENGTH, CARRAY_GET, CARRAY_SET) map (_ -> CHAR)) ++
-    (List(IARRAY_LENGTH, IARRAY_GET, IARRAY_SET) map (_ -> INT)) ++
-    (List(LARRAY_LENGTH, LARRAY_GET, LARRAY_SET) map (_ -> LONG)) ++
-    (List(FARRAY_LENGTH, FARRAY_GET, FARRAY_SET) map (_ -> FLOAT)) ++
-    (List(DARRAY_LENGTH, DARRAY_GET, DARRAY_SET) map (_ -> DOUBLE)) ++
-    (List(OARRAY_LENGTH, OARRAY_GET, OARRAY_SET) map (_ -> REFERENCE(AnyRefClass))) : _*
-  )
-
   /** Check whether the given operation code is an array operation. */
   def isArrayOp(code: Int): Boolean =
     isArrayNew(code) | isArrayLength(code) | isArrayGet(code) | isArraySet(code)
@@ -535,24 +522,11 @@ abstract class ScalaPrimitives {
     case _ => false
   }
 
-  /** If code is a coercion primitive, the result type */
-  def generatedKind(code: Int): TypeKind = code match {
-    case B2B | C2B | S2B | I2B | L2B | F2B | D2B => BYTE
-    case B2C | C2C | S2C | I2C | L2C | F2C | D2C => CHAR
-    case B2S | C2S | S2S | I2S | L2S | F2S | D2S => SHORT
-    case B2I | C2I | S2I | I2I | L2I | F2I | D2I => INT
-    case B2L | C2L | S2L | I2L | L2L | F2L | D2L => LONG
-    case B2F | C2F | S2F | I2F | L2F | F2F | D2F => FLOAT
-    case B2D | C2D | S2D | I2D | L2D | F2D | D2D => DOUBLE
-  }
-
   def isPrimitive(sym: Symbol): Boolean = primitives contains sym
 
   /** Return the code for the given symbol. */
-  def getPrimitive(sym: Symbol): Int = {
-    assert(isPrimitive(sym), "Unknown primitive " + sym)
-    primitives(sym)
-  }
+  def getPrimitive(sym: Symbol): Int =
+    primitives.getOrElse(sym, throw new AssertionError(s"Unknown primitive $sym"))
 
   /**
    * Return the primitive code of the given operation. If the
@@ -565,6 +539,7 @@ abstract class ScalaPrimitives {
    */
   def getPrimitive(fun: Symbol, tpe: Type): Int = {
     import definitions._
+    import genBCode.bTypes._
     val code = getPrimitive(fun)
 
     def elementType = enteringTyper {
@@ -577,7 +552,7 @@ abstract class ScalaPrimitives {
     code match {
 
       case APPLY =>
-        toTypeKind(elementType) match {
+        typeToBType(elementType) match {
           case BOOL    => ZARRAY_GET
           case BYTE    => BARRAY_GET
           case SHORT   => SARRAY_GET
@@ -586,13 +561,13 @@ abstract class ScalaPrimitives {
           case LONG    => LARRAY_GET
           case FLOAT   => FARRAY_GET
           case DOUBLE  => DARRAY_GET
-          case REFERENCE(_) | ARRAY(_) => OARRAY_GET
+          case _: ClassBType | _: ArrayBType => OARRAY_GET
           case _ =>
             abort("Unexpected array element type: " + elementType)
         }
 
       case UPDATE =>
-        toTypeKind(elementType) match {
+        typeToBType(elementType) match {
           case BOOL    => ZARRAY_SET
           case BYTE    => BARRAY_SET
           case SHORT   => SARRAY_SET
@@ -601,13 +576,13 @@ abstract class ScalaPrimitives {
           case LONG    => LARRAY_SET
           case FLOAT   => FARRAY_SET
           case DOUBLE  => DARRAY_SET
-          case REFERENCE(_) | ARRAY(_) => OARRAY_SET
+          case _: ClassBType | _: ArrayBType => OARRAY_SET
           case _ =>
             abort("Unexpected array element type: " + elementType)
         }
 
       case LENGTH =>
-        toTypeKind(elementType) match {
+        typeToBType(elementType) match {
           case BOOL    => ZARRAY_LENGTH
           case BYTE    => BARRAY_LENGTH
           case SHORT   => SARRAY_LENGTH
@@ -616,7 +591,7 @@ abstract class ScalaPrimitives {
           case LONG    => LARRAY_LENGTH
           case FLOAT   => FARRAY_LENGTH
           case DOUBLE  => DARRAY_LENGTH
-          case REFERENCE(_) | ARRAY(_) => OARRAY_LENGTH
+          case _: ClassBType | _: ArrayBType => OARRAY_LENGTH
           case _ =>
             abort("Unexpected array element type: " + elementType)
         }
diff --git a/src/compiler/scala/tools/nsc/backend/WorklistAlgorithm.scala b/src/compiler/scala/tools/nsc/backend/WorklistAlgorithm.scala
deleted file mode 100644
index 45ca39fee4..0000000000
--- a/src/compiler/scala/tools/nsc/backend/WorklistAlgorithm.scala
+++ /dev/null
@@ -1,51 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend
-
-import scala.collection.mutable
-
-/**
- * Simple implementation of a worklist algorithm. A processing
- * function is applied repeatedly to the first element in the
- * worklist, as long as the stack is not empty.
- *
- * The client class should mix-in this class and initialize the worklist
- * field and define the `processElement` method. Then call the `run` method
- * providing a function that initializes the worklist.
- *
- * @author  Martin Odersky
- * @version 1.0
- * @see     [[scala.tools.nsc.backend.icode.Linearizers]]
- */
-trait WorklistAlgorithm {
-  type Elem
-  type WList = mutable.Stack[Elem]
-
-  val worklist: WList
-
-  /**
-   * Run the iterative algorithm until the worklist remains empty.
-   * The initializer is run once before the loop starts and should
-   * initialize the worklist.
-   */
-  def run(initWorklist: => Unit) = {
-    initWorklist
-
-    while (worklist.nonEmpty)
-      processElement(dequeue)
-  }
-
-  /**
-   * Process the current element from the worklist.
-   */
-  def processElement(e: Elem): Unit
-
-  /**
-   * Remove and return the first element to be processed from the worklist.
-   */
-  def dequeue: Elem
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala b/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala
deleted file mode 100644
index ad1975ef23..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala
+++ /dev/null
@@ -1,553 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend
-package icode
-
-import scala.collection.{ mutable, immutable }
-import mutable.ListBuffer
-import backend.icode.analysis.ProgramPoint
-import scala.language.postfixOps
-
-trait BasicBlocks {
-  self: ICodes =>
-
-  import opcodes._
-  import global._
-
-  /** Override Array creation for efficiency (to not go through reflection). */
-  private implicit val instructionTag: scala.reflect.ClassTag[Instruction] = new scala.reflect.ClassTag[Instruction] {
-    def runtimeClass: java.lang.Class[Instruction] = classOf[Instruction]
-    final override def newArray(len: Int): Array[Instruction] = new Array[Instruction](len)
-  }
-
-  object NoBasicBlock extends BasicBlock(-1, null)
-
-  /** This class represents a basic block. Each
-   *  basic block contains a list of instructions that are
-   *  either executed all, or none. No jumps
-   *  to/from the "middle" of the basic block are allowed (modulo exceptions).
-   */
-  class BasicBlock(val label: Int, val method: IMethod) extends ProgramPoint[BasicBlock] {
-    outer =>
-
-    import BBFlags._
-
-    def code = if (method eq null) NoCode else method.code
-
-    private final class SuccessorList() {
-      private var successors: List[BasicBlock] = Nil
-      /** This method is very hot! Handle with care. */
-      private def updateConserve() {
-        var lb: ListBuffer[BasicBlock]              = null
-        var matches                                 = 0
-        var remaining                               = successors
-        val direct                                  = directSuccessors
-        var scratchHandlers: List[ExceptionHandler] = method.exh
-        var scratchBlocks: List[BasicBlock]         = direct
-
-        def addBlock(bb: BasicBlock) {
-          if (matches < 0)
-            lb += bb
-          else if (remaining.isEmpty || bb != remaining.head) {
-            lb = ListBuffer[BasicBlock]() ++= (successors take matches) += bb
-            matches = -1
-          }
-          else {
-            matches += 1
-            remaining = remaining.tail
-          }
-        }
-
-        while (scratchBlocks ne Nil) {
-          addBlock(scratchBlocks.head)
-          scratchBlocks = scratchBlocks.tail
-        }
-        /* Return a list of successors for 'b' that come from exception handlers
-         * covering b's (non-exceptional) successors. These exception handlers
-         * might not cover 'b' itself. This situation corresponds to an
-         * exception being thrown as the first thing of one of b's successors.
-         */
-        while (scratchHandlers ne Nil) {
-          val handler = scratchHandlers.head
-          if (handler covers outer)
-            addBlock(handler.startBlock)
-
-          scratchBlocks = direct
-          while (scratchBlocks ne Nil) {
-            if (handler covers scratchBlocks.head)
-              addBlock(handler.startBlock)
-            scratchBlocks = scratchBlocks.tail
-          }
-          scratchHandlers = scratchHandlers.tail
-        }
-        // Blocks did not align: create a new list.
-        if (matches < 0)
-          successors = lb.toList
-        // Blocks aligned, but more blocks remain.  Take a prefix of the list.
-        else if (remaining.nonEmpty)
-          successors = successors take matches
-        // Otherwise the list is unchanged, leave it alone.
-      }
-
-      /** This is called millions of times: it is performance sensitive. */
-      def updateSuccs() {
-        if (isEmpty) {
-          if (successors.nonEmpty)
-            successors = Nil
-        }
-        else updateConserve()
-      }
-      def toList = successors
-    }
-
-    /** Flags of this basic block. */
-    private[this] var flags: Int = 0
-
-    /** Does this block have the given flag? */
-    def hasFlag(flag: Int): Boolean = (flags & flag) != 0
-
-    /** Set the given flag. */
-    private def setFlag(flag: Int): Unit = flags |= flag
-    private def resetFlag(flag: Int) {
-      flags &= ~flag
-    }
-
-    /** Is this block closed? */
-    def closed: Boolean = hasFlag(CLOSED)
-    def closed_=(b: Boolean) = if (b) setFlag(CLOSED) else resetFlag(CLOSED)
-
-    /** When set, the `emit` methods will be ignored. */
-    def ignore: Boolean = hasFlag(IGNORING)
-    def ignore_=(b: Boolean) = if (b) setFlag(IGNORING) else resetFlag(IGNORING)
-
-    /** Is this block the head of a while? */
-    def loopHeader = hasFlag(LOOP_HEADER)
-    def loopHeader_=(b: Boolean) =
-      if (b) setFlag(LOOP_HEADER) else resetFlag(LOOP_HEADER)
-
-    /** Is this block the start block of an exception handler? */
-    def exceptionHandlerStart = hasFlag(EX_HEADER)
-    def exceptionHandlerStart_=(b: Boolean) =
-      if (b) setFlag(EX_HEADER) else resetFlag(EX_HEADER)
-
-    /** Has this basic block been modified since the last call to 'successors'? */
-    def touched = hasFlag(DIRTYSUCCS)
-    def touched_=(b: Boolean) = if (b) {
-      setFlag(DIRTYSUCCS | DIRTYPREDS)
-    } else {
-      resetFlag(DIRTYSUCCS | DIRTYPREDS)
-    }
-
-    // basic blocks start in a dirty state
-    setFlag(DIRTYSUCCS | DIRTYPREDS)
-
-    /** Cached predecessors. */
-    var preds: List[BasicBlock] = Nil
-
-    /** Local variables that are in scope at entry of this basic block. Used
-     *  for debugging information.
-     */
-    val varsInScope: mutable.Set[Local] = new mutable.LinkedHashSet()
-
-    /** ICode instructions, used as temporary storage while emitting code.
-     * Once closed is called, only the `instrs` array should be used.
-     */
-    private var instructionList: List[Instruction] = Nil
-    private var instrs: Array[Instruction] = _
-
-    def take(n: Int): Seq[Instruction] =
-      if (closed) instrs take n else instructionList takeRight n reverse
-
-    def toList: List[Instruction] =
-      if (closed) instrs.toList else instructionList.reverse
-
-    /** Return an iterator over the instructions in this basic block. */
-    def iterator: Iterator[Instruction] =
-      if (closed) instrs.iterator else instructionList.reverseIterator
-
-    /** return the underlying array of instructions */
-    def getArray: Array[Instruction] = {
-      assert(closed, this)
-      instrs
-    }
-
-    def fromList(is: List[Instruction]) {
-      code.touched = true
-      instrs = is.toArray
-      closed = true
-    }
-
-    /** Return the index of inst. Uses reference equality.
-     *  Returns -1 if not found.
-     */
-    def indexOf(inst: Instruction): Int = {
-      assert(closed, this)
-      instrs indexWhere (_ eq inst)
-    }
-
-    /** Apply a function to all the instructions of the block. */
-    final def foreach[U](f: Instruction => U) = {
-      if (!closed) dumpMethodAndAbort(method, this)
-      else instrs foreach f
-
-      // !!! If I replace "instrs foreach f" with the following:
-      // var i = 0
-      // val len = instrs.length
-      // while (i < len) {
-      //   f(instrs(i))
-      //   i += 1
-      // }
-      //
-      // Then when compiling under -optimise, quick.plugins fails as follows:
-      //
-      // quick.plugins:
-      //     [mkdir] Created dir: /scratch/trunk6/build/quick/classes/continuations-plugin
-      // [scalacfork] Compiling 5 files to /scratch/trunk6/build/quick/classes/continuations-plugin
-      // [scalacfork] error: java.lang.VerifyError: (class: scala/tools/nsc/typechecker/Implicits$ImplicitSearch, method: typedImplicit0 signature: (Lscala/tools/nsc/typechecker/Implicits$ImplicitInfo;Z)Lscala/tools/nsc/typechecker/Implicits$SearchResult;) Incompatible object argument for function call
-      // [scalacfork]   at scala.tools.nsc.typechecker.Implicits$class.inferImplicit(Implicits.scala:67)
-      // [scalacfork]   at scala.tools.nsc.Global$$anon$1.inferImplicit(Global.scala:419)
-      // [scalacfork]   at scala.tools.nsc.typechecker.Typers$Typer.wrapImplicit$1(Typers.scala:170)
-      // [scalacfork]   at scala.tools.nsc.typechecker.Typers$Typer.inferView(Typers.scala:174)
-      // [scalacfork]   at scala.tools.nsc.typechecker.Typers$Typer.adapt(Typers.scala:963)
-      // [scalacfork]   at scala.tools.nsc.typechecker.Typers$Typer.typed(Typers.scala:4378)
-      //
-      // This is bad and should be understood/eliminated.
-    }
-
-    /** The number of instructions in this basic block so far. */
-    def length = if (closed) instrs.length else instructionList.length
-    def size = length
-
-    /** Return the n-th instruction. */
-    def apply(n: Int): Instruction =
-      if (closed) instrs(n) else instructionList.reverse(n)
-
-    ///////////////////// Substitutions ///////////////////////
-
-    /**
-     * Replace the instruction at the given position. Used by labels when they are anchored.
-     * The replacing instruction is given the nsc.util.Position of the instruction it replaces.
-     */
-    def replaceInstruction(pos: Int, instr: Instruction): Boolean = {
-      assert(closed, "Instructions can be replaced only after the basic block is closed")
-      instr.setPos(instrs(pos).pos)
-      instrs(pos) = instr
-      code.touched = true
-      true
-    }
-
-    /**
-     * Replace the given instruction with the new one.
-     * Returns `true` if it actually changed something.
-     * The replacing instruction is given the nsc.util.Position of the instruction it replaces.
-     */
-    def replaceInstruction(oldInstr: Instruction, newInstr: Instruction): Boolean = {
-      assert(closed, "Instructions can be replaced only after the basic block is closed")
-
-      indexOf(oldInstr) match {
-        case -1   => false
-        case idx  =>
-          newInstr setPos oldInstr.pos
-          instrs(idx) = newInstr
-          code.touched = true
-          true
-      }
-    }
-
-    /** Replaces `oldInstr` with `is`. It does not update
-     *  the position field in the newly inserted instructions, so it behaves
-     *  differently than the one-instruction versions of this function.
-     */
-    def replaceInstruction(oldInstr: Instruction, is: List[Instruction]): Boolean = {
-      assert(closed, "Instructions can be replaced only after the basic block is closed")
-
-      indexOf(oldInstr) match {
-        case -1   => false
-        case idx  =>
-          instrs = instrs.patch(idx, is, 1)
-          code.touched = true
-          true
-      }
-    }
-
-    /** Removes instructions found at the given positions.
-     */
-    def removeInstructionsAt(positions: Int*) {
-      assert(closed, this)
-      instrs = instrs.indices.toArray filterNot positions.toSet map instrs
-      code.touched = true
-    }
-
-    /** Remove the last instruction of this basic block. It is
-     *  fast for an open block, but slower when the block is closed.
-     */
-    def removeLastInstruction() {
-      if (closed)
-        removeInstructionsAt(length)
-      else {
-        instructionList = instructionList.tail
-        code.touched = true
-      }
-    }
-
-    /** Replaces all instructions found in the map.
-     */
-    def subst(map: Map[Instruction, Instruction]): Unit =
-      if (!closed)
-        instructionList = instructionList map (x => map.getOrElse(x, x))
-      else
-        instrs.iterator.zipWithIndex foreach {
-          case (oldInstr, i) =>
-            if (map contains oldInstr) {
-              // SI-6288 clone important here because `replaceInstruction` assigns
-              // a position to `newInstr`. Without this, a single instruction can
-              // be added twice, and the position last position assigned clobbers
-              // all previous positions in other usages.
-              val newInstr = map(oldInstr).clone()
-              code.touched |= replaceInstruction(i, newInstr)
-            }
-        }
-
-    ////////////////////// Emit //////////////////////
-
-
-    /** Add a new instruction at the end of the block,
-     *  using the same source position as the last emitted instruction
-     */
-    def emit(instr: Instruction) {
-      val pos = if (instructionList.isEmpty) NoPosition else instructionList.head.pos
-      emit(instr, pos)
-    }
-
-    /** Emitting does not set touched to true. During code generation this is a hotspot and
-     *  setting the flag for each emit is a waste. Caching should happen only after a block
-     *  is closed, which sets the DIRTYSUCCS flag.
-     */
-    def emit(instr: Instruction, pos: Position) {
-      assert(!closed || ignore, this)
-
-      if (ignore) {
-        if (settings.debug) {
-          /* Trying to pin down what it's likely to see after a block has been
-           * put into ignore mode so we hear about it if there's a problem.
-           */
-          instr match {
-            case JUMP(_) | RETURN(_) | THROW(_) | SCOPE_EXIT(_)                  => // ok
-            case STORE_LOCAL(local) if nme.isExceptionResultName(local.sym.name) => // ok
-            case x                                                               => log("Ignoring instruction, possibly at our peril, at " + pos + ": " + x)
-          }
-        }
-      }
-      else {
-        instr.setPos(pos)
-        instructionList ::= instr
-      }
-    }
-
-    def emit(is: Seq[Instruction]) {
-      is foreach (i => emit(i, i.pos))
-    }
-
-    /** The semantics of this are a little odd but it's designed to work
-     *  seamlessly with the existing code.  It emits each supplied instruction,
-     *  then closes the block.  The odd part is that if the instruction has
-     *  pos == NoPosition, it calls the 1-arg emit, but otherwise it calls
-     *  the 2-arg emit.  This way I could retain existing behavior exactly by
-     *  calling setPos on any instruction using the two arg version which
-     *  I wanted to include in a call to emitOnly.
-     */
-    def emitOnly(is: Instruction*) {
-      is foreach (i => if (i.pos == NoPosition) emit(i) else emit(i, i.pos))
-      this.close()
-    }
-
-    /** do nothing if block is already closed */
-    def closeWith(instr: Instruction) {
-      if (!closed) {
-        emit(instr)
-        close()
-      }
-    }
-
-    def closeWith(instr: Instruction, pos: Position) {
-      if (!closed) {
-        emit(instr, pos)
-        close()
-      }
-    }
-
-    /** Close the block */
-    def close() {
-      assert(!closed || ignore, this)
-      if (ignore && closed) { // redundant `ignore &&` for clarity -- we should never be in state `!ignore && closed`
-        // not doing anything to this block is important...
-        // because the else branch reverses innocent blocks, which is wrong when they're in ignore mode (and closed)
-        // reversing the instructions when (closed && ignore) wreaks havoc for nested label jumps (see comments in genLoad)
-      } else {
-        closed = true
-        setFlag(DIRTYSUCCS)
-        instructionList = instructionList.reverse
-        instrs = instructionList.toArray
-        if (instructionList.isEmpty) {
-          debuglog(s"Removing empty block $this")
-          code removeBlock this
-        }
-      }
-    }
-
-    /**
-     * if cond is true, closes this block, entersIgnoreMode, and removes the block from
-     * its list of blocks. Used to allow a block to be started and then cancelled when it
-     * is discovered to be unreachable.
-     */
-    def killIf(cond: Boolean) {
-      if (!settings.YdisableUnreachablePrevention && cond) {
-        debuglog(s"Killing block $this")
-        assert(instructionList.isEmpty, s"Killing a non empty block $this")
-        // only checked under debug because fetching predecessor list is moderately expensive
-        if (settings.debug)
-          assert(predecessors.isEmpty, s"Killing block $this which is referred to from ${predecessors.mkString}")
-
-        close()
-        enterIgnoreMode()
-      }
-    }
-
-    /**
-     * Same as killIf but with the logic of the condition reversed
-     */
-    def killUnless(cond: Boolean) {
-      this killIf !cond
-    }
-
-    def open() {
-      assert(closed, this)
-      closed = false
-      ignore = false
-      touched = true
-      instructionList = instructionList.reverse  // prepare for appending to the head
-    }
-
-    def clear() {
-      instructionList = Nil
-      instrs = null
-      preds  = Nil
-    }
-
-    final def isEmpty = instructionList.isEmpty
-    final def nonEmpty = !isEmpty
-
-    /** Enter ignore mode: new 'emit'ted instructions will not be
-     *  added to this basic block. It makes the generation of THROW
-     *  and RETURNs easier.
-     */
-    def enterIgnoreMode() = {
-      ignore = true
-    }
-
-    /** Return the last instruction of this basic block. */
-    def lastInstruction =
-      if (closed) instrs(instrs.length - 1)
-      else instructionList.head
-
-    def exceptionSuccessors: List[BasicBlock] =
-      exceptionSuccessorsForBlock(this)
-
-    def exceptionSuccessorsForBlock(block: BasicBlock): List[BasicBlock] =
-      method.exh collect { case x if x covers block => x.startBlock }
-
-    /** Cached value of successors. Must be recomputed whenever a block in the current method is changed. */
-    private val succs = new SuccessorList
-
-    def successors: List[BasicBlock] = {
-      if (touched) {
-        succs.updateSuccs()
-        resetFlag(DIRTYSUCCS)
-      }
-      succs.toList
-    }
-
-    def directSuccessors: List[BasicBlock] =
-      if (isEmpty) Nil else lastInstruction match {
-        case JUMP(whereto)            => whereto :: Nil
-        case CJUMP(succ, fail, _, _)  => fail :: succ :: Nil
-        case CZJUMP(succ, fail, _, _) => fail :: succ :: Nil
-        case SWITCH(_, labels)        => labels
-        case RETURN(_)                => Nil
-        case THROW(_)                 => Nil
-        case _                        =>
-          if (closed)
-            devWarning(s"$lastInstruction/${lastInstruction.getClass.getName} is not a control flow instruction")
-
-          Nil
-      }
-
-    /** Returns the predecessors of this block.     */
-    def predecessors: List[BasicBlock] = {
-      if (hasFlag(DIRTYPREDS)) {
-        resetFlag(DIRTYPREDS)
-        preds = code.blocks.iterator filter (_.successors contains this) toList
-      }
-      preds
-    }
-
-    override def equals(other: Any): Boolean = other match {
-      case that: BasicBlock => (that.label == label) && (that.code == code)
-      case _ => false
-    }
-
-    override def hashCode = label * 41 + code.hashCode
-
-    private def succString = if (successors.isEmpty) "[S: N/A]" else successors.distinct.mkString("[S: ", ", ", "]")
-    private def predString = if (predecessors.isEmpty) "[P: N/A]" else predecessors.distinct.mkString("[P: ", ", ", "]")
-
-    override def toString(): String = "" + label
-
-    def blockContents = {
-      def posStr(p: Position) = if (p.isDefined) p.line.toString else "<??>"
-      val xs = this.toList map (instr => posStr(instr.pos) + "\t" + instr)
-      xs.mkString(fullString + " {\n  ", "\n  ", "\n}")
-    }
-    def predContents = predecessors.map(_.blockContents).mkString(predecessors.size + " preds:\n", "\n", "\n")
-    def succContents = successors.map(_.blockContents).mkString(successors.size + " succs:\n", "\n", "\n")
-
-    def fullString: String = List("Block", label, succString, predString, flagsString) mkString " "
-    def flagsString: String = BBFlags.flagsToString(flags)
-  }
-}
-
-object BBFlags {
-  /** This block is a loop header (was translated from a while). */
-  final val LOOP_HEADER = (1 << 0)
-
-  /** Ignoring mode: emit instructions are dropped. */
-  final val IGNORING    = (1 << 1)
-
-  /** This block is the header of an exception handler. */
-  final val EX_HEADER   = (1 << 2)
-
-  /** This block is closed. No new instructions can be added. */
-  final val CLOSED      = (1 << 3)
-
-  /** Code has been changed, recompute successors. */
-  final val DIRTYSUCCS  = (1 << 4)
-
-  /** Code has been changed, recompute predecessors. */
-  final val DIRTYPREDS  = (1 << 5)
-
-  val flagMap = Map[Int, String](
-    LOOP_HEADER -> "loopheader",
-    IGNORING    -> "ignore",
-    EX_HEADER   -> "exheader",
-    CLOSED      -> "closed",
-    DIRTYSUCCS  -> "dirtysuccs",
-    DIRTYPREDS  -> "dirtypreds"
-  )
-  def flagsToString(flags: Int) = {
-    flagMap collect { case (bit, name) if (bit & flags) != 0 => "<" + name + ">" } mkString " "
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/CheckerException.scala b/src/compiler/scala/tools/nsc/backend/icode/CheckerException.scala
deleted file mode 100644
index 8bcdb6dbd2..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/CheckerException.scala
+++ /dev/null
@@ -1,10 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend
-package icode
-
-class CheckerException(s: String) extends Exception(s)
diff --git a/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala b/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala
deleted file mode 100644
index 7243264773..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala
+++ /dev/null
@@ -1,71 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend
-package icode
-
-import scala.collection.immutable
-
-/**
- * Exception handlers are pieces of code that `handle` exceptions on
- * the covered basic blocks. Since Scala's exception handling uses
- * pattern matching instead of just class names to identify handlers,
- * all our handlers will catch `Throwable` and rely on proper ordering
- * in the generated code to preserve nesting.
- */
-trait ExceptionHandlers {
-  self: ICodes =>
-
-  import global._
-  import definitions.{ ThrowableClass }
-
-  class ExceptionHandler(val method: IMethod, val label: TermName, val cls: Symbol, val pos: Position) {
-    def loadExceptionClass = if (cls == NoSymbol) ThrowableClass else cls
-    private var _startBlock: BasicBlock = _
-    var finalizer: Finalizer = _
-
-    def setStartBlock(b: BasicBlock) = {
-      _startBlock = b
-      b.exceptionHandlerStart = true
-    }
-    def startBlock = _startBlock
-
-    /** The list of blocks that are covered by this exception handler */
-    var covered: immutable.Set[BasicBlock] = immutable.HashSet.empty[BasicBlock]
-
-    def addCoveredBlock(b: BasicBlock): this.type = {
-      covered = covered + b
-      this
-    }
-
-    /** Is `b` covered by this exception handler? */
-    def covers(b: BasicBlock): Boolean = covered(b)
-
-    /** The body of this exception handler. May contain 'dead' blocks (which will not
-      * make it into generated code because linearizers may not include them) */
-    var blocks: List[BasicBlock] = Nil
-
-    def addBlock(b: BasicBlock): Unit = blocks = b :: blocks
-
-    override def toString() = "exh_" + label + "(" + cls.simpleName + ")"
-
-    /** A standard copy constructor */
-    def this(other: ExceptionHandler) = {
-      this(other.method, other.label, other.cls, other.pos)
-
-      covered   = other.covered
-      setStartBlock(other.startBlock)
-      finalizer = other.finalizer
-    }
-
-    def dup: ExceptionHandler = new ExceptionHandler(this)
-  }
-
-  class Finalizer(method: IMethod, label: TermName, pos: Position) extends ExceptionHandler(method, label, NoSymbol, pos) {
-    override def toString() = "finalizer_" + label
-    override def dup: Finalizer = new Finalizer(method, label, pos)
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
deleted file mode 100644
index a927097b62..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
+++ /dev/null
@@ -1,2239 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-
-package scala
-package tools.nsc
-package backend
-package icode
-
-import scala.collection.{ mutable, immutable }
-import scala.collection.mutable.{ ListBuffer, Buffer }
-import scala.tools.nsc.symtab._
-import scala.annotation.switch
-
-/**
- *  @author  Iulian Dragos
- *  @version 1.0
- */
-abstract class GenICode extends SubComponent {
-  import global._
-  import icodes._
-  import icodes.opcodes._
-  import definitions._
-  import scalaPrimitives.{
-    isArrayOp, isComparisonOp, isLogicalOp,
-    isUniversalEqualityOp, isReferenceEqualityOp
-  }
-  import platform.isMaybeBoxed
-
-  private val bCodeICodeCommon: jvm.BCodeICodeCommon[global.type] = new jvm.BCodeICodeCommon(global)
-  import bCodeICodeCommon._
-
-  val phaseName = "icode"
-
-  override def newPhase(prev: Phase) = new ICodePhase(prev)
-
-  @inline private def debugassert(cond: => Boolean, msg: => Any) {
-    if (settings.debug)
-      assert(cond, msg)
-  }
-
-  class ICodePhase(prev: Phase) extends StdPhase(prev) {
-
-    override def description = "Generate ICode from the AST"
-
-    var unit: CompilationUnit = NoCompilationUnit
-
-    override def run() {
-      if (!settings.isBCodeActive) {
-        scalaPrimitives.init()
-        classes.clear()
-      }
-      super.run()
-    }
-
-    override def apply(unit: CompilationUnit): Unit = {
-      if (settings.isBCodeActive) { return }
-      this.unit = unit
-      unit.icode.clear()
-      informProgress("Generating icode for " + unit)
-      gen(unit.body)
-      this.unit = NoCompilationUnit
-    }
-
-    def gen(tree: Tree): Context = gen(tree, new Context())
-
-    def gen(trees: List[Tree], ctx: Context): Context = {
-      var ctx1 = ctx
-      for (t <- trees) ctx1 = gen(t, ctx1)
-      ctx1
-    }
-
-    /** If the selector type has a member with the right name,
-     *  it is the host class; otherwise the symbol's owner.
-     */
-    def findHostClass(selector: Type, sym: Symbol) = selector member sym.name match {
-      case NoSymbol   => debuglog(s"Rejecting $selector as host class for $sym") ; sym.owner
-      case _          => selector.typeSymbol
-    }
-
-    /////////////////// Code generation ///////////////////////
-
-    def gen(tree: Tree, ctx: Context): Context = tree match {
-      case EmptyTree => ctx
-
-      case PackageDef(pid, stats) =>
-        gen(stats, ctx setPackage pid.name)
-
-      case ClassDef(mods, name, _, impl) =>
-        debuglog("Generating class: " + tree.symbol.fullName)
-        val outerClass = ctx.clazz
-        ctx setClass (new IClass(tree.symbol) setCompilationUnit unit)
-        addClassFields(ctx, tree.symbol)
-        classes += (tree.symbol -> ctx.clazz)
-        unit.icode += ctx.clazz
-        gen(impl, ctx)
-        ctx.clazz.methods = ctx.clazz.methods.reverse // preserve textual order
-        ctx.clazz.fields  = ctx.clazz.fields.reverse  // preserve textual order
-        ctx setClass outerClass
-
-      // !! modules should be eliminated by refcheck... or not?
-      case ModuleDef(mods, name, impl) =>
-        abort("Modules should not reach backend! " + tree)
-
-      case ValDef(mods, name, tpt, rhs) =>
-        ctx // we use the symbol to add fields
-
-      case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
-        debuglog("Entering method " + name)
-        val m = new IMethod(tree.symbol)
-        m.sourceFile = unit.source
-        m.returnType = if (tree.symbol.isConstructor) UNIT
-                       else toTypeKind(tree.symbol.info.resultType)
-        ctx.clazz.addMethod(m)
-
-        var ctx1 = ctx.enterMethod(m, tree.asInstanceOf[DefDef])
-        addMethodParams(ctx1, vparamss)
-        m.native = m.symbol.hasAnnotation(definitions.NativeAttr)
-
-        if (!m.isAbstractMethod && !m.native) {
-          ctx1 = genLoad(rhs, ctx1, m.returnType)
-
-          // reverse the order of the local variables, to match the source-order
-          m.locals = m.locals.reverse
-
-          rhs match {
-            case Block(_, Return(_)) => ()
-            case Return(_) => ()
-            case EmptyTree =>
-              globalError("Concrete method has no definition: " + tree + (
-                if (settings.debug) "(found: " + m.symbol.owner.info.decls.toList.mkString(", ") + ")"
-                else "")
-              )
-            case _ => if (ctx1.bb.isEmpty)
-              ctx1.bb.closeWith(RETURN(m.returnType), rhs.pos)
-            else
-              ctx1.bb.closeWith(RETURN(m.returnType))
-          }
-          if (!ctx1.bb.closed) ctx1.bb.close()
-          prune(ctx1.method)
-        } else
-          ctx1.method.setCode(NoCode)
-        ctx1
-
-      case Template(_, _, body) =>
-        gen(body, ctx)
-
-      case _ =>
-        abort("Illegal tree in gen: " + tree)
-    }
-
-    private def genStat(trees: List[Tree], ctx: Context): Context =
-      trees.foldLeft(ctx)((currentCtx, t) => genStat(t, currentCtx))
-
-    /**
-     * Generate code for the given tree. The trees should contain statements
-     * and not produce any value. Use genLoad for expressions which leave
-     * a value on top of the stack.
-     *
-     * @return a new context. This is necessary for control flow instructions
-     *         which may change the current basic block.
-     */
-    private def genStat(tree: Tree, ctx: Context): Context = tree match {
-      case Assign(lhs @ Select(_, _), rhs) =>
-        val isStatic = lhs.symbol.isStaticMember
-        var ctx1 = if (isStatic) ctx else genLoadQualifier(lhs, ctx)
-
-        ctx1 = genLoad(rhs, ctx1, toTypeKind(lhs.symbol.info))
-        ctx1.bb.emit(STORE_FIELD(lhs.symbol, isStatic), tree.pos)
-        ctx1
-
-      case Assign(lhs, rhs) =>
-        val ctx1 = genLoad(rhs, ctx, toTypeKind(lhs.symbol.info))
-        val Some(l) = ctx.method.lookupLocal(lhs.symbol)
-        ctx1.bb.emit(STORE_LOCAL(l), tree.pos)
-        ctx1
-
-      case _ =>
-        genLoad(tree, ctx, UNIT)
-    }
-
-    private def genThrow(expr: Tree, ctx: Context): (Context, TypeKind) = {
-      require(expr.tpe <:< ThrowableTpe, expr.tpe)
-
-      val thrownKind = toTypeKind(expr.tpe)
-      val ctx1       = genLoad(expr, ctx, thrownKind)
-      ctx1.bb.emit(THROW(expr.tpe.typeSymbol), expr.pos)
-      ctx1.bb.enterIgnoreMode()
-
-      (ctx1, NothingReference)
-    }
-
-    /**
-     * Generate code for primitive arithmetic operations.
-     * Returns (Context, Generated Type)
-     */
-    private def genArithmeticOp(tree: Tree, ctx: Context, code: Int): (Context, TypeKind) = {
-      val Apply(fun @ Select(larg, _), args) = tree
-      var ctx1 = ctx
-      var resKind = toTypeKind(larg.tpe)
-
-      debugassert(args.length <= 1,
-               "Too many arguments for primitive function: " + fun.symbol)
-      debugassert(resKind.isNumericType | resKind == BOOL,
-               resKind.toString() + " is not a numeric or boolean type " +
-               "[operation: " + fun.symbol + "]")
-
-      args match {
-        // unary operation
-        case Nil =>
-          ctx1 = genLoad(larg, ctx1, resKind)
-          code match {
-            case scalaPrimitives.POS =>
-              () // nothing
-            case scalaPrimitives.NEG =>
-              ctx1.bb.emit(CALL_PRIMITIVE(Negation(resKind)), larg.pos)
-            case scalaPrimitives.NOT =>
-              ctx1.bb.emit(CALL_PRIMITIVE(Arithmetic(NOT, resKind)), larg.pos)
-            case _ =>
-              abort("Unknown unary operation: " + fun.symbol.fullName +
-                    " code: " + code)
-          }
-
-        // binary operation
-        case rarg :: Nil =>
-          resKind = getMaxType(larg.tpe :: rarg.tpe :: Nil)
-          if (scalaPrimitives.isShiftOp(code) || scalaPrimitives.isBitwiseOp(code))
-            assert(resKind.isIntegralType | resKind == BOOL,
-                 resKind.toString() + " incompatible with arithmetic modulo operation: " + ctx1)
-
-          ctx1 = genLoad(larg, ctx1, resKind)
-          ctx1 = genLoad(rarg,
-                         ctx1, // check .NET size of shift arguments!
-                         if (scalaPrimitives.isShiftOp(code)) INT else resKind)
-
-          val primitiveOp = code match {
-            case scalaPrimitives.ADD    => Arithmetic(ADD, resKind)
-            case scalaPrimitives.SUB    => Arithmetic(SUB, resKind)
-            case scalaPrimitives.MUL    => Arithmetic(MUL, resKind)
-            case scalaPrimitives.DIV    => Arithmetic(DIV, resKind)
-            case scalaPrimitives.MOD    => Arithmetic(REM, resKind)
-            case scalaPrimitives.OR     => Logical(OR, resKind)
-            case scalaPrimitives.XOR    => Logical(XOR, resKind)
-            case scalaPrimitives.AND    => Logical(AND, resKind)
-            case scalaPrimitives.LSL    => Shift(LSL, resKind)
-            case scalaPrimitives.LSR    => Shift(LSR, resKind)
-            case scalaPrimitives.ASR    => Shift(ASR, resKind)
-            case _                      => abort("Unknown primitive: " + fun.symbol + "[" + code + "]")
-          }
-          ctx1.bb.emit(CALL_PRIMITIVE(primitiveOp), tree.pos)
-
-        case _ =>
-          abort("Too many arguments for primitive function: " + tree)
-      }
-      (ctx1, resKind)
-    }
-
-    /** Generate primitive array operations.
-     */
-    private def genArrayOp(tree: Tree, ctx: Context, code: Int, expectedType: TypeKind): (Context, TypeKind) = {
-      import scalaPrimitives._
-      val Apply(Select(arrayObj, _), args) = tree
-      val k = toTypeKind(arrayObj.tpe)
-      val ARRAY(elem) = k
-      var ctx1 = genLoad(arrayObj, ctx, k)
-      val elementType = typeOfArrayOp.getOrElse(code, abort("Unknown operation on arrays: " + tree + " code: " + code))
-
-      var generatedType = expectedType
-
-      if (scalaPrimitives.isArrayGet(code)) {
-        // load argument on stack
-        debugassert(args.length == 1,
-                 "Too many arguments for array get operation: " + tree)
-        ctx1 = genLoad(args.head, ctx1, INT)
-        generatedType = elem
-        ctx1.bb.emit(LOAD_ARRAY_ITEM(elementType), tree.pos)
-        // it's tempting to just drop array loads of type Null instead
-        // of adapting them but array accesses can cause
-        // ArrayIndexOutOfBounds so we can't. Besides, Array[Null]
-        // probably isn't common enough to figure out an optimization
-        adaptNullRef(generatedType, expectedType, ctx1, tree.pos)
-      }
-      else if (scalaPrimitives.isArraySet(code)) {
-        debugassert(args.length == 2,
-                 "Too many arguments for array set operation: " + tree)
-        ctx1 = genLoad(args.head, ctx1, INT)
-        ctx1 = genLoad(args.tail.head, ctx1, toTypeKind(args.tail.head.tpe))
-        // the following line should really be here, but because of bugs in erasure
-        // we pretend we generate whatever type is expected from us.
-        //generatedType = UNIT
-
-        ctx1.bb.emit(STORE_ARRAY_ITEM(elementType), tree.pos)
-      }
-      else {
-        generatedType = INT
-        ctx1.bb.emit(CALL_PRIMITIVE(ArrayLength(elementType)), tree.pos)
-      }
-
-      (ctx1, generatedType)
-    }
-    private def genSynchronized(tree: Apply, ctx: Context, expectedType: TypeKind): (Context, TypeKind) = {
-      val Apply(fun, args) = tree
-      val monitor = ctx.makeLocal(tree.pos, ObjectTpe, "monitor")
-      var monitorResult: Local = null
-      val argTpe = args.head.tpe
-      val hasResult = expectedType != UNIT
-      if (hasResult)
-        monitorResult = ctx.makeLocal(tree.pos, argTpe, "monitorResult")
-
-      var ctx1 = genLoadQualifier(fun, ctx)
-      ctx1.bb.emit(Seq(
-        DUP(ObjectReference),
-        STORE_LOCAL(monitor),
-        MONITOR_ENTER() setPos tree.pos
-      ))
-      ctx1.enterSynchronized(monitor)
-      debuglog("synchronized block start")
-
-      ctx1 = ctx1.Try(
-        bodyCtx => {
-          val ctx2 = genLoad(args.head, bodyCtx, expectedType /* toTypeKind(tree.tpe.resultType) */)
-          if (hasResult)
-            ctx2.bb.emit(STORE_LOCAL(monitorResult))
-          ctx2.bb.emit(Seq(
-            LOAD_LOCAL(monitor),
-            MONITOR_EXIT() setPos tree.pos
-          ))
-          ctx2
-        }, List(
-          // tree.tpe / fun.tpe is object, which is no longer true after this transformation
-          (ThrowableClass, expectedType, exhCtx => {
-            exhCtx.bb.emit(Seq(
-              LOAD_LOCAL(monitor),
-              MONITOR_EXIT() setPos tree.pos,
-              THROW(ThrowableClass)
-            ))
-            exhCtx.bb.enterIgnoreMode()
-            exhCtx
-          })), EmptyTree, tree)
-
-      debuglog("synchronized block end with block %s closed=%s".format(ctx1.bb, ctx1.bb.closed))
-      ctx1.exitSynchronized(monitor)
-      if (hasResult)
-        ctx1.bb.emit(LOAD_LOCAL(monitorResult))
-      (ctx1, expectedType)
-    }
-
-    private def genLoadIf(tree: If, ctx: Context, expectedType: TypeKind): (Context, TypeKind) = {
-      val If(cond, thenp, elsep) = tree
-
-      var thenCtx = ctx.newBlock()
-      var elseCtx = ctx.newBlock()
-      val contCtx = ctx.newBlock()
-
-      genCond(cond, ctx, thenCtx, elseCtx)
-
-      val ifKind = toTypeKind(tree.tpe)
-      val thenKind = toTypeKind(thenp.tpe)
-      val elseKind = if (elsep == EmptyTree) UNIT else toTypeKind(elsep.tpe)
-
-      // we need to drop unneeded results, if one branch gives
-      // unit and the other gives something on the stack, because
-      // the type of 'if' is scala.Any, and its erasure would be Object.
-      // But unboxed units are not Objects...
-      def hasUnitBranch = thenKind == UNIT || elseKind == UNIT
-      val resKind = if (hasUnitBranch) UNIT else ifKind
-
-      if (hasUnitBranch)
-        debuglog("Will drop result from an if branch")
-
-      thenCtx = genLoad(thenp, thenCtx, resKind)
-      elseCtx = genLoad(elsep, elseCtx, resKind)
-
-      debugassert(!hasUnitBranch || expectedType == UNIT,
-        "I produce UNIT in a context where " + expectedType + " is expected!")
-
-      // alternatives may be already closed by a tail-recursive jump
-      val contReachable = !(thenCtx.bb.ignore && elseCtx.bb.ignore)
-      thenCtx.bb.closeWith(JUMP(contCtx.bb))
-      elseCtx.bb.closeWith(
-          if (elsep == EmptyTree) JUMP(contCtx.bb)
-          else JUMP(contCtx.bb) setPos tree.pos
-        )
-
-      contCtx.bb killUnless contReachable
-      (contCtx, resKind)
-    }
-    private def genLoadTry(tree: Try, ctx: Context, setGeneratedType: TypeKind => Unit): Context = {
-      val Try(block, catches, finalizer) = tree
-      val kind = toTypeKind(tree.tpe)
-
-      val caseHandlers =
-        for (CaseDef(pat, _, body) <- catches.reverse) yield {
-          def genWildcardHandler(sym: Symbol): (Symbol, TypeKind, Context => Context) =
-            (sym, kind, ctx => {
-              ctx.bb.emit(DROP(REFERENCE(sym))) // drop the loaded exception
-              genLoad(body, ctx, kind)
-            })
-
-          pat match {
-            case Typed(Ident(nme.WILDCARD), tpt)  => genWildcardHandler(tpt.tpe.typeSymbol)
-            case Ident(nme.WILDCARD)              => genWildcardHandler(ThrowableClass)
-            case Bind(_, _)                       =>
-              val exception = ctx.method addLocal new Local(pat.symbol, toTypeKind(pat.symbol.tpe), false) // the exception will be loaded and stored into this local
-
-              (pat.symbol.tpe.typeSymbol, kind, {
-                ctx: Context =>
-                  ctx.bb.emit(STORE_LOCAL(exception), pat.pos)
-                  genLoad(body, ctx, kind)
-              })
-          }
-        }
-
-      ctx.Try(
-        bodyCtx => {
-          setGeneratedType(kind)
-          genLoad(block, bodyCtx, kind)
-        },
-        caseHandlers,
-        finalizer,
-        tree)
-    }
-
-    private def genPrimitiveOp(tree: Apply, ctx: Context, expectedType: TypeKind): (Context, TypeKind) = {
-      val sym = tree.symbol
-      val Apply(fun @ Select(receiver, _), _) = tree
-      val code = scalaPrimitives.getPrimitive(sym, receiver.tpe)
-
-      if (scalaPrimitives.isArithmeticOp(code))
-        genArithmeticOp(tree, ctx, code)
-      else if (code == scalaPrimitives.CONCAT)
-        (genStringConcat(tree, ctx), StringReference)
-      else if (code == scalaPrimitives.HASH)
-        (genScalaHash(receiver, ctx), INT)
-      else if (isArrayOp(code))
-        genArrayOp(tree, ctx, code, expectedType)
-      else if (isLogicalOp(code) || isComparisonOp(code)) {
-        val trueCtx, falseCtx, afterCtx = ctx.newBlock()
-
-        genCond(tree, ctx, trueCtx, falseCtx)
-        trueCtx.bb.emitOnly(
-          CONSTANT(Constant(true)) setPos tree.pos,
-          JUMP(afterCtx.bb)
-        )
-        falseCtx.bb.emitOnly(
-          CONSTANT(Constant(false)) setPos tree.pos,
-          JUMP(afterCtx.bb)
-        )
-        (afterCtx, BOOL)
-      }
-      else if (code == scalaPrimitives.SYNCHRONIZED)
-        genSynchronized(tree, ctx, expectedType)
-      else if (scalaPrimitives.isCoercion(code)) {
-        val ctx1 = genLoad(receiver, ctx, toTypeKind(receiver.tpe))
-        genCoercion(tree, ctx1, code)
-        (ctx1, scalaPrimitives.generatedKind(code))
-      }
-      else abort(
-        "Primitive operation not handled yet: " + sym.fullName + "(" +
-        fun.symbol.simpleName + ") " + " at: " + (tree.pos)
-      )
-    }
-
-    /**
-     * Generate code for trees that produce values on the stack
-     *
-     * @param tree The tree to be translated
-     * @param ctx  The current context
-     * @param expectedType The type of the value to be generated on top of the
-     *                     stack.
-     * @return The new context. The only thing that may change is the current
-     *         basic block (as the labels map is mutable).
-     */
-    private def genLoad(tree: Tree, ctx: Context, expectedType: TypeKind): Context = {
-      var generatedType = expectedType
-      debuglog("at line: " + (if (tree.pos.isDefined) tree.pos.line else tree.pos))
-
-      val resCtx: Context = tree match {
-        case LabelDef(name, params, rhs) =>
-          def genLoadLabelDef = {
-            val ctx1 = ctx.newBlock() // note: we cannot kill ctx1 if ctx is in ignore mode because
-                                      // label defs can be the target of jumps from other locations.
-                                      // that means label defs can lead to unreachable code without
-                                      // proper reachability analysis
-
-            if (nme.isLoopHeaderLabel(name))
-              ctx1.bb.loopHeader = true
-
-            ctx1.labels.get(tree.symbol) match {
-              case Some(label) =>
-                debuglog("Found existing label for " + tree.symbol.fullLocationString)
-                label.anchor(ctx1.bb)
-                label.patch(ctx.method.code)
-
-              case None =>
-                val pair = (tree.symbol -> (new Label(tree.symbol) anchor ctx1.bb setParams (params map (_.symbol))))
-                debuglog("Adding label " + tree.symbol.fullLocationString + " in genLoad.")
-                ctx1.labels += pair
-                ctx.method.addLocals(params map (p => new Local(p.symbol, toTypeKind(p.symbol.info), false)))
-            }
-
-            ctx.bb.closeWith(JUMP(ctx1.bb), tree.pos)
-            genLoad(rhs, ctx1, expectedType /*toTypeKind(tree.symbol.info.resultType)*/)
-          }
-          genLoadLabelDef
-
-        case ValDef(_, name, _, rhs) =>
-          def genLoadValDef =
-            if (name == nme.THIS) {
-              debuglog("skipping trivial assign to _$this: " + tree)
-              ctx
-            } else {
-              val sym = tree.symbol
-              val local = ctx.method.addLocal(new Local(sym, toTypeKind(sym.info), false))
-
-              if (rhs == EmptyTree) {
-                debuglog("Uninitialized variable " + tree + " at: " + (tree.pos))
-                ctx.bb.emit(getZeroOf(local.kind))
-              }
-
-              var ctx1 = ctx
-              if (rhs != EmptyTree)
-                ctx1 = genLoad(rhs, ctx, local.kind)
-
-              ctx1.bb.emit(STORE_LOCAL(local), tree.pos)
-              ctx1.scope.add(local)
-              ctx1.bb.emit(SCOPE_ENTER(local))
-              generatedType = UNIT
-              ctx1
-            }
-          genLoadValDef
-
-        case t @ If(cond, thenp, elsep) =>
-          val (newCtx, resKind) = genLoadIf(t, ctx, expectedType)
-          generatedType = resKind
-          newCtx
-
-        case Return(expr) =>
-          def genLoadReturn = {
-            val returnedKind = toTypeKind(expr.tpe)
-            debuglog("Return(" + expr + ") with returnedKind = " + returnedKind)
-
-            var ctx1         = genLoad(expr, ctx, returnedKind)
-            lazy val tmp     = ctx1.makeLocal(tree.pos, expr.tpe, "tmp")
-            val saved        = savingCleanups(ctx1) {
-              var savedFinalizer = false
-              ctx1.cleanups foreach {
-                case MonitorRelease(m) =>
-                  debuglog("removing " + m + " from cleanups: " + ctx1.cleanups)
-                  ctx1.bb.emit(Seq(LOAD_LOCAL(m), MONITOR_EXIT()))
-                  ctx1.exitSynchronized(m)
-
-                case Finalizer(f, finalizerCtx) =>
-                  debuglog("removing " + f + " from cleanups: " + ctx1.cleanups)
-                  if (returnedKind != UNIT && mayCleanStack(f)) {
-                    log("Emitting STORE_LOCAL for " + tmp + " to save finalizer.")
-                    ctx1.bb.emit(STORE_LOCAL(tmp))
-                    savedFinalizer = true
-                  }
-
-                  // duplicate finalizer (takes care of anchored labels)
-                  val f1 = duplicateFinalizer(Set.empty ++ ctx1.labels.keySet, ctx1, f)
-
-                  // we have to run this without the same finalizer in
-                  // the list, otherwise infinite recursion happens for
-                  // finalizers that contain 'return'
-                  val fctx = finalizerCtx.newBlock()
-                  fctx.bb killIf ctx1.bb.ignore
-                  ctx1.bb.closeWith(JUMP(fctx.bb))
-                  ctx1 = genLoad(f1, fctx, UNIT)
-              }
-              savedFinalizer
-            }
-
-            if (saved) {
-              log("Emitting LOAD_LOCAL for " + tmp + " after saving finalizer.")
-              ctx1.bb.emit(LOAD_LOCAL(tmp))
-            }
-            adapt(returnedKind, ctx1.method.returnType, ctx1, tree.pos)
-            ctx1.bb.emit(RETURN(ctx.method.returnType), tree.pos)
-            ctx1.bb.enterIgnoreMode()
-            generatedType = expectedType
-            ctx1
-          }
-          genLoadReturn
-
-        case t @ Try(_, _, _) =>
-          genLoadTry(t, ctx, generatedType = _)
-
-        case Throw(expr) =>
-          val (ctx1, expectedType) = genThrow(expr, ctx)
-          generatedType = expectedType
-          ctx1
-
-        case New(tpt) =>
-          abort("Unexpected New(" + tpt.summaryString + "/" + tpt + ") received in icode.\n" +
-            "  Call was genLoad" + ((tree, ctx, expectedType)))
-
-        case Apply(TypeApply(fun, targs), _) =>
-          def genLoadApply1 = {
-            val sym = fun.symbol
-            val cast = sym match {
-              case Object_isInstanceOf  => false
-              case Object_asInstanceOf  => true
-              case _                    => abort("Unexpected type application " + fun + "[sym: " + sym.fullName + "]" + " in: " + tree)
-            }
-
-            val Select(obj, _) = fun
-            val l = toTypeKind(obj.tpe)
-            val r = toTypeKind(targs.head.tpe)
-            val ctx1 = genLoadQualifier(fun, ctx)
-
-            if (l.isValueType && r.isValueType)
-              genConversion(l, r, ctx1, cast)
-            else if (l.isValueType) {
-              ctx1.bb.emit(DROP(l), fun.pos)
-              if (cast) {
-                ctx1.bb.emit(Seq(
-                  NEW(REFERENCE(definitions.ClassCastExceptionClass)),
-                  DUP(ObjectReference),
-                  THROW(definitions.ClassCastExceptionClass)
-                ))
-              } else
-                ctx1.bb.emit(CONSTANT(Constant(false)))
-            } else if (r.isValueType && cast) {
-              /* Erasure should have added an unboxing operation to prevent that. */
-              abort("should have been unboxed by erasure: " + tree)
-            } else if (r.isValueType) {
-              ctx.bb.emit(IS_INSTANCE(REFERENCE(definitions.boxedClass(r.toType.typeSymbol))))
-            } else {
-              genCast(l, r, ctx1, cast)
-            }
-            generatedType = if (cast) r else BOOL
-            ctx1
-          }
-          genLoadApply1
-
-        // 'super' call: Note: since constructors are supposed to
-        // return an instance of what they construct, we have to take
-        // special care. On JVM they are 'void', and Scala forbids (syntactically)
-        // to call super constructors explicitly and/or use their 'returned' value.
-        // therefore, we can ignore this fact, and generate code that leaves nothing
-        // on the stack (contrary to what the type in the AST says).
-        case Apply(fun @ Select(Super(_, mix), _), args) =>
-          def genLoadApply2 = {
-            debuglog("Call to super: " + tree)
-            val invokeStyle = SuperCall(mix)
-            // if (fun.symbol.isConstructor) Static(true) else SuperCall(mix);
-
-            ctx.bb.emit(THIS(ctx.clazz.symbol), tree.pos)
-            val ctx1 = genLoadArguments(args, fun.symbol.info.paramTypes, ctx)
-
-            ctx1.bb.emit(CALL_METHOD(fun.symbol, invokeStyle), tree.pos)
-            generatedType =
-              if (fun.symbol.isConstructor) UNIT
-              else toTypeKind(fun.symbol.info.resultType)
-            ctx1
-          }
-          genLoadApply2
-
-        // 'new' constructor call: Note: since constructors are
-        // thought to return an instance of what they construct,
-        // we have to 'simulate' it by DUPlicating the freshly created
-        // instance (on JVM, <init> methods return VOID).
-        case Apply(fun @ Select(New(tpt), nme.CONSTRUCTOR), args) =>
-          def genLoadApply3 = {
-            val ctor = fun.symbol
-            debugassert(ctor.isClassConstructor,
-                        "'new' call to non-constructor: " + ctor.name)
-
-            generatedType = toTypeKind(tpt.tpe)
-            debugassert(generatedType.isReferenceType || generatedType.isArrayType,
-                        "Non reference type cannot be instantiated: " + generatedType)
-
-            generatedType match {
-              case arr @ ARRAY(elem) =>
-                val ctx1 = genLoadArguments(args, ctor.info.paramTypes, ctx)
-                val dims = arr.dimensions
-                var elemKind = arr.elementKind
-                if (args.length > dims)
-                  reporter.error(tree.pos, "too many arguments for array constructor: found " + args.length +
-                             " but array has only " + dims + " dimension(s)")
-                if (args.length != dims)
-                  for (i <- args.length until dims) elemKind = ARRAY(elemKind)
-                ctx1.bb.emit(CREATE_ARRAY(elemKind, args.length), tree.pos)
-                ctx1
-
-              case rt @ REFERENCE(cls) =>
-                debugassert(ctor.owner == cls,
-                            "Symbol " + ctor.owner.fullName + " is different than " + tpt)
-
-                val nw = NEW(rt)
-                ctx.bb.emit(nw, tree.pos)
-                ctx.bb.emit(DUP(generatedType))
-                val ctx1 = genLoadArguments(args, ctor.info.paramTypes, ctx)
-
-                val init = CALL_METHOD(ctor, Static(onInstance = true))
-                nw.init = init
-                ctx1.bb.emit(init, tree.pos)
-                ctx1
-              case _ =>
-                abort("Cannot instantiate " + tpt + " of kind: " + generatedType)
-            }
-          }
-          genLoadApply3
-
-        case Apply(fun @ _, List(expr)) if currentRun.runDefinitions.isBox(fun.symbol) =>
-          def genLoadApply4 = {
-            debuglog("BOX : " + fun.symbol.fullName)
-            val ctx1 = genLoad(expr, ctx, toTypeKind(expr.tpe))
-            val nativeKind = toTypeKind(expr.tpe)
-            if (settings.Xdce) {
-              // we store this boxed value to a local, even if not really needed.
-              // boxing optimization might use it, and dead code elimination will
-              // take care of unnecessary stores
-              val loc1 = ctx.makeLocal(tree.pos, expr.tpe, "boxed")
-              ctx1.bb.emit(STORE_LOCAL(loc1))
-              ctx1.bb.emit(LOAD_LOCAL(loc1))
-            }
-            ctx1.bb.emit(BOX(nativeKind), expr.pos)
-            generatedType = toTypeKind(fun.symbol.tpe.resultType)
-            ctx1
-          }
-          genLoadApply4
-
-        case Apply(fun @ _, List(expr)) if (currentRun.runDefinitions.isUnbox(fun.symbol)) =>
-          debuglog("UNBOX : " + fun.symbol.fullName)
-          val ctx1 = genLoad(expr, ctx, toTypeKind(expr.tpe))
-          val boxType = toTypeKind(fun.symbol.owner.linkedClassOfClass.tpe)
-          generatedType = boxType
-          ctx1.bb.emit(UNBOX(boxType), expr.pos)
-          ctx1
-
-        case app @ Apply(fun, args) =>
-          def genLoadApply6 = {
-            val sym = fun.symbol
-
-            if (sym.isLabel) {  // jump to a label
-              val label = ctx.labels.getOrElse(sym, {
-                // it is a forward jump, scan for labels
-                resolveForwardLabel(ctx.defdef, ctx, sym)
-                ctx.labels.get(sym) match {
-                  case Some(l) =>
-                    debuglog("Forward jump for " + sym.fullLocationString + ": scan found label " + l)
-                    l
-                  case _       =>
-                    abort("Unknown label target: " + sym + " at: " + (fun.pos) + ": ctx: " + ctx)
-                }
-              })
-              // note: when one of the args to genLoadLabelArguments is a jump to a label,
-              // it will call back into genLoad and arrive at this case, which will then set ctx1.bb.ignore to true,
-              // this is okay, since we're jumping unconditionally, so the loads and jumps emitted by the outer
-              // call to genLoad (by calling genLoadLabelArguments and emitOnly) can safely be ignored,
-              // however, as emitOnly will close the block, which reverses its instructions (when it's still open),
-              // we better not reverse when the block has already been closed but is in ignore mode
-              // (if it's not in ignore mode, double-closing is an error)
-              val ctx1 = genLoadLabelArguments(args, label, ctx)
-              ctx1.bb.emitOnly(if (label.anchored) JUMP(label.block) else PJUMP(label))
-              ctx1.bb.enterIgnoreMode()
-              ctx1
-            } else if (isPrimitive(sym)) { // primitive method call
-              val (newCtx, resKind) = genPrimitiveOp(app, ctx, expectedType)
-              generatedType = resKind
-              newCtx
-            } else {  // normal method call
-              debuglog("Gen CALL_METHOD with sym: " + sym + " isStaticSymbol: " + sym.isStaticMember)
-              val invokeStyle =
-                if (sym.isStaticMember)
-                  Static(onInstance = false)
-                else if (sym.isPrivate || sym.isClassConstructor)
-                  Static(onInstance = true)
-                else
-                  Dynamic
-
-              var ctx1 = if (invokeStyle.hasInstance) genLoadQualifier(fun, ctx) else ctx
-              ctx1 = genLoadArguments(args, sym.info.paramTypes, ctx1)
-              val cm = CALL_METHOD(sym, invokeStyle)
-
-              /* In a couple cases, squirrel away a little extra information in the
-               * CALL_METHOD for use by GenASM.
-               */
-              fun match {
-                case Select(qual, _) =>
-                  val qualSym = findHostClass(qual.tpe, sym)
-                  if (qualSym == ArrayClass) {
-                    val kind = toTypeKind(qual.tpe)
-                    cm setTargetTypeKind kind
-                    log(s"Stored target type kind for {$sym.fullName} as $kind")
-                  }
-                  else {
-                    cm setHostClass qualSym
-                    if (qual.tpe.typeSymbol != qualSym)
-                      log(s"Precisified host class for $sym from ${qual.tpe.typeSymbol.fullName} to ${qualSym.fullName}")
-                  }
-                case _ =>
-              }
-              ctx1.bb.emit(cm, tree.pos)
-              ctx1.method.updateRecursive(sym)
-              generatedType =
-                if (sym.isClassConstructor) UNIT
-                else toTypeKind(sym.info.resultType)
-              // deal with methods that return Null
-              adaptNullRef(generatedType, expectedType, ctx1, tree.pos)
-              ctx1
-            }
-          }
-          genLoadApply6
-
-        case ApplyDynamic(qual, args) =>
-          // TODO - this is where we'd catch dynamic applies for invokedynamic.
-          sys.error("No invokedynamic support yet.")
-          // val ctx1 = genLoad(qual, ctx, ObjectReference)
-          // genLoadArguments(args, tree.symbol.info.paramTypes, ctx1)
-          // ctx1.bb.emit(CALL_METHOD(tree.symbol, InvokeDynamic), tree.pos)
-          // ctx1
-
-        case This(qual) =>
-          def genLoadThis = {
-            assert(tree.symbol == ctx.clazz.symbol || tree.symbol.isModuleClass,
-                   "Trying to access the this of another class: " +
-                   "tree.symbol = " + tree.symbol + ", ctx.clazz.symbol = " + ctx.clazz.symbol + " compilation unit:"+unit)
-            if (tree.symbol.isModuleClass && tree.symbol != ctx.clazz.symbol) {
-              genLoadModule(ctx, tree)
-              generatedType = REFERENCE(tree.symbol)
-            } else {
-              ctx.bb.emit(THIS(ctx.clazz.symbol), tree.pos)
-              generatedType = REFERENCE(
-                if (tree.symbol == ArrayClass) ObjectClass else ctx.clazz.symbol
-              )
-            }
-            ctx
-          }
-          genLoadThis
-
-        case Select(Ident(nme.EMPTY_PACKAGE_NAME), module) =>
-          debugassert(tree.symbol.isModule,
-            "Selection of non-module from empty package: " + tree +
-            " sym: " + tree.symbol + " at: " + (tree.pos)
-          )
-          genLoadModule(ctx, tree)
-
-        case Select(qualifier, selector) =>
-          def genLoadSelect = {
-            val sym = tree.symbol
-            generatedType = toTypeKind(sym.info)
-            val hostClass = findHostClass(qualifier.tpe, sym)
-            debuglog(s"Host class of $sym with qual $qualifier (${qualifier.tpe}) is $hostClass")
-            val qualSafeToElide = treeInfo isQualifierSafeToElide qualifier
-
-            def genLoadQualUnlessElidable: Context =
-              if (qualSafeToElide) ctx else genLoadQualifier(tree, ctx)
-
-            if (sym.isModule) {
-              genLoadModule(genLoadQualUnlessElidable, tree)
-            } else {
-              val isStatic = sym.isStaticMember
-              val ctx1 = if (isStatic) genLoadQualUnlessElidable
-                         else          genLoadQualifier(tree, ctx)
-              ctx1.bb.emit(LOAD_FIELD(sym, isStatic) setHostClass hostClass, tree.pos)
-              // it's tempting to drop field accesses of type Null instead of adapting them,
-              // but field access can cause static class init so we can't. Besides, fields
-              // of type Null probably aren't common enough to figure out an optimization
-              adaptNullRef(generatedType, expectedType, ctx1, tree.pos)
-              ctx1
-            }
-          }
-          genLoadSelect
-
-        case Ident(name) =>
-          def genLoadIdent = {
-            val sym = tree.symbol
-            if (!sym.hasPackageFlag) {
-              if (sym.isModule) {
-                genLoadModule(ctx, tree)
-                generatedType = toTypeKind(sym.info)
-              } else {
-                ctx.method.lookupLocal(sym) match {
-                  case Some(l) =>
-                    ctx.bb.emit(LOAD_LOCAL(l), tree.pos)
-                    generatedType = l.kind
-                  case None =>
-                    val saved = settings.uniqid
-                    settings.uniqid.value = true
-                    try {
-                      val methodCode = unit.body.collect { case dd: DefDef
-                        if dd.symbol == ctx.method.symbol => showCode(dd);
-                      }.headOption.getOrElse("<unknown>")
-                      abort(s"symbol $sym does not exist in ${ctx.method}, which contains locals ${ctx.method.locals.mkString(",")}. \nMethod code: $methodCode")
-                    }
-                    finally settings.uniqid.value = saved
-                }
-              }
-            }
-            ctx
-          }
-          genLoadIdent
-
-        case Literal(value) =>
-          def genLoadLiteral = {
-            if (value.tag != UnitTag) (value.tag, expectedType) match {
-              case (IntTag, LONG) =>
-                ctx.bb.emit(CONSTANT(Constant(value.longValue)), tree.pos)
-                generatedType = LONG
-              case (FloatTag, DOUBLE) =>
-                ctx.bb.emit(CONSTANT(Constant(value.doubleValue)), tree.pos)
-                generatedType = DOUBLE
-              case (NullTag, _) =>
-                ctx.bb.emit(CONSTANT(value), tree.pos)
-                generatedType = NullReference
-              case _ =>
-                ctx.bb.emit(CONSTANT(value), tree.pos)
-                generatedType = toTypeKind(tree.tpe)
-            }
-            ctx
-          }
-          genLoadLiteral
-
-        case Block(stats, expr) =>
-          ctx.enterScope()
-          var ctx1 = genStat(stats, ctx)
-          ctx1 = genLoad(expr, ctx1, expectedType)
-          ctx1.exitScope()
-          ctx1
-
-        case Typed(Super(_, _), _) =>
-          genLoad(This(ctx.clazz.symbol), ctx, expectedType)
-
-        case Typed(expr, _) =>
-          genLoad(expr, ctx, expectedType)
-
-        case Assign(_, _) =>
-          generatedType = UNIT
-          genStat(tree, ctx)
-
-        case ArrayValue(tpt @ TypeTree(), _elems) =>
-          def genLoadArrayValue = {
-            var ctx1 = ctx
-            val elmKind = toTypeKind(tpt.tpe)
-            generatedType = ARRAY(elmKind)
-            val elems = _elems.toIndexedSeq
-
-            ctx1.bb.emit(CONSTANT(new Constant(elems.length)), tree.pos)
-            ctx1.bb.emit(CREATE_ARRAY(elmKind, 1))
-            // inline array literals
-            var i = 0
-            while (i < elems.length) {
-              ctx1.bb.emit(DUP(generatedType), tree.pos)
-              ctx1.bb.emit(CONSTANT(new Constant(i)))
-              ctx1 = genLoad(elems(i), ctx1, elmKind)
-              ctx1.bb.emit(STORE_ARRAY_ITEM(elmKind))
-              i = i + 1
-            }
-            ctx1
-          }
-          genLoadArrayValue
-
-        case Match(selector, cases) =>
-          def genLoadMatch = {
-            debuglog("Generating SWITCH statement.")
-            val ctx1 = genLoad(selector, ctx, INT) // TODO: Java 7 allows strings in switches (so, don't assume INT and don't convert the literals using intValue)
-            val afterCtx = ctx1.newBlock()
-            afterCtx.bb killIf ctx1.bb.ignore
-            var afterCtxReachable = false
-            var caseCtx: Context  = null
-            generatedType = toTypeKind(tree.tpe)
-
-            var targets: List[BasicBlock] = Nil
-            var tags: List[Int] = Nil
-            var default: BasicBlock = afterCtx.bb
-
-            for (caze @ CaseDef(pat, guard, body) <- cases) {
-              assert(guard == EmptyTree, guard)
-              val tmpCtx = ctx1.newBlock()
-              tmpCtx.bb killIf ctx1.bb.ignore
-              pat match {
-                case Literal(value) =>
-                  tags = value.intValue :: tags
-                  targets = tmpCtx.bb :: targets
-                case Ident(nme.WILDCARD) =>
-                  default = tmpCtx.bb
-                case Alternative(alts) =>
-                  alts foreach {
-                    case Literal(value) =>
-                      tags = value.intValue :: tags
-                      targets = tmpCtx.bb :: targets
-                    case _ =>
-                      abort("Invalid case in alternative in switch-like pattern match: " +
-                            tree + " at: " + tree.pos)
-                  }
-                case _ =>
-                  abort("Invalid case statement in switch-like pattern match: " +
-                        tree + " at: " + (tree.pos))
-              }
-
-              caseCtx = genLoad(body, tmpCtx, generatedType)
-              afterCtxReachable ||= !caseCtx.bb.ignore
-              // close the block unless it's already been closed by the body, which closes the block if it ends in a jump (which is emitted to have alternatives share their body)
-              caseCtx.bb.closeWith(JUMP(afterCtx.bb) setPos caze.pos)
-            }
-            afterCtxReachable ||= (default == afterCtx)
-            ctx1.bb.emitOnly(
-              SWITCH(tags.reverse map (x => List(x)), (default :: targets).reverse) setPos tree.pos
-            )
-            afterCtx.bb killUnless afterCtxReachable
-            afterCtx
-          }
-          genLoadMatch
-
-        case EmptyTree =>
-          if (expectedType != UNIT)
-            ctx.bb.emit(getZeroOf(expectedType))
-          ctx
-
-        case _ =>
-          abort("Unexpected tree in genLoad: " + tree + "/" + tree.getClass + " at: " + tree.pos)
-      }
-
-      // emit conversion
-      if (generatedType != expectedType) {
-        tree match {
-          case Literal(Constant(null)) if generatedType == NullReference && expectedType != UNIT =>
-            // literal null on the stack (as opposed to a boxed null, see SI-8233),
-            // we can bypass `adapt` which would otherwise emit a redundant [DROP, CONSTANT(null)]
-            // except one case: when expected type is UNIT (unboxed) where we need to emit just a DROP
-          case _ =>
-            adapt(generatedType, expectedType, resCtx, tree.pos)
-        }
-      }
-
-      resCtx
-    }
-
-    /**
-     * If we have a method call, field load, or array element load of type Null then
-     * we need to convince the JVM that we have a null value because in Scala
-     * land Null is a subtype of all ref types, but in JVM land scala.runtime.Null$
-     * is not. Note we don't have to adapt loads of locals because the JVM type
-     * system for locals does have a null type which it tracks internally. As
-     * long as we adapt these other things, the JVM will know that a Scala local of
-     * type Null is holding a null.
-     */
-    private def adaptNullRef(from: TypeKind, to: TypeKind, ctx: Context, pos: Position) {
-      debuglog(s"GenICode#adaptNullRef($from, $to, $ctx, $pos)")
-
-      // Don't need to adapt null to unit because we'll just drop it anyway. Don't
-      // need to adapt to Object or AnyRef because the JVM is happy with
-      // upcasting Null to them.
-      // We do have to adapt from NullReference to NullReference because we could be storing
-      // this value into a local of type Null and we want the JVM to see that it's
-      // a null value so we don't have to also adapt local loads.
-      if (from == NullReference && to != UNIT && to != ObjectReference && to != AnyRefReference) {
-        assert(to.isRefOrArrayType, s"Attempt to adapt a null to a non reference type $to.")
-        // adapt by dropping what we've got and pushing a null which
-        // will convince the JVM we really do have null
-        ctx.bb.emit(DROP(from), pos)
-        ctx.bb.emit(CONSTANT(Constant(null)), pos)
-      }
-    }
-
-    private def adapt(from: TypeKind, to: TypeKind, ctx: Context, pos: Position) {
-      // An awful lot of bugs explode here - let's leave ourselves more clues.
-      // A typical example is an overloaded type assigned after typer.
-      debuglog(s"GenICode#adapt($from, $to, $ctx, $pos)")
-
-      def coerce(from: TypeKind, to: TypeKind) = ctx.bb.emit(CALL_PRIMITIVE(Conversion(from, to)), pos)
-
-      (from, to) match {
-        // The JVM doesn't have a Nothing equivalent, so it doesn't know that a method of type Nothing can't actually return. So for instance, with
-        //    def f: String = ???
-        // we need
-        //   0:	getstatic	#25; //Field scala/Predef$.MODULE$:Lscala/Predef$;
-        //   3:	invokevirtual	#29; //Method scala/Predef$.$qmark$qmark$qmark:()Lscala/runtime/Nothing$;
-        //   6:	athrow
-        // So this case tacks on the ahtrow which makes the JVM happy because class Nothing is declared as a subclass of Throwable
-        case (NothingReference, _) =>
-          ctx.bb.emit(THROW(ThrowableClass))
-          ctx.bb.enterIgnoreMode()
-        case (NullReference, REFERENCE(_)) =>
-          // SI-8223 we can't assume that the stack contains a `null`, it might contain a Null$
-          ctx.bb.emit(Seq(DROP(from), CONSTANT(Constant(null))))
-        case _ if from isAssignabledTo to =>
-          ()
-        case (_, UNIT) =>
-          ctx.bb.emit(DROP(from), pos)
-        // otherwise we'd better be doing a primitive -> primitive coercion or there's a problem
-        case _ if !from.isRefOrArrayType && !to.isRefOrArrayType =>
-          coerce(from, to)
-        case _ =>
-          assert(false, s"Can't convert from $from to $to in unit ${unit.source} at $pos")
-      }
-    }
-
-    /** Load the qualifier of `tree` on top of the stack. */
-    private def genLoadQualifier(tree: Tree, ctx: Context): Context =
-      tree match {
-        case Select(qualifier, _) =>
-          genLoad(qualifier, ctx, toTypeKind(qualifier.tpe))
-        case _ =>
-          abort("Unknown qualifier " + tree)
-      }
-
-    /**
-     * Generate code that loads args into label parameters.
-     */
-    private def genLoadLabelArguments(args: List[Tree], label: Label, ctx: Context): Context = {
-      debugassert(
-        args.length == label.params.length,
-        "Wrong number of arguments in call to label " + label.symbol
-      )
-      var ctx1 = ctx
-
-      def isTrivial(kv: (Tree, Symbol)) = kv match {
-        case (This(_), p) if p.name == nme.THIS     => true
-        case (arg @ Ident(_), p) if arg.symbol == p => true
-        case _                                      => false
-      }
-
-      val stores = args zip label.params filterNot isTrivial map {
-        case (arg, param) =>
-          val local = ctx.method.lookupLocal(param).get
-          ctx1 = genLoad(arg, ctx1, local.kind)
-
-          val store =
-            if (param.name == nme.THIS) STORE_THIS(toTypeKind(ctx1.clazz.symbol.tpe))
-            else STORE_LOCAL(local)
-
-          store setPos arg.pos
-      }
-
-      // store arguments in reverse order on the stack
-      ctx1.bb.emit(stores.reverse)
-      ctx1
-    }
-
-    private def genLoadArguments(args: List[Tree], tpes: List[Type], ctx: Context): Context =
-      (args zip tpes).foldLeft(ctx) {
-        case (res, (arg, tpe)) =>
-          genLoad(arg, res, toTypeKind(tpe))
-      }
-
-    private def genLoadModule(ctx: Context, tree: Tree): Context = {
-      // Working around SI-5604.  Rather than failing the compile when we see
-      // a package here, check if there's a package object.
-      val sym = (
-        if (!tree.symbol.isPackageClass) tree.symbol
-        else tree.symbol.info.packageObject match {
-          case NoSymbol => abort("Cannot use package as value: " + tree)
-          case s        =>
-            devWarning(s"Found ${tree.symbol} where a package object is required. Converting to ${s.moduleClass}")
-            s.moduleClass
-        }
-      )
-      debuglog("LOAD_MODULE from %s: %s".format(tree.shortClass, sym))
-      ctx.bb.emit(LOAD_MODULE(sym), tree.pos)
-      ctx
-    }
-
-    def genConversion(from: TypeKind, to: TypeKind, ctx: Context, cast: Boolean) = {
-      if (cast)
-        ctx.bb.emit(CALL_PRIMITIVE(Conversion(from, to)))
-      else {
-        ctx.bb.emit(DROP(from))
-        ctx.bb.emit(CONSTANT(Constant(from == to)))
-      }
-    }
-
-    def genCast(from: TypeKind, to: TypeKind, ctx: Context, cast: Boolean) =
-      ctx.bb.emit(if (cast) CHECK_CAST(to) else IS_INSTANCE(to))
-
-    def getZeroOf(k: TypeKind): Instruction = k match {
-      case UNIT            => CONSTANT(Constant(()))
-      case BOOL            => CONSTANT(Constant(false))
-      case BYTE            => CONSTANT(Constant(0: Byte))
-      case SHORT           => CONSTANT(Constant(0: Short))
-      case CHAR            => CONSTANT(Constant(0: Char))
-      case INT             => CONSTANT(Constant(0: Int))
-      case LONG            => CONSTANT(Constant(0: Long))
-      case FLOAT           => CONSTANT(Constant(0.0f))
-      case DOUBLE          => CONSTANT(Constant(0.0d))
-      case REFERENCE(cls)  => CONSTANT(Constant(null: Any))
-      case ARRAY(elem)     => CONSTANT(Constant(null: Any))
-      case BOXED(_)        => CONSTANT(Constant(null: Any))
-      case ConcatClass     => abort("no zero of ConcatClass")
-    }
-
-
-    /** Is the given symbol a primitive operation? */
-    def isPrimitive(fun: Symbol): Boolean = scalaPrimitives.isPrimitive(fun)
-
-    /** Generate coercion denoted by "code"
-     */
-    def genCoercion(tree: Tree, ctx: Context, code: Int) = {
-      import scalaPrimitives._
-      (code: @switch) match {
-        case B2B => ()
-        case B2C => ctx.bb.emit(CALL_PRIMITIVE(Conversion(BYTE, CHAR)), tree.pos)
-        case B2S => ctx.bb.emit(CALL_PRIMITIVE(Conversion(BYTE, SHORT)), tree.pos)
-        case B2I => ctx.bb.emit(CALL_PRIMITIVE(Conversion(BYTE, INT)), tree.pos)
-        case B2L => ctx.bb.emit(CALL_PRIMITIVE(Conversion(BYTE, LONG)), tree.pos)
-        case B2F => ctx.bb.emit(CALL_PRIMITIVE(Conversion(BYTE, FLOAT)), tree.pos)
-        case B2D => ctx.bb.emit(CALL_PRIMITIVE(Conversion(BYTE, DOUBLE)), tree.pos)
-
-        case S2B => ctx.bb.emit(CALL_PRIMITIVE(Conversion(SHORT, BYTE)), tree.pos)
-        case S2S => ()
-        case S2C => ctx.bb.emit(CALL_PRIMITIVE(Conversion(SHORT, CHAR)), tree.pos)
-        case S2I => ctx.bb.emit(CALL_PRIMITIVE(Conversion(SHORT, INT)), tree.pos)
-        case S2L => ctx.bb.emit(CALL_PRIMITIVE(Conversion(SHORT, LONG)), tree.pos)
-        case S2F => ctx.bb.emit(CALL_PRIMITIVE(Conversion(SHORT, FLOAT)), tree.pos)
-        case S2D => ctx.bb.emit(CALL_PRIMITIVE(Conversion(SHORT, DOUBLE)), tree.pos)
-
-        case C2B => ctx.bb.emit(CALL_PRIMITIVE(Conversion(CHAR, BYTE)), tree.pos)
-        case C2S => ctx.bb.emit(CALL_PRIMITIVE(Conversion(CHAR, SHORT)), tree.pos)
-        case C2C => ()
-        case C2I => ctx.bb.emit(CALL_PRIMITIVE(Conversion(CHAR, INT)), tree.pos)
-        case C2L => ctx.bb.emit(CALL_PRIMITIVE(Conversion(CHAR, LONG)), tree.pos)
-        case C2F => ctx.bb.emit(CALL_PRIMITIVE(Conversion(CHAR, FLOAT)), tree.pos)
-        case C2D => ctx.bb.emit(CALL_PRIMITIVE(Conversion(CHAR, DOUBLE)), tree.pos)
-
-        case I2B => ctx.bb.emit(CALL_PRIMITIVE(Conversion(INT, BYTE)), tree.pos)
-        case I2S => ctx.bb.emit(CALL_PRIMITIVE(Conversion(INT, SHORT)), tree.pos)
-        case I2C => ctx.bb.emit(CALL_PRIMITIVE(Conversion(INT, CHAR)), tree.pos)
-        case I2I => ()
-        case I2L => ctx.bb.emit(CALL_PRIMITIVE(Conversion(INT, LONG)), tree.pos)
-        case I2F => ctx.bb.emit(CALL_PRIMITIVE(Conversion(INT, FLOAT)), tree.pos)
-        case I2D => ctx.bb.emit(CALL_PRIMITIVE(Conversion(INT, DOUBLE)), tree.pos)
-
-        case L2B => ctx.bb.emit(CALL_PRIMITIVE(Conversion(LONG, BYTE)), tree.pos)
-        case L2S => ctx.bb.emit(CALL_PRIMITIVE(Conversion(LONG, SHORT)), tree.pos)
-        case L2C => ctx.bb.emit(CALL_PRIMITIVE(Conversion(LONG, CHAR)), tree.pos)
-        case L2I => ctx.bb.emit(CALL_PRIMITIVE(Conversion(LONG, INT)), tree.pos)
-        case L2L => ()
-        case L2F => ctx.bb.emit(CALL_PRIMITIVE(Conversion(LONG, FLOAT)), tree.pos)
-        case L2D => ctx.bb.emit(CALL_PRIMITIVE(Conversion(LONG, DOUBLE)), tree.pos)
-
-        case F2B => ctx.bb.emit(CALL_PRIMITIVE(Conversion(FLOAT, BYTE)), tree.pos)
-        case F2S => ctx.bb.emit(CALL_PRIMITIVE(Conversion(FLOAT, SHORT)), tree.pos)
-        case F2C => ctx.bb.emit(CALL_PRIMITIVE(Conversion(FLOAT, CHAR)), tree.pos)
-        case F2I => ctx.bb.emit(CALL_PRIMITIVE(Conversion(FLOAT, INT)), tree.pos)
-        case F2L => ctx.bb.emit(CALL_PRIMITIVE(Conversion(FLOAT, LONG)), tree.pos)
-        case F2F => ()
-        case F2D => ctx.bb.emit(CALL_PRIMITIVE(Conversion(FLOAT, DOUBLE)), tree.pos)
-
-        case D2B => ctx.bb.emit(CALL_PRIMITIVE(Conversion(DOUBLE, BYTE)), tree.pos)
-        case D2S => ctx.bb.emit(CALL_PRIMITIVE(Conversion(DOUBLE, SHORT)), tree.pos)
-        case D2C => ctx.bb.emit(CALL_PRIMITIVE(Conversion(DOUBLE, CHAR)), tree.pos)
-        case D2I => ctx.bb.emit(CALL_PRIMITIVE(Conversion(DOUBLE, INT)), tree.pos)
-        case D2L => ctx.bb.emit(CALL_PRIMITIVE(Conversion(DOUBLE, LONG)), tree.pos)
-        case D2F => ctx.bb.emit(CALL_PRIMITIVE(Conversion(DOUBLE, FLOAT)), tree.pos)
-        case D2D => ()
-
-        case _ => abort("Unknown coercion primitive: " + code)
-      }
-    }
-
-    /** The Object => String overload.
-     */
-    private lazy val String_valueOf: Symbol = getMember(StringModule, nme.valueOf) filter (sym =>
-      sym.info.paramTypes match {
-        case List(pt) => pt.typeSymbol == ObjectClass
-        case _        => false
-      }
-    )
-
-    // I wrote it this way before I realized all the primitive types are
-    // boxed at this point, so I'd have to unbox them.  Keeping it around in
-    // case we want to get more precise.
-    //
-    // private def valueOfForType(tp: Type): Symbol = {
-    //   val xs = getMember(StringModule, nme.valueOf) filter (sym =>
-    //     // We always exclude the Array[Char] overload because java throws an NPE if
-    //     // you pass it a null.  It will instead find the Object one, which doesn't.
-    //     sym.info.paramTypes match {
-    //       case List(pt) => pt.typeSymbol != ArrayClass && (tp <:< pt)
-    //       case _        => false
-    //     }
-    //   )
-    //   xs.alternatives match {
-    //     case List(sym)  => sym
-    //     case _          => NoSymbol
-    //   }
-    // }
-
-    /** Generate string concatenation.
-     */
-    def genStringConcat(tree: Tree, ctx: Context): Context = {
-      liftStringConcat(tree) match {
-        // Optimization for expressions of the form "" + x.  We can avoid the StringBuilder.
-        case List(Literal(Constant("")), arg) =>
-          debuglog("Rewriting \"\" + x as String.valueOf(x) for: " + arg)
-          val ctx1 = genLoad(arg, ctx, ObjectReference)
-          ctx1.bb.emit(CALL_METHOD(String_valueOf, Static(onInstance = false)), arg.pos)
-          ctx1
-        case concatenations =>
-          debuglog("Lifted string concatenations for " + tree + "\n to: " + concatenations)
-          var ctx1 = ctx
-          ctx1.bb.emit(CALL_PRIMITIVE(StartConcat), tree.pos)
-          for (elem <- concatenations) {
-            val kind = toTypeKind(elem.tpe)
-            ctx1 = genLoad(elem, ctx1, kind)
-            ctx1.bb.emit(CALL_PRIMITIVE(StringConcat(kind)), elem.pos)
-          }
-          ctx1.bb.emit(CALL_PRIMITIVE(EndConcat), tree.pos)
-          ctx1
-      }
-    }
-
-    /** Generate the scala ## method.
-     */
-    def genScalaHash(tree: Tree, ctx: Context): Context = {
-      val hashMethod = {
-        ctx.bb.emit(LOAD_MODULE(ScalaRunTimeModule))
-        getMember(ScalaRunTimeModule, nme.hash_)
-      }
-
-      val ctx1 = genLoad(tree, ctx, ObjectReference)
-      ctx1.bb.emit(CALL_METHOD(hashMethod, Static(onInstance = false)))
-      ctx1
-    }
-
-    /**
-     * Returns a list of trees that each should be concatenated, from
-     * left to right. It turns a chained call like "a".+("b").+("c") into
-     * a list of arguments.
-     */
-    def liftStringConcat(tree: Tree): List[Tree] = tree match {
-      case Apply(fun @ Select(larg, method), rarg) =>
-        if (isPrimitive(fun.symbol) &&
-            scalaPrimitives.getPrimitive(fun.symbol) == scalaPrimitives.CONCAT)
-          liftStringConcat(larg) ::: rarg
-        else
-          List(tree)
-      case _ =>
-        List(tree)
-    }
-
-    /**
-     * Find the label denoted by `lsym` and enter it in context `ctx`.
-     *
-     * We only enter one symbol at a time, even though we might traverse the same
-     * tree more than once per method. That's because we cannot enter labels that
-     * might be duplicated (for instance, inside finally blocks).
-     *
-     * TODO: restrict the scanning to smaller subtrees than the whole method.
-     *  It is sufficient to scan the trees of the innermost enclosing block.
-     */
-    private def resolveForwardLabel(tree: Tree, ctx: Context, lsym: Symbol): Unit = tree foreachPartial {
-      case t @ LabelDef(_, params, rhs) if t.symbol == lsym =>
-        ctx.labels.getOrElseUpdate(t.symbol, {
-          val locals  = params map (p => new Local(p.symbol, toTypeKind(p.symbol.info), false))
-          ctx.method addLocals locals
-
-          new Label(t.symbol) setParams (params map (_.symbol))
-        })
-        rhs
-    }
-
-    /**
-     * Generate code for conditional expressions. The two basic blocks
-     * represent the continuation in case of success/failure of the
-     * test.
-     */
-    private def genCond(tree: Tree,
-                        ctx: Context,
-                        thenCtx: Context,
-                        elseCtx: Context): Boolean =
-    {
-      /**
-       * Generate the de-sugared comparison mechanism that will underly an '=='
-       *
-       * @param l       left-hand side of the '=='
-       * @param r       right-hand side of the '=='
-       * @param code    the comparison operator to use
-       * @return true if either branch can continue normally to a follow on block, false otherwise
-       */
-      def genComparisonOp(l: Tree, r: Tree, code: Int): Boolean = {
-        val op: TestOp = code match {
-          case scalaPrimitives.LT => LT
-          case scalaPrimitives.LE => LE
-          case scalaPrimitives.GT => GT
-          case scalaPrimitives.GE => GE
-          case scalaPrimitives.ID | scalaPrimitives.EQ => EQ
-          case scalaPrimitives.NI | scalaPrimitives.NE => NE
-
-          case _ => abort("Unknown comparison primitive: " + code)
-        }
-
-        // special-case reference (in)equality test for null (null eq x, x eq null)
-        lazy val nonNullSide = ifOneIsNull(l, r)
-        if (isReferenceEqualityOp(code) && nonNullSide != null) {
-          val ctx1 = genLoad(nonNullSide, ctx, ObjectReference)
-          val branchesReachable = !ctx1.bb.ignore
-          ctx1.bb.emitOnly(
-            CZJUMP(thenCtx.bb, elseCtx.bb, op, ObjectReference)
-          )
-          branchesReachable
-        }
-        else {
-          val kind = getMaxType(l.tpe :: r.tpe :: Nil)
-          var ctx1 = genLoad(l, ctx, kind)
-          ctx1 = genLoad(r, ctx1, kind)
-          val branchesReachable = !ctx1.bb.ignore
-
-          ctx1.bb.emitOnly(
-            CJUMP(thenCtx.bb, elseCtx.bb, op, kind) setPos r.pos
-          )
-          branchesReachable
-        }
-      }
-
-      debuglog("Entering genCond with tree: " + tree)
-
-      // the default emission
-      def default(): Boolean = {
-        val ctx1 = genLoad(tree, ctx, BOOL)
-        val branchesReachable = !ctx1.bb.ignore
-        ctx1.bb.closeWith(CZJUMP(thenCtx.bb, elseCtx.bb, NE, BOOL) setPos tree.pos)
-        branchesReachable
-      }
-
-      tree match {
-        // The comparison symbol is in ScalaPrimitives's "primitives" map
-        case Apply(fun, args) if isPrimitive(fun.symbol) =>
-          import scalaPrimitives.{ ZNOT, ZAND, ZOR, EQ, getPrimitive }
-
-          // lhs and rhs of test
-          lazy val Select(lhs, _) = fun
-          lazy val rhs = args.head
-
-          def genZandOrZor(and: Boolean): Boolean = {
-            val ctxInterm = ctx.newBlock()
-
-            val lhsBranchesReachable = if (and) genCond(lhs, ctx, ctxInterm, elseCtx)
-            else genCond(lhs, ctx, thenCtx, ctxInterm)
-            // If lhs is known to throw, we can kill the just created ctxInterm.
-            ctxInterm.bb killUnless lhsBranchesReachable
-
-            val rhsBranchesReachable = genCond(rhs, ctxInterm, thenCtx, elseCtx)
-
-            // Reachable means "it does not always throw", i.e. "it might not throw".
-            // In an expression (a && b) or (a || b), the b branch might not be evaluated.
-            // Such an expression is therefore known to throw only if both expressions throw. Or,
-            // successors are reachable if either of the two is reachable (SI-8625).
-            lhsBranchesReachable || rhsBranchesReachable
-          }
-          def genRefEq(isEq: Boolean) = {
-            val f = genEqEqPrimitive(lhs, rhs, ctx) _
-            if (isEq) f(thenCtx, elseCtx)
-            else f(elseCtx, thenCtx)
-          }
-
-          getPrimitive(fun.symbol) match {
-            case ZNOT   => genCond(lhs, ctx, elseCtx, thenCtx)
-            case ZAND   => genZandOrZor(and = true)
-            case ZOR    => genZandOrZor(and = false)
-            case code   =>
-              // x == y where LHS is reference type
-              if (isUniversalEqualityOp(code) && toTypeKind(lhs.tpe).isReferenceType) {
-                if (code == EQ) genRefEq(isEq = true)
-                else genRefEq(isEq = false)
-              }
-              else if (isComparisonOp(code))
-                genComparisonOp(lhs, rhs, code)
-              else
-                default()
-          }
-
-        case _ => default()
-      }
-    }
-
-    /**
-     * Generate the "==" code for object references. It is equivalent of
-     * if (l eq null) r eq null else l.equals(r);
-     *
-     * @param l       left-hand side of the '=='
-     * @param r       right-hand side of the '=='
-     * @param ctx     current context
-     * @param thenCtx target context if the comparison yields true
-     * @param elseCtx target context if the comparison yields false
-     * @return true if either branch can continue normally to a follow on block, false otherwise
-     */
-    def genEqEqPrimitive(l: Tree, r: Tree, ctx: Context)(thenCtx: Context, elseCtx: Context): Boolean = {
-      def getTempLocal = ctx.method.lookupLocal(nme.EQEQ_LOCAL_VAR) getOrElse {
-        ctx.makeLocal(l.pos, AnyRefTpe, nme.EQEQ_LOCAL_VAR.toString)
-      }
-
-      /* True if the equality comparison is between values that require the use of the rich equality
-       * comparator (scala.runtime.Comparator.equals). This is the case when either side of the
-       * comparison might have a run-time type subtype of java.lang.Number or java.lang.Character.
-       * When it is statically known that both sides are equal and subtypes of Number of Character,
-       * not using the rich equality is possible (their own equals method will do ok.)*/
-      def mustUseAnyComparator: Boolean = {
-        def areSameFinals = l.tpe.isFinalType && r.tpe.isFinalType && (l.tpe =:= r.tpe)
-        !areSameFinals && isMaybeBoxed(l.tpe.typeSymbol) && isMaybeBoxed(r.tpe.typeSymbol)
-      }
-
-      if (mustUseAnyComparator) {
-        // when -optimise is on we call the @inline-version of equals, found in ScalaRunTime
-        val equalsMethod: Symbol = {
-          if (!settings.optimise) {
-            if (l.tpe <:< BoxedNumberClass.tpe) {
-              if (r.tpe <:< BoxedNumberClass.tpe) platform.externalEqualsNumNum
-              else if (r.tpe <:< BoxedCharacterClass.tpe) platform.externalEqualsNumChar
-              else platform.externalEqualsNumObject
-            } else platform.externalEquals
-          } else {
-            ctx.bb.emit(LOAD_MODULE(ScalaRunTimeModule))
-            getMember(ScalaRunTimeModule, nme.inlinedEquals)
-          }
-        }
-
-        val ctx1 = genLoad(l, ctx, ObjectReference)
-        val ctx2 = genLoad(r, ctx1, ObjectReference)
-        val branchesReachable = !ctx2.bb.ignore
-        ctx2.bb.emitOnly(
-          CALL_METHOD(equalsMethod, if (settings.optimise) Dynamic else Static(onInstance = false)),
-          CZJUMP(thenCtx.bb, elseCtx.bb, NE, BOOL)
-        )
-        branchesReachable
-      }
-      else {
-        if (isNull(l)) {
-          // null == expr -> expr eq null
-          val ctx1 = genLoad(r, ctx, ObjectReference)
-          val branchesReachable = !ctx1.bb.ignore
-          ctx1.bb emitOnly CZJUMP(thenCtx.bb, elseCtx.bb, EQ, ObjectReference)
-          branchesReachable
-        } else if (isNull(r)) {
-          // expr == null -> expr eq null
-          val ctx1 = genLoad(l, ctx, ObjectReference)
-          val branchesReachable = !ctx1.bb.ignore
-          ctx1.bb emitOnly CZJUMP(thenCtx.bb, elseCtx.bb, EQ, ObjectReference)
-          branchesReachable
-        } else if (isNonNullExpr(l)) {
-          // Avoid null check if L is statically non-null.
-          //
-          // "" == expr -> "".equals(expr)
-          // Nil == expr -> Nil.equals(expr)
-          //
-          // Common enough (through pattern matching) to treat this specially here rather than
-          // hoping that -Yconst-opt is enabled. The impossible branches for null checks lead
-          // to spurious "branch not covered" warnings in Jacoco code coverage.
-          var ctx1 = genLoad(l, ctx, ObjectReference)
-          val branchesReachable = !ctx1.bb.ignore
-          ctx1 = genLoad(r, ctx1, ObjectReference)
-          ctx1.bb emitOnly(
-            CALL_METHOD(Object_equals, Dynamic),
-            CZJUMP(thenCtx.bb, elseCtx.bb, NE, BOOL)
-          )
-          branchesReachable
-        } else {
-          val eqEqTempLocal = getTempLocal
-          var ctx1 = genLoad(l, ctx, ObjectReference)
-          val branchesReachable = !ctx1.bb.ignore
-          lazy val nonNullCtx = {
-            val block = ctx1.newBlock()
-            block.bb killUnless branchesReachable
-            block
-          }
-
-          // l == r -> if (l eq null) r eq null else l.equals(r)
-          ctx1 = genLoad(r, ctx1, ObjectReference)
-          val nullCtx = ctx1.newBlock()
-          nullCtx.bb killUnless branchesReachable
-
-          ctx1.bb.emitOnly(
-            STORE_LOCAL(eqEqTempLocal) setPos l.pos,
-            DUP(ObjectReference),
-            CZJUMP(nullCtx.bb, nonNullCtx.bb, EQ, ObjectReference)
-          )
-          nullCtx.bb.emitOnly(
-            DROP(ObjectReference) setPos l.pos, // type of AnyRef
-            LOAD_LOCAL(eqEqTempLocal),
-            CZJUMP(thenCtx.bb, elseCtx.bb, EQ, ObjectReference)
-          )
-          nonNullCtx.bb.emitOnly(
-            LOAD_LOCAL(eqEqTempLocal) setPos l.pos,
-            CALL_METHOD(Object_equals, Dynamic),
-            CZJUMP(thenCtx.bb, elseCtx.bb, NE, BOOL)
-          )
-          branchesReachable
-        }
-      }
-    }
-
-    /**
-     * Add all fields of the given class symbol to the current ICode
-     * class.
-     */
-    private def addClassFields(ctx: Context, cls: Symbol) {
-      debugassert(ctx.clazz.symbol eq cls,
-               "Classes are not the same: " + ctx.clazz.symbol + ", " + cls)
-
-      /* Non-method term members are fields, except for module members. Module
-       * members can only happen on .NET (no flatten) for inner traits. There,
-       * a module symbol is generated (transformInfo in mixin) which is used
-       * as owner for the members of the implementation class (so that the
-       * backend emits them as static).
-       * No code is needed for this module symbol.
-       */
-      for (f <- cls.info.decls ; if !f.isMethod && f.isTerm && !f.isModule)
-        ctx.clazz addField new IField(f)
-    }
-
-    /**
-     * Add parameters to the current ICode method. It is assumed the methods
-     * have been uncurried, so the list of lists contains just one list.
-     */
-    private def addMethodParams(ctx: Context, vparamss: List[List[ValDef]]) {
-      vparamss match {
-        case Nil => ()
-
-        case vparams :: Nil =>
-          for (p <- vparams) {
-            val lv = new Local(p.symbol, toTypeKind(p.symbol.info), true)
-            ctx.method.addParam(lv)
-            ctx.scope.add(lv)
-            ctx.bb.varsInScope += lv
-          }
-          ctx.method.params = ctx.method.params.reverse
-
-        case _ =>
-          abort("Malformed parameter list: " + vparamss)
-      }
-    }
-
-    /** Does this tree have a try-catch block? */
-    def mayCleanStack(tree: Tree): Boolean = tree exists {
-      case Try(_, _, _) => true
-      case _            => false
-    }
-
-    /**
-     *  If the block consists of a single unconditional jump, prune
-     *  it by replacing the instructions in the predecessor to jump
-     *  directly to the JUMP target of the block.
-     */
-    def prune(method: IMethod) = {
-      var changed = false
-      var n = 0
-
-      def prune0(block: BasicBlock): Unit = {
-        val optCont = block.lastInstruction match {
-          case JUMP(b) if (b != block) => Some(b)
-          case _ => None
-        }
-        if (block.size == 1 && optCont.isDefined) {
-          val Some(cont) = optCont
-          val pred = block.predecessors
-          debuglog("Preds: " + pred + " of " + block + " (" + optCont + ")")
-          pred foreach { p =>
-            changed = true
-            p.lastInstruction match {
-              case CJUMP(succ, fail, cond, kind) if (succ == block || fail == block) =>
-                debuglog("Pruning empty if branch.")
-                p.replaceInstruction(p.lastInstruction,
-                                     if (block == succ)
-                                       if (block == fail)
-                                         CJUMP(cont, cont, cond, kind)
-                                       else
-                                         CJUMP(cont, fail, cond, kind)
-                                     else if (block == fail)
-                                       CJUMP(succ, cont, cond, kind)
-                                     else
-                                       abort("Could not find block in preds: " + method + " " + block + " " + pred + " " + p))
-
-              case CZJUMP(succ, fail, cond, kind) if (succ == block || fail == block) =>
-                debuglog("Pruning empty ifz branch.")
-                p.replaceInstruction(p.lastInstruction,
-                                     if (block == succ)
-                                       if (block == fail)
-                                         CZJUMP(cont, cont, cond, kind)
-                                       else
-                                         CZJUMP(cont, fail, cond, kind)
-                                     else if (block == fail)
-                                       CZJUMP(succ, cont, cond, kind)
-                                     else
-                                       abort("Could not find block in preds"))
-
-              case JUMP(b) if (b == block) =>
-                debuglog("Pruning empty JMP branch.")
-                val replaced = p.replaceInstruction(p.lastInstruction, JUMP(cont))
-                debugassert(replaced, "Didn't find p.lastInstruction")
-
-              case SWITCH(tags, labels) if (labels contains block) =>
-                debuglog("Pruning empty SWITCH branch.")
-                p.replaceInstruction(p.lastInstruction,
-                                     SWITCH(tags, labels map (l => if (l == block) cont else l)))
-
-              // the last instr of the predecessor `p` is not a jump to the block `block`.
-              // this happens when `block` is part of an exception handler covering `b`.
-              case _ => ()
-            }
-          }
-          if (changed) {
-            debuglog("Removing block: " + block)
-            method.code.removeBlock(block)
-            for (e <- method.exh) {
-              e.covered = e.covered filter (_ != block)
-              e.blocks  = e.blocks filter (_ != block)
-              if (e.startBlock eq block)
-                e setStartBlock cont
-            }
-          }
-        }
-      }
-
-      do {
-        changed = false
-        n += 1
-        method.blocks foreach prune0
-      } while (changed)
-
-      debuglog("Prune fixpoint reached in " + n + " iterations.")
-    }
-
-    def getMaxType(ts: List[Type]): TypeKind =
-      ts map toTypeKind reduceLeft (_ maxType _)
-
-    /** Tree transformer that duplicates code and at the same time creates
-     *  fresh symbols for existing labels. Since labels may be used before
-     *  they are defined (forward jumps), all labels found are mapped to fresh
-     *  symbols. References to the same label (use or definition) will remain
-     *  consistent after this transformation (both the use and the definition of
-     *  some label l will be mapped to the same label l').
-     *
-     *  Note: If the tree fragment passed to the duplicator contains unbound
-     *  label names, the bind to the outer labeldef will be lost! That's because
-     *  a use of an unbound label l will be transformed to l', and the corresponding
-     *  label def, being outside the scope of this transformation, will not be updated.
-     *
-     *  All LabelDefs are entered into the context label map, since it makes no sense
-     *  to delay it any more: they will be used at some point.
-     */
-    class DuplicateLabels(boundLabels: Set[Symbol]) extends Transformer {
-      val labels = perRunCaches.newMap[Symbol, Symbol]()
-      var method: Symbol = _
-      var ctx: Context = _
-
-      def apply(ctx: Context, t: Tree) = {
-        this.method = ctx.method.symbol
-        this.ctx = ctx
-        transform(t)
-      }
-
-      override def transform(t: Tree): Tree = {
-        val sym = t.symbol
-        def getLabel(pos: Position, name: Name) =
-          labels.getOrElseUpdate(sym,
-            method.newLabel(unit.freshTermName(name.toString), sym.pos) setInfo sym.tpe
-          )
-
-        t match {
-          case t @ Apply(_, args) if sym.isLabel && !boundLabels(sym) =>
-            val newSym = getLabel(sym.pos, sym.name)
-            Apply(global.gen.mkAttributedRef(newSym), transformTrees(args)) setPos t.pos setType t.tpe
-
-          case t @ LabelDef(name, params, rhs) =>
-            val newSym = getLabel(t.pos, name)
-            val tree = treeCopy.LabelDef(t, newSym.name, params, transform(rhs))
-            tree.symbol = newSym
-
-            val pair = (newSym -> (new Label(newSym) setParams (params map (_.symbol))))
-            log("Added " + pair + " to labels.")
-            ctx.labels += pair
-            ctx.method.addLocals(params map (p => new Local(p.symbol, toTypeKind(p.symbol.info), false)))
-
-            tree
-
-          case _ => super.transform(t)
-        }
-      }
-    }
-
-    /////////////////////// Context ////////////////////////////////
-
-    sealed abstract class Cleanup(val value: AnyRef) {
-      def contains(x: AnyRef) = value == x
-    }
-    case class MonitorRelease(m: Local) extends Cleanup(m) { }
-    case class Finalizer(f: Tree, ctx: Context) extends Cleanup (f) { }
-
-    def duplicateFinalizer(boundLabels: Set[Symbol], targetCtx: Context, finalizer: Tree) =  {
-      (new DuplicateLabels(boundLabels))(targetCtx, finalizer)
-    }
-
-    def savingCleanups[T](ctx: Context)(body: => T): T = {
-      val saved = ctx.cleanups
-      try body
-      finally ctx.cleanups = saved
-    }
-
-    /**
-     * The Context class keeps information relative to the current state
-     * in code generation
-     */
-    class Context {
-      /** The current package. */
-      var packg: Name = _
-
-      /** The current class. */
-      var clazz: IClass = _
-
-      /** The current method. */
-      var method: IMethod = _
-
-      /** The current basic block. */
-      var bb: BasicBlock = _
-
-      /** Map from label symbols to label objects. */
-      var labels = perRunCaches.newMap[Symbol, Label]()
-
-      /** Current method definition. */
-      var defdef: DefDef = _
-
-      /** current exception handlers */
-      var handlers: List[ExceptionHandler] = Nil
-
-      /** The current monitors or finalizers, to be cleaned up upon `return`. */
-      var cleanups: List[Cleanup] = Nil
-
-      /** The exception handlers we are currently generating code for */
-      var currentExceptionHandlers: List[ExceptionHandler] = Nil
-
-      /** The current local variable scope. */
-      var scope: Scope = EmptyScope
-
-      var handlerCount = 0
-
-      override def toString =
-        s"package $packg { class $clazz { def $method { bb=$bb } } }"
-
-      def loadException(ctx: Context, exh: ExceptionHandler, pos: Position) = {
-        debuglog("Emitting LOAD_EXCEPTION for class: " + exh.loadExceptionClass)
-        ctx.bb.emit(LOAD_EXCEPTION(exh.loadExceptionClass) setPos pos, pos)
-      }
-
-      def this(other: Context) = {
-        this()
-        this.packg = other.packg
-        this.clazz = other.clazz
-        this.method = other.method
-        this.bb = other.bb
-        this.labels = other.labels
-        this.defdef = other.defdef
-        this.handlers = other.handlers
-        this.handlerCount = other.handlerCount
-        this.cleanups = other.cleanups
-        this.currentExceptionHandlers = other.currentExceptionHandlers
-        this.scope = other.scope
-      }
-
-      def setPackage(p: Name): this.type = {
-        this.packg = p
-        this
-      }
-
-      def setClass(c: IClass): this.type = {
-        this.clazz = c
-        this
-      }
-
-      def setMethod(m: IMethod): this.type = {
-        this.method = m
-        this
-      }
-
-      def setBasicBlock(b: BasicBlock): this.type = {
-        this.bb = b
-        this
-      }
-
-      def enterSynchronized(monitor: Local): this.type = {
-        cleanups = MonitorRelease(monitor) :: cleanups
-        this
-      }
-
-      def exitSynchronized(monitor: Local): this.type = {
-        assert(cleanups.head contains monitor,
-               "Bad nesting of cleanup operations: " + cleanups + " trying to exit from monitor: " + monitor)
-        cleanups = cleanups.tail
-        this
-      }
-
-      def addFinalizer(f: Tree, ctx: Context): this.type = {
-        cleanups = Finalizer(f, ctx) :: cleanups
-        this
-      }
-
-      /** Prepare a new context upon entry into a method.
-       */
-      def enterMethod(m: IMethod, d: DefDef): Context = {
-        val ctx1 = new Context(this) setMethod(m)
-        ctx1.labels = mutable.HashMap()
-        ctx1.method.code = new Code(m)
-        ctx1.bb = ctx1.method.startBlock
-        ctx1.defdef = d
-        ctx1.scope = EmptyScope
-        ctx1.enterScope()
-        ctx1
-      }
-
-      /** Return a new context for a new basic block. */
-      def newBlock(): Context = {
-        val block = method.code.newBlock()
-        handlers foreach (_ addCoveredBlock block)
-        currentExceptionHandlers foreach (_ addBlock block)
-        block.varsInScope.clear()
-        block.varsInScope ++= scope.varsInScope
-        new Context(this) setBasicBlock block
-      }
-
-      def enterScope() {
-        scope = new Scope(scope)
-      }
-
-      def exitScope() {
-        if (bb.nonEmpty) {
-          scope.locals foreach { lv => bb.emit(SCOPE_EXIT(lv)) }
-        }
-        scope = scope.outer
-      }
-
-      /** Create a new exception handler and adds it in the list
-       * of current exception handlers. All new blocks will be
-       * 'covered' by this exception handler (in addition to the
-       * previously active handlers).
-       */
-      private def newExceptionHandler(cls: Symbol, pos: Position): ExceptionHandler = {
-        handlerCount += 1
-        val exh = new ExceptionHandler(method, newTermNameCached("" + handlerCount), cls, pos)
-        method.addHandler(exh)
-        handlers = exh :: handlers
-        debuglog("added handler: " + exh)
-
-        exh
-      }
-
-      /** Add an active exception handler in this context. It will cover all new basic blocks
-       *  created from now on. */
-      private def addActiveHandler(exh: ExceptionHandler) {
-        handlerCount += 1
-        handlers = exh :: handlers
-        debuglog("added handler: " + exh)
-      }
-
-      /** Return a new context for generating code for the given
-       * exception handler.
-       */
-      private def enterExceptionHandler(exh: ExceptionHandler): Context = {
-        currentExceptionHandlers ::= exh
-        val ctx = newBlock()
-        exh.setStartBlock(ctx.bb)
-        ctx
-      }
-
-      def endHandler() {
-        currentExceptionHandlers = currentExceptionHandlers.tail
-      }
-
-      /** Clone the current context */
-      def dup: Context = new Context(this)
-
-      /** Make a fresh local variable. It ensures the 'name' is unique. */
-      def makeLocal(pos: Position, tpe: Type, name: String): Local = {
-        val sym = method.symbol.newVariable(unit.freshTermName(name), pos, Flags.SYNTHETIC) setInfo tpe
-        this.method.addLocal(new Local(sym, toTypeKind(tpe), false))
-      }
-
-
-      /**
-       * Generate exception handlers for the body. Body is evaluated
-       * with a context where all the handlers are active. Handlers are
-       * evaluated in the 'outer' context.
-       *
-       * It returns the resulting context, with the same active handlers as
-       * before the call. Use it like:
-       *
-       * ` ctx.Try( ctx => {
-       *   ctx.bb.emit(...) // protected block
-       * }, (ThrowableClass,
-       *   ctx => {
-       *     ctx.bb.emit(...); // exception handler
-       *   }), (AnotherExceptionClass,
-       *   ctx => {...
-       *   } ))`
-       *
-       *   The resulting structure will look something like
-       *
-       *   outer:
-       *     // this 'useless' jump will be removed later,
-       *     // for now it separates the try body's blocks from previous
-       *     // code since the try body needs its own exception handlers
-       *     JUMP body
-       *
-       *   body:
-       *     [ try body ]
-       *     JUMP normalExit
-       *
-       *   catch[i]:
-       *     [ handler[i] body ]
-       *     JUMP normalExit
-       *
-       *   catchAll:
-       *     STORE exception
-       *     [ finally body ]
-       *     THROW exception
-       *
-       *   normalExit:
-       *     [ finally body ]
-       *
-       *  each catch[i] will cover body.  catchAll will cover both body and each catch[i]
-       *  Additional finally copies are created on the emission of every RETURN in the try body and exception handlers.
-       *
-       *  This could result in unreachable code which has to be cleaned up later, e.g. if the try and all the exception
-       *  handlers always end in RETURN then there will be no "normal" flow out of the try/catch/finally.
-       *  Later reachability analysis will remove unreachable code.
-       */
-      def Try(body: Context => Context,
-              handlers: List[(Symbol, TypeKind, Context => Context)],
-              finalizer: Tree,
-              tree: Tree) = {
-
-        val outerCtx = this.dup       // context for generating exception handlers, covered by the catch-all finalizer
-        val finalizerCtx = this.dup   // context for generating finalizer handler
-        val normalExitCtx = outerCtx.newBlock() // context where flow will go on a "normal" (non-return, non-throw) exit from a try or catch handler
-        var normalExitReachable = false
-        var tmp: Local = null
-        val kind = toTypeKind(tree.tpe)
-        val guardResult = kind != UNIT && mayCleanStack(finalizer)
-        // we need to save bound labels before any code generation is performed on
-        // the current context (otherwise, any new labels in the finalizer that need to
-        // be duplicated would be incorrectly considered bound -- see #2850).
-        val boundLabels: Set[Symbol] = Set.empty ++ labels.keySet
-
-        if (guardResult) {
-          tmp = this.makeLocal(tree.pos, tree.tpe, "tmp")
-        }
-
-        def emitFinalizer(ctx: Context): Context = if (!finalizer.isEmpty) {
-          val ctx1 = finalizerCtx.dup.newBlock()
-          ctx1.bb killIf ctx.bb.ignore
-          ctx.bb.closeWith(JUMP(ctx1.bb))
-
-          if (guardResult) {
-            ctx1.bb.emit(STORE_LOCAL(tmp))
-            val ctx2 = genLoad(duplicateFinalizer(boundLabels, ctx1, finalizer), ctx1, UNIT)
-            ctx2.bb.emit(LOAD_LOCAL(tmp))
-            ctx2
-          } else
-            genLoad(duplicateFinalizer(boundLabels, ctx1, finalizer), ctx1, UNIT)
-        } else ctx
-
-
-        // Generate the catch-all exception handler that deals with uncaught exceptions coming
-        // from the try or exception handlers. It catches the exception, runs the finally code, then rethrows
-        // the exception
-        if (settings.YdisableUnreachablePrevention || !outerCtx.bb.ignore) {
-          if (finalizer != EmptyTree) {
-            val exh = outerCtx.newExceptionHandler(NoSymbol, finalizer.pos) // finalizer covers exception handlers
-            this.addActiveHandler(exh)  // .. and body as well
-            val exhStartCtx = finalizerCtx.enterExceptionHandler(exh)
-            exhStartCtx.bb killIf outerCtx.bb.ignore
-            val exception = exhStartCtx.makeLocal(finalizer.pos, ThrowableTpe, "exc")
-            loadException(exhStartCtx, exh, finalizer.pos)
-            exhStartCtx.bb.emit(STORE_LOCAL(exception))
-            val exhEndCtx = genLoad(finalizer, exhStartCtx, UNIT)
-            exhEndCtx.bb.emit(LOAD_LOCAL(exception))
-            exhEndCtx.bb.closeWith(THROW(ThrowableClass))
-            exhEndCtx.bb.enterIgnoreMode()
-            finalizerCtx.endHandler()
-          }
-
-          // Generate each exception handler
-          for ((sym, kind, handler) <- handlers) {
-            val exh = this.newExceptionHandler(sym, tree.pos)
-            val exhStartCtx = outerCtx.enterExceptionHandler(exh)
-            exhStartCtx.bb killIf outerCtx.bb.ignore
-            exhStartCtx.addFinalizer(finalizer, finalizerCtx)
-            loadException(exhStartCtx, exh, tree.pos)
-            val exhEndCtx = handler(exhStartCtx)
-            normalExitReachable ||= !exhEndCtx.bb.ignore
-            exhEndCtx.bb.closeWith(JUMP(normalExitCtx.bb))
-            outerCtx.endHandler()
-          }
-        }
-
-        val bodyCtx = this.newBlock()
-        bodyCtx.bb killIf outerCtx.bb.ignore
-        if (finalizer != EmptyTree)
-          bodyCtx.addFinalizer(finalizer, finalizerCtx)
-
-        val bodyEndCtx = body(bodyCtx)
-
-        outerCtx.bb.closeWith(JUMP(bodyCtx.bb))
-
-        normalExitReachable ||= !bodyEndCtx.bb.ignore
-        normalExitCtx.bb killUnless normalExitReachable
-        bodyEndCtx.bb.closeWith(JUMP(normalExitCtx.bb))
-
-        emitFinalizer(normalExitCtx)
-      }
-    }
-  }
-
-    /**
-     * Represent a label in the current method code. In order
-     * to support forward jumps, labels can be created without
-     * having a designated target block. They can later be attached
-     * by calling `anchor`.
-     */
-    class Label(val symbol: Symbol) {
-      var anchored = false
-      var block: BasicBlock = _
-      var params: List[Symbol] = _
-
-      private var toPatch: List[Instruction] = Nil
-
-      /** Fix this label to the given basic block. */
-      def anchor(b: BasicBlock): Label = {
-        assert(!anchored, "Cannot anchor an already anchored label!")
-        anchored = true
-        this.block = b
-        this
-      }
-
-      def setParams(p: List[Symbol]): Label = {
-        assert(params eq null, "Cannot set label parameters twice!")
-        params = p
-        this
-      }
-
-      /** Add an instruction that refers to this label. */
-      def addCallingInstruction(i: Instruction) =
-        toPatch = i :: toPatch
-
-      /**
-       * Patch the code by replacing pseudo call instructions with
-       * jumps to the given basic block.
-       */
-      def patch(code: Code) {
-        val map = mapFrom(toPatch)(patch)
-        code.blocks foreach (_ subst map)
-      }
-
-      /**
-       * Return the patched instruction. If the given instruction
-       * jumps to this label, replace it with the basic block. Otherwise,
-       * return the same instruction. Conditional jumps have more than one
-       * label, so they are replaced only if all labels are anchored.
-       */
-      def patch(instr: Instruction): Instruction = {
-        assert(anchored, "Cannot patch until this label is anchored: " + this)
-
-        instr match {
-          case PJUMP(self)
-          if (self == this) => JUMP(block)
-
-          case PCJUMP(self, failure, cond, kind)
-          if (self == this && failure.anchored) =>
-            CJUMP(block, failure.block, cond, kind)
-
-          case PCJUMP(success, self, cond, kind)
-          if (self == this && success.anchored) =>
-            CJUMP(success.block, block, cond, kind)
-
-          case PCZJUMP(self, failure, cond, kind)
-          if (self == this && failure.anchored) =>
-            CZJUMP(block, failure.block, cond, kind)
-
-          case PCZJUMP(success, self, cond, kind)
-          if (self == this && success.anchored) =>
-            CZJUMP(success.block, block, cond, kind)
-
-          case _ => instr
-        }
-      }
-
-      override def toString() = symbol.toString()
-    }
-
-    ///////////////// Fake instructions //////////////////////////
-
-    /**
-     * Pseudo jump: it takes a Label instead of a basic block.
-     * It is used temporarily during code generation. It is replaced
-     * by a real JUMP instruction when all labels are resolved.
-     */
-    abstract class PseudoJUMP(label: Label) extends Instruction {
-      override def toString = s"PJUMP(${label.symbol})"
-      override def consumed = 0
-      override def produced = 0
-
-      // register with the given label
-      if (!label.anchored)
-        label.addCallingInstruction(this)
-    }
-
-    case class PJUMP(whereto: Label) extends PseudoJUMP(whereto)
-
-    case class PCJUMP(success: Label, failure: Label, cond: TestOp, kind: TypeKind)
-    extends PseudoJUMP(success) {
-      override def toString(): String =
-        "PCJUMP (" + kind + ") " + success.symbol.simpleName +
-        " : " + failure.symbol.simpleName
-
-      if (!failure.anchored)
-        failure.addCallingInstruction(this)
-    }
-
-    case class PCZJUMP(success: Label, failure: Label, cond: TestOp, kind: TypeKind)
-    extends PseudoJUMP(success) {
-      override def toString(): String =
-        "PCZJUMP (" + kind + ") " + success.symbol.simpleName +
-        " : " + failure.symbol.simpleName
-
-      if (!failure.anchored)
-        failure.addCallingInstruction(this)
-    }
-
-  /** Local variable scopes. Keep track of line numbers for debugging info. */
-  class Scope(val outer: Scope) {
-    val locals: ListBuffer[Local] = new ListBuffer
-
-    def add(l: Local)     = locals += l
-
-    /** Return all locals that are in scope. */
-    def varsInScope: Buffer[Local] = outer.varsInScope.clone() ++= locals
-
-    override def toString() = locals.mkString(outer.toString + "[", ", ", "]")
-  }
-
-  object EmptyScope extends Scope(null) {
-    override def toString() = "[]"
-    override def varsInScope: Buffer[Local] = new ListBuffer
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/ICodeCheckers.scala b/src/compiler/scala/tools/nsc/backend/icode/ICodeCheckers.scala
deleted file mode 100644
index 0f17b5d694..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/ICodeCheckers.scala
+++ /dev/null
@@ -1,711 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend
-package icode
-
-import scala.collection.mutable
-import scala.collection.mutable.ListBuffer
-
-abstract class ICodeCheckers {
-  val global: Global
-  import global._
-
-  /** <p>
-   *    This class performs a set of checks similar to what the bytecode
-   *    verifier does. For each basic block, it checks that:
-   *  </p>
-   *  <ul>
-   *    <li>
-   *      for primitive operations: the type and number of operands match
-   *      the type of the operation
-   *    </li>
-   *    <li>
-   *      for method calls: the method exists in the type of the receiver
-   *      and the number and type of arguments match the declared type of
-   *      the method.
-   *    </li>
-   *    <li>
-   *      for object creation: the constructor can be called.
-   *    </li>
-   *    <li>
-   *      for load/stores: the field/local/param exists and the type
-   *      of the value matches that of the target.
-   *    </li>
-   *  </ul>
-   *  <p>
-   *    For a control flow graph it checks that type stacks at entry to
-   *    each basic block 'agree':
-   *  </p>
-   *  <ul>
-   *    <li>they have the same length</li>
-   *    <li>there exists a lub for all types at the same position in stacks.</li>
-   *  </ul>
-   *
-   *  @author  Iulian Dragos
-   *  @version 1.0, 06/09/2005
-   *
-   *  @todo Better checks for `MONITOR_ENTER/EXIT`
-   *        Better checks for local var initializations
-   *
-   *  @todo Iulian says: I think there's some outdated logic in the checker.
-   * The issue with exception handlers being special for least upper
-   * bounds pointed out some refactoring in the lattice class. Maybe
-   * a worthwhile refactoring would be to make the checker use the
-   * DataFlowAnalysis class, and use the lattice trait. In the
-   * implementation of LUB, there's a flag telling if one of the
-   * successors is 'exceptional'. The inliner is using this mechanism.
-   */
-  class ICodeChecker {
-    import icodes._
-    import opcodes._
-
-    var clasz: IClass = _
-    var method: IMethod = _
-    var code: Code = _
-
-    val in: mutable.Map[BasicBlock, TypeStack]  = perRunCaches.newMap()
-    val out: mutable.Map[BasicBlock, TypeStack] = perRunCaches.newMap()
-    val emptyStack = new TypeStack() {
-      override def toString = "<empty>"
-    }
-
-    /** The presence of emptyStack means that path has not yet been checked
-     *  (and may not be empty).
-     */
-    def notChecked(ts: TypeStack) = ts eq emptyStack
-    def initMaps(bs: Seq[BasicBlock]): Unit = {
-      in.clear()
-      out.clear()
-      bs foreach { b =>
-        in(b) = emptyStack
-        out(b) = emptyStack
-      }
-    }
-
-    /** A wrapper to route log messages to debug output also.
-     */
-    def logChecker(msg: String) = {
-      log(msg)
-      checkerDebug(msg)
-    }
-
-    def checkICodes(): Unit = {
-      if (settings.verbose)
-      println("[[consistency check at the beginning of phase " + globalPhase.name + "]]")
-      classes.values foreach check
-    }
-
-    private def posStr(p: Position) =
-      if (p.isDefined) p.line.toString else "<??>"
-
-    private def indent(s: String, prefix: String): String = {
-      val lines = s split "\\n"
-      lines map (prefix + _) mkString "\n"
-    }
-
-    /** Only called when m1 < m2, so already known that (m1 ne m2).
-     */
-    private def isConflict(m1: IMember, m2: IMember, canOverload: Boolean) = (
-      (m1.symbol.name == m2.symbol.name) &&
-      (!canOverload || (m1.symbol.tpe =:= m2.symbol.tpe))
-    )
-
-    def check(cls: IClass) {
-      logChecker("\n<<-- Checking class " + cls + " -->>")
-      clasz = cls
-
-      for (f1 <- cls.fields ; f2 <- cls.fields ; if f1 < f2)
-        if (isConflict(f1, f2, canOverload = false))
-          icodeError("Repetitive field name: " + f1.symbol.fullName)
-
-      for (m1 <- cls.methods ; m2 <- cls.methods ; if m1 < m2)
-        if (isConflict(m1, m2, canOverload = true))
-          icodeError("Repetitive method: " + m1.symbol.fullName)
-
-      clasz.methods foreach check
-    }
-
-    def check(m: IMethod) {
-      logChecker("\n<< Checking method " + m.symbol.name + " >>")
-      method = m
-      if (!m.isAbstractMethod)
-        check(m.code)
-    }
-
-    def check(c: Code) {
-      val worklist = new ListBuffer[BasicBlock]
-      def append(elems: List[BasicBlock]) =
-        worklist ++= (elems filterNot (worklist contains _))
-
-      code = c
-      worklist += c.startBlock
-      initMaps(c.blocks)
-
-      while (worklist.nonEmpty) {
-        val block  = worklist remove 0
-        val output = check(block, in(block))
-        if (output != out(block) || notChecked(out(block))) {
-          if (block.successors.nonEmpty)
-            logChecker("** Output change for %s: %s -> %s".format(block, out(block), output))
-
-          out(block) = output
-          append(block.successors)
-          block.successors foreach meet
-        }
-      }
-    }
-
-    /**
-     * Apply the meet operator of the stack lattice on bl's predecessors.
-     * :-). Compute the input to bl by checking that all stacks have the
-     * same length, and taking the lub of types at the same positions.
-     */
-    def meet(bl: BasicBlock) {
-      val preds = bl.predecessors
-
-      def hasNothingType(s: TypeStack) = s.nonEmpty && (s.head == NothingReference)
-
-      /* XXX workaround #1: one stack empty, the other has BoxedUnit.
-       * One example where this arises is:
-       *
-       * def f(b: Boolean): Unit = synchronized { if (b) () }
-       */
-      def allUnits(s: TypeStack)   = s.types forall (_ == BoxedUnitReference)
-
-      def ifAthenB[T](f: T => Boolean): PartialFunction[(T, T), T] = {
-        case (x1, x2) if f(x1)  => x2
-        case (x1, x2) if f(x2)  => x1
-      }
-
-      /* XXX workaround #2: different stacks heading into an exception
-       * handler which will clear them anyway.  Examples where it arises:
-       *
-       * var bippy: Int = synchronized { if (b) 5 else 10 }
-       */
-      def isHandlerBlock() = bl.exceptionHandlerStart
-
-      def meet2(s1: TypeStack, s2: TypeStack): TypeStack = {
-        def workaround(msg: String) = {
-          checkerDebug(msg + ": " + method + " at block " + bl)
-          checkerDebug("  s1: " + s1)
-          checkerDebug("  s2: " + s2)
-          new TypeStack()
-        }
-        def incompatibleString = (
-          "Incompatible stacks: " + s1 + " and " + s2 + " in " + method + " at entry to block " + bl.label + ":\n" +
-          indent(bl.predContents, "// ") +
-          indent(bl.succContents, "// ") +
-          indent(bl.blockContents, "// ")
-        )
-
-        val f: ((TypeStack, TypeStack)) => TypeStack = {
-          ifAthenB(notChecked) orElse ifAthenB(hasNothingType) orElse {
-            case (s1: TypeStack, s2: TypeStack) =>
-              if (s1.length != s2.length) {
-                if (allUnits(s1) && allUnits(s2))
-                  workaround("Ignoring mismatched boxed units")
-                else if (isHandlerBlock())
-                  workaround("Ignoring mismatched stacks entering exception handler")
-                else
-                  throw new CheckerException(incompatibleString)
-              }
-              else {
-                val newStack: TypeStack = try {
-                    new TypeStack((s1.types, s2.types).zipped map lub)
-                } catch {
-                  case t: Exception =>
-                    checkerDebug(t.toString + ": " + s1.types.toString + " vs " + s2.types.toString)
-                    new TypeStack(s1.types)
-                }
-                if (newStack.isEmpty || s1.types == s2.types) ()  // not interesting to report
-                else checkerDebug("Checker created new stack:\n  (%s, %s) => %s".format(s1, s2, newStack))
-
-                newStack
-              }
-          }
-        }
-
-        f((s1, s2))
-      }
-
-      if (preds.nonEmpty) {
-        in(bl) = (preds map out.apply) reduceLeft meet2
-        log("Input changed for block: " + bl +" to: " + in(bl))
-      }
-    }
-
-    private var instruction: Instruction = null
-    private var basicBlock: BasicBlock = null
-    private var stringConcatDepth = 0
-    private def stringConcatIndent() = "  " * stringConcatDepth
-    private def currentInstrString: String = {
-      val (indent, str) = this.instruction match {
-        case CALL_PRIMITIVE(StartConcat)      =>
-          val x = stringConcatIndent()
-          stringConcatDepth += 1
-          (x, "concat(")
-        case CALL_PRIMITIVE(EndConcat)        =>
-          if (stringConcatDepth > 0) {
-            stringConcatDepth -= 1
-            (stringConcatIndent(), ") // end concat")
-          }
-          else ("", "")
-        case _ =>
-          (stringConcatIndent(), this.instruction match {
-            case CALL_PRIMITIVE(StringConcat(el)) => "..."
-            case null                             => "null"
-            case cm @ CALL_METHOD(_, _)           => if (clasz.symbol == cm.hostClass) cm.toShortString else cm.toString
-            case x                                => x.toString
-          })
-      }
-      indent + str
-    }
-    /** A couple closure creators to reduce noise in the output: when multiple
-     *  items are pushed or popped, this lets us print something short and sensible
-     *  for those beyond the first.
-     */
-    def mkInstrPrinter(f: Int => String): () => String = {
-      var counter = -1
-      val indent = stringConcatIndent()
-      () => {
-        counter += 1
-        if (counter == 0) currentInstrString
-        else indent + f(counter)
-      }
-    }
-    def defaultInstrPrinter: () => String = mkInstrPrinter(_ => "\"\"\"")
-
-    /**
-     * Check the basic block to be type correct and return the
-     * produced type stack.
-     */
-    def check(b: BasicBlock, initial: TypeStack): TypeStack = {
-      this.basicBlock = b
-
-      logChecker({
-        val prefix = "** Checking " + b.fullString
-
-        if (initial.isEmpty) prefix
-        else prefix + " with initial stack " + initial.types.mkString("[", ", ", "]")
-      })
-
-      val stack = new TypeStack(initial)
-      def checkStack(len: Int) {
-        if (stack.length < len)
-          ICodeChecker.this.icodeError("Expected at least " + len + " elements on the stack", stack)
-      }
-
-      def sizeString(push: Boolean) = {
-        val arrow = if (push) "-> " else "<- "
-        val sp    = "   " * stack.length
-
-        sp + stack.length + arrow
-      }
-      def printStackString(isPush: Boolean, value: TypeKind, instrString: String) = {
-        val pushString = if (isPush) "+" else "-"
-        val posString  = posStr(this.instruction.pos)
-
-        checkerDebug("%-70s %-4s %s %s".format(sizeString(isPush) + value, posString, pushString, instrString))
-      }
-      def _popStack: TypeKind = {
-        if (stack.isEmpty) {
-          icodeError("Popped empty stack in " + b.fullString + ", throwing a Unit")
-          return UNIT
-        }
-        stack.pop
-      }
-      def popStackN(num: Int, instrFn: () => String = defaultInstrPrinter) = {
-        List.range(0, num) map { _ =>
-          val res = _popStack
-          printStackString(isPush = false, res, instrFn())
-          res
-        }
-      }
-      def pushStackN(xs: Seq[TypeKind], instrFn: () => String) = {
-        xs foreach { x =>
-          stack push x
-          printStackString(isPush = true, x, instrFn())
-        }
-      }
-
-      def popStack     = { checkStack(1) ; (popStackN(1): @unchecked) match { case List(x) => x } }
-      def popStack2    = { checkStack(2) ; (popStackN(2): @unchecked) match { case List(x, y) => (x, y) } }
-      def popStack3    = { checkStack(3) ; (popStackN(3): @unchecked) match { case List(x, y, z) => (x, y, z) } }
-
-      /* Called by faux instruction LOAD_EXCEPTION to wipe out the stack. */
-      def clearStack() = {
-        if (stack.nonEmpty)
-          logChecker("Wiping out the " + stack.length + " element stack for exception handler: " + stack)
-
-        1 to stack.length foreach (_ => popStack)
-      }
-
-      def pushStack(xs: TypeKind*): Unit = {
-        pushStackN(xs filterNot (_ == UNIT), defaultInstrPrinter)
-      }
-
-      def typeError(k1: TypeKind, k2: TypeKind) {
-        icodeError("\n  expected: " + k1 + "\n     found: " + k2)
-      }
-      def isSubtype(k1: TypeKind, k2: TypeKind) = (k1 isAssignabledTo k2) || {
-        import platform.isMaybeBoxed
-
-        (k1, k2) match {
-          case (REFERENCE(_), REFERENCE(_)) if k1.isInterfaceType || k2.isInterfaceType =>
-            logChecker("Considering %s <:< %s because at least one is an interface".format(k1, k2))
-            true
-          case (REFERENCE(cls1), REFERENCE(cls2)) if isMaybeBoxed(cls1) || isMaybeBoxed(cls2) =>
-            logChecker("Considering %s <:< %s because at least one might be a boxed primitive".format(cls1, cls2))
-            true
-          case _ =>
-            false
-        }
-      }
-
-      def subtypeTest(k1: TypeKind, k2: TypeKind): Unit =
-        if (isSubtype(k1, k2)) ()
-        else typeError(k2, k1)
-
-      for (instr <- b) {
-        this.instruction = instr
-
-        def checkLocal(local: Local) {
-          if ((method lookupLocal local.sym.name).isEmpty)
-            icodeError(s" $local is not defined in method $method")
-        }
-        def checkField(obj: TypeKind, field: Symbol): Unit = obj match {
-          case REFERENCE(sym) =>
-            if (sym.info.member(field.name) == NoSymbol)
-              icodeError(" " + field + " is not defined in class " + clasz)
-          case _ =>
-            icodeError(" expected reference type, but " + obj + " found")
-        }
-
-        /* Checks that tpe is a subtype of one of the allowed types */
-        def checkType(tpe: TypeKind, allowed: TypeKind*) = (
-          if (allowed exists (k => isSubtype(tpe, k))) ()
-          else icodeError(tpe + " is not one of: " + allowed.mkString("{ ", ", ", " }"))
-        )
-        def checkNumeric(tpe: TypeKind) =
-          checkType(tpe, BYTE, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE)
-
-        /* Checks that the 2 topmost elements on stack are of the kind TypeKind. */
-        def checkBinop(kind: TypeKind) {
-          val (a, b) = popStack2
-          checkType(a, kind)
-          checkType(b, kind)
-        }
-
-        /* Check that arguments on the stack match method params. */
-        def checkMethodArgs(method: Symbol) {
-          val params = method.info.paramTypes
-          checkStack(params.length)
-          (
-            popStackN(params.length, mkInstrPrinter(num => "<arg" + num + ">")),
-            params.reverse map toTypeKind).zipped foreach ((x, y) => checkType(x, y)
-          )
-        }
-
-        /* Checks that the object passed as receiver has a method
-         * `method` and that it is callable from the current method.
-         */
-        def checkMethod(receiver: TypeKind, method: Symbol) =
-          receiver match {
-            case REFERENCE(sym) =>
-              checkBool(sym.info.member(method.name) != NoSymbol,
-                        "Method " + method + " does not exist in " + sym.fullName)
-              if (method.isPrivate)
-                checkBool(method.owner == clasz.symbol,
-                          "Cannot call private method of " + method.owner.fullName
-                          + " from " + clasz.symbol.fullName)
-              else if (method.isProtected) {
-                val isProtectedOK = (
-                  (clasz.symbol isSubClass method.owner) ||
-                  (clasz.symbol.typeOfThis.typeSymbol isSubClass method.owner)  // see pos/bug780.scala
-                )
-
-                checkBool(isProtectedOK,
-                          "Cannot call protected method of " + method.owner.fullName
-                          + " from " + clasz.symbol.fullName)
-              }
-
-            case ARRAY(_) =>
-              checkBool(receiver.toType.member(method.name) != NoSymbol,
-                        "Method " + method + " does not exist in " + receiver)
-
-            case t =>
-              icodeError("Not a reference type: " + t)
-          }
-
-        def checkBool(cond: Boolean, msg: String) =
-          if (!cond) icodeError(msg)
-
-        if (settings.debug) {
-          log("PC: " + instr)
-          log("stack: " + stack)
-          log("================")
-        }
-        instr match {
-          case THIS(clasz) =>
-            pushStack(toTypeKind(clasz.tpe))
-
-          case CONSTANT(const) =>
-            pushStack(toTypeKind(const.tpe))
-
-          case LOAD_ARRAY_ITEM(kind) =>
-            popStack2 match {
-              case (INT, ARRAY(elem)) =>
-                subtypeTest(elem, kind)
-                pushStack(elem)
-              case (a, b) =>
-                icodeError(" expected an INT and an array reference, but " +
-                    a + ", " + b + " found")
-            }
-
-         case LOAD_LOCAL(local) =>
-           checkLocal(local)
-           pushStack(local.kind)
-
-         case LOAD_FIELD(field, isStatic) =>
-           // the symbol's owner should contain its field, but
-           // this is already checked by the type checker, no need
-           // to redo that here
-           if (isStatic) ()
-           else checkField(popStack, field)
-
-           pushStack(toTypeKind(field.tpe))
-
-         case LOAD_MODULE(module) =>
-           checkBool((module.isModule || module.isModuleClass),
-                     "Expected module: " + module + " flags: " + module.flagString)
-           pushStack(toTypeKind(module.tpe))
-
-          case STORE_THIS(kind) =>
-           val actualType = popStack
-           if (actualType.isReferenceType) subtypeTest(actualType, kind)
-           else icodeError("Expected this reference but found: " + actualType)
-
-         case STORE_ARRAY_ITEM(kind) =>
-           popStack3 match {
-             case (k, INT, ARRAY(elem)) =>
-               subtypeTest(k, kind)
-               subtypeTest(k, elem)
-             case (a, b, c) =>
-                icodeError(" expected and array reference, and int and " + kind +
-                      " but " + a + ", " + b + ", " + c + " found")
-           }
-
-         case STORE_LOCAL(local) =>
-           checkLocal(local)
-           val actualType = popStack
-           if (local.kind != NullReference)
-            subtypeTest(actualType, local.kind)
-
-         case STORE_FIELD(field, true) =>     // static
-           val fieldType = toTypeKind(field.tpe)
-           val actualType = popStack
-           subtypeTest(actualType, fieldType)
-
-         case STORE_FIELD(field, false) =>    // not static
-           val (value, obj) = popStack2
-           checkField(obj, field)
-           val fieldType = toTypeKind(field.tpe)
-           if (fieldType == NullReference) ()
-           else subtypeTest(value, fieldType)
-
-         case CALL_PRIMITIVE(primitive) =>
-           checkStack(instr.consumed)
-           primitive match {
-             case Negation(kind) =>
-               checkType(kind, BOOL, BYTE, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE)
-               checkType(popStack, kind)
-               pushStack(kind)
-
-             case Test(op, kind, zero) =>
-               if (zero) checkType(popStack, kind)
-               else checkBinop(kind)
-
-               pushStack(BOOL)
-
-             case Comparison(op, kind) =>
-               checkNumeric(kind)
-               checkBinop(kind)
-               pushStack(INT)
-
-             case Arithmetic(op, kind) =>
-               checkNumeric(kind)
-               if (op == NOT)
-                 checkType(popStack, kind)
-               else
-                 checkBinop(kind)
-               pushStack(kind)
-
-             case Logical(op, kind) =>
-               checkType(kind, BOOL, BYTE, CHAR, SHORT, INT, LONG)
-               checkBinop(kind)
-               pushStack(kind)
-
-             case Shift(op, kind) =>
-               checkType(kind, BYTE, CHAR, SHORT, INT, LONG)
-               val (a, b) = popStack2
-               checkType(a, INT)
-               checkType(b, kind)
-               pushStack(kind)
-
-             case Conversion(src, dst) =>
-               checkNumeric(src)
-               checkNumeric(dst)
-               checkType(popStack, src)
-               pushStack(dst)
-
-             case ArrayLength(kind) =>
-               popStack match {
-                 case ARRAY(elem) => checkType(elem, kind)
-                 case arr         => icodeError(" array reference expected, but " + arr + " found")
-               }
-               pushStack(INT)
-
-             case StartConcat =>
-               pushStack(ConcatClass)
-
-             case EndConcat =>
-               checkType(popStack, ConcatClass)
-               pushStack(StringReference)
-
-             case StringConcat(el) =>
-               checkType(popStack, el)
-               checkType(popStack, ConcatClass)
-               pushStack(ConcatClass)
-           }
-
-         case CALL_METHOD(method, style) =>
-           // PP to ID: I moved the if (!method.isConstructor) check to cover all
-           // the styles to address checker failure.  Can you confirm if the change
-           // was correct? If I remember right it's a matter of whether some brand
-           // of supercall should leave a value on the stack, and I know there is some
-           // trickery performed elsewhere regarding this.
-           val paramCount = method.info.paramTypes.length match {
-             case x if style.hasInstance  => x + 1
-             case x                       => x
-           }
-           if (style == Static(onInstance = true))
-             checkBool(method.isPrivate || method.isConstructor, "Static call to non-private method.")
-
-          checkStack(paramCount)
-          checkMethodArgs(method)
-          if (style.hasInstance)
-            checkMethod(popStack, method)
-          if (!method.isConstructor)
-            pushStack(toTypeKind(method.info.resultType))
-
-          case NEW(kind) =>
-            pushStack(kind)
-
-          case CREATE_ARRAY(elem, dims) =>
-            checkStack(dims)
-            stack.pop(dims) foreach (checkType(_, INT))
-            pushStack(ARRAY(elem))
-
-          case IS_INSTANCE(tpe) =>
-            val ref = popStack
-            checkBool(!ref.isValueType, "IS_INSTANCE on primitive type: " + ref)
-            checkBool(!tpe.isValueType, "IS_INSTANCE on primitive type: " + tpe)
-            pushStack(BOOL)
-
-          case CHECK_CAST(tpe) =>
-            val ref = popStack
-            checkBool(!ref.isValueType, "CHECK_CAST to primitive type: " + ref)
-            checkBool(!tpe.isValueType, "CHECK_CAST to primitive type: " + tpe)
-            pushStack(tpe)
-
-          case SWITCH(tags, labels) =>
-            checkType(popStack, INT)
-            checkBool(tags.length == labels.length - 1,
-                      "The number of tags and labels does not coincide.")
-            checkBool(labels forall (b => code.blocks contains b),
-                      "Switch target cannot be found in code.")
-
-          case JUMP(whereto) =>
-            checkBool(code.blocks contains whereto,
-                      "Jump to non-existant block " + whereto)
-
-          case CJUMP(success, failure, cond, kind) =>
-            checkBool(code.blocks contains success,
-                      "Jump to non-existant block " + success)
-            checkBool(code.blocks contains failure,
-                      "Jump to non-existant block " + failure)
-            checkBinop(kind)
-
-          case CZJUMP(success, failure, cond, kind) =>
-            checkBool(code.blocks contains success,
-                      "Jump to non-existant block " + success)
-            checkBool(code.blocks contains failure,
-                      "Jump to non-existant block " + failure)
-            checkType(popStack, kind)
-
-          case RETURN(UNIT) => ()
-          case RETURN(kind) =>
-            val top = popStack
-            if (kind.isValueType) checkType(top, kind)
-            else checkBool(!top.isValueType, "" + kind + " is a reference type, but " + top + " is not")
-
-          case THROW(clasz) =>
-            checkType(popStack, toTypeKind(clasz.tpe))
-            pushStack(NothingReference)
-
-          case DROP(kind) =>
-            checkType(popStack, kind)
-
-          case DUP(kind) =>
-            val top = popStack
-            checkType(top, kind)
-            pushStack(top)
-            pushStack(top)
-
-          case MONITOR_ENTER() =>
-            checkBool(popStack.isReferenceType, "MONITOR_ENTER on non-reference type")
-
-          case MONITOR_EXIT() =>
-            checkBool(popStack.isReferenceType, "MONITOR_EXIT on non-reference type")
-
-          case BOX(kind) =>
-            checkType(popStack, kind)
-            pushStack(REFERENCE(definitions.boxedClass(kind.toType.typeSymbol)))
-
-          case UNBOX(kind) =>
-            popStack
-            pushStack(kind)
-
-          case LOAD_EXCEPTION(clasz) =>
-            clearStack()
-            pushStack(REFERENCE(clasz))
-
-          case SCOPE_ENTER(_) | SCOPE_EXIT(_) =>
-            ()
-
-          case _ =>
-            abort("Unknown instruction: " + instr)
-        }
-      }
-      stack
-    }
-
-    //////////////// Error reporting /////////////////////////
-
-    def icodeError(msg: String) {
-      ICodeCheckers.this.global.warning(
-        "!! ICode checker fatality in " + method +
-        "\n  at: " + basicBlock.fullString +
-        "\n  error message: " + msg
-      )
-    }
-
-    def icodeError(msg: String, stack: TypeStack) {
-      icodeError(msg + "\n type stack: " + stack)
-    }
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/ICodes.scala b/src/compiler/scala/tools/nsc/backend/icode/ICodes.scala
deleted file mode 100644
index 10f0c6ee00..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/ICodes.scala
+++ /dev/null
@@ -1,129 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend
-package icode
-
-import java.io.PrintWriter
-import analysis.{ Liveness, ReachingDefinitions }
-import scala.tools.nsc.symtab.classfile.ICodeReader
-import scala.reflect.io.AbstractFile
-
-/** Glue together ICode parts.
- *
- *  @author Iulian Dragos
- */
-abstract class ICodes extends AnyRef
-                                 with Members
-                                 with BasicBlocks
-                                 with Opcodes
-                                 with TypeStacks
-                                 with TypeKinds
-                                 with ExceptionHandlers
-                                 with Primitives
-                                 with Linearizers
-                                 with Printers
-                                 with Repository
-{
-  val global: Global
-  import global.{ log, definitions, settings, perRunCaches, devWarning }
-
-  /** The ICode representation of classes */
-  val classes = perRunCaches.newMap[global.Symbol, IClass]()
-
-  /** Debugging flag */
-  def shouldCheckIcode = settings.check contains global.genicode.phaseName
-  def checkerDebug(msg: String) = if (shouldCheckIcode && global.settings.debug) println(msg)
-
-  /** The ICode linearizer. */
-  val linearizer: Linearizer = settings.Xlinearizer.value match {
-    case "rpo"    => new ReversePostOrderLinearizer()
-    case "dfs"    => new DepthFirstLinerizer()
-    case "normal" => new NormalLinearizer()
-    case "dump"   => new DumpLinearizer()
-    case x        => global.abort("Unknown linearizer: " + x)
-  }
-
-  def newTextPrinter() =
-    new TextPrinter(new PrintWriter(Console.out, true), new DumpLinearizer)
-
-  /** Have to be careful because dump calls around, possibly
-   *  re-entering methods which initiated the dump (like foreach
-   *  in BasicBlocks) which leads to the icode output olympics.
-   */
-  private var alreadyDumping = false
-
-  /** Print all classes and basic blocks. Used for debugging. */
-
-  def dumpClassesAndAbort(msg: String): Nothing = {
-    if (alreadyDumping) global.abort(msg)
-    else alreadyDumping = true
-
-    Console.println(msg)
-    val printer = newTextPrinter()
-    classes.values foreach printer.printClass
-    global.abort(msg)
-  }
-
-  def dumpMethodAndAbort(m: IMethod, msg: String): Nothing = {
-    Console.println("Fatal bug in inlinerwhile traversing " + m + ": " + msg)
-    m.dump()
-    global.abort("" + m)
-  }
-  def dumpMethodAndAbort(m: IMethod, b: BasicBlock): Nothing =
-    dumpMethodAndAbort(m, "found open block " + b + " " + b.flagsString)
-
-  def checkValid(m: IMethod) {
-    // always slightly dicey to iterate over mutable structures
-    m foreachBlock { b =>
-      if (!b.closed) {
-        // Something is leaving open/empty blocks around (see SI-4840) so
-        // let's not kill the deal unless it's nonempty.
-        if (b.isEmpty) {
-          devWarning(s"Found open but empty block while inlining $m: removing from block list.")
-          m.code removeBlock b
-        }
-        else dumpMethodAndAbort(m, b)
-      }
-    }
-  }
-
-  object liveness extends Liveness {
-    val global: ICodes.this.global.type = ICodes.this.global
-  }
-
-  object reachingDefinitions extends ReachingDefinitions {
-    val global: ICodes.this.global.type = ICodes.this.global
-  }
-
-  lazy val AnyRefReference: TypeKind    = REFERENCE(definitions.AnyRefClass)
-  lazy val BoxedUnitReference: TypeKind = REFERENCE(definitions.BoxedUnitClass)
-  lazy val NothingReference: TypeKind   = REFERENCE(definitions.NothingClass)
-  lazy val NullReference: TypeKind      = REFERENCE(definitions.NullClass)
-  lazy val ObjectReference: TypeKind    = REFERENCE(definitions.ObjectClass)
-  lazy val StringReference: TypeKind    = REFERENCE(definitions.StringClass)
-
-  object icodeReader extends ICodeReader {
-    lazy val global: ICodes.this.global.type = ICodes.this.global
-    import global._
-    def lookupMemberAtTyperPhaseIfPossible(sym: Symbol, name: Name): Symbol =
-      global.loaders.lookupMemberAtTyperPhaseIfPossible(sym, name)
-    lazy val symbolTable: global.type = global
-    lazy val loaders: global.loaders.type = global.loaders
-
-    def classFileLookup: util.ClassFileLookup[AbstractFile] = global.classPath
-  }
-
-  /** A phase which works on icode. */
-  abstract class ICodePhase(prev: Phase) extends global.GlobalPhase(prev) {
-    override def erasedTypes = true
-    override def apply(unit: global.CompilationUnit): Unit =
-      unit.icode foreach apply
-
-    def apply(cls: global.icodes.IClass): Unit
-  }
-}
-
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala b/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala
deleted file mode 100644
index 54be9d18f1..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala
+++ /dev/null
@@ -1,201 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-
-package scala
-package tools.nsc
-package backend
-package icode
-
-import scala.collection.{ mutable, immutable }
-import mutable.ListBuffer
-
-trait Linearizers {
-  self: ICodes =>
-
-  import global.debuglog
-  import opcodes._
-
-  abstract class Linearizer {
-    def linearize(c: IMethod): List[BasicBlock]
-    def linearizeAt(c: IMethod, start: BasicBlock): List[BasicBlock]
-  }
-
-  /**
-   * A simple linearizer which predicts all branches to
-   * take the 'success' branch and tries to schedule those
-   * blocks immediately after the test. This is in sync with
-   * how 'while' statements are translated (if the test is
-   * 'true', the loop continues).
-   */
-  class NormalLinearizer extends Linearizer with WorklistAlgorithm {
-    type Elem = BasicBlock
-    val worklist: WList = new mutable.Stack()
-    var blocks: List[BasicBlock] = Nil
-
-    def linearize(m: IMethod): List[BasicBlock] = {
-      val b = m.startBlock
-      blocks = Nil
-
-      run {
-        worklist pushAll (m.exh map (_.startBlock))
-        worklist.push(b)
-      }
-
-      blocks.reverse
-    }
-
-    def linearizeAt(m: IMethod, start: BasicBlock): List[BasicBlock] = {
-      blocks = Nil
-      worklist.clear()
-      linearize(start)
-    }
-
-    /** Linearize another subtree and append it to the existing blocks. */
-    def linearize(startBlock: BasicBlock): List[BasicBlock] = {
-      //blocks = startBlock :: Nil;
-      run( { worklist.push(startBlock); } )
-      blocks.reverse
-    }
-
-    def processElement(b: BasicBlock) =
-      if (b.nonEmpty) {
-        add(b)
-        b.lastInstruction match {
-          case JUMP(whereto) =>
-            add(whereto)
-          case CJUMP(success, failure, _, _) =>
-            add(success)
-            add(failure)
-          case CZJUMP(success, failure, _, _) =>
-            add(success)
-            add(failure)
-          case SWITCH(_, labels) =>
-            add(labels)
-          case RETURN(_) => ()
-          case THROW(clasz) =>   ()
-        }
-      }
-
-    def dequeue: Elem = worklist.pop()
-
-    /**
-     * Prepend b to the list, if not already scheduled.
-     * TODO: use better test than linear search
-     */
-    def add(b: BasicBlock) {
-      if (blocks.contains(b))
-        ()
-      else {
-        blocks = b :: blocks
-        worklist push b
-      }
-    }
-
-    def add(bs: List[BasicBlock]): Unit = bs foreach add
-  }
-
-  /**
-   * Linearize code using a depth first traversal.
-   */
-  class DepthFirstLinerizer extends Linearizer {
-    var blocks: List[BasicBlock] = Nil
-
-    def linearize(m: IMethod): List[BasicBlock] = {
-      blocks = Nil
-
-      dfs(m.startBlock)
-      m.exh foreach (b => dfs(b.startBlock))
-
-      blocks.reverse
-    }
-
-    def linearizeAt(m: IMethod, start: BasicBlock): List[BasicBlock] = {
-      blocks = Nil
-      dfs(start)
-      blocks.reverse
-    }
-
-    def dfs(b: BasicBlock): Unit =
-      if (b.nonEmpty && add(b))
-        b.successors foreach dfs
-
-    /**
-     * Prepend b to the list, if not already scheduled.
-     * TODO: use better test than linear search
-     * @return Returns true if the block was added.
-     */
-    def add(b: BasicBlock): Boolean =
-      !(blocks contains b) && {
-        blocks = b :: blocks
-        true
-      }
-  }
-
-  /**
-   * Linearize code in reverse post order. In fact, it does
-   * a post order traversal, prepending visited nodes to the list.
-   * This way, it is constructed already in reverse post order.
-   */
-  class ReversePostOrderLinearizer extends Linearizer {
-    var blocks: List[BasicBlock] = Nil
-    val visited = new mutable.HashSet[BasicBlock]
-    val added = new mutable.BitSet
-
-    def linearize(m: IMethod): List[BasicBlock] = {
-      blocks = Nil
-      visited.clear()
-      added.clear()
-
-      m.exh foreach (b => rpo(b.startBlock))
-      rpo(m.startBlock)
-
-      // if the start block has predecessors, it won't be the first one
-      // in the linearization, so we need to enforce it here
-      if (m.startBlock.predecessors eq Nil)
-        blocks
-      else
-        m.startBlock :: (blocks.filterNot(_ == m.startBlock))
-    }
-
-    def linearizeAt(m: IMethod, start: BasicBlock): List[BasicBlock] = {
-      blocks = Nil
-      visited.clear()
-      added.clear()
-
-      rpo(start)
-      blocks
-    }
-
-    def rpo(b: BasicBlock): Unit =
-      if (b.nonEmpty && !visited(b)) {
-        visited += b
-        b.successors foreach rpo
-        add(b)
-      }
-
-    /**
-     * Prepend b to the list, if not already scheduled.
-     * @return Returns true if the block was added.
-     */
-    def add(b: BasicBlock) = {
-      debuglog("Linearizer adding block " + b.label)
-
-      if (!added(b.label)) {
-        added += b.label
-        blocks = b :: blocks
-      }
-    }
-  }
-
-  /** A 'dump' of the blocks in this method, which does not
-   *  require any well-formedness of the basic blocks (like
-   *  the last instruction being a jump).
-   */
-  class DumpLinearizer extends Linearizer {
-    def linearize(m: IMethod): List[BasicBlock] = m.blocks
-    def linearizeAt(m: IMethod, start: BasicBlock): List[BasicBlock] = sys.error("not implemented")
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Members.scala b/src/compiler/scala/tools/nsc/backend/icode/Members.scala
deleted file mode 100644
index c0e0240210..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/Members.scala
+++ /dev/null
@@ -1,297 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala
-package tools.nsc
-package backend
-package icode
-
-import scala.collection.{ mutable, immutable }
-import scala.reflect.internal.Flags
-import scala.reflect.internal.util.{ SourceFile, NoSourceFile }
-
-trait ReferenceEquality {
-  override def hashCode = System.identityHashCode(this)
-  override def equals(that: Any) = this eq that.asInstanceOf[AnyRef]
-}
-
-trait Members {
-  self: ICodes =>
-
-  import global._
-
-  object NoCode extends Code(null, TermName("NoCode")) {
-    override def blocksList: List[BasicBlock] = Nil
-  }
-
-  /**
-   * This class represents the intermediate code of a method or
-   * other multi-block piece of code, like exception handlers.
-   */
-  class Code(method: IMethod, name: Name) {
-    def this(method: IMethod) = this(method, method.symbol.name)
-    /** The set of all blocks */
-    val blocks = mutable.ListBuffer[BasicBlock]()
-
-    /** The start block of the method */
-    var startBlock: BasicBlock = NoBasicBlock
-
-    private var currentLabel: Int = 0
-    private var _touched = false
-
-    def blocksList: List[BasicBlock] = blocks.toList
-    def instructions                 = blocksList flatMap (_.iterator)
-    def blockCount                   = blocks.size
-    def instructionCount             = (blocks map (_.length)).sum
-
-    def touched = _touched
-    def touched_=(b: Boolean): Unit = {
-      @annotation.tailrec def loop(xs: List[BasicBlock]) {
-        xs match {
-          case Nil     =>
-          case x :: xs => x.touched = true ; loop(xs)
-        }
-      }
-      if (b) loop(blocks.toList)
-
-      _touched = b
-    }
-
-    // Constructor code
-    startBlock = newBlock()
-
-    def removeBlock(b: BasicBlock) {
-      if (settings.debug) {
-        // only do this sanity check when debug is turned on because it's moderately expensive
-        val referers = blocks filter (_.successors contains b)
-        assert(referers.isEmpty, s"Trying to removing block $b (with preds ${b.predecessors.mkString}) but it is still refered to from block(s) ${referers.mkString}")
-      }
-
-      if (b == startBlock) {
-        assert(b.successors.length == 1,
-          s"Removing start block ${b} with ${b.successors.length} successors (${b.successors.mkString})."
-        )
-        startBlock = b.successors.head
-      }
-
-      blocks -= b
-      assert(!blocks.contains(b))
-      method.exh filter (_ covers b) foreach (_.covered -= b)
-      touched = true
-    }
-
-    /** This methods returns a string representation of the ICode */
-    override def toString = "ICode '" + name.decoded + "'"
-
-    /* Compute a unique new label */
-    def nextLabel: Int = {
-      currentLabel += 1
-      currentLabel
-    }
-
-    /* Create a new block and append it to the list
-     */
-    def newBlock(): BasicBlock = {
-      touched = true
-      val block = new BasicBlock(nextLabel, method)
-      blocks += block
-      block
-    }
-  }
-
-  /** Common interface for IClass/IField/IMethod. */
-  trait IMember extends Ordered[IMember] {
-    def symbol: Symbol
-
-    def compare(other: IMember) =
-      if (symbol eq other.symbol) 0
-      else if (symbol isLess other.symbol) -1
-      else 1
-
-    override def equals(other: Any): Boolean =
-      other match {
-        case other: IMember => (this compare other) == 0
-        case _ => false
-      }
-
-    override def hashCode = symbol.##
-  }
-
-  /** Represent a class in ICode */
-  class IClass(val symbol: Symbol) extends IMember {
-    var fields: List[IField] = Nil
-    var methods: List[IMethod] = Nil
-    var cunit: CompilationUnit = _
-
-    def addField(f: IField): this.type = {
-      fields = f :: fields
-      this
-    }
-
-    def addMethod(m: IMethod): this.type = {
-      methods = m :: methods
-      this
-    }
-
-    def setCompilationUnit(unit: CompilationUnit): this.type = {
-      this.cunit = unit
-      this
-    }
-
-    override def toString() = symbol.fullName
-
-    def lookupMethod(s: Symbol) = methods find (_.symbol == s)
-
-    /* returns this methods static ctor if it has one. */
-    def lookupStaticCtor: Option[IMethod] = methods find (_.symbol.isStaticConstructor)
-  }
-
-  /** Represent a field in ICode */
-  class IField(val symbol: Symbol) extends IMember { }
-
-  object NoIMethod extends IMethod(NoSymbol) { }
-
-  /**
-   * Represents a method in ICode. Local variables contain
-   * both locals and parameters, similar to the way the JVM
-   * 'sees' them.
-   *
-   * Locals and parameters are added in reverse order, as they
-   * are kept in cons-lists. The 'builder' is responsible for
-   * reversing them and putting them back, when the generation is
-   * finished (GenICode does that).
-   */
-  class IMethod(val symbol: Symbol) extends IMember {
-    var code: Code = NoCode
-
-    def newBlock() = code.newBlock()
-    def startBlock = code.startBlock
-    def lastBlock  = { assert(blocks.nonEmpty, symbol); blocks.last }
-    def blocks = code.blocksList
-    def linearizedBlocks(lin: Linearizer = self.linearizer): List[BasicBlock] = lin linearize this
-
-    def foreachBlock[U](f: BasicBlock  => U): Unit = blocks foreach f
-
-    var native = false
-
-    /** The list of exception handlers, ordered from innermost to outermost. */
-    var exh: List[ExceptionHandler] = Nil
-    var sourceFile: SourceFile = NoSourceFile
-    var returnType: TypeKind = _
-    var recursive: Boolean = false
-    var bytecodeHasEHs = false // set by ICodeReader only, used by Inliner to prevent inlining (SI-6188)
-    var bytecodeHasInvokeDynamic = false // set by ICodeReader only, used by Inliner to prevent inlining until we have proper invoke dynamic support
-
-    /** local variables and method parameters */
-    var locals: List[Local] = Nil
-
-    /** method parameters */
-    var params: List[Local] = Nil
-
-    def hasCode = code ne NoCode
-    def setCode(code: Code): IMethod = {
-      this.code = code
-      this
-    }
-
-    final def updateRecursive(called: Symbol): Unit = {
-      recursive ||= (called == symbol)
-    }
-
-    def addLocal(l: Local): Local = findOrElse(locals)(_ == l) { locals ::= l ; l }
-
-    def addParam(p: Local): Unit =
-      if (params contains p) ()
-      else {
-        params ::= p
-        locals ::= p
-      }
-
-    def addLocals(ls: List[Local]) = ls foreach addLocal
-
-    def lookupLocal(n: Name): Option[Local]     = locals find (_.sym.name == n)
-    def lookupLocal(sym: Symbol): Option[Local] = locals find (_.sym == sym)
-
-    def addHandler(e: ExceptionHandler) = exh ::= e
-
-    /** Is this method deferred ('abstract' in Java sense)?
-     */
-    def isAbstractMethod = symbol.isDeferred || (symbol.owner.isInterface && !symbol.hasFlag(Flags.JAVA_DEFAULTMETHOD)) || native
-
-    def isStatic: Boolean = symbol.isStaticMember
-
-    override def toString() = symbol.fullName
-
-    import opcodes._
-
-    /** Merge together blocks that have a single successor which has a
-     * single predecessor. Exception handlers are taken into account (they
-     * might force to break a block of straight line code like that).
-     *
-     * This method should be most effective after heavy inlining.
-     */
-    def normalize(): Unit = if (this.hasCode) {
-      val nextBlock: mutable.Map[BasicBlock, BasicBlock] = mutable.HashMap.empty
-      for (b <- code.blocks.toList
-        if b.successors.length == 1;
-        succ = b.successors.head
-        if succ ne b
-        if succ.predecessors.length == 1
-        if succ.predecessors.head eq b
-        if !(exh.exists { (e: ExceptionHandler) =>
-            (e.covers(succ) && !e.covers(b)) || (e.covers(b) && !e.covers(succ)) })) {
-          nextBlock(b) = succ
-      }
-
-      var bb = code.startBlock
-      while (!nextBlock.isEmpty) {
-        if (nextBlock.isDefinedAt(bb)) {
-          bb.open()
-          var succ = bb
-          do {
-            succ = nextBlock(succ)
-            val lastInstr = bb.lastInstruction
-            /* Ticket SI-5672
-             * Besides removing the control-flow instruction at the end of `bb` (usually a JUMP), we have to pop any values it pushes.
-             * Examples:
-             *   `SWITCH` consisting of just the default case, or
-             *   `CJUMP(targetBlock, targetBlock, _, _)` ie where success and failure targets coincide (this one consumes two stack values).
-             */
-            val oldTKs = lastInstr.consumedTypes
-            assert(lastInstr.consumed == oldTKs.size, "Someone forgot to override consumedTypes() in " +  lastInstr)
-
-              bb.removeLastInstruction()
-              for(tk <- oldTKs.reverse) { bb.emit(DROP(tk), lastInstr.pos) }
-              succ.toList foreach { i => bb.emit(i, i.pos) }
-              code.removeBlock(succ)
-              exh foreach { e => e.covered = e.covered - succ }
-
-            nextBlock -= bb
-          } while (nextBlock.isDefinedAt(succ))
-          bb.close()
-        } else
-          bb = nextBlock.keysIterator.next()
-      }
-      checkValid(this)
-    }
-
-    def dump() {
-      Console.println("dumping IMethod(" + symbol + ")")
-      newTextPrinter() printMethod this
-    }
-  }
-
-  /** Represent local variables and parameters */
-  class Local(val sym: Symbol, val kind: TypeKind, val arg: Boolean) {
-    var index: Int = -1
-
-    override def equals(other: Any): Boolean = other match {
-      case x: Local => sym == x.sym
-      case _        => false
-    }
-    override def hashCode = sym.hashCode
-    override def toString(): String = sym.toString
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
deleted file mode 100644
index 351a8e33d3..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
+++ /dev/null
@@ -1,767 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala
-package tools.nsc
-package backend
-package icode
-
-import scala.reflect.internal.util.{Position,NoPosition}
-
-/*
-  A pattern match
-
-  // locals
-    case THIS(clasz) =>
-    case STORE_THIS(kind) =>
-    case LOAD_LOCAL(local) =>
-    case STORE_LOCAL(local) =>
-    case SCOPE_ENTER(lv) =>
-    case SCOPE_EXIT(lv) =>
-  // stack
-    case LOAD_MODULE(module) =>
-    case LOAD_EXCEPTION(clasz) =>
-    case DROP(kind) =>
-    case DUP(kind) =>
-  // constants
-    case CONSTANT(const) =>
-  // arithlogic
-    case CALL_PRIMITIVE(primitive) =>
-  // casts
-    case IS_INSTANCE(tpe) =>
-    case CHECK_CAST(tpe) =>
-  // objs
-    case NEW(kind) =>
-    case MONITOR_ENTER() =>
-    case MONITOR_EXIT() =>
-    case BOX(boxType) =>
-    case UNBOX(tpe) =>
-  // flds
-    case LOAD_FIELD(field, isStatic) =>
-    case STORE_FIELD(field, isStatic) =>
-  // mthds
-    case CALL_METHOD(method, style) =>
-  // arrays
-    case LOAD_ARRAY_ITEM(kind) =>
-    case STORE_ARRAY_ITEM(kind) =>
-    case CREATE_ARRAY(elem, dims) =>
-  // jumps
-    case SWITCH(tags, labels) =>
-    case JUMP(whereto) =>
-    case CJUMP(success, failure, cond, kind) =>
-    case CZJUMP(success, failure, cond, kind) =>
-  // ret
-    case RETURN(kind) =>
-    case THROW(clasz) =>
-*/
-
-
-/**
- * The ICode intermediate representation. It is a stack-based
- * representation, very close to the JVM and .NET. It uses the
- * erased types of Scala and references Symbols to refer named entities
- * in the source files.
- */
-trait Opcodes { self: ICodes =>
-  import global.{Symbol, NoSymbol, Name, Constant}
-
-  // categories of ICode instructions
-  final val localsCat =  1
-  final val stackCat  =  2
-  final val constCat  =  3
-  final val arilogCat =  4
-  final val castsCat  =  5
-  final val objsCat   =  6
-  final val fldsCat   =  7
-  final val mthdsCat  =  8
-  final val arraysCat =  9
-  final val jumpsCat  = 10
-  final val retCat    = 11
-
-  private lazy val ObjectReferenceList = ObjectReference :: Nil
-
-  /** This class represents an instruction of the intermediate code.
-   *  Each case subclass will represent a specific operation.
-   */
-  abstract class Instruction extends Cloneable {
-    // Vlad: I used these for checking the quality of the implementation, and we should regularly run a build with them
-    // enabled. But for production these should definitely be disabled, unless we enjoy getting angry emails from Greg :)
-    //if (!this.isInstanceOf[opcodes.LOAD_EXCEPTION])
-    //  assert(consumed == consumedTypes.length)
-    //assert(produced == producedTypes.length)
-
-    def category: Int = 0 // undefined
-
-    /** This abstract method returns the number of used elements on the stack */
-    def consumed : Int = 0
-
-    /** This abstract method returns the number of produced elements on the stack */
-    def produced : Int = 0
-
-    /** This instruction consumes these types from the top of the stack, the first
-     *  element in the list is the deepest element on the stack.
-     */
-    def consumedTypes: List[TypeKind] = Nil
-
-    /** This instruction produces these types on top of the stack. */
-    // Vlad: I wonder why we keep producedTypes around -- it looks like an useless thing to have
-    def producedTypes: List[TypeKind] = Nil
-
-    /** The corresponding position in the source file */
-    private var _pos: Position = NoPosition
-
-    def pos: Position = _pos
-
-    def setPos(p: Position): this.type = {
-      _pos = p
-      this
-    }
-
-    /** Clone this instruction. */
-    override def clone(): Instruction =
-      super.clone.asInstanceOf[Instruction]
-  }
-
-  object opcodes {
-    /** Loads "this" on top of the stack.
-     * Stack: ...
-     *    ->: ...:ref
-     */
-    case class THIS(clasz: Symbol) extends Instruction {
-      /** Returns a string representation of this constant */
-      override def toString = "THIS(" + clasz.name + ")"
-
-      override def consumed = 0
-      override def produced = 1
-
-      override def producedTypes =
-        // we're not allowed to have REFERENCE(Array), but what about compiling the Array class? Well, we use object for it.
-        if (clasz != global.definitions.ArrayClass)
-          REFERENCE(clasz) :: Nil
-        else
-          ObjectReference :: Nil
-
-      override def category = localsCat
-    }
-
-    /** Loads a constant on the stack.
-     * Stack: ...
-     *    ->: ...:constant
-     */
-    case class CONSTANT(constant: Constant) extends Instruction {
-      override def toString = "CONSTANT(" + constant.escapedStringValue + ")"
-      override def consumed = 0
-      override def produced = 1
-
-      override def producedTypes = toTypeKind(constant.tpe) :: Nil
-
-      override def category = constCat
-    }
-
-    /** Loads an element of an array. The array and the index should
-     * be on top of the stack.
-     * Stack: ...:array[a](Ref):index(Int)
-     *    ->: ...:element(a)
-     */
-    case class LOAD_ARRAY_ITEM(kind: TypeKind) extends Instruction {
-      override def consumed = 2
-      override def produced = 1
-
-      override def consumedTypes = ARRAY(kind) :: INT :: Nil
-      override def producedTypes = kind :: Nil
-
-      override def category = arraysCat
-    }
-
-    /** Load a local variable on the stack. It can be a method argument.
-     * Stack: ...
-     *    ->: ...:value
-     */
-    case class LOAD_LOCAL(local: Local) extends Instruction {
-      override def consumed = 0
-      override def produced = 1
-
-      override def producedTypes = local.kind :: Nil
-
-      override def category = localsCat
-    }
-
-    /** Load a field on the stack. The object to which it refers should be
-     * on the stack.
-     * Stack: ...:ref       (assuming isStatic = false)
-     *    ->: ...:value
-     */
-    case class LOAD_FIELD(field: Symbol, isStatic: Boolean) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String =
-        "LOAD_FIELD " + (if (isStatic) field.fullName else field.toString())
-
-      override def consumed = if (isStatic) 0 else 1
-      override def produced = 1
-
-      override def consumedTypes = if (isStatic) Nil else REFERENCE(field.owner) :: Nil
-      override def producedTypes = toTypeKind(field.tpe) :: Nil
-
-      // more precise information about how to load this field
-      // see #4283
-      var hostClass: Symbol = field.owner
-      def setHostClass(cls: Symbol): this.type = { hostClass = cls; this }
-
-      override def category = fldsCat
-    }
-
-    case class LOAD_MODULE(module: Symbol) extends Instruction {
-      assert(module != NoSymbol, "Invalid module symbol")
-      /** Returns a string representation of this instruction */
-      override def toString(): String = "LOAD_MODULE " + module
-
-      override def consumed = 0
-      override def produced = 1
-
-      override def producedTypes = REFERENCE(module) :: Nil
-
-      override def category = stackCat
-    }
-
-    /** Store a value into an array at a specified index.
-     * Stack: ...:array[a](Ref):index(Int):value(a)
-     *    ->: ...
-     */
-    case class STORE_ARRAY_ITEM(kind: TypeKind) extends Instruction {
-      override def consumed = 3
-      override def produced = 0
-
-      override def consumedTypes = ARRAY(kind) :: INT :: kind :: Nil
-
-      override def category = arraysCat
-    }
-
-    /** Store a value into a local variable. It can be an argument.
-     * Stack: ...:value
-     *    ->: ...
-     */
-    case class STORE_LOCAL(local: Local) extends Instruction {
-      override def consumed = 1
-      override def produced = 0
-
-      override def consumedTypes = local.kind :: Nil
-
-      override def category = localsCat
-    }
-
-    /** Store a value into a field.
-     * Stack: ...:ref:value   (assuming isStatic=false)
-     *    ->: ...
-     */
-    case class STORE_FIELD(field: Symbol, isStatic: Boolean) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String =
-        "STORE_FIELD "+field + (if (isStatic) " (static)" else " (dynamic)")
-
-      override def consumed = if(isStatic) 1 else 2
-
-      override def produced = 0
-
-      override def consumedTypes =
-        if (isStatic)
-          toTypeKind(field.tpe) :: Nil
-        else
-          REFERENCE(field.owner) :: toTypeKind(field.tpe) :: Nil
-
-      override def category = fldsCat
-    }
-
-    /** Store a value into the 'this' pointer.
-       * Stack: ...:ref
-       *    ->: ...
-       */
-    case class STORE_THIS(kind: TypeKind) extends Instruction {
-      override def consumed = 1
-      override def produced = 0
-      override def consumedTypes = kind :: Nil
-      override def category = localsCat
-    }
-
-    /** Call a primitive function.
-     * Stack: ...:arg1:arg2:...:argn
-     *    ->: ...:result
-     */
-    case class CALL_PRIMITIVE(primitive: Primitive) extends Instruction {
-      override def consumed = primitive match {
-        case Negation(_)       => 1
-        case Test(_,_, true)   => 1
-        case Test(_,_, false)  => 2
-        case Comparison(_,_)   => 2
-        case Arithmetic(NOT,_) => 1
-        case Arithmetic(_,_)   => 2
-        case Logical(_,_)      => 2
-        case Shift(_,_)        => 2
-        case Conversion(_,_)   => 1
-        case ArrayLength(_)    => 1
-        case StringConcat(_)   => 2
-        case StartConcat       => 0
-        case EndConcat         => 1
-      }
-      override def produced = 1
-
-      override def consumedTypes = primitive match {
-        case Negation(kind)        => kind :: Nil
-        case Test(_, kind, true)   => kind :: Nil
-        case Test(_, kind, false)  => kind :: kind :: Nil
-        case Comparison(_, kind)   => kind :: kind :: Nil
-        case Arithmetic(NOT, kind) => kind :: Nil
-        case Arithmetic(_, kind)   => kind :: kind :: Nil
-        case Logical(_, kind)      => kind :: kind :: Nil
-        case Shift(_, kind)        => kind :: INT :: Nil
-        case Conversion(from, _)   => from :: Nil
-        case ArrayLength(kind)     => ARRAY(kind) :: Nil
-        case StringConcat(kind)    => ConcatClass :: kind :: Nil
-        case StartConcat           => Nil
-        case EndConcat             => ConcatClass :: Nil
-      }
-
-      override def producedTypes = primitive match {
-        case Negation(kind)      => kind :: Nil
-        case Test(_, _, true)    => BOOL :: Nil
-        case Test(_, _, false)   => BOOL :: Nil
-        case Comparison(_, _)    => INT :: Nil
-        case Arithmetic(_, kind) => kind :: Nil
-        case Logical(_, kind)    => kind :: Nil
-        case Shift(_, kind)      => kind :: Nil
-        case Conversion(_, to)   => to :: Nil
-        case ArrayLength(_)      => INT :: Nil
-        case StringConcat(_)     => ConcatClass :: Nil
-        case StartConcat         => ConcatClass :: Nil
-        case EndConcat           => REFERENCE(global.definitions.StringClass) :: Nil
-      }
-
-      override def category = arilogCat
-   }
-
-    /** This class represents a CALL_METHOD instruction
-     * STYLE: dynamic / static(StaticInstance)
-     * Stack: ...:ref:arg1:arg2:...:argn
-     *    ->: ...:result
-     *
-     * STYLE: static(StaticClass)
-     * Stack: ...:arg1:arg2:...:argn
-     *    ->: ...:result
-     *
-     */
-    case class CALL_METHOD(method: Symbol, style: InvokeStyle) extends Instruction with ReferenceEquality {
-      def toShortString =
-        "CALL_METHOD " + method.name +" ("+style+")"
-
-      /** Returns a string representation of this instruction */
-      override def toString(): String =
-        "CALL_METHOD " + method.fullName +" ("+style+")"
-
-      var hostClass: Symbol = method.owner
-      def setHostClass(cls: Symbol): this.type = { hostClass = cls; this }
-
-      /** This is specifically for preserving the target native Array type long
-       *  enough that clone() can generate the right call.
-       */
-      var targetTypeKind: TypeKind = UNIT // the default should never be used, so UNIT should fail fast.
-      def setTargetTypeKind(tk: TypeKind) = targetTypeKind = tk
-
-      private def params = method.info.paramTypes
-      private def consumesInstance = style match {
-        case Static(false)  => 0
-        case _              => 1
-      }
-
-      override def consumed = params.length + consumesInstance
-      override def consumedTypes = {
-        val args = params map toTypeKind
-        if (consumesInstance > 0) ObjectReference :: args
-        else args
-      }
-
-      private val producedList = toTypeKind(method.info.resultType) match {
-        case UNIT                      => Nil
-        case _ if method.isConstructor => Nil
-        case kind                      => kind :: Nil
-      }
-      override def produced = producedList.size
-      override def producedTypes = producedList
-
-      /** object identity is equality for CALL_METHODs. Needed for
-       *  being able to store such instructions into maps, when more
-       *  than one CALL_METHOD to the same method might exist.
-       */
-
-      override def category = mthdsCat
-    }
-
-    /**
-     * A place holder entry that allows us to parse class files with invoke dynamic
-     * instructions. Because the compiler doesn't yet really understand the
-     * behavior of invokeDynamic, this op acts as a poison pill. Any attempt to analyze
-     * this instruction will cause a failure. The only optimization that
-     * should ever look at non-Scala generated icode is the inliner, and it
-     * has been modified to not examine any method with invokeDynamic
-     * instructions. So if this poison pill ever causes problems then
-     * there's been a serious misunderstanding
-     */
-    // TODO do the real thing
-    case class INVOKE_DYNAMIC(poolEntry: Int) extends Instruction {
-      private def error = sys.error("INVOKE_DYNAMIC is not fully implemented and should not be analyzed")
-      override def consumed = error
-      override def produced = error
-      override def producedTypes = error
-      override def category = error
-    }
-
-    case class BOX(boxType: TypeKind) extends Instruction {
-      assert(boxType.isValueType && (boxType ne UNIT)) // documentation
-      override def toString(): String = "BOX " + boxType
-      override def consumed = 1
-      override def consumedTypes = boxType :: Nil
-      override def produced = 1
-      override def producedTypes = BOXED(boxType) :: Nil
-      override def category = objsCat
-    }
-
-    case class UNBOX(boxType: TypeKind) extends Instruction {
-      assert(boxType.isValueType && !boxType.isInstanceOf[BOXED] && (boxType ne UNIT)) // documentation
-      override def toString(): String = "UNBOX " + boxType
-      override def consumed = 1
-      override def consumedTypes = ObjectReferenceList
-      override def produced = 1
-      override def producedTypes = boxType :: Nil
-      override def category = objsCat
-    }
-
-    /** Create a new instance of a class through the specified constructor
-     * Stack: ...:arg1:arg2:...:argn
-     *    ->: ...:ref
-     */
-    case class NEW(kind: REFERENCE) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String = "NEW "+ kind
-
-      override def consumed = 0
-
-      override def produced = 1
-
-      override def producedTypes = kind :: Nil
-
-      /** The corresponding constructor call. */
-      var init: CALL_METHOD = _
-
-      override def category = objsCat
-    }
-
-
-    /** This class represents a CREATE_ARRAY instruction
-     * Stack: ...:size_1:size_2:..:size_n
-     *    ->: ...:arrayref
-     */
-    case class CREATE_ARRAY(elem: TypeKind, dims: Int) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String ="CREATE_ARRAY "+elem + " x " + dims
-
-      override def consumed = dims
-
-      override def consumedTypes = List.fill(dims)(INT)
-      override def produced = 1
-
-      override def producedTypes = ARRAY(elem) :: Nil
-
-      override def category = arraysCat
-    }
-
-    /** This class represents a IS_INSTANCE instruction
-     * Stack: ...:ref
-     *    ->: ...:result(boolean)
-     */
-    case class IS_INSTANCE(typ: TypeKind) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String ="IS_INSTANCE "+typ
-
-      override def consumed = 1
-      override def produced = 1
-      override def consumedTypes = ObjectReferenceList
-      override def producedTypes = BOOL :: Nil
-
-      override def category = castsCat
-    }
-
-    /** This class represents a CHECK_CAST instruction
-     * Stack: ...:ref(oldtype)
-     *    ->: ...:ref(typ <=: oldtype)
-     */
-    case class CHECK_CAST(typ: TypeKind) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String ="CHECK_CAST "+typ
-
-      override def consumed = 1
-      override def produced = 1
-      override def consumedTypes = ObjectReferenceList
-      override def producedTypes = typ :: Nil
-
-      override def category = castsCat
-    }
-
-    /** This class represents a SWITCH instruction
-     * Stack: ...:index(int)
-     *    ->: ...:
-     *
-     * The tags array contains one entry per label, each entry consisting of
-     * an array of ints, any of which will trigger the jump to the corresponding label.
-     * labels should contain an extra label, which is the 'default' jump.
-     */
-    case class SWITCH(tags: List[List[Int]], labels: List[BasicBlock]) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String ="SWITCH ..."
-
-      override def consumed = 1
-      override def produced = 0
-
-      override def consumedTypes = INT :: Nil
-
-      def flatTagsCount: Int = { var acc = 0; var rest = tags; while(rest.nonEmpty) { acc += rest.head.length; rest = rest.tail }; acc } // a one-liner
-
-      override def category = jumpsCat
-    }
-
-    /** This class represents a JUMP instruction
-     * Stack: ...
-     *    ->: ...
-     */
-    case class JUMP(whereto: BasicBlock) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String ="JUMP "+whereto.label
-
-      override def consumed = 0
-      override def produced = 0
-
-      override def category = jumpsCat
-    }
-
-    /** This class represents a CJUMP instruction
-     * It compares the two values on the stack with the 'cond' test operator
-     * Stack: ...:value1:value2
-     *    ->: ...
-     */
-    case class CJUMP(successBlock: BasicBlock,
-		     failureBlock: BasicBlock,
-		     cond: TestOp,
-                     kind: TypeKind) extends Instruction
-    {
-
-      /** Returns a string representation of this instruction */
-      override def toString(): String = (
-        "CJUMP (" + kind + ")" +
-        cond + " ? "+successBlock.label+" : "+failureBlock.label
-      )
-
-      override def consumed = 2
-      override def produced = 0
-
-      override def consumedTypes = kind :: kind :: Nil
-
-      override def category = jumpsCat
-    }
-
-    /** This class represents a CZJUMP instruction
-     * It compares the one value on the stack and zero with the 'cond' test operator
-     * Stack: ...:value:
-     *    ->: ...
-     */
-    case class CZJUMP(successBlock: BasicBlock,
-                      failureBlock: BasicBlock,
-                      cond: TestOp,
-                      kind: TypeKind) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String = (
-        "CZJUMP (" + kind + ")" +
-        cond + " ? "+successBlock.label+" : "+failureBlock.label
-      )
-
-      override def consumed = 1
-      override def produced = 0
-
-      override def consumedTypes = kind :: Nil
-      override def category = jumpsCat
-    }
-
-
-    /** This class represents a RETURN instruction
-     * Stack: ...
-     *    ->: ...
-     */
-    case class RETURN(kind: TypeKind) extends Instruction {
-      override def consumed = if (kind == UNIT) 0 else 1
-      override def produced = 0
-
-      override def consumedTypes = if (kind == UNIT) Nil else kind :: Nil
-
-      override def category = retCat
-    }
-
-    /** This class represents a THROW instruction
-     * Stack: ...:Throwable(Ref)
-     *    ->: ...:
-     */
-    case class THROW(clasz: Symbol) extends Instruction {
-      /** PP to ID: We discussed parameterizing LOAD_EXCEPTION but
-       *  not THROW, which came about organically.  It seems like the
-       *  right thing, but can you confirm?
-       */
-      override def toString = "THROW(" + clasz.name + ")"
-
-      override def consumed = 1
-      override def produced = 0
-
-      override def consumedTypes = toTypeKind(clasz.tpe) :: Nil
-
-      override def category = retCat
-    }
-
-    /** This class represents a DROP instruction
-     * Stack: ...:something
-     *    ->: ...
-     */
-    case class DROP (typ: TypeKind) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String ="DROP "+typ
-
-      override def consumed = 1
-      override def produced = 0
-
-      override def consumedTypes = typ :: Nil
-
-      override def category = stackCat
-    }
-
-    /** This class represents a DUP instruction
-     * Stack: ...:something
-     *    ->: ...:something:something
-     */
-    case class DUP (typ: TypeKind) extends Instruction {
-      override def consumed = 1
-      override def produced = 2
-      override def consumedTypes = typ :: Nil
-      override def producedTypes = typ :: typ :: Nil
-      override def category = stackCat
-    }
-
-    /** This class represents a MONITOR_ENTER instruction
-     * Stack: ...:object(ref)
-     *    ->: ...:
-     */
-    case class MONITOR_ENTER() extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String ="MONITOR_ENTER"
-
-      override def consumed = 1
-      override def produced = 0
-
-      override def consumedTypes = ObjectReference :: Nil
-
-      override def category = objsCat
-    }
-
-    /** This class represents a MONITOR_EXIT instruction
-     * Stack: ...:object(ref)
-     *    ->: ...:
-     */
-    case class MONITOR_EXIT() extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String ="MONITOR_EXIT"
-
-      override def consumed = 1
-
-      override def produced = 0
-
-      override def consumedTypes = ObjectReference :: Nil
-
-      override def category = objsCat
-    }
-
-    /** A local variable becomes visible at this point in code.
-     *  Used only for generating precise local variable tables as
-     *  debugging information.
-     */
-    case class SCOPE_ENTER(lv: Local) extends Instruction {
-      override def toString(): String = "SCOPE_ENTER " + lv
-      override def consumed = 0
-      override def produced = 0
-      override def category = localsCat
-    }
-
-    /** A local variable leaves its scope at this point in code.
-     *  Used only for generating precise local variable tables as
-     *  debugging information.
-     */
-    case class SCOPE_EXIT(lv: Local) extends Instruction {
-      override def toString(): String = "SCOPE_EXIT " + lv
-      override def consumed = 0
-      override def produced = 0
-      override def category = localsCat
-    }
-
-    /** Fake instruction. It designates the VM who pushes an exception
-     *  on top of the /empty/ stack at the beginning of each exception handler.
-     *  Note: Unlike other instructions, it consumes all elements on the stack!
-     *        then pushes one exception instance.
-     */
-    case class LOAD_EXCEPTION(clasz: Symbol) extends Instruction {
-      override def consumed = sys.error("LOAD_EXCEPTION does clean the whole stack, no idea how many things it consumes!")
-      override def produced = 1
-      override def producedTypes = REFERENCE(clasz) :: Nil
-      override def category = stackCat
-    }
-
-    /** This class represents a method invocation style. */
-    sealed abstract class InvokeStyle {
-      /** Is this a dynamic method call? */
-      def isDynamic: Boolean = false
-
-      /** Is this a static method call? */
-      def isStatic: Boolean = false
-
-      def isSuper: Boolean = false
-
-      /** Is this an instance method call? */
-      def hasInstance: Boolean = true
-
-      /** Returns a string representation of this style. */
-      override def toString(): String
-    }
-
-    /** Virtual calls.
-     *  On JVM, translated to either `invokeinterface` or `invokevirtual`.
-     */
-    case object Dynamic extends InvokeStyle {
-      override def isDynamic = true
-      override def toString(): String = "dynamic"
-    }
-
-    /**
-     * Special invoke:
-     *   Static(true)  is used for calls to private members, ie `invokespecial` on JVM.
-     *   Static(false) is used for calls to class-level instance-less static methods, ie `invokestatic` on JVM.
-     */
-    case class Static(onInstance: Boolean) extends InvokeStyle {
-      override def isStatic    = true
-      override def hasInstance = onInstance
-      override def toString(): String = {
-        if(onInstance) "static-instance"
-        else           "static-class"
-      }
-    }
-
-    /** Call through super[mix].
-     *  On JVM, translated to `invokespecial`.
-     */
-    case class SuperCall(mix: Name) extends InvokeStyle {
-      override def isSuper = true
-      override def toString(): String = { "super(" + mix + ")" }
-    }
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala b/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala
deleted file mode 100644
index 27bf836484..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala
+++ /dev/null
@@ -1,247 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-
-package scala.tools.nsc
-package backend
-package icode
-
-import java.io.PrintWriter
-
-trait Primitives { self: ICodes =>
-
-  /** This class represents a primitive operation. */
-  class Primitive {
-  }
-
-
-  // type : (type) => type
-  // range: type <- { BOOL, Ix, Ux, Rx }
-  // jvm  : {i, l, f, d}neg
-  case class Negation(kind: TypeKind) extends Primitive
-
-  // type : zero ? (type) => BOOL : (type,type) => BOOL
-  // range: type <- { BOOL, Ix, Ux, Rx, REF }
-  // jvm  : if{eq, ne, lt, ge, le, gt}, if{null, nonnull}
-  //        if_icmp{eq, ne, lt, ge, le, gt}, if_acmp{eq,ne}
-  case class Test(op: TestOp, kind: TypeKind,  zero: Boolean)  extends Primitive
-
-  // type : (type,type) => I4
-  // range: type <- { Ix, Ux, Rx }
-  // jvm  : lcmp, {f, d}cmp{l, g}
-  case class Comparison(op: ComparisonOp, kind: TypeKind) extends Primitive
-
-  // type : (type,type) => type
-  // range: type <- { Ix, Ux, Rx }
-  // jvm  : {i, l, f, d}{add, sub, mul, div, rem}
-  case class Arithmetic(op: ArithmeticOp, kind: TypeKind) extends Primitive
-
-  // type : (type,type) => type
-  // range: type <- { BOOL, Ix, Ux }
-  // jvm  : {i, l}{and, or, xor}
-  case class Logical(op: LogicalOp, kind: TypeKind) extends Primitive
-
-  // type : (type,I4) => type
-  // range: type <- { Ix, Ux }
-  // jvm  : {i, l}{shl, ushl, shr}
-  case class Shift(op: ShiftOp, kind: TypeKind) extends Primitive
-
-  // type : (src) => dst
-  // range: src,dst <- { Ix, Ux, Rx }
-  // jvm  : i2{l, f, d}, l2{i, f, d}, f2{i, l, d}, d2{i, l, f}, i2{b, c, s}
-  case class Conversion(src: TypeKind, dst: TypeKind) extends Primitive
-
-  // type : (Array[REF]) => I4
-  // range: type <- { BOOL, Ix, Ux, Rx, REF }
-  // jvm  : arraylength
-  case class ArrayLength(kind: TypeKind) extends Primitive
-
-  // type : (buf,el) => buf
-  // range: lf,rg <- { BOOL, Ix, Ux, Rx, REF, STR }
-  // jvm  : It should call the appropriate 'append' method on StringBuffer
-  case class StringConcat(el: TypeKind) extends Primitive
-
-  /** Signals the beginning of a series of concatenations.
-   *  On the JVM platform, it should create a new StringBuffer
-   */
-  case object StartConcat extends Primitive
-
-  /**
-   * type: (buf) => STR
-   * jvm : It should turn the StringBuffer into a String.
-   */
-  case object EndConcat extends Primitive
-
-  /** Pretty printer for primitives */
-  class PrimitivePrinter(out: PrintWriter) {
-    def print(s: String): PrimitivePrinter = {
-      out.print(s)
-      this
-    }
-  }
-
-  /** This class represents a comparison operation. */
-  class ComparisonOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case CMPL => "CMPL"
-      case CMP  => "CMP"
-      case CMPG => "CMPG"
-      case _ => throw new RuntimeException("ComparisonOp unknown case")
-    }
-  }
-
-  /** A comparison operation with -1 default for NaNs */
-  case object CMPL extends ComparisonOp
-
-  /** A comparison operation with no default for NaNs */
-  case object CMP extends ComparisonOp
-
-    /** A comparison operation with +1 default for NaNs */
-  case object CMPG extends ComparisonOp
-
-
-  /** This class represents a test operation. */
-  sealed abstract class TestOp {
-
-    /** Returns the negation of this operation. */
-    def negate(): TestOp
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String
-
-    /** used only from GenASM */
-    def opcodeIF(): Int
-
-    /** used only from GenASM */
-    def opcodeIFICMP(): Int
-
-  }
-
-  /** An equality test */
-  case object EQ extends TestOp {
-    def negate() = NE
-    override def toString() = "EQ"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFEQ
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPEQ
-  }
-
-  /** A non-equality test */
-  case object NE extends TestOp {
-    def negate() = EQ
-    override def toString() = "NE"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFNE
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPNE
-  }
-
-  /** A less-than test */
-  case object LT extends TestOp {
-    def negate() = GE
-    override def toString() = "LT"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFLT
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPLT
-  }
-
-  /** A greater-than-or-equal test */
-  case object GE extends TestOp {
-    def negate() = LT
-    override def toString() = "GE"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFGE
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPGE
-  }
-
-  /** A less-than-or-equal test */
-  case object LE extends TestOp {
-    def negate() = GT
-    override def toString() = "LE"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFLE
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPLE
-  }
-
-  /** A greater-than test */
-  case object GT extends TestOp {
-    def negate() = LE
-    override def toString() = "GT"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFGT
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPGT
-  }
-
-  /** This class represents an arithmetic operation. */
-  class ArithmeticOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case ADD => "ADD"
-      case SUB => "SUB"
-      case MUL => "MUL"
-      case DIV => "DIV"
-      case REM => "REM"
-      case NOT => "NOT"
-      case _   => throw new RuntimeException("ArithmeticOp unknown case")
-    }
-  }
-
-  /** An arithmetic addition operation */
-  case object ADD extends ArithmeticOp
-
-  /** An arithmetic subtraction operation */
-  case object SUB extends ArithmeticOp
-
-  /** An arithmetic multiplication operation */
-  case object MUL extends ArithmeticOp
-
-  /** An arithmetic division operation */
-  case object DIV extends ArithmeticOp
-
-  /** An arithmetic remainder operation */
-  case object REM extends ArithmeticOp
-
-  /** Bitwise negation. */
-  case object NOT extends ArithmeticOp
-
-  /** This class represents a shift operation. */
-  class ShiftOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case LSL =>  "LSL"
-      case ASR =>  "ASR"
-      case LSR =>  "LSR"
-      case _  => throw new RuntimeException("ShitOp unknown case")
-    }
-  }
-
-  /** A logical shift to the left */
-  case object LSL extends ShiftOp
-
-  /** An arithmetic shift to the right */
-  case object ASR extends ShiftOp
-
-  /** A logical shift to the right */
-  case object LSR extends ShiftOp
-
-  /** This class represents a logical operation. */
-  class LogicalOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case AND => "AND"
-      case OR  => "OR"
-      case XOR => "XOR"
-      case _  => throw new RuntimeException("LogicalOp unknown case")
-    }
-  }
-
-  /** A bitwise AND operation */
-  case object AND extends LogicalOp
-
-  /** A bitwise OR operation */
-  case object OR extends LogicalOp
-
-  /** A bitwise XOR operation */
-  case object XOR extends LogicalOp
-}
-
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Printers.scala b/src/compiler/scala/tools/nsc/backend/icode/Printers.scala
deleted file mode 100644
index 1fe33f78e7..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/Printers.scala
+++ /dev/null
@@ -1,126 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend
-package icode
-
-import java.io.PrintWriter
-
-trait Printers { self: ICodes =>
-  import global._
-
-  class TextPrinter(writer: PrintWriter, lin: Linearizer) {
-    private var margin = 0
-    private var out = writer
-
-    final val TAB = 2
-
-    def setWriter(w: PrintWriter) { out = w }
-
-    def indent() { margin += TAB }
-    def undent() { margin -= TAB }
-
-    def print(s: String) { out.print(s) }
-    def print(o: Any) { print(o.toString()) }
-
-    def println(s: String) {
-      print(s)
-      println()
-    }
-
-    def println() {
-      out.println()
-      var i = 0
-      while (i < margin) {
-        print(" ")
-        i += 1
-      }
-    }
-
-    def printList[A](l: List[A], sep: String): Unit = l match {
-      case Nil =>
-      case x :: Nil => print(x)
-      case x :: xs  => print(x); print(sep); printList(xs, sep)
-    }
-
-    def printList[A](pr: A => Unit)(l: List[A], sep: String): Unit = l match {
-      case Nil =>
-      case x :: Nil => pr(x)
-      case x :: xs  => pr(x); print(sep); printList(pr)(xs, sep)
-    }
-
-    def printClass(cls: IClass) {
-      print(cls.symbol.toString()); print(" extends ")
-      printList(cls.symbol.info.parents, ", ")
-      indent(); println(" {")
-      println("// fields:")
-      cls.fields.foreach(printField); println()
-      println("// methods")
-      cls.methods.foreach(printMethod)
-      undent(); println()
-      println("}")
-    }
-
-    def printField(f: IField) {
-      print(f.symbol.keyString); print(" ")
-      print(f.symbol.nameString); print(": ")
-      println(f.symbol.info.toString())
-    }
-
-    def printMethod(m: IMethod) {
-      print("def "); print(m.symbol.name)
-      print("("); printList(printParam)(m.params, ", "); print(")")
-      print(": "); print(m.symbol.info.resultType)
-
-      if (!m.isAbstractMethod) {
-        println(" {")
-        println("locals: " + m.locals.mkString("", ", ", ""))
-        println("startBlock: " + m.startBlock)
-        println("blocks: " + m.code.blocks.mkString("[", ",", "]"))
-        println()
-        lin.linearize(m) foreach printBlock
-        println("}")
-
-        indent(); println("Exception handlers: ")
-        m.exh foreach printExceptionHandler
-
-        undent(); println()
-      } else
-        println()
-    }
-
-    def printParam(p: Local) {
-      print(p.sym.name); print(": "); print(p.sym.info)
-      print(" ("); print(p.kind); print(")")
-    }
-
-    def printExceptionHandler(e: ExceptionHandler) {
-      indent()
-      println("catch (" + e.cls.simpleName + ") in " + e.covered.toSeq.sortBy(_.label) + " starting at: " + e.startBlock)
-      println("consisting of blocks: " + e.blocks)
-      undent()
-      println("with finalizer: " + e.finalizer)
-      //      linearizer.linearize(e.startBlock) foreach printBlock;
-    }
-
-    def printBlock(bb: BasicBlock) {
-      print(bb.label)
-      if (bb.loopHeader) print("[loop header]")
-      print(": ")
-      if (settings.debug) print("pred: " + bb.predecessors + " succs: " + bb.successors + " flags: " + bb.flagsString)
-      indent(); println()
-      bb.toList foreach printInstruction
-      undent(); println()
-    }
-
-    def printInstruction(i: Instruction) {
-//      if (settings.Xdce.value)
-//        print(if (i.useful) "   " else " * ");
-      if (i.pos.isDefined) print(i.pos.line.toString + "\t") else print("?\t")
-      println(i.toString())
-    }
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Repository.scala b/src/compiler/scala/tools/nsc/backend/icode/Repository.scala
deleted file mode 100644
index 10d57df4a3..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/Repository.scala
+++ /dev/null
@@ -1,47 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-
-package scala.tools.nsc
-package backend
-package icode
-
-import scala.collection._
-
-/**
- *  @author Iulian Dragos
- */
-trait Repository {
-  val global: Global
-  import global._
-  import icodes._
-
-  val loaded: mutable.Map[Symbol, IClass] = perRunCaches.newMap()
-
-  /** Is the given class available as icode? */
-  def available(sym: Symbol) = classes.contains(sym) || loaded.contains(sym)
-
-  /** The icode of the given class, if available */
-  def icode(sym: Symbol): Option[IClass] = (classes get sym) orElse (loaded get sym)
-
-  /** Load bytecode for given symbol. */
-  def load(sym: Symbol): Boolean = {
-    try {
-      val (c1, c2) = icodeReader.readClass(sym)
-
-      assert(c1.symbol == sym || c2.symbol == sym, "c1.symbol = %s, c2.symbol = %s, sym = %s".format(c1.symbol, c2.symbol, sym))
-      loaded += (c1.symbol -> c1)
-      loaded += (c2.symbol -> c2)
-
-      true
-    } catch {
-      case e: Throwable => // possible exceptions are MissingRequirementError, IOException and TypeError -> no better common supertype
-        log("Failed to load %s. [%s]".format(sym.fullName, e.getMessage))
-        if (settings.debug) { e.printStackTrace }
-
-        false
-    }
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
deleted file mode 100644
index a6d0d3b9fa..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
+++ /dev/null
@@ -1,438 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend
-package icode
-
-/* A type case
-
-    case UNIT            =>
-    case BOOL            =>
-    case BYTE            =>
-    case SHORT           =>
-    case CHAR            =>
-    case INT             =>
-    case LONG            =>
-    case FLOAT           =>
-    case DOUBLE          =>
-    case REFERENCE(cls)  =>
-    case ARRAY(elem)     =>
-
-*/
-
-trait TypeKinds { self: ICodes =>
-  import global._
-  import definitions.{ ArrayClass, AnyRefClass, ObjectClass, NullClass, NothingClass, arrayType }
-
-  /** A map from scala primitive Types to ICode TypeKinds */
-  lazy val primitiveTypeMap: Map[Symbol, TypeKind] = {
-    import definitions._
-    Map(
-      UnitClass     -> UNIT,
-      BooleanClass  -> BOOL,
-      CharClass     -> CHAR,
-      ByteClass     -> BYTE,
-      ShortClass    -> SHORT,
-      IntClass      -> INT,
-      LongClass     -> LONG,
-      FloatClass    -> FLOAT,
-      DoubleClass   -> DOUBLE
-    )
-  }
-  /** Reverse map for toType */
-  private lazy val reversePrimitiveMap: Map[TypeKind, Symbol] =
-    (primitiveTypeMap map (_.swap)).toMap
-
-  /** This class represents a type kind. Type kinds
-   * represent the types that the VM know (or the ICode
-   * view of what VMs know).
-   */
-  sealed abstract class TypeKind {
-    def maxType(other: TypeKind): TypeKind
-
-    def toType: Type = reversePrimitiveMap get this map (_.tpe) getOrElse {
-      this match {
-        case REFERENCE(cls) => cls.tpe_*
-        case ARRAY(elem)    => arrayType(elem.toType)
-        case _              => abort("Unknown type kind.")
-      }
-    }
-
-    def isReferenceType           = false
-    def isArrayType               = false
-    def isValueType               = false
-    def isBoxedType               = false
-    final def isRefOrArrayType    = isReferenceType || isArrayType
-    final def isNothingType       = this == NothingReference
-    final def isNullType          = this == NullReference
-    final def isInterfaceType     = this match {
-      case REFERENCE(cls) if cls.isInterface || cls.isTrait => true
-      case _                                                => false
-    }
-
-    /** On the JVM,
-     *    BOOL, BYTE, CHAR, SHORT, and INT
-     *  are like Ints for the purposes of calculating the lub.
-     */
-    def isIntSizedType: Boolean = false
-
-    /** On the JVM, similar to isIntSizedType except that BOOL isn't integral while LONG is. */
-    def isIntegralType: Boolean = false
-
-    /** On the JVM, FLOAT and DOUBLE. */
-    def isRealType: Boolean = false
-
-    final def isNumericType: Boolean = isIntegralType | isRealType
-
-    /** Simple subtyping check */
-    def <:<(other: TypeKind): Boolean
-
-    /**
-     * this is directly assignable to other if no coercion or
-     * casting is needed to convert this to other. It's a distinct
-     * relationship from <:< because on the JVM, BOOL, BYTE, CHAR,
-     * SHORT need no coercion to INT even though JVM arrays
-     * are covariant, ARRAY[SHORT] is not a subtype of ARRAY[INT]
-     */
-    final def isAssignabledTo(other: TypeKind): Boolean = other match {
-      case INT  => this.isIntSizedType
-      case _    => this <:< other
-    }
-
-    /** Is this type a category 2 type in JVM terms? (ie, is it LONG or DOUBLE?) */
-    def isWideType: Boolean = false
-
-    /** The number of dimensions for array types. */
-    def dimensions: Int = 0
-
-    protected def uncomparable(thisKind: String, other: TypeKind): Nothing =
-      abort("Uncomparable type kinds: " + thisKind + " with " + other)
-
-    protected def uncomparable(other: TypeKind): Nothing =
-      uncomparable(this.toString, other)
-  }
-
-  sealed abstract class ValueTypeKind extends TypeKind {
-    override def isValueType = true
-    override def toString = {
-      this.getClass.getName stripSuffix "$" dropWhile (_ != '$') drop 1
-    }
-    def <:<(other: TypeKind): Boolean = this eq other
-  }
-
-  /**
-   * The least upper bound of two typekinds. They have to be either
-   * REFERENCE or ARRAY kinds.
-   *
-   * The lub is based on the lub of scala types.
-   */
-  def lub(a: TypeKind, b: TypeKind): TypeKind = {
-    /* The compiler's lub calculation does not order classes before traits.
-     * This is apparently not wrong but it is inconvenient, and causes the
-     * icode checker to choke when things don't match up.  My attempts to
-     * alter the calculation at the compiler level were failures, so in the
-     * interests of a working icode checker I'm making the adjustment here.
-     *
-     * Example where we'd like a different answer:
-     *
-     *   abstract class Tom
-     *   case object Bob extends Tom
-     *   case object Harry extends Tom
-     *   List(Bob, Harry)  // compiler calculates "Product with Tom" rather than "Tom with Product"
-     *
-     * Here we make the adjustment by rewinding to a pre-erasure state and
-     * sifting through the parents for a class type.
-     */
-    def lub0(tk1: TypeKind, tk2: TypeKind): Type = enteringUncurry {
-      val tp = global.lub(List(tk1.toType, tk2.toType))
-      val (front, rest) = tp.parents span (_.typeSymbol.isTrait)
-
-      if (front.isEmpty || rest.isEmpty || rest.head.typeSymbol == ObjectClass) tp
-      else rest.head
-    }
-
-    def isIntLub = (
-      (a == INT && b.isIntSizedType) ||
-      (b == INT && a.isIntSizedType)
-    )
-
-    if (a == b) a
-    else if (a.isNothingType) b
-    else if (b.isNothingType) a
-    else if (a.isBoxedType || b.isBoxedType) AnyRefReference  // we should do better
-    else if (isIntLub) INT
-    else if (a.isRefOrArrayType && b.isRefOrArrayType) {
-      if (a.isNullType) b
-      else if (b.isNullType) a
-      else toTypeKind(lub0(a, b))
-    }
-    else throw new CheckerException("Incompatible types: " + a + " with " + b)
-  }
-
-  /** The unit value */
-  case object UNIT extends ValueTypeKind {
-    def maxType(other: TypeKind) = other match {
-      case UNIT | REFERENCE(NothingClass)   => UNIT
-      case _                                => uncomparable(other)
-    }
-  }
-
-  /** A boolean value */
-  case object BOOL extends ValueTypeKind {
-    override def isIntSizedType = true
-    def maxType(other: TypeKind) = other match {
-      case BOOL | REFERENCE(NothingClass)   => BOOL
-      case _                                => uncomparable(other)
-    }
-  }
-
-  /** Note that the max of Char/Byte and Char/Short is Int, because
-   *  neither strictly encloses the other due to unsignedness.
-   *  See ticket #2087 for a consequence.
-   */
-
-  /** A 1-byte signed integer */
-  case object BYTE extends ValueTypeKind {
-    override def isIntSizedType = true
-    override def isIntegralType = true
-    def maxType(other: TypeKind) = {
-      if (other == BYTE || other.isNothingType) BYTE
-      else if (other == CHAR) INT
-      else if (other.isNumericType) other
-      else uncomparable(other)
-    }
-  }
-
-  /** A 2-byte signed integer */
-  case object SHORT extends ValueTypeKind {
-    override def isIntSizedType = true
-    override def isIntegralType = true
-    override def maxType(other: TypeKind) = other match {
-      case BYTE | SHORT | REFERENCE(NothingClass) => SHORT
-      case CHAR                                   => INT
-      case INT | LONG | FLOAT | DOUBLE            => other
-      case _                                      => uncomparable(other)
-    }
-  }
-
-  /** A 2-byte UNSIGNED integer */
-  case object CHAR extends ValueTypeKind {
-    override def isIntSizedType = true
-    override def isIntegralType = true
-    override def maxType(other: TypeKind) = other match {
-      case CHAR | REFERENCE(NothingClass) => CHAR
-      case BYTE | SHORT                   => INT
-      case INT | LONG | FLOAT | DOUBLE    => other
-      case _                              => uncomparable(other)
-    }
-  }
-
-  /** A 4-byte signed integer */
-  case object INT extends ValueTypeKind {
-    override def isIntSizedType = true
-    override def isIntegralType = true
-    override def maxType(other: TypeKind) = other match {
-      case BYTE | SHORT | CHAR | INT | REFERENCE(NothingClass)  => INT
-      case LONG | FLOAT | DOUBLE                                => other
-      case _                                                    => uncomparable(other)
-    }
-  }
-
-  /** An 8-byte signed integer */
-  case object LONG extends ValueTypeKind {
-    override def isIntegralType = true
-    override def isWideType = true
-    override def maxType(other: TypeKind): TypeKind =
-      if (other.isIntegralType || other.isNothingType) LONG
-      else if (other.isRealType) DOUBLE
-      else uncomparable(other)
-  }
-
-  /** A 4-byte floating point number */
-  case object FLOAT extends ValueTypeKind {
-    override def isRealType = true
-    override def maxType(other: TypeKind): TypeKind =
-      if (other == DOUBLE) DOUBLE
-      else if (other.isNumericType || other.isNothingType) FLOAT
-      else uncomparable(other)
-  }
-
-  /** An 8-byte floating point number */
-  case object DOUBLE extends ValueTypeKind {
-    override def isRealType = true
-    override def isWideType = true
-    override def maxType(other: TypeKind): TypeKind =
-      if (other.isNumericType || other.isNothingType) DOUBLE
-      else uncomparable(other)
-  }
-
-  /** A class type. */
-  final case class REFERENCE(cls: Symbol) extends TypeKind {
-    override def toString = "REF(" + cls + ")"
-    assert(cls ne null,
-           "REFERENCE to null class symbol.")
-    assert(cls != ArrayClass,
-           "REFERENCE to Array is not allowed, should be ARRAY[..] instead")
-    assert(cls != NoSymbol,
-           "REFERENCE to NoSymbol not allowed!")
-
-    /**
-     * Approximate `lub`. The common type of two references is
-     * always AnyRef. For 'real' least upper bound wrt to subclassing
-     * use method 'lub'.
-     */
-    override def maxType(other: TypeKind) = other match {
-      case REFERENCE(_) | ARRAY(_)  => AnyRefReference
-      case _                        => uncomparable("REFERENCE", other)
-    }
-
-    /** Checks subtyping relationship. */
-    def <:<(other: TypeKind) = isNothingType || (other match {
-      case REFERENCE(cls2)  => cls.tpe <:< cls2.tpe
-      case ARRAY(_)         => cls == NullClass
-      case _                => false
-    })
-    override def isReferenceType = true
-  }
-
-  def ArrayN(elem: TypeKind, dims: Int): ARRAY = {
-    assert(dims > 0)
-    if (dims == 1) ARRAY(elem)
-    else ARRAY(ArrayN(elem, dims - 1))
-  }
-
-  final case class ARRAY(elem: TypeKind) extends TypeKind {
-    override def toString    = "ARRAY[" + elem + "]"
-    override def isArrayType = true
-    override def dimensions  = 1 + elem.dimensions
-
-    /** The ultimate element type of this array. */
-    def elementKind: TypeKind = elem match {
-      case a @ ARRAY(_) => a.elementKind
-      case k            => k
-    }
-
-    /**
-     * Approximate `lub`. The common type of two references is
-     * always AnyRef. For 'real' least upper bound wrt to subclassing
-     * use method 'lub'.
-     */
-    override def maxType(other: TypeKind) = other match {
-      case ARRAY(elem2) if elem == elem2  => ARRAY(elem)
-      case ARRAY(_) | REFERENCE(_)        => AnyRefReference
-      case _                              => uncomparable("ARRAY", other)
-    }
-
-    /** Array subtyping is covariant, as in Java. Necessary for checking
-     *  code that interacts with Java. */
-    def <:<(other: TypeKind) = other match {
-      case ARRAY(elem2)                         => elem <:< elem2
-      case REFERENCE(AnyRefClass | ObjectClass) => true // TODO: platform dependent!
-      case _                                    => false
-    }
-  }
-
-  /** A boxed value. */
-  case class BOXED(kind: TypeKind) extends TypeKind {
-    override def isBoxedType = true
-
-    override def maxType(other: TypeKind) = other match {
-      case BOXED(`kind`)                      => this
-      case REFERENCE(_) | ARRAY(_) | BOXED(_) => AnyRefReference
-      case _                                  => uncomparable("BOXED", other)
-    }
-
-    /** Checks subtyping relationship. */
-    def <:<(other: TypeKind) = other match {
-      case BOXED(`kind`)                        => true
-      case REFERENCE(AnyRefClass | ObjectClass) => true // TODO: platform dependent!
-      case _                                    => false
-    }
-  }
-
- /**
-  * Dummy TypeKind to represent the ConcatClass in a platform-independent
-  * way. For JVM it would have been a REFERENCE to 'StringBuffer'.
-  */
-  case object ConcatClass extends TypeKind {
-    override def toString = "ConcatClass"
-    def <:<(other: TypeKind): Boolean = this eq other
-
-    /**
-     * Approximate `lub`. The common type of two references is
-     * always AnyRef. For 'real' least upper bound wrt to subclassing
-     * use method 'lub'.
-     */
-    override def maxType(other: TypeKind) = other match {
-      case REFERENCE(_) => AnyRefReference
-      case _            => uncomparable(other)
-    }
-  }
-
-  ////////////////// Conversions //////////////////////////////
-
-  /** Return the TypeKind of the given type
-   *
-   *  Call to dealiasWiden fixes #3003 (follow type aliases). Otherwise,
-   *  arrayOrClassType below would return ObjectReference.
-   */
-  def toTypeKind(t: Type): TypeKind = t.dealiasWiden match {
-    case ThisType(ArrayClass)            => ObjectReference
-    case ThisType(sym)                   => REFERENCE(sym)
-    case SingleType(_, sym)              => primitiveOrRefType(sym)
-    case ConstantType(_)                 => toTypeKind(t.underlying)
-    case TypeRef(_, sym, args)           => primitiveOrClassType(sym, args)
-    case ClassInfoType(_, _, ArrayClass) => abort("ClassInfoType to ArrayClass!")
-    case ClassInfoType(_, _, sym)        => primitiveOrRefType(sym)
-
-    // !!! Iulian says types which make no sense after erasure should not reach here,
-    // which includes the ExistentialType, AnnotatedType, RefinedType.  I don't know
-    // if the first two cases exist because they do or as a defensive measure, but
-    // at the time I added it, RefinedTypes were indeed reaching here.
-    case ExistentialType(_, t)           => toTypeKind(t)
-    case AnnotatedType(_, t)             => toTypeKind(t)
-    case RefinedType(parents, _)         => parents map toTypeKind reduceLeft lub
-    // For sure WildcardTypes shouldn't reach here either, but when
-    // debugging such situations this may come in handy.
-    // case WildcardType                    => REFERENCE(ObjectClass)
-    case norm => abort(
-      "Unknown type: %s, %s [%s, %s] TypeRef? %s".format(
-        t, norm, t.getClass, norm.getClass, t.isInstanceOf[TypeRef]
-      )
-    )
-  }
-
-  /** Return the type kind of a class, possibly an array type.
-   */
-  private def arrayOrClassType(sym: Symbol, targs: List[Type]) = sym match {
-    case ArrayClass       => ARRAY(toTypeKind(targs.head))
-    case _ if sym.isClass => newReference(sym)
-    case _                =>
-      assert(sym.isType, sym) // it must be compiling Array[a]
-      ObjectReference
-  }
-  /** Interfaces have to be handled delicately to avoid introducing
-   *  spurious errors, but if we treat them all as AnyRef we lose too
-   *  much information.
-   */
-  private def newReference(sym: Symbol): TypeKind = {
-    // Can't call .toInterface (at this phase) or we trip an assertion.
-    // See PackratParser#grow for a method which fails with an apparent mismatch
-    // between "object PackratParsers$class" and "trait PackratParsers"
-    if (sym.isImplClass) {
-      // pos/spec-List.scala is the sole failure if we don't check for NoSymbol
-      val traitSym = sym.owner.info.decl(tpnme.interfaceName(sym.name))
-      if (traitSym != NoSymbol)
-        return REFERENCE(traitSym)
-    }
-    REFERENCE(sym)
-  }
-
-  private def primitiveOrRefType(sym: Symbol) =
-    primitiveTypeMap.getOrElse(sym, newReference(sym))
-  private def primitiveOrClassType(sym: Symbol, targs: List[Type]) =
-    primitiveTypeMap.getOrElse(sym, arrayOrClassType(sym, targs))
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
deleted file mode 100644
index 57d51dad49..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
+++ /dev/null
@@ -1,82 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend
-package icode
-
-/** This trait ...
- *
- *  @author  Iulian Dragos
- *  @version 1.0
- */
-trait TypeStacks {
-  self: ICodes =>
-
-  /* This class simulates the type of the operand
-   * stack of the ICode.
-   */
-  type Rep = List[TypeKind]
-
-  class TypeStack(var types: Rep) {
-    if (types.nonEmpty)
-      checkerDebug("Created " + this)
-
-    def this() = this(Nil)
-    def this(that: TypeStack) = this(that.types)
-
-    def length: Int = types.length
-    def isEmpty     = length == 0
-    def nonEmpty    = length != 0
-
-    /** Push a type on the type stack. UNITs are ignored. */
-    def push(t: TypeKind) = {
-      if (t != UNIT)
-        types = t :: types
-    }
-
-    def head: TypeKind = types.head
-
-    /** Removes the value on top of the stack, and returns it. It assumes
-     *  the stack contains at least one element.
-     */
-    def pop: TypeKind = {
-      val t = types.head
-      types = types.tail
-      t
-    }
-
-    /** Return the topmost two values on the stack. It assumes the stack
-     *  is large enough. Topmost element first.
-     */
-    def pop2: (TypeKind, TypeKind) = (pop, pop)
-
-    /** Return the topmost three values on the stack. It assumes the stack
-     *  is large enough. Topmost element first.
-     */
-    def pop3: (TypeKind, TypeKind, TypeKind) = (pop, pop, pop)
-
-    /** Drop the first n elements of the stack. */
-    def pop(n: Int): List[TypeKind] = {
-      val prefix = types.take(n)
-      types = types.drop(n)
-      prefix
-    }
-
-    def apply(n: Int): TypeKind = types(n)
-
-    /* This method returns a String representation of the stack */
-    override def toString() =
-      if (types.isEmpty) "[]"
-      else types.mkString("[", " ", "]")
-
-    override def hashCode() = types.hashCode()
-    override def equals(other: Any): Boolean = other match {
-      case x: TypeStack => x.types == types
-      case _            => false
-    }
-  }
-
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
deleted file mode 100644
index 9d48d7a0d3..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
+++ /dev/null
@@ -1,553 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala
-package tools.nsc
-package backend.icode.analysis
-
-import scala.collection.{ mutable, immutable }
-
-/** A modified copy-propagation like analysis. It
- *  is augmented with a record-like value which is used
- *  to represent closures.
- *
- *  @author Iulian Dragos
- */
-abstract class CopyPropagation {
-  val global: Global
-  import global._
-  import icodes._
-
-  /** Locations can be local variables, this, and fields. */
-  abstract sealed class Location
-  case class LocalVar(l: Local) extends Location
-  case class Field(r: Record, sym: Symbol) extends Location
-  case object This extends Location
-
-  /** Values that can be on the stack. */
-  sealed abstract class Value { }
-  case class Record(cls: Symbol, bindings: mutable.Map[Symbol, Value]) extends Value { }
-  /** The value of some location in memory. */
-  case class Deref(l: Location) extends Value
-
-  /** The boxed value of some location. */
-  case class Boxed(l: Location) extends Value
-
-  /** The constant value c. */
-  case class Const(c: Constant) extends Value
-
-  /** Unknown. */
-  case object Unknown extends Value
-
-  /** The bottom record. */
-  object AllRecords extends Record(NoSymbol, mutable.HashMap[Symbol, Value]())
-
-  /** The lattice for this analysis.   */
-  object copyLattice extends SemiLattice {
-    type Bindings = mutable.Map[Location, Value]
-
-    def emptyBinding = mutable.HashMap[Location, Value]()
-
-    class State(val bindings: Bindings, var stack: List[Value]) {
-
-      override def hashCode = bindings.hashCode + stack.hashCode
-      /* comparison with bottom is reference equality! */
-      override def equals(that: Any): Boolean = that match {
-        case x: State =>
-          if ((this eq bottom) || (this eq top) || (x eq bottom) || (x eq top)) this eq x
-          else bindings == x.bindings && stack == x.stack
-        case _ =>
-          false
-      }
-
-      /* Return an alias for the given local. It returns the last
-       * local in the chain of aliased locals. Cycles are not allowed
-       * to exist (by construction).
-       */
-      def getAlias(l: Local): Local = {
-        var target = l
-        var stop = false
-
-        while (bindings.isDefinedAt(LocalVar(target)) && !stop) {
-          bindings(LocalVar(target)) match {
-            case Deref(LocalVar(t)) => target = t
-            case _ => stop = true
-          }
-        }
-        target
-      }
-
-      /* Return the value bound to the given local. */
-      def getBinding(l: Local): Value = {
-        def loop(lv: Local): Option[Value] = (bindings get LocalVar(lv)) match {
-          case Some(Deref(LocalVar(t))) => loop(t)
-          case x                        => x
-        }
-        loop(l) getOrElse Deref(LocalVar(l))
-      }
-
-      /** Return a local which contains the same value as this field, if any.
-       * If the field holds a reference to a local, the returned value is the
-       * binding of that local.
-       */
-      def getFieldValue(r: Record, f: Symbol): Option[Value] = r.bindings get f map {
-        case Deref(LocalVar(l))             => getBinding(l)
-        case target @ Deref(Field(r1, f1))  => getFieldValue(r1, f1) getOrElse target
-        case target                         => target
-      }
-
-      /** The same as getFieldValue, but never returns Record/Field values. Use
-       *  this when you want to find a replacement for a field value (either a local,
-       *  or a constant/this value).
-       */
-      def getFieldNonRecordValue(r: Record, f: Symbol): Option[Value] = {
-        assert(r.bindings contains f, "Record " + r + " does not contain a field " + f)
-
-        r.bindings(f) match {
-          case Deref(LocalVar(l)) =>
-            val alias = getAlias(l)
-            val derefAlias = Deref(LocalVar(alias))
-
-            Some(getBinding(alias) match {
-              case Record(_, _)         => derefAlias
-              case Deref(Field(r1, f1)) => getFieldNonRecordValue(r1, f1) getOrElse derefAlias
-              case Boxed(_)             => derefAlias
-              case v                    => v
-            })
-          case Deref(Field(r1, f1)) => getFieldNonRecordValue(r1, f1)
-          case target @ Deref(This) => Some(target)
-          case target @ Const(k)    => Some(target)
-          case _                    => None
-        }
-      }
-
-      override def toString(): String =
-        "\nBindings: " + bindings + "\nStack: " + stack
-
-      def dup: State = {
-        val b: Bindings = mutable.HashMap()
-        b ++= bindings
-        new State(b, stack)
-      }
-    }
-
-    type Elem = State
-
-    val top    = new State(emptyBinding, Nil)
-    val bottom = new State(emptyBinding, Nil)
-
-    val exceptionHandlerStack = Unknown :: Nil
-
-    def lub2(exceptional: Boolean)(a: Elem, b: Elem): Elem = {
-      if (a eq bottom) b
-      else if (b eq bottom) a
-      else if (a == b) a
-      else {
-        //assert(!(a.stack eq exceptionHandlerStack) && !(b.stack eq exceptionHandlerStack))
-        val resStack =
-          if (exceptional) exceptionHandlerStack
-          else {
-//            if (a.stack.length != b.stack.length)
-//              throw new LubException(a, b, "Invalid stacks in states: ");
-            (a.stack, b.stack).zipped map { (v1, v2) =>
-              if (v1 == v2) v1 else Unknown
-            }
-          }
-
-/*        if (a.stack.length != b.stack.length)
-          throw new LubException(a, b, "Invalid stacks in states: ");
-        val resStack = List.map2(a.stack, b.stack) { (v1, v2) =>
-          if (v1 == v2) v1 else Unknown
-        }
-        */
-        val resBindings = mutable.HashMap[Location, Value]()
-
-        for ((k, v) <- a.bindings if b.bindings.isDefinedAt(k) && v == b.bindings(k))
-          resBindings += (k -> v)
-        new State(resBindings, resStack)
-      }
-    }
-  }
-
-  final class CopyAnalysis extends DataFlowAnalysis[copyLattice.type] {
-    type P = BasicBlock
-    val lattice = copyLattice
-
-    var method: IMethod = _
-
-    def init(m: IMethod) {
-      this.method = m
-
-      init {
-        worklist += m.startBlock
-        worklist ++= (m.exh map (_.startBlock))
-        m foreachBlock { b =>
-          in(b)  = lattice.bottom
-          out(b) = lattice.bottom
-          assert(out.contains(b), out)
-          debuglog("CopyAnalysis added point: " + b)
-        }
-        m.exh foreach { e =>
-          in(e.startBlock) = new copyLattice.State(copyLattice.emptyBinding, copyLattice.exceptionHandlerStack)
-        }
-
-        // first block is special: it's not bottom, but a precisely defined state with no bindings
-        in(m.startBlock) = new lattice.State(lattice.emptyBinding, Nil)
-      }
-    }
-
-    override def run() {
-      forwardAnalysis(blockTransfer)
-      if (settings.debug) {
-        linearizer.linearize(method).foreach(b => if (b != method.startBlock)
-          assert(in(b) != lattice.bottom,
-            "Block " + b + " in " + this.method + " has input equal to bottom -- not visited?"))
-      }
-    }
-
-    def blockTransfer(b: BasicBlock, in: lattice.Elem): lattice.Elem =
-      b.iterator.foldLeft(in)(interpret)
-
-    import opcodes._
-
-    private def retain[A, B](map: mutable.Map[A, B])(p: (A, B) => Boolean) = {
-      for ((k, v) <- map ; if !p(k, v)) map -= k
-      map
-    }
-
-    /** Abstract interpretation for one instruction. */
-    def interpret(in: copyLattice.Elem, i: Instruction): copyLattice.Elem = {
-      var out = in.dup
-      debuglog("- " + i + "\nin: " + in + "\n")
-
-      i match {
-        case THIS(_) =>
-          out.stack = Deref(This) :: out.stack
-
-        case CONSTANT(k) =>
-          if (k.tag != UnitTag)
-            out.stack = Const(k) :: out.stack
-
-        case LOAD_ARRAY_ITEM(_) =>
-          out.stack = (Unknown :: out.stack.drop(2))
-
-        case LOAD_LOCAL(local) =>
-          out.stack = Deref(LocalVar(local)) :: out.stack
-
-        case LOAD_FIELD(field, isStatic) =>
-          if (isStatic)
-            out.stack = Unknown :: out.stack; /* ignore static fields */
-          else {
-            val v1 = in.stack match {
-              case (r @ Record(cls, bindings)) :: xs =>
-                Deref(Field(r, field))
-
-              case Deref(LocalVar(l)) :: _ =>
-                in.getBinding(l) match {
-                  case r @ Record(cls, bindings) => Deref(Field(r, field))
-                  case _ => Unknown
-                }
-
-              case Deref(Field(r, f)) :: _ =>
-                val fld = in.getFieldValue(r, f)
-                fld match {
-                  case Some(r @ Record(cls, bindings)) if bindings.isDefinedAt(f) =>
-                  	in.getFieldValue(r, f).getOrElse(Unknown)
-                  case _ => Unknown
-                }
-
-              case _ => Unknown
-            }
-            out.stack = v1 :: out.stack.drop(1)
-          }
-
-        case LOAD_MODULE(module) =>
-          out.stack = Unknown :: out.stack
-
-        case STORE_ARRAY_ITEM(kind) =>
-          out.stack = out.stack.drop(3)
-
-        case STORE_LOCAL(local) =>
-          cleanReferencesTo(out, LocalVar(local))
-          in.stack match {
-            case Unknown :: xs => ()
-            case v :: vs =>
-              v match {
-                case Deref(LocalVar(other)) =>
-                  if (other != local)
-                    out.bindings += (LocalVar(local) -> v)
-                case _ =>
-                  out.bindings += (LocalVar(local) -> v)
-              }
-            case Nil =>
-              sys.error("Incorrect icode in " + method + ". Expecting something on the stack.")
-          }
-          out.stack = out.stack drop 1
-
-        case STORE_THIS(_) =>
-          cleanReferencesTo(out, This)
-          out.stack = out.stack drop 1
-
-        case STORE_FIELD(field, isStatic) =>
-          if (isStatic)
-            out.stack = out.stack.drop(1)
-          else {
-            out.stack = out.stack.drop(2)
-            cleanReferencesTo(out, Field(AllRecords, field))
-            in.stack match {
-              case v :: Record(_, bindings) :: vs =>
-                bindings += (field -> v)
-              case _ => ()
-            }
-          }
-
-        case CALL_PRIMITIVE(primitive) =>
-          // TODO: model primitives
-          out.stack = Unknown :: out.stack.drop(i.consumed)
-
-        case CALL_METHOD(method, style) => style match {
-          case Dynamic =>
-            out = simulateCall(in, method, static = false)
-
-          case Static(onInstance) =>
-            if (onInstance) {
-              val obj = out.stack.drop(method.info.paramTypes.length).head
-//              if (method.isPrimaryConstructor) {
-              if (method.isPrimaryConstructor) {
-                obj match {
-                  case Record(_, bindings) =>
-                    for (v <- out.stack.take(method.info.paramTypes.length + 1)
-                         if v ne obj) {
-                       bindings ++= getBindingsForPrimaryCtor(in, method)
-                    }
-                  case _ => ()
-                }
-                // put the Record back on the stack and remove the 'returned' value
-                out.stack = out.stack.drop(1 + method.info.paramTypes.length)
-              } else
-                out = simulateCall(in, method, static = false)
-            } else
-              out = simulateCall(in, method, static = true)
-
-          case SuperCall(_) =>
-            out = simulateCall(in, method, static = false)
-        }
-
-        case BOX(tpe) =>
-          val top = out.stack.head match {
-            case Deref(loc) => Boxed(loc)
-            case _          => Unknown
-          }
-          out.stack = top :: out.stack.tail
-
-        case UNBOX(tpe) =>
-          val top = out.stack.head
-          top match {
-            case Boxed(loc) => Deref(loc) :: out.stack.tail
-            case _          => out.stack = Unknown :: out.stack.drop(1)
-          }
-
-        case NEW(kind) =>
-          val v1 = kind match {
-            case REFERENCE(cls) => Record(cls, mutable.HashMap[Symbol, Value]())
-            case _              => Unknown
-          }
-          out.stack = v1 :: out.stack
-
-        case CREATE_ARRAY(elem, dims) =>
-          out.stack = Unknown :: out.stack.drop(dims)
-
-        case IS_INSTANCE(tpe) =>
-          out.stack = Unknown :: out.stack.drop(1)
-
-        case CHECK_CAST(tpe) =>
-          out.stack = Unknown :: out.stack.drop(1)
-
-        case SWITCH(tags, labels) =>
-          out.stack = out.stack.drop(1)
-
-        case JUMP(whereto) =>
-          ()
-
-        case CJUMP(success, failure, cond, kind) =>
-          out.stack = out.stack.drop(2)
-
-        case CZJUMP(success, failure, cond, kind) =>
-          out.stack = out.stack.drop(1)
-
-        case RETURN(kind) =>
-          if (kind != UNIT)
-            out.stack = out.stack.drop(1)
-
-        case THROW(_) =>
-          out.stack = out.stack.drop(1)
-
-        case DROP(kind) =>
-          out.stack = out.stack.drop(1)
-
-        case DUP(kind) =>
-          out.stack = out.stack.head :: out.stack
-
-        case MONITOR_ENTER() =>
-          out.stack = out.stack.drop(1)
-
-        case MONITOR_EXIT() =>
-          out.stack = out.stack.drop(1)
-
-        case SCOPE_ENTER(_) | SCOPE_EXIT(_) =>
-          ()
-
-        case LOAD_EXCEPTION(_) =>
-          out.stack = Unknown :: Nil
-
-        case _ =>
-          dumpClassesAndAbort("Unknown instruction: " + i)
-      }
-      out
-    } /* def interpret */
-
-    /** Remove all references to this local variable from both stack
-     *  and bindings. It is called when a new assignment destroys
-     *  previous copy-relations.
-     */
-    final def cleanReferencesTo(s: copyLattice.State, target: Location) {
-      def cleanRecord(r: Record): Record = {
-        retain(r.bindings) { (loc, value) =>
-          (value match {
-            case Deref(loc1) if (loc1 == target) => false
-            case Boxed(loc1) if (loc1 == target)  => false
-            case _ => true
-          }) && (target match {
-            case Field(AllRecords, sym1) => !(loc == sym1)
-            case _ => true
-          })
-        }
-        r
-      }
-
-      s.stack = s.stack map { v => v match {
-        case Record(_, bindings) =>
-          cleanRecord(v.asInstanceOf[Record])
-        case Boxed(loc1) if (loc1 == target) => Unknown
-        case _ => v
-      }}
-
-      retain(s.bindings) { (loc, value) =>
-        (value match {
-          case Deref(loc1) if (loc1 == target) => false
-          case Boxed(loc1) if (loc1 == target) => false
-          case rec @ Record(_, _) =>
-            cleanRecord(rec)
-            true
-          case _ => true
-        }) &&
-        (loc match {
-          case l: Location if (l == target) => false
-          case _ => true
-        })
-      }
-    }
-
-    /** Update the state `s` after the call to `method`.
-     *  The stack elements are dropped and replaced by the result of the call.
-     *  If the method is impure, all bindings to record fields are cleared.
-     */
-    final def simulateCall(state: copyLattice.State, method: Symbol, static: Boolean): copyLattice.State = {
-      val out = new copyLattice.State(state.bindings, state.stack)
-      out.stack = out.stack.drop(method.info.paramTypes.length + (if (static) 0 else 1))
-      if (method.info.resultType != definitions.UnitTpe && !method.isConstructor)
-        out.stack = Unknown :: out.stack
-      if (!isPureMethod(method))
-        invalidateRecords(out)
-      out
-    }
-
-    /** Drop everything known about mutable record fields.
-     *
-     *  A simple escape analysis would help here. Some of the records we
-     *  track never leak to other methods, therefore they can not be changed.
-     *  We should not drop their bindings in this case. A closure object
-     *  would be such an example. Some complications:
-     *
-     *   - outer pointers. An closure escapes as an outer pointer to another
-     *     nested closure.
-     */
-    final def invalidateRecords(state: copyLattice.State) {
-      def shouldRetain(sym: Symbol): Boolean = {
-        if (sym.isMutable)
-          log("dropping binding for " + sym.fullName)
-        !sym.isMutable
-      }
-      state.stack = state.stack map { v => v match {
-        case Record(cls, bindings) =>
-          retain(bindings) { (sym, _) => shouldRetain(sym) }
-          Record(cls, bindings)
-        case _ => v
-      }}
-
-      retain(state.bindings) { (loc, value) =>
-        value match {
-          case Deref(Field(rec, sym)) => shouldRetain(sym)
-          case Boxed(Field(rec, sym)) => shouldRetain(sym)
-          case _ => true
-        }
-      }
-    }
-
-    /** Return bindings from an object fields to the values on the stack. This
-     *  method has to find the correct mapping from fields to the order in which
-     *  they are passed on the stack. It works for primary constructors.
-     */
-    private def getBindingsForPrimaryCtor(in: copyLattice.State, ctor: Symbol): mutable.Map[Symbol, Value] = {
-      val paramAccessors = ctor.owner.constrParamAccessors
-      var values         = in.stack.take(1 + ctor.info.paramTypes.length).reverse.drop(1)
-      val bindings       = mutable.HashMap[Symbol, Value]()
-
-      debuglog("getBindings for: " + ctor + " acc: " + paramAccessors)
-
-      var paramTypes = ctor.tpe.paramTypes
-      val diff = paramTypes.length - paramAccessors.length
-      diff match {
-        case 0 => ()
-        case 1 if ctor.tpe.paramTypes.head == ctor.owner.rawowner.tpe =>
-          // it's an unused outer
-          debuglog("considering unused outer at position 0 in " + ctor.tpe.paramTypes)
-          paramTypes = paramTypes.tail
-          values = values.tail
-        case _ =>
-          debuglog("giving up on " + ctor + "(diff: " + diff + ")")
-          return bindings
-      }
-
-      // this relies on having the same order in paramAccessors and
-      // the arguments on the stack. It should be the same!
-      for ((p, i) <- paramAccessors.zipWithIndex) {
-//        assert(p.tpe == paramTypes(i), "In: " + ctor.fullName
-//               + " having acc: " + (paramAccessors map (_.tpe))+ " vs. params" + paramTypes
-//               + "\n\t failed at pos " + i + " with " + p.tpe + " == " + paramTypes(i))
-        if (p.tpe == paramTypes(i))
-          bindings += (p -> values.head)
-        values = values.tail
-      }
-
-      debuglog("\t" + bindings)
-      bindings
-    }
-
-    /** Is symbol `m` a pure method?
-     */
-    final def isPureMethod(m: Symbol): Boolean =
-      m.isGetter // abstract getters are still pure, as we 'know'
-
-    final override def toString() = (
-      if (method eq null) List("<null>")
-      else method.blocks map { b =>
-        "\nIN(%s):\t Bindings: %s".format(b.label, in(b).bindings) +
-        "\nIN(%s):\t Stack: %s".format(b.label, in(b).stack)
-      }
-    ).mkString
-
-  } /* class CopyAnalysis */
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala
deleted file mode 100644
index a378998f8f..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala
+++ /dev/null
@@ -1,92 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-
-package scala
-package tools.nsc
-package backend.icode.analysis
-
-import scala.collection.{ mutable, immutable }
-
-/** A generic framework for data flow analysis.
- */
-trait DataFlowAnalysis[L <: SemiLattice] {
-  /** A type for program points. */
-  type P <: ProgramPoint[P]
-  val  lattice: L
-
-  val worklist: mutable.Set[P]          = new mutable.LinkedHashSet
-  val in:  mutable.Map[P, lattice.Elem] = new mutable.HashMap
-  val out: mutable.Map[P, lattice.Elem] = new mutable.HashMap
-  val visited: mutable.HashSet[P]       = new mutable.HashSet
-
-  /** collect statistics? */
-  var stat = true
-
-  /** the number of times we iterated before reaching a fixpoint. */
-  var iterations = 0
-
-  /* Implement this function to initialize the worklist.  */
-  def init(f: => Unit): Unit = {
-    iterations = 0
-    in.clear(); out.clear(); worklist.clear(); visited.clear()
-    f
-  }
-
-  def run(): Unit
-
-  /** Implements forward dataflow analysis: the transfer function is
-   *  applied when inputs to a Program point change, to obtain the new
-   *  output value.
-   *
-   *  @param f the transfer function.
-   */
-  def forwardAnalysis(f: (P, lattice.Elem) => lattice.Elem): Unit = try {
-    while (!worklist.isEmpty) {
-      if (stat) iterations += 1
-      //Console.println("worklist in: " + worklist);
-      val point = worklist.iterator.next(); worklist -= point; visited += point
-      //Console.println("taking out point: " + point + " worklist out: " + worklist);
-      val output = f(point, in(point))
-
-      if ((lattice.bottom == out(point)) || output != out(point)) {
-        // Console.println("Output changed at " + point
-        //                 + " from: " + out(point) + " to: " + output
-        //                 + " for input: " + in(point) + " and they are different: " + (output != out(point)))
-        out(point) = output
-        val succs = point.successors
-        succs foreach { p =>
-          val updated = lattice.lub(in(p) :: (p.predecessors map out.apply), p.exceptionHandlerStart)
-          if(updated != in(p)) {
-            in(p) = updated
-            if (!worklist(p)) { worklist += p; }
-          }
-        }
-      }
-    }
-  } catch {
-    case e: NoSuchElementException =>
-      Console.println("in: " + in.mkString("", "\n", ""))
-      Console.println("out: " + out.mkString("", "\n", ""))
-      e.printStackTrace
-      sys.error("Could not find element " + e.getMessage)
-  }
-
-  def backwardAnalysis(f: (P, lattice.Elem) => lattice.Elem): Unit =
-    while (worklist.nonEmpty) {
-      if (stat) iterations += 1
-      val point = worklist.head
-      worklist -= point
-
-      out(point) = lattice.lub(point.successors map in.apply, exceptional = false) // TODO check for exception handlers
-      val input = f(point, out(point))
-
-      if ((lattice.bottom == in(point)) || input != in(point)) {
-        in(point) = input
-        worklist ++= point.predecessors
-      }
-    }
-
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/Liveness.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/Liveness.scala
deleted file mode 100644
index 939641c3eb..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/Liveness.scala
+++ /dev/null
@@ -1,102 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-
-package scala.tools.nsc
-package backend.icode
-package analysis
-
-import scala.collection.{ mutable, immutable }
-import immutable.ListSet
-
-/**
- * Compute liveness information for local variables.
- *
- * @author Iulian Dragos
- */
-abstract class Liveness {
-  val global: Global
-  import global._
-  import icodes._
-
-  /** The lattice for this analysis.   */
-  object livenessLattice extends SemiLattice {
-    type Elem = Set[Local]
-
-    object top extends ListSet[Local] with ReferenceEquality
-    object bottom extends ListSet[Local] with ReferenceEquality
-
-    def lub2(exceptional: Boolean)(a: Elem, b: Elem): Elem = a ++ b
-  }
-
-  final class LivenessAnalysis extends DataFlowAnalysis[livenessLattice.type] {
-    type P = BasicBlock
-    val lattice                                   = livenessLattice
-    var method: IMethod                           = _
-    val gen: mutable.Map[BasicBlock, Set[Local]]  = perRunCaches.newMap()
-    val kill: mutable.Map[BasicBlock, Set[Local]] = perRunCaches.newMap()
-
-    def init(m: IMethod) {
-      this.method = m
-      gen.clear()
-      kill.clear()
-
-      m foreachBlock { b =>
-        val (g, k) = genAndKill(b)
-        gen  += (b -> g)
-        kill += (b -> k)
-      }
-
-      init {
-        m foreachBlock { b =>
-          worklist += b
-          in(b)  = lattice.bottom
-          out(b) = lattice.bottom
-        }
-      }
-    }
-
-    import opcodes._
-
-    /** Return the gen and kill sets for this block. */
-    def genAndKill(b: BasicBlock): (Set[Local], Set[Local]) = {
-      var genSet = new ListSet[Local]
-      var killSet = new ListSet[Local]
-      for (i <- b) i match {
-        case LOAD_LOCAL(local)  if (!killSet(local)) => genSet = genSet + local
-        case STORE_LOCAL(local) if (!genSet(local))  => killSet = killSet + local
-        case _ => ()
-      }
-      (genSet, killSet)
-    }
-
-    override def run() {
-      backwardAnalysis(blockTransfer)
-      if (settings.debug) {
-        linearizer.linearize(method).foreach(b => if (b != method.startBlock)
-          assert(lattice.bottom != in(b),
-            "Block " + b + " in " + this.method + " has input equal to bottom -- not visited?"))
-      }
-    }
-
-    def blockTransfer(b: BasicBlock, out: lattice.Elem): lattice.Elem =
-      gen(b) ++ (out -- kill(b))
-
-    /** Abstract interpretation for one instruction. Very important:
-     *  liveness is a backward DFA, so this method should be used to compute
-     *  liveness *before* the given instruction `i`.
-     */
-    def interpret(out: lattice.Elem, i: Instruction): lattice.Elem = {
-      debuglog("- " + i + "\nout: " + out + "\n")
-      i match {
-        case LOAD_LOCAL(l)  => out + l
-        case STORE_LOCAL(l) => out - l
-        case _              => out
-      }
-    }
-    override def toString() =
-      (method.blocks map (b => "\nlive-in(%s)=%s\nlive-out(%s)=%s".format(b, in(b), b, out(b)))).mkString
-  } /* Liveness analysis */
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/LubException.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/LubException.scala
deleted file mode 100644
index e91bf7a044..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/LubException.scala
+++ /dev/null
@@ -1,12 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-
-package scala.tools.nsc
-package backend.icode.analysis
-
-class LubException(a: Any, b: Any, msg: String) extends Exception {
-  override def toString() = "Lub error: " + msg + a + b
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/ProgramPoint.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/ProgramPoint.scala
deleted file mode 100644
index 4e4026f526..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/ProgramPoint.scala
+++ /dev/null
@@ -1,18 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-
-package scala.tools.nsc
-package backend.icode.analysis
-
-/** Program points are locations in the program where we want to
- *  assert certain properties through data flow analysis, e.g.
- *  basic blocks.
- */
-trait ProgramPoint[a <: ProgramPoint[a]] {
-  def predecessors: List[a]
-  def successors: List[a]
-  def exceptionHandlerStart: Boolean
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala
deleted file mode 100644
index fecd48ed27..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/ReachingDefinitions.scala
+++ /dev/null
@@ -1,250 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-
-package scala.tools.nsc
-package backend.icode
-package analysis
-
-import scala.collection.{ mutable, immutable }
-import immutable.ListSet
-
-/** Compute reaching definitions. We are only interested in reaching
- *  definitions for local variables, since values on the stack
- *  behave as-if in SSA form: the closest instruction which produces a value
- *  on the stack is a reaching definition.
- */
-abstract class ReachingDefinitions {
-  val global: Global
-  import global._
-  import icodes._
-
-  /** The lattice for reaching definitions. Elements are
-   *  a triple (local variable, basic block, index of instruction of that basic block)
-   */
-  object rdefLattice extends SemiLattice {
-    type Definition = (Local, BasicBlock, Int)
-    type Elem       = IState[ListSet[Definition], Stack]
-    type StackPos   = ListSet[(BasicBlock, Int)]
-    type Stack      = List[StackPos]
-
-    private def referenceEqualSet(name: String) = new ListSet[Definition] with ReferenceEquality {
-      override def toString = "<" + name + ">"
-    }
-
-    val top: Elem    = IState(referenceEqualSet("top"), Nil)
-    val bottom: Elem = IState(referenceEqualSet("bottom"), Nil)
-
-    /** The least upper bound is set inclusion for locals, and pairwise set inclusion for stacks. */
-    def lub2(exceptional: Boolean)(a: Elem, b: Elem): Elem = {
-      if (bottom == a) b
-      else if (bottom == b) a
-      else IState(a.vars ++ b.vars,
-        if (a.stack.isEmpty) b.stack
-        else if (b.stack.isEmpty) a.stack
-        else {
-          // !!! These stacks are with some frequency not of the same size.
-          // I can't reverse engineer the logic well enough to say whether this
-          // indicates a problem.  Even if it doesn't indicate a problem,
-          // it'd be nice not to call zip with mismatched sequences because
-          // it makes it harder to spot the real problems.
-          val result = (a.stack, b.stack).zipped map (_ ++ _)
-          if (settings.debug && (a.stack.length != b.stack.length))
-            devWarning(s"Mismatched stacks in ReachingDefinitions#lub2: ${a.stack}, ${b.stack}, returning $result")
-          result
-        }
-      )
-    }
-  }
-
-  class ReachingDefinitionsAnalysis extends DataFlowAnalysis[rdefLattice.type] {
-    type P = BasicBlock
-    val lattice = rdefLattice
-    import lattice.{ Definition, Stack, Elem, StackPos }
-    var method: IMethod = _
-
-    val gen      = mutable.Map[BasicBlock, ListSet[Definition]]()
-    val kill     = mutable.Map[BasicBlock, ListSet[Local]]()
-    val drops    = mutable.Map[BasicBlock, Int]()
-    val outStack = mutable.Map[BasicBlock, Stack]()
-
-    def init(m: IMethod) {
-      this.method = m
-
-      gen.clear()
-      kill.clear()
-      drops.clear()
-      outStack.clear()
-
-      m foreachBlock { b =>
-        val (g, k) = genAndKill(b)
-        val (d, st) = dropsAndGen(b)
-
-        gen  += (b -> g)
-        kill += (b -> k)
-        drops += (b -> d)
-        outStack += (b -> st)
-      }
-
-      init {
-        m foreachBlock { b =>
-          worklist += b
-          in(b)  = lattice.bottom
-          out(b) = lattice.bottom
-        }
-        m.exh foreach { e =>
-          in(e.startBlock) = lattice.IState(new ListSet[Definition], List(new StackPos))
-        }
-      }
-    }
-
-    import opcodes._
-
-    def genAndKill(b: BasicBlock): (ListSet[Definition], ListSet[Local]) = {
-      var genSet  = ListSet[Definition]()
-      var killSet = ListSet[Local]()
-      for ((STORE_LOCAL(local), idx) <- b.toList.zipWithIndex) {
-        killSet = killSet + local
-        genSet  = updateReachingDefinition(b, idx, genSet)
-      }
-      (genSet, killSet)
-    }
-
-    private def dropsAndGen(b: BasicBlock): (Int, Stack) = {
-      var depth, drops = 0
-      var stackOut: Stack = Nil
-
-      for ((instr, idx) <- b.toList.zipWithIndex) {
-        instr match {
-          case LOAD_EXCEPTION(_)            => ()
-          case _ if instr.consumed > depth  =>
-            drops += (instr.consumed - depth)
-            depth = 0
-            stackOut = Nil
-          case _ =>
-            stackOut = stackOut.drop(instr.consumed)
-            depth -= instr.consumed
-        }
-        var prod = instr.produced
-        depth += prod
-        while (prod > 0) {
-          stackOut ::= ListSet((b, idx))
-          prod -= 1
-        }
-      }
-//      Console.println("drops(" + b + ") = " + drops)
-//      Console.println("stackout(" + b + ") = " + stackOut)
-      (drops, stackOut)
-    }
-
-    override def run() {
-      forwardAnalysis(blockTransfer)
-      if (settings.debug) {
-        linearizer.linearize(method).foreach(b => if (b != method.startBlock)
-          assert(lattice.bottom != in(b),
-            "Block " + b + " in " + this.method + " has input equal to bottom -- not visited? " + in(b)
-                 + ": bot: " + lattice.bottom
-                 + "\nin(b) == bottom: " + (in(b) == lattice.bottom)
-                 + "\nbottom == in(b): " + (lattice.bottom == in(b))))
-      }
-    }
-
-    import opcodes._
-    import lattice.IState
-    def updateReachingDefinition(b: BasicBlock, idx: Int, rd: ListSet[Definition]): ListSet[Definition] = {
-      val STORE_LOCAL(local) = b(idx)
-      val tmp = local
-      (rd filter { case (l, _, _) => l != tmp }) + ((tmp, b, idx))
-    }
-
-    private def blockTransfer(b: BasicBlock, in: lattice.Elem): lattice.Elem = {
-      var locals: ListSet[Definition] = (in.vars filter { case (l, _, _) => !kill(b)(l) }) ++ gen(b)
-      if (locals eq lattice.bottom.vars) locals = new ListSet[Definition]
-      IState(locals, outStack(b) ::: in.stack.drop(drops(b)))
-    }
-
-    /** Return the reaching definitions corresponding to the point after idx. */
-    def interpret(b: BasicBlock, idx: Int, in: lattice.Elem): Elem = {
-      var locals = in.vars
-      var stack  = in.stack
-      val instr  = b(idx)
-
-      instr match {
-        case STORE_LOCAL(l1) =>
-          locals = updateReachingDefinition(b, idx, locals)
-          stack = stack.drop(instr.consumed)
-        case LOAD_EXCEPTION(_) =>
-          stack = Nil
-        case _ =>
-          stack = stack.drop(instr.consumed)
-      }
-
-      var prod = instr.produced
-      while (prod > 0) {
-        stack ::= ListSet((b, idx))
-        prod -= 1
-      }
-
-      IState(locals, stack)
-    }
-
-    /** Return the instructions that produced the 'm' elements on the stack, below given 'depth'.
-     *  for instance, findefs(bb, idx, 1, 1) returns the instructions that might have produced the
-     *  value found below the topmost element of the stack.
-     */
-    def findDefs(bb: BasicBlock, idx: Int, m: Int, depth: Int): List[(BasicBlock, Int)] = if (idx > 0) {
-      assert(bb.closed, bb)
-
-      val instrs = bb.getArray
-      var res: List[(BasicBlock, Int)] = Nil
-      var i = idx
-      var n = m
-      var d = depth
-      // "I look for who produced the 'n' elements below the 'd' topmost slots of the stack"
-      while (n > 0 && i > 0) {
-        i -= 1
-        val prod = instrs(i).produced
-        if (prod > d) {
-          res = (bb, i) :: res
-          n   = n - (prod - d)
-          instrs(i) match {
-            case LOAD_EXCEPTION(_)  => ()
-            case _                  => d = instrs(i).consumed
-          }
-        } else {
-          d -= prod
-          d += instrs(i).consumed
-        }
-      }
-
-      if (n > 0) {
-        val stack = this.in(bb).stack
-        assert(stack.length >= n, "entry stack is too small, expected: " + n + " found: " + stack)
-        stack.drop(d).take(n) foreach { defs =>
-          res = defs.toList ::: res
-        }
-      }
-      res
-    } else {
-      val stack = this.in(bb).stack
-      assert(stack.length >= m, "entry stack is too small, expected: " + m + " found: " + stack)
-      stack.drop(depth).take(m) flatMap (_.toList)
-    }
-
-    /** Return the definitions that produced the topmost 'm' elements on the stack,
-     *  and that reach the instruction at index 'idx' in basic block 'bb'.
-     */
-    def findDefs(bb: BasicBlock, idx: Int, m: Int): List[(BasicBlock, Int)] =
-      findDefs(bb, idx, m, 0)
-
-    override def toString: String = {
-      if (method eq null) "<null>"
-      else method.code.blocks map { b =>
-        "  entry(%s) = %s\n".format(b, in(b)) +
-        "   exit(%s) = %s\n".format(b, out(b))
-      } mkString ("ReachingDefinitions {\n", "\n", "\n}")
-    }
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/SemiLattice.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/SemiLattice.scala
deleted file mode 100644
index f718c705c2..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/SemiLattice.scala
+++ /dev/null
@@ -1,49 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend.icode
-package analysis
-
-/** A complete lattice.
- */
-trait SemiLattice {
-  type Elem <: AnyRef
-
-  /** Hold together local variable and stack state. The
-   *  equals method uses reference equality for top and bottom,
-   *  and structural equality for other values.
-   */
-  final case class IState[V, S](vars: V, stack: S) {
-    override def hashCode = vars.hashCode + stack.hashCode
-    override def equals(other: Any): Boolean = other match {
-      case x: IState[_, _]  =>
-        if ((this eq bottom) || (this eq top) || (x eq bottom) || (x eq top)) this eq x
-        else stack == x.stack && vars == x.vars
-      case _ =>
-        false
-    }
-    private def tstring(x: Any): String = x match {
-      case xs: TraversableOnce[_] => xs map tstring mkString " "
-      case _                      => "" + x
-    }
-    override def toString = "IState(" + tstring(vars) + ", " + tstring(stack) + ")"
-  }
-
-  /** Return the least upper bound of a and b. */
-  def lub2(exceptional: Boolean)(a: Elem, b: Elem): Elem
-
-  /** Return the top element. */
-  def top: Elem
-
-  /** Return the bottom element. */
-  def bottom: Elem
-
-  /** Compute the least upper bound of a list of elements. */
-  def lub(xs: List[Elem], exceptional: Boolean): Elem =
-    if (xs.isEmpty) bottom
-    else try xs reduceLeft lub2(exceptional)
-    catch { case e: LubException  => Console.println("Lub on blocks: " + xs) ; throw e }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala
deleted file mode 100644
index 64c9901a3e..0000000000
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala
+++ /dev/null
@@ -1,725 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala
-package tools.nsc
-package backend.icode.analysis
-
-import scala.collection.{mutable, immutable}
-import java.util.concurrent.TimeUnit
-
-/** A data-flow analysis on types, that works on `ICode`.
- *
- *  @author Iulian Dragos
- */
-abstract class TypeFlowAnalysis {
-  val global: Global
-  import global._
-  import definitions.{ ObjectClass, NothingClass, AnyRefClass, StringClass, ThrowableClass }
-
-  /** The lattice of ICode types.
-   */
-  object typeLattice extends SemiLattice {
-    type Elem = icodes.TypeKind
-
-    val top    = icodes.REFERENCE(ObjectClass)
-    val bottom = icodes.REFERENCE(NothingClass)
-
-    def lub2(exceptional: Boolean)(a: Elem, b: Elem) =
-      if (a eq bottom) b
-      else if (b eq bottom) a
-      else icodes.lub(a, b)
-  }
-
-  /** The lattice of type stacks. It is a straight forward extension of
-   *  the type lattice (lub is pairwise lub of the list elements).
-   */
-  object typeStackLattice extends SemiLattice {
-    import icodes._
-    type Elem = TypeStack
-
-    val top                   = new TypeStack
-    val bottom                = new TypeStack
-    val exceptionHandlerStack = new TypeStack(List(REFERENCE(AnyRefClass)))
-
-    def lub2(exceptional: Boolean)(s1: TypeStack, s2: TypeStack) = {
-      if (s1 eq bottom) s2
-      else if (s2 eq bottom) s1
-      else if ((s1 eq exceptionHandlerStack) || (s2 eq exceptionHandlerStack)) sys.error("merging with exhan stack")
-      else {
-//        if (s1.length != s2.length)
-//          throw new CheckerException("Incompatible stacks: " + s1 + " and " + s2);
-        new TypeStack((s1.types, s2.types).zipped map icodes.lub)
-      }
-    }
-  }
-
-  /** A map which returns the bottom type for unfound elements */
-  class VarBinding extends mutable.HashMap[icodes.Local, icodes.TypeKind] {
-    override def default(l: icodes.Local) = typeLattice.bottom
-
-    def this(o: VarBinding) = {
-      this()
-      this ++= o
-    }
-  }
-
-  /** The type flow lattice contains a binding from local variable
-   *  names to types and a type stack.
-   */
-  object typeFlowLattice extends SemiLattice {
-    type Elem = IState[VarBinding, icodes.TypeStack]
-
-    val top    = new Elem(new VarBinding, typeStackLattice.top)
-    val bottom = new Elem(new VarBinding, typeStackLattice.bottom)
-
-    def lub2(exceptional: Boolean)(a: Elem, b: Elem) = {
-      val IState(env1, _) = a
-      val IState(env2, _) = b
-
-      val resultingLocals = new VarBinding
-      env1 foreach { case (k, v) =>
-        resultingLocals += ((k, typeLattice.lub2(exceptional)(v, env2(k))))
-      }
-      env2 collect { case (k, v) if resultingLocals(k) eq typeLattice.bottom =>
-        resultingLocals += ((k, typeLattice.lub2(exceptional)(v, env1(k))))
-      }
-      val stack =
-        if (exceptional) typeStackLattice.exceptionHandlerStack
-        else typeStackLattice.lub2(exceptional)(a.stack, b.stack)
-
-      IState(resultingLocals, stack)
-    }
-  }
-
-  val timer = new Timer
-
-  class MethodTFA extends DataFlowAnalysis[typeFlowLattice.type] {
-    import icodes._
-    import icodes.opcodes._
-
-    type P = BasicBlock
-    val lattice = typeFlowLattice
-
-    val STRING = icodes.REFERENCE(StringClass)
-    var method: IMethod = _
-
-    /** Initialize the in/out maps for the analysis of the given method. */
-    def init(m: icodes.IMethod) {
-      this.method = m
-      //typeFlowLattice.lubs = 0
-      init {
-        worklist += m.startBlock
-        worklist ++= (m.exh map (_.startBlock))
-        m foreachBlock { b =>
-          in(b)  = typeFlowLattice.bottom
-          out(b) = typeFlowLattice.bottom
-        }
-
-        // start block has var bindings for each of its parameters
-        val entryBindings     = new VarBinding ++= (m.params map (p => ((p, p.kind))))
-        in(m.startBlock) = lattice.IState(entryBindings, typeStackLattice.bottom)
-
-        m.exh foreach { e =>
-          in(e.startBlock) = lattice.IState(in(e.startBlock).vars, typeStackLattice.exceptionHandlerStack)
-        }
-      }
-    }
-
-    def this(m: icodes.IMethod) {
-      this()
-      init(m)
-    }
-
-    def run() = {
-      timer.start()
-      // icodes.lubs0 = 0
-      forwardAnalysis(blockTransfer)
-      timer.stop
-      if (settings.debug) {
-        linearizer.linearize(method).foreach(b => if (b != method.startBlock)
-          assert(visited.contains(b),
-            "Block " + b + " in " + this.method + " has input equal to bottom -- not visited? .." + visited))
-      }
-      // log("" + method.symbol.fullName + " ["  + method.code.blocks.size + " blocks] "
-      //     + "\n\t" + iterations + " iterations: " + t + " ms."
-      //     + "\n\tlubs: " + typeFlowLattice.lubs + " out of which " + icodes.lubs0 + " typer lubs")
-    }
-
-    def blockTransfer(b: BasicBlock, in: lattice.Elem): lattice.Elem = {
-      var result = lattice.IState(new VarBinding(in.vars), new TypeStack(in.stack))
-      var instrs = b.toList
-      while(!instrs.isEmpty) {
-        val i  = instrs.head
-        result = mutatingInterpret(result, i)
-        instrs = instrs.tail
-      }
-      result
-    }
-
-    /** Abstract interpretation for one instruction. */
-    def interpret(in: typeFlowLattice.Elem, i: Instruction): typeFlowLattice.Elem = {
-      val out = lattice.IState(new VarBinding(in.vars), new TypeStack(in.stack))
-      mutatingInterpret(out, i)
-    }
-
-    def mutatingInterpret(out: typeFlowLattice.Elem, i: Instruction): typeFlowLattice.Elem = {
-      val bindings = out.vars
-      val stack = out.stack
-
-      if (settings.debug) {
-        // Console.println("[before] Stack: " + stack);
-        // Console.println(i);
-      }
-      i match {
-
-        case THIS(clasz)     => stack push toTypeKind(clasz.tpe)
-        case CONSTANT(const) => stack push toTypeKind(const.tpe)
-
-        case LOAD_ARRAY_ITEM(kind) =>
-          stack.pop2 match {
-            case (idxKind, ARRAY(elem)) =>
-              assert(idxKind == INT || idxKind == CHAR || idxKind == SHORT || idxKind == BYTE)
-              stack.push(elem)
-            case (_, _) =>
-              stack.push(kind)
-          }
-
-        case LOAD_LOCAL(local) =>
-          val t = bindings(local)
-          stack push (if (t == typeLattice.bottom) local.kind  else t)
-
-        case LOAD_FIELD(field, isStatic) =>
-          if (!isStatic) { stack.pop }
-          stack push toTypeKind(field.tpe)
-
-        case LOAD_MODULE(module)    => stack push toTypeKind(module.tpe)
-        case STORE_ARRAY_ITEM(kind) => stack.pop3
-        case STORE_LOCAL(local)     => val t = stack.pop; bindings += (local -> t)
-        case STORE_THIS(_)          => stack.pop
-
-        case STORE_FIELD(field, isStatic) => if (isStatic) stack.pop else stack.pop2
-
-        case CALL_PRIMITIVE(primitive) =>
-          primitive match {
-            case Negation(kind) => stack.pop; stack.push(kind)
-
-            case Test(_, kind, zero) =>
-              stack.pop
-              if (!zero) { stack.pop }
-              stack push BOOL
-
-            case Comparison(_, _) => stack.pop2; stack push INT
-
-            case Arithmetic(op, kind) =>
-              stack.pop
-              if (op != NOT) { stack.pop }
-              val k = kind match {
-                case BYTE | SHORT | CHAR => INT
-                case _ => kind
-              }
-              stack push k
-
-            case Logical(op, kind)    => stack.pop2; stack push kind
-            case Shift(op, kind)      => stack.pop2; stack push kind
-            case Conversion(src, dst) => stack.pop;  stack push dst
-            case ArrayLength(kind)    => stack.pop;  stack push INT
-            case StartConcat          => stack.push(ConcatClass)
-            case EndConcat            => stack.pop;  stack.push(STRING)
-            case StringConcat(el)     => stack.pop2; stack push ConcatClass
-          }
-
-        case cm @ CALL_METHOD(_, _) =>
-          stack pop cm.consumed
-          cm.producedTypes foreach (stack push _)
-
-        case BOX(kind)   => stack.pop; stack.push(BOXED(kind))
-        case UNBOX(kind) => stack.pop; stack.push(kind)
-
-        case NEW(kind) => stack.push(kind)
-
-        case CREATE_ARRAY(elem, dims) => stack.pop(dims); stack.push(ARRAY(elem))
-
-        case IS_INSTANCE(tpe) => stack.pop; stack.push(BOOL)
-        case CHECK_CAST(tpe)  => stack.pop; stack.push(tpe)
-
-        case _: SWITCH => stack.pop
-        case _: JUMP   => ()
-        case _: CJUMP  => stack.pop2
-        case _: CZJUMP => stack.pop
-
-        case RETURN(kind) => if (kind != UNIT) { stack.pop }
-        case THROW(_)     => stack.pop
-
-        case DROP(kind) => stack.pop
-        case DUP(kind)  => stack.push(stack.head)
-
-        case MONITOR_ENTER() | MONITOR_EXIT()  => stack.pop
-
-        case SCOPE_ENTER(_)  | SCOPE_EXIT(_) => ()
-
-        case LOAD_EXCEPTION(clasz) =>
-          stack.pop(stack.length)
-          stack.push(toTypeKind(clasz.tpe))
-
-        case _ =>
-          dumpClassesAndAbort("Unknown instruction: " + i)
-      }
-      out
-    } // interpret
-
-	abstract class InferredType {
-      /** Return the type kind pointed by this inferred type. */
-      def getKind(in: lattice.Elem): icodes.TypeKind = this match {
-        case Const(k) =>
-          k
-        case TypeOfVar(l: icodes.Local) =>
-          if (in.vars.isDefinedAt(l)) in.vars(l) else l.kind
-        case TypeOfStackPos(n: Int) =>
-          assert(in.stack.length >= n)
-          in.stack(n)
-      }
-    }
-	/** A type that does not depend on input to the transfer function. */
-	case class Const(t: icodes.TypeKind) extends InferredType
-	/** The type of a given local variable. */
-	case class TypeOfVar(l: icodes.Local) extends InferredType
-	/** The type found at a stack position. */
-	case class TypeOfStackPos(n: Int) extends InferredType
-
-	abstract class Gen
-	case class Bind(l: icodes.Local, t: InferredType) extends Gen
-	case class Push(t: InferredType) extends Gen
-
-    /** A flow transfer function of a basic block. */
-	class TransferFunction(consumed: Int, gens: List[Gen]) extends (lattice.Elem => lattice.Elem) {
-	  def apply(in: lattice.Elem): lattice.Elem = {
-        val out = lattice.IState(new VarBinding(in.vars), new TypeStack(in.stack))
-        val stack = out.stack
-
-        out.stack.pop(consumed)
-        for (g <- gens) g match {
-          case Bind(l, t) =>
-            out.vars += (l -> t.getKind(in))
-          case Push(t) =>
-            stack.push(t.getKind(in))
-        }
-        out
-      }
-	}
-  }
-
-  case class CallsiteInfo(bb: icodes.BasicBlock, receiver: Symbol, stackLength: Int, concreteMethod: Symbol)
-
-  /**
-
-    A full type-flow analysis on a method computes in- and out-flows for each basic block (that's what MethodTFA does).
-
-    For the purposes of Inliner, doing so guarantees that an abstract typestack-slot is available by the time an inlining candidate (a CALL_METHOD instruction) is visited.
-    This subclass (MTFAGrowable) of MethodTFA also aims at performing such analysis on CALL_METHOD instructions, with some differences:
-
-      (a) early screening is performed while the type-flow is being computed (in an override of `blockTransfer`) by testing a subset of the conditions that Inliner checks later.
-          The reasoning here is: if the early check fails at some iteration, there's no chance a follow-up iteration (with a yet more lub-ed typestack-slot) will succeed.
-          Failure is sufficient to remove that particular CALL_METHOD from the typeflow's `remainingCALLs`.
-          A forward note: in case inlining occurs at some basic block B, all blocks reachable from B get their CALL_METHOD instructions considered again as candidates
-          (because of the more precise types that -- perhaps -- can be computed).
-
-      (b) in case the early check does not fail, no conclusive decision can be made, thus the CALL_METHOD stays `isOnwatchlist`.
-
-    In other words, `remainingCALLs` tracks those callsites that still remain as candidates for inlining, so that Inliner can focus on those.
-    `remainingCALLs` also caches info about the typestack just before the callsite, so as to spare computing them again at inlining time.
-
-    Besides caching, a further optimization involves skipping those basic blocks whose in-flow and out-flow isn't needed anyway (as explained next).
-    A basic block lacking a callsite in `remainingCALLs`, when visited by the standard algorithm, won't cause any inlining.
-    But as we know from the way type-flows are computed, computing the in- and out-flow for a basic block relies in general on those of other basic blocks.
-    In detail, we want to focus on that sub-graph of the CFG such that control flow may reach a remaining candidate callsite.
-    Those basic blocks not in that subgraph can be skipped altogether. That's why:
-       - `forwardAnalysis()` in `MTFAGrowable` now checks for inclusion of a basic block in `relevantBBs`
-       - same check is performed before adding a block to the worklist, and as part of choosing successors.
-    The bookkeeping supporting on-the-fly pruning of irrelevant blocks requires overriding most methods of the dataflow-analysis.
-
-    The rest of the story takes place in Inliner, which does not visit all of the method's basic blocks but only on those represented in `remainingCALLs`.
-
-    @author Miguel Garcia, http://lampwww.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/
-
-   */
-  class MTFAGrowable extends MethodTFA {
-
-    import icodes._
-
-    val remainingCALLs = mutable.Map.empty[opcodes.CALL_METHOD, CallsiteInfo]
-
-    val preCandidates  = mutable.Set.empty[BasicBlock]
-
-    var callerLin: Traversable[BasicBlock] = null
-
-    override def run {
-
-      timer.start()
-      forwardAnalysis(blockTransfer)
-      timer.stop
-
-      /* Now that `forwardAnalysis(blockTransfer)` has finished, all inlining candidates can be found in `remainingCALLs`,
-         whose keys are callsites and whose values are pieces of information about the typestack just before the callsite in question.
-         In order to keep `analyzeMethod()` simple, we collect in `preCandidates` those basic blocks containing at least one candidate. */
-      preCandidates.clear()
-      for(rc <- remainingCALLs) {
-        preCandidates += rc._2.bb
-      }
-
-      if (settings.debug) {
-        for(b <- callerLin; if (b != method.startBlock) && preCandidates(b)) {
-          assert(visited.contains(b),
-                 "Block " + b + " in " + this.method + " has input equal to bottom -- not visited? .." + visited)
-        }
-      }
-
-    }
-
-    var shrinkedWatchlist = false
-
-    /*
-      This is the method where information cached elsewhere is put to use. References are given those other places that populate those caches.
-
-      The goal is avoiding computing type-flows for blocks we don't need (ie blocks not tracked in `relevantBBs`). The method used to add to `relevantBBs` is `putOnRadar`.
-
-      Moreover, it's often the case that the last CALL_METHOD of interest ("of interest" equates to "being tracked in `isOnWatchlist`) isn't the last instruction on the block.
-      There are cases where the typeflows computed past this `lastInstruction` are needed, and cases when they aren't.
-      The reasoning behind this decision is described in `populatePerimeter()`. All `blockTransfer()` needs to do (in order to know at which instruction it can stop)
-      is querying `isOnPerimeter`.
-
-      Upon visiting a CALL_METHOD that's an inlining candidate, the relevant pieces of information about the pre-instruction typestack are collected for future use.
-      That is, unless the candidacy test fails. The reasoning here is: if such early check fails at some iteration, there's no chance a follow-up iteration
-      (with a yet more lub-ed typestack-slot) will succeed. In case of failure we can safely remove the CALL_METHOD from both `isOnWatchlist` and `remainingCALLs`.
-
-     */
-    override def blockTransfer(b: BasicBlock, in: lattice.Elem): lattice.Elem = {
-      var result = lattice.IState(new VarBinding(in.vars), new TypeStack(in.stack))
-
-      val stopAt = if(isOnPerimeter(b)) lastInstruction(b) else null
-      var isPastLast = false
-
-      var instrs = b.toList
-      while(!isPastLast && !instrs.isEmpty) {
-        val i  = instrs.head
-
-        if(isOnWatchlist(i)) {
-          val cm = i.asInstanceOf[opcodes.CALL_METHOD]
-          val msym = cm.method
-          val paramsLength = msym.info.paramTypes.size
-          val receiver = result.stack.types.drop(paramsLength).head match {
-            case REFERENCE(s) => s
-            case _            => NoSymbol // e.g. the scrutinee is BOX(s) or ARRAY
-          }
-          val concreteMethod = inliner.lookupImplFor(msym, receiver)
-          val isCandidate = {
-            ( inliner.isClosureClass(receiver) || concreteMethod.isEffectivelyFinalOrNotOverridden || receiver.isEffectivelyFinalOrNotOverridden ) &&
-            !blackballed(concreteMethod)
-          }
-          if(isCandidate) {
-            remainingCALLs(cm) = CallsiteInfo(b, receiver, result.stack.length, concreteMethod)
-          } else {
-            remainingCALLs.remove(cm)
-            isOnWatchlist.remove(cm)
-            shrinkedWatchlist = true
-          }
-        }
-
-        isPastLast = (i eq stopAt)
-
-        if(!isPastLast) {
-          result = mutatingInterpret(result, i)
-          instrs = instrs.tail
-        }
-      }
-
-      result
-    } // end of method blockTransfer
-
-    val isOnWatchlist = mutable.Set.empty[Instruction]
-
-    val warnIfInlineFails = mutable.Set.empty[opcodes.CALL_METHOD] // cache for a given IMethod (ie cleared on Inliner.analyzeMethod).
-
-    /* Each time CallerCalleeInfo.isSafeToInline determines a concrete callee is unsafe to inline in the current caller,
-       the fact is recorded in this TFA instance for the purpose of avoiding devoting processing to that callsite next time.
-       The condition of "being unsafe to inline in the current caller" sticks across inlinings and TFA re-inits
-       because it depends on the instructions of the callee, which stay unchanged during the course of `analyzeInc(caller)`
-       (with the caveat of the side-effecting `makePublic` in `helperIsSafeToInline`).*/
-    val knownUnsafe = mutable.Set.empty[Symbol]
-    val knownSafe   = mutable.Set.empty[Symbol]
-    val knownNever  = mutable.Set.empty[Symbol] // `knownNever` needs be cleared only at the very end of the inlining phase (unlike `knownUnsafe` and `knownSafe`)
-    final def blackballed(msym: Symbol): Boolean = { knownUnsafe(msym) || knownNever(msym) }
-
-    val relevantBBs   = mutable.Set.empty[BasicBlock]
-
-    /*
-     * Rationale to prevent some methods from ever being inlined:
-     *
-     *   (1) inlining getters and setters results in exposing a private field,
-     *       which may itself prevent inlining of the caller (at best) or
-     *       lead to situations like SI-5442 ("IllegalAccessError when mixing optimized and unoptimized bytecode")
-     *
-     *   (2) only invocations having a receiver object are considered (ie no static-methods are ever inlined).
-     *       This is taken care of by checking `isDynamic` (ie virtual method dispatch) and `Static(true)` (ie calls to private members)
-     */
-    private def isPreCandidate(cm: opcodes.CALL_METHOD): Boolean = {
-      val msym  = cm.method
-      val style = cm.style
-
-      !blackballed(msym)  &&
-      !msym.isConstructor &&
-      (!msym.isAccessor || inliner.isClosureClass(msym.owner)) &&
-      (style.isDynamic  || (style.hasInstance && style.isStatic))
-    }
-
-    override def init(m: icodes.IMethod) {
-      super.init(m)
-      remainingCALLs.clear()
-      knownUnsafe.clear()
-      knownSafe.clear()
-      // initially populate the watchlist with all callsites standing a chance of being inlined
-      isOnWatchlist.clear()
-      relevantBBs.clear()
-      warnIfInlineFails.clear()
-        /* TODO Do we want to perform inlining in non-finally exception handlers?
-         * Seems counterproductive (the larger the method the less likely it will be JITed.
-         * It's not that putting on radar only `linearizer linearizeAt (m, m.startBlock)` makes for much shorter inlining times (a minor speedup nonetheless)
-         * but the effect on method size could be explored.  */
-      putOnRadar(m.linearizedBlocks(linearizer))
-      populatePerimeter()
-      // usually but not always true (counterexample in SI-6015) `(relevantBBs.isEmpty || relevantBBs.contains(m.startBlock))`
-    }
-
-    def conclusives(b: BasicBlock): List[opcodes.CALL_METHOD] = {
-      knownBeforehand(b) filter { cm => inliner.isMonadicMethod(cm.method) || inliner.hasInline(cm.method) }
-    }
-
-    def knownBeforehand(b: BasicBlock): List[opcodes.CALL_METHOD] = {
-      b.toList collect { case c : opcodes.CALL_METHOD => c } filter { cm => isPreCandidate(cm) && isReceiverKnown(cm) }
-    }
-
-    private def isReceiverKnown(cm: opcodes.CALL_METHOD): Boolean = {
-      cm.method.isEffectivelyFinalOrNotOverridden && cm.method.owner.isEffectivelyFinalOrNotOverridden
-    }
-
-    private def putOnRadar(blocks: Traversable[BasicBlock]) {
-      for(bb <- blocks) {
-        val calls = bb.toList collect { case cm : opcodes.CALL_METHOD => cm }
-        for(c <- calls; if(inliner.hasInline(c.method))) {
-           warnIfInlineFails += c
-        }
-        val preCands = calls filter isPreCandidate
-        isOnWatchlist ++= preCands
-      }
-      relevantBBs ++= blocks
-    }
-
-    /* those BBs in the argument are also included in the result */
-    private def transitivePreds(starters: Traversable[BasicBlock]): Set[BasicBlock] = {
-      val result = mutable.Set.empty[BasicBlock]
-      var toVisit: List[BasicBlock] = starters.toList.distinct
-      while(toVisit.nonEmpty) {
-        val h   = toVisit.head
-        toVisit = toVisit.tail
-        result += h
-        for(p <- h.predecessors; if !result(p) && !toVisit.contains(p)) { toVisit = p :: toVisit }
-      }
-      result.toSet
-    }
-
-    /* A basic block B is "on the perimeter" of the current control-flow subgraph if none of its successors belongs to that subgraph.
-     * In that case, for the purposes of inlining, we're interested in the typestack right before the last inline candidate in B, not in those afterwards.
-     * In particular we can do without computing the outflow at B. */
-    private def populatePerimeter() {
-      isOnPerimeter.clear()
-      var done = true
-      do {
-        val (frontier, toPrune) = (relevantBBs filter hasNoRelevantSuccs) partition isWatching
-        isOnPerimeter ++= frontier
-        relevantBBs   --= toPrune
-        done = toPrune.isEmpty
-      } while(!done)
-
-      lastInstruction.clear()
-      for (b <- isOnPerimeter; lastIns = b.toList.reverse find isOnWatchlist) {
-        lastInstruction += (b -> lastIns.get.asInstanceOf[opcodes.CALL_METHOD])
-      }
-
-      // assertion: "no relevant block can have a predecessor that is on perimeter"
-      assert((for (b <- relevantBBs; if transitivePreds(b.predecessors) exists isOnPerimeter) yield b).isEmpty)
-    }
-
-    private val isOnPerimeter   = mutable.Set.empty[BasicBlock]
-    private val lastInstruction = mutable.Map.empty[BasicBlock, opcodes.CALL_METHOD]
-
-    def hasNoRelevantSuccs(x: BasicBlock): Boolean = { !(x.successors exists relevantBBs) }
-
-    def isWatching(x: BasicBlock): Boolean = (x.toList exists isOnWatchlist)
-
-
-
-
-    /**
-
-      This method is invoked after one or more inlinings have been performed in basic blocks whose in-flow is non-bottom (this makes a difference later).
-      What we know about those inlinings is given by:
-
-        - `staleOut`: These are the blocks where a callsite was inlined.
-                      For each callsite, all instructions in that block before the callsite were left in the block, and the rest moved to an `afterBlock`.
-                      The out-flow of these basic blocks is thus in general stale, that's why we'll add them to the TFA worklist.
-
-        - `inlined` : These blocks were spliced into the method's CFG as part of inlining. Being new blocks, they haven't been visited yet by the typeflow analysis.
-
-        - `staleIn` : These blocks are what `doInline()` calls `afterBlock`s, ie the new home for instructions that previously appeared
-                      after a callsite in a `staleOut` block.
-
-      Based on the above information, we have to bring up-to-date the caches that `forwardAnalysis` and `blockTransfer` use to skip blocks and instructions.
-      Those caches are `relevantBBs` and `isOnPerimeter` (for blocks) and `isOnWatchlist` and `lastInstruction` (for CALL_METHODs).
-      Please notice that all `inlined` and `staleIn` blocks are reachable from `staleOut` blocks.
-
-      The update takes place in two steps:
-
-        (1) `staleOut foreach { so => putOnRadar(linearizer linearizeAt (m, so)) }`
-            This results in initial populations for `relevantBBs` and `isOnWatchlist`.
-            Because of the way `isPreCandidate` reuses previous decision-outcomes that are still valid,
-            this already prunes some candidates standing no chance of being inlined.
-
-        (2) `populatePerimeter()`
-            Based on the CFG-subgraph determined in (1) as reflected in `relevantBBs`,
-            this method detects some blocks whose typeflows aren't needed past a certain CALL_METHOD
-            (not needed because none of its successors is relevant for the purposes of inlining, see `hasNoRelevantSuccs`).
-            The blocks thus chosen are said to be "on the perimeter" of the CFG-subgraph.
-            For each of them, its `lastInstruction` (after which no more typeflows are needed) is found.
-
-     */
-    def reinit(m: icodes.IMethod, staleOut: List[BasicBlock], inlined: scala.collection.Set[BasicBlock], staleIn: scala.collection.Set[BasicBlock]) {
-      if (this.method == null || this.method.symbol != m.symbol) {
-        init(m)
-        return
-      } else if(staleOut.isEmpty && inlined.isEmpty && staleIn.isEmpty) {
-        // this promotes invoking reinit if in doubt, no performance degradation will ensue!
-        return
-      }
-
-      worklist.clear() // calling reinit(f: => Unit) would also clear visited, thus forgetting about blocks visited before reinit.
-
-      // asserts conveying an idea what CFG shapes arrive here:
-      //   staleIn foreach (p => assert( !in.isDefinedAt(p), p))
-      //   staleIn foreach (p => assert(!out.isDefinedAt(p), p))
-      //   inlined foreach (p => assert( !in.isDefinedAt(p), p))
-      //   inlined foreach (p => assert(!out.isDefinedAt(p), p))
-      //   inlined foreach (p => assert(!p.successors.isEmpty || p.lastInstruction.isInstanceOf[icodes.opcodes.THROW], p))
-      //   staleOut foreach (p => assert(  in.isDefinedAt(p), p))
-
-      // remainingCALLs.clear()
-      isOnWatchlist.clear()
-      relevantBBs.clear()
-
-      // never rewrite in(m.startBlock)
-      staleOut foreach { b =>
-        enqueue(b)
-        out(b)    = typeFlowLattice.bottom
-      }
-      // nothing else is added to the worklist, bb's reachable via succs will be tfa'ed
-      blankOut(inlined)
-      blankOut(staleIn)
-      // no need to add startBlocks from m.exh
-
-      staleOut foreach { so => putOnRadar(linearizer linearizeAt (m, so)) }
-      populatePerimeter()
-
-    } // end of method reinit
-
-    /* this is not a general purpose method to add to the worklist,
-     * because the assert is expected to hold only when called from MTFAGrowable.reinit() */
-    private def enqueue(b: BasicBlock) {
-      assert(in(b) ne typeFlowLattice.bottom)
-      if(!worklist.contains(b)) { worklist += b }
-    }
-
-    private def blankOut(blocks: scala.collection.Set[BasicBlock]) {
-      blocks foreach { b =>
-        in(b)  = typeFlowLattice.bottom
-        out(b) = typeFlowLattice.bottom
-      }
-    }
-
-    /*
-      This is basically the plain-old forward-analysis part of a dataflow algorithm,
-      adapted to skip non-relevant blocks (as determined by `reinit()` via `populatePerimeter()`).
-
-      The adaptations are:
-
-        - only relevant blocks dequeued from the worklist move on to have the transfer function applied
-
-        - `visited` now means the transfer function was applied to the block,
-          but please notice that this does not imply anymore its out-flow to be different from bottom,
-          because a block on the perimeter will have per-instruction typeflows computed only up to its `lastInstruction`.
-          In case you need to know whether a visted block `v` has been "fully visited", evaluate `out(v) ne typeflowLattice.bottom`
-
-        - given that the transfer function may remove callsite-candidates from the watchlist (thus, they are not candidates anymore)
-          there's an opportunity to detect whether a previously relevant block has been left without candidates.
-          That's what `shrinkedWatchlist` detects. Provided the block was on the perimeter, we know we can skip it from now now,
-          and we can also constrain the CFG-subgraph by finding a new perimeter (thus the invocation to `populatePerimeter()`).
-     */
-    override def forwardAnalysis(f: (P, lattice.Elem) => lattice.Elem): Unit = {
-      while (!worklist.isEmpty && relevantBBs.nonEmpty) {
-        if (stat) iterations += 1
-        val point = worklist.iterator.next(); worklist -= point
-        if(relevantBBs(point)) {
-          shrinkedWatchlist = false
-          val output = f(point, in(point))
-          visited += point
-          if(isOnPerimeter(point)) {
-            if(shrinkedWatchlist && !isWatching(point)) {
-              relevantBBs -= point
-              populatePerimeter()
-            }
-          } else {
-            val propagate = ((lattice.bottom == out(point)) || output != out(point))
-            if (propagate) {
-              out(point) = output
-              val succs = point.successors filter relevantBBs
-              succs foreach { p =>
-                assert((p.predecessors filter isOnPerimeter).isEmpty)
-                val existing = in(p)
-                // TODO move the following assertion to typeFlowLattice.lub2 for wider applicability (ie MethodTFA in addition to MTFAGrowable).
-                assert(existing == lattice.bottom ||
-                       p.exceptionHandlerStart    ||
-                       (output.stack.length == existing.stack.length),
-                       "Trying to merge non-bottom type-stacks with different stack heights. For a possible cause see SI-6157.")
-                val updated = lattice.lub(List(output, existing), p.exceptionHandlerStart)
-                if(updated != in(p)) {
-                  in(p) = updated
-                  enqueue(p)
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-  }
-
-  class Timer {
-    var millis = 0L
-
-    private var lastStart = 0L
-
-    def start() {
-      lastStart = System.nanoTime()
-    }
-
-    /** Stop the timer and return the number of milliseconds since the last
-     * call to start. The 'millis' field is increased by the elapsed time.
-     */
-    def stop: Long = {
-      val elapsed = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - lastStart)
-      millis += elapsed
-      elapsed
-    }
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
index a921ef3966..32f8c7826f 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
@@ -8,8 +8,9 @@ package scala.tools.nsc.backend.jvm
 import scala.tools.asm.tree.{InsnList, AbstractInsnNode, ClassNode, MethodNode}
 import java.io.{StringWriter, PrintWriter}
 import scala.tools.asm.util.{CheckClassAdapter, TraceClassVisitor, TraceMethodVisitor, Textifier}
-import scala.tools.asm.{ClassWriter, Attribute, ClassReader}
+import scala.tools.asm.{ClassReader, ClassWriter, Attribute}
 import scala.collection.convert.decorateAsScala._
+import scala.collection.convert.decorateAsJava._
 import scala.tools.nsc.backend.jvm.analysis.InitialProducer
 import scala.tools.nsc.backend.jvm.opt.InlineInfoAttributePrototype
 
@@ -55,11 +56,30 @@ object AsmUtils {
     node
   }
 
-  def readClass(filename: String): ClassNode = {
-    val f = new java.io.RandomAccessFile(filename, "r")
-    val b = new Array[Byte](f.length.toInt)
-    f.read(b)
-    readClass(b)
+  def readClass(filename: String): ClassNode = readClass(classBytes(filename))
+
+  def classBytes(file: String): Array[Byte] = {
+    val f = new java.io.RandomAccessFile(file, "r")
+    val bytes = new Array[Byte](f.length.toInt)
+    f.read(bytes)
+    bytes
+  }
+
+  def textifyClassStably(bytes: Array[Byte]): Unit = {
+    val node = new ClassNode()
+    new ClassReader(bytes).accept(node, ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES)
+
+    node.fields  = node.fields.asScala.sortBy(_.name).asJava
+    node.methods = node.methods.asScala.sortBy(_.name).asJava
+    node.visibleAnnotations = null
+    node.attrs = null
+    node.invisibleAnnotations = null
+
+    println(textify(node))
+  }
+
+  def main(args: Array[String]): Unit = {
+    textifyClassStably(classBytes(args.head))
   }
 
   /**
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
deleted file mode 100644
index 42738d3e1c..0000000000
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
+++ /dev/null
@@ -1,476 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2014 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend.jvm
-
-import scala.tools.nsc.Global
-import scala.tools.nsc.backend.jvm.BTypes.{InternalName, MethodInlineInfo, InlineInfo}
-import BackendReporting.ClassSymbolInfoFailureSI9111
-import scala.tools.asm
-
-/**
- * This trait contains code shared between GenBCode and GenASM that depends on types defined in
- * the compiler cake (Global).
- */
-final class BCodeAsmCommon[G <: Global](val global: G) {
-  import global._
-  import definitions._
-
-  val ExcludedForwarderFlags = {
-    import scala.tools.nsc.symtab.Flags._
-    // Should include DEFERRED but this breaks findMember.
-    SPECIALIZED | LIFTED | PROTECTED | STATIC | EXPANDEDNAME | BridgeAndPrivateFlags | MACRO
-  }
-
-  /**
-   * True for classes generated by the Scala compiler that are considered top-level in terms of
-   * the InnerClass / EnclosingMethod classfile attributes. See comment in BTypes.
-   */
-  def considerAsTopLevelImplementationArtifact(classSym: Symbol) = {
-    classSym.isImplClass || classSym.isSpecialized
-  }
-
-  /**
-   * Cache the value of delambdafy == "inline" for each run. We need to query this value many
-   * times, so caching makes sense.
-   */
-  object delambdafyInline {
-    private var runId = -1
-    private var value = false
-
-    def apply(): Boolean = {
-      if (runId != global.currentRunId) {
-        runId = global.currentRunId
-        value = settings.Ydelambdafy.value == "inline"
-      }
-      value
-    }
-  }
-
-  /**
-   * True if `classSym` is an anonymous class or a local class. I.e., false if `classSym` is a
-   * member class. This method is used to decide if we should emit an EnclosingMethod attribute.
-   * It is also used to decide whether the "owner" field in the InnerClass attribute should be
-   * null.
-   */
-  def isAnonymousOrLocalClass(classSym: Symbol): Boolean = {
-    assert(classSym.isClass, s"not a class: $classSym")
-    val r = exitingPickler(classSym.isAnonymousClass) || !classSym.originalOwner.isClass
-    if (r && settings.Ybackend.value == "GenBCode") {
-      // this assertion only holds in GenBCode. lambda lift renames symbols and may accidentally
-      // introduce `$lambda` into a class name, making `isDelambdafyFunction` true. under GenBCode
-      // we prevent this, see `nonAnon` in LambdaLift.
-      // phase travel necessary: after flatten, the name includes the name of outer classes.
-      // if some outer name contains $lambda, a non-lambda class is considered lambda.
-      assert(exitingPickler(!classSym.isDelambdafyFunction), classSym.name)
-    }
-    r
-  }
-
-  /**
-   * The next enclosing definition in the source structure. Includes anonymous function classes
-   * under delambdafy:inline, even though they are only generated during UnCurry.
-   */
-  def nextEnclosing(sym: Symbol): Symbol = {
-    val origOwner = sym.originalOwner
-    // phase travel necessary: after flatten, the name includes the name of outer classes.
-    // if some outer name contains $anon, a non-anon class is considered anon.
-    if (delambdafyInline() && sym.rawowner.isAnonymousFunction) {
-      // SI-9105: special handling for anonymous functions under delambdafy:inline.
-      //
-      //   class C { def t = () => { def f { class Z } } }
-      //
-      //   class C { def t = byNameMethod { def f { class Z } } }
-      //
-      // In both examples, the method f lambda-lifted into the anonfun class.
-      //
-      // In both examples, the enclosing method of Z is f, the enclosing class is the anonfun.
-      // So nextEnclosing needs to return the following chain:  Z - f - anonFunClassSym - ...
-      //
-      // In the first example, the initial owner of f is a TermSymbol named "$anonfun" (note: not the anonFunClassSym!)
-      // In the second, the initial owner of f is t (no anon fun term symbol for by-name args!).
-      //
-      // In both cases, the rawowner of class Z is the anonFunClassSym. So the check in the `if`
-      // above makes sure we don't jump over the anonymous function in the by-name argument case.
-      //
-      // However, we cannot directly return the rawowner: if `sym` is Z, we need to include method f
-      // in the result. This is done by comparing the rawowners (read: lambdalift-targets) of `sym`
-      // and `sym.originalOwner`: if they are the same, then the originalOwner is "in between", and
-      // we need to return it.
-      // If the rawowners are different, the symbol was not in between. In the first example, the
-      // originalOwner of `f` is the anonfun-term-symbol, whose rawowner is C. So the nextEnclosing
-      // of `f` is its rawowner, the anonFunClassSym.
-      //
-      // In delambdafy:method we don't have that problem. The f method is lambda-lifted into C,
-      // not into the anonymous function class. The originalOwner chain is Z - f - C.
-      if (sym.originalOwner.rawowner == sym.rawowner) sym.originalOwner
-      else sym.rawowner
-    } else {
-      origOwner
-    }
-  }
-
-  def nextEnclosingClass(sym: Symbol): Symbol = {
-    if (sym.isClass) sym
-    else nextEnclosingClass(nextEnclosing(sym))
-  }
-
-  def classOriginallyNestedInClass(nestedClass: Symbol, enclosingClass: Symbol) ={
-    nextEnclosingClass(nextEnclosing(nestedClass)) == enclosingClass
-  }
-
-  /**
-   * Returns the enclosing method for non-member classes. In the following example
-   *
-   * class A {
-   *   def f = {
-   *     class B {
-   *       class C
-   *     }
-   *   }
-   * }
-   *
-   * the method returns Some(f) for B, but None for C, because C is a member class. For non-member
-   * classes that are not enclosed by a method, it returns None:
-   *
-   * class A {
-   *   { class B }
-   * }
-   *
-   * In this case, for B, we return None.
-   *
-   * The EnclosingMethod attribute needs to be added to non-member classes (see doc in BTypes).
-   * This is a source-level property, so we need to use the originalOwner chain to reconstruct it.
-   */
-  private def enclosingMethodForEnclosingMethodAttribute(classSym: Symbol): Option[Symbol] = {
-    assert(classSym.isClass, classSym)
-
-    def doesNotExist(method: Symbol) = {
-      // (1) SI-9124, some trait methods don't exist in the generated interface. see comment in BTypes.
-      // (2) Value classes. Member methods of value classes exist in the generated box class. However,
-      //     nested methods lifted into a value class are moved to the companion object and don't exist
-      //     in the value class itself. We can identify such nested methods: the initial enclosing class
-      //     is a value class, but the current owner is some other class (the module class).
-      method.owner.isTrait && method.isImplOnly || { // (1)
-        val enclCls = nextEnclosingClass(method)
-        exitingPickler(enclCls.isDerivedValueClass) && method.owner != enclCls // (2)
-      }
-    }
-
-    def enclosingMethod(sym: Symbol): Option[Symbol] = {
-      if (sym.isClass || sym == NoSymbol) None
-      else if (sym.isMethod) {
-        if (doesNotExist(sym)) None else Some(sym)
-      }
-      else enclosingMethod(nextEnclosing(sym))
-    }
-    enclosingMethod(nextEnclosing(classSym))
-  }
-
-  /**
-   * The enclosing class for emitting the EnclosingMethod attribute. Since this is a source-level
-   * property, this method looks at the originalOwner chain. See doc in BTypes.
-   */
-  private def enclosingClassForEnclosingMethodAttribute(classSym: Symbol): Symbol = {
-    assert(classSym.isClass, classSym)
-    val r = nextEnclosingClass(nextEnclosing(classSym))
-    // this should be an assertion, but we are more cautious for now as it was introduced before the 2.11.6 minor release
-    if (considerAsTopLevelImplementationArtifact(r)) devWarning(s"enclosing class of $classSym should not be an implementation artifact class: $r")
-    r
-  }
-
-  final case class EnclosingMethodEntry(owner: String, name: String, methodDescriptor: String)
-
-  /**
-   * Data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not
-   * an anonymous or local class). See doc in BTypes.
-   *
-   * The class is parametrized by two functions to obtain a bytecode class descriptor for a class
-   * symbol, and to obtain a method signature descriptor fro a method symbol. These function depend
-   * on the implementation of GenASM / GenBCode, so they need to be passed in.
-   */
-  def enclosingMethodAttribute(classSym: Symbol, classDesc: Symbol => String, methodDesc: Symbol => String): Option[EnclosingMethodEntry] = {
-    // trait impl classes are always top-level, see comment in BTypes
-    if (isAnonymousOrLocalClass(classSym) && !considerAsTopLevelImplementationArtifact(classSym)) {
-      val enclosingClass = enclosingClassForEnclosingMethodAttribute(classSym)
-      val methodOpt = enclosingMethodForEnclosingMethodAttribute(classSym) match {
-        case some @ Some(m) =>
-          if (m.owner != enclosingClass) {
-            // This should never happen. In case it does, it prevents emitting an invalid
-            // EnclosingMethod attribute: if the attribute specifies an enclosing method,
-            // it needs to exist in the specified enclosing class.
-            devWarning(s"the owner of the enclosing method ${m.locationString} should be the same as the enclosing class $enclosingClass")
-            None
-          } else some
-        case none => none
-      }
-      Some(EnclosingMethodEntry(
-        classDesc(enclosingClass),
-        methodOpt.map(_.javaSimpleName.toString).orNull,
-        methodOpt.map(methodDesc).orNull))
-    } else {
-      None
-    }
-  }
-
-  /**
-   * This is basically a re-implementation of sym.isStaticOwner, but using the originalOwner chain.
-   *
-   * The problem is that we are interested in a source-level property. Various phases changed the
-   * symbol's properties in the meantime, mostly lambdalift modified (destructively) the owner.
-   * Therefore, `sym.isStatic` is not what we want. For example, in
-   *   object T { def f { object U } }
-   * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here.
-   */
-  def isOriginallyStaticOwner(sym: Symbol): Boolean = {
-    sym.isPackageClass || sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner)
-  }
-
-  /**
-   * Reconstruct the classfile flags from a Java defined class symbol.
-   *
-   * The implementation of this method is slightly different that `javaFlags` in BTypesFromSymbols.
-   * The javaFlags method is primarily used to map Scala symbol flags to sensible classfile flags
-   * that are used in the generated classfiles. For example, all classes emitted by the Scala
-   * compiler have ACC_PUBLIC.
-   *
-   * When building a [[ClassBType]] from a Java class symbol, the flags in the type's `info` have
-   * to correspond exactly to the flags in the classfile. For example, if the class is package
-   * protected (i.e., it doesn't have the ACC_PUBLIC flag), this needs to be reflected in the
-   * ClassBType. For example, the inliner needs the correct flags for access checks.
-   *
-   * Class flags are listed here:
-   *   https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.1-200-E.1
-   */
-  def javaClassfileFlags(classSym: Symbol): Int = {
-    assert(classSym.isJava, s"Expected Java class symbol, got ${classSym.fullName}")
-    import asm.Opcodes._
-    def enumFlags = ACC_ENUM | {
-      // Java enums have the `ACC_ABSTRACT` flag if they have a deferred method.
-      // We cannot trust `hasAbstractFlag`: the ClassfileParser adds `ABSTRACT` and `SEALED` to all
-      // Java enums for exhaustiveness checking.
-      val hasAbstractMethod = classSym.info.decls.exists(s => s.isMethod && s.isDeferred)
-      if (hasAbstractMethod) ACC_ABSTRACT else 0
-    }
-    GenBCode.mkFlags(
-      // SI-9393: the classfile / java source parser make java annotation symbols look like classes.
-      // here we recover the actual classfile flags.
-      if (classSym.hasJavaAnnotationFlag)                        ACC_ANNOTATION | ACC_INTERFACE | ACC_ABSTRACT else 0,
-      if (classSym.isPublic)                                     ACC_PUBLIC    else 0,
-      if (classSym.isFinal)                                      ACC_FINAL     else 0,
-      // see the link above. javac does the same: ACC_SUPER for all classes, but not interfaces.
-      if (classSym.isInterface)                                  ACC_INTERFACE else ACC_SUPER,
-      // for Java enums, we cannot trust `hasAbstractFlag` (see comment in enumFlags)
-      if (!classSym.hasJavaEnumFlag && classSym.hasAbstractFlag) ACC_ABSTRACT  else 0,
-      if (classSym.isArtifact)                                   ACC_SYNTHETIC else 0,
-      if (classSym.hasJavaEnumFlag)                              enumFlags     else 0
-    )
-  }
-
-  /**
-   * The member classes of a class symbol. Note that the result of this method depends on the
-   * current phase, for example, after lambdalift, all local classes become member of the enclosing
-   * class.
-   *
-   * Impl classes are always considered top-level, see comment in BTypes.
-   */
-  def memberClassesForInnerClassTable(classSymbol: Symbol): List[Symbol] = classSymbol.info.decls.collect({
-    case sym if sym.isClass && !considerAsTopLevelImplementationArtifact(sym) =>
-      sym
-    case sym if sym.isModule && !considerAsTopLevelImplementationArtifact(sym) => // impl classes get the lateMODULE flag in mixin
-      val r = exitingPickler(sym.moduleClass)
-      assert(r != NoSymbol, sym.fullLocationString)
-      r
-  })(collection.breakOut)
-
-  lazy val AnnotationRetentionPolicyModule       = AnnotationRetentionPolicyAttr.companionModule
-  lazy val AnnotationRetentionPolicySourceValue  = AnnotationRetentionPolicyModule.tpe.member(TermName("SOURCE"))
-  lazy val AnnotationRetentionPolicyClassValue   = AnnotationRetentionPolicyModule.tpe.member(TermName("CLASS"))
-  lazy val AnnotationRetentionPolicyRuntimeValue = AnnotationRetentionPolicyModule.tpe.member(TermName("RUNTIME"))
-
-  /** Whether an annotation should be emitted as a Java annotation
-    * .initialize: if 'annot' is read from pickle, atp might be uninitialized
-    */
-  def shouldEmitAnnotation(annot: AnnotationInfo) = {
-    annot.symbol.initialize.isJavaDefined &&
-      annot.matches(ClassfileAnnotationClass) &&
-      retentionPolicyOf(annot) != AnnotationRetentionPolicySourceValue &&
-      annot.args.isEmpty
-  }
-
-  def isRuntimeVisible(annot: AnnotationInfo): Boolean = {
-    annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr) match {
-      case Some(retentionAnnot) =>
-        retentionAnnot.assocs.contains(nme.value -> LiteralAnnotArg(Constant(AnnotationRetentionPolicyRuntimeValue)))
-      case _ =>
-        // SI-8926: if the annotation class symbol doesn't have a @RetentionPolicy annotation, the
-        // annotation is emitted with visibility `RUNTIME`
-        true
-    }
-  }
-
-  private def retentionPolicyOf(annot: AnnotationInfo): Symbol =
-    annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr).map(_.assocs).flatMap(assoc =>
-      assoc.collectFirst {
-        case (`nme`.value, LiteralAnnotArg(Constant(value: Symbol))) => value
-      }).getOrElse(AnnotationRetentionPolicyClassValue)
-
-  def implementedInterfaces(classSym: Symbol): List[Symbol] = {
-    // Additional interface parents based on annotations and other cues
-    def newParentForAnnotation(ann: AnnotationInfo): Option[Type] = ann.symbol match {
-      case RemoteAttr => Some(RemoteInterfaceClass.tpe)
-      case _          => None
-    }
-
-    // SI-9393: java annotations are interfaces, but the classfile / java source parsers make them look like classes.
-    def isInterfaceOrTrait(sym: Symbol) = sym.isInterface || sym.isTrait || sym.hasJavaAnnotationFlag
-
-    val classParents = {
-      val parents = classSym.info.parents
-      // SI-9393: the classfile / java source parsers add Annotation and ClassfileAnnotation to the
-      // parents of a java annotations. undo this for the backend (where we need classfile-level information).
-      if (classSym.hasJavaAnnotationFlag) parents.filterNot(c => c.typeSymbol == ClassfileAnnotationClass || c.typeSymbol == AnnotationClass)
-      else parents
-    }
-
-    val allParents = classParents ++ classSym.annotations.flatMap(newParentForAnnotation)
-
-    // We keep the superClass when computing minimizeParents to eliminate more interfaces.
-    // Example: T can be eliminated from D
-    //   trait T
-    //   class C extends T
-    //   class D extends C with T
-    val interfaces = erasure.minimizeParents(allParents) match {
-      case superClass :: ifs if !isInterfaceOrTrait(superClass.typeSymbol) =>
-        ifs
-      case ifs =>
-        // minimizeParents removes the superclass if it's redundant, for example:
-        //  trait A
-        //  class C extends Object with A  // minimizeParents removes Object
-        ifs
-    }
-    interfaces.map(_.typeSymbol)
-  }
-
-  /**
-   * This is a hack to work around SI-9111. The completer of `methodSym` may report type errors. We
-   * cannot change the typer context of the completer at this point and make it silent: the context
-   * captured when creating the completer in the namer. However, we can temporarily replace
-   * global.reporter (it's a var) to store errors.
-   */
-  def completeSilentlyAndCheckErroneous(sym: Symbol): Boolean = {
-    if (sym.hasCompleteInfo) false
-    else {
-      val originalReporter = global.reporter
-      val storeReporter = new reporters.StoreReporter()
-      global.reporter = storeReporter
-      try {
-        sym.info
-      } finally {
-        global.reporter = originalReporter
-      }
-      sym.isErroneous
-    }
-  }
-
-  /**
-   * Build the [[InlineInfo]] for a class symbol.
-   */
-  def buildInlineInfoFromClassSymbol(classSym: Symbol, classSymToInternalName: Symbol => InternalName, methodSymToDescriptor: Symbol => String): InlineInfo = {
-    val traitSelfType = if (classSym.isTrait && !classSym.isImplClass) {
-      // The mixin phase uses typeOfThis for the self parameter in implementation class methods.
-      val selfSym = classSym.typeOfThis.typeSymbol
-      if (selfSym != classSym) Some(classSymToInternalName(selfSym)) else None
-    } else {
-      None
-    }
-
-    val isEffectivelyFinal = classSym.isEffectivelyFinal
-
-    val sam = {
-      if (classSym.isImplClass || classSym.isEffectivelyFinal) None
-      else {
-        // Phase travel necessary. For example, nullary methods (getter of an abstract val) get an
-        // empty parameter list in later phases and would therefore be picked as SAM.
-        val samSym = exitingPickler(definitions.findSam(classSym.tpe))
-        if (samSym == NoSymbol) None
-        else Some(samSym.javaSimpleName.toString + methodSymToDescriptor(samSym))
-      }
-    }
-
-    var warning = Option.empty[ClassSymbolInfoFailureSI9111]
-
-    // Primitive methods cannot be inlined, so there's no point in building a MethodInlineInfo. Also, some
-    // primitive methods (e.g., `isInstanceOf`) have non-erased types, which confuses [[typeToBType]].
-    val methodInlineInfos = classSym.info.decls.iterator.filter(m => m.isMethod && !scalaPrimitives.isPrimitive(m)).flatMap({
-      case methodSym =>
-        if (completeSilentlyAndCheckErroneous(methodSym)) {
-          // Happens due to SI-9111. Just don't provide any MethodInlineInfo for that method, we don't need fail the compiler.
-          if (!classSym.isJavaDefined) devWarning("SI-9111 should only be possible for Java classes")
-          warning = Some(ClassSymbolInfoFailureSI9111(classSym.fullName))
-          None
-        } else {
-          val name      = methodSym.javaSimpleName.toString // same as in genDefDef
-          val signature = name + methodSymToDescriptor(methodSym)
-
-          // Some detours are required here because of changing flags (lateDEFERRED, lateMODULE):
-          // 1. Why the phase travel? Concrete trait methods obtain the lateDEFERRED flag in Mixin.
-          //    This makes isEffectivelyFinalOrNotOverridden false, which would prevent non-final
-          //    but non-overridden methods of sealed traits from being inlined.
-          // 2. Why the special case for `classSym.isImplClass`? Impl class symbols obtain the
-          //    lateMODULE flag during Mixin. During the phase travel to exitingPickler, the late
-          //    flag is ignored. The members are therefore not isEffectivelyFinal (their owner
-          //    is not a module). Since we know that all impl class members are static, we can
-          //    just take the shortcut.
-          val effectivelyFinal = classSym.isImplClass || exitingPickler(methodSym.isEffectivelyFinalOrNotOverridden)
-
-          // Identify trait interface methods that have a static implementation in the implementation
-          // class. Invocations of these methods can be re-wrired directly to the static implementation
-          // if they are final or the receiver is known.
-          //
-          // Using `erasure.needsImplMethod` is not enough: it keeps field accessors, module getters
-          // and super accessors. When AddInterfaces creates the impl class, these methods are
-          // initially added to it.
-          //
-          // The mixin phase later on filters out most of these members from the impl class (see
-          // Mixin.isImplementedStatically). However, accessors for concrete lazy vals remain in the
-          // impl class after mixin. So the filter in mixin is not exactly what we need here (we
-          // want to identify concrete trait methods, not any accessors). So we check some symbol
-          // properties manually.
-          val traitMethodWithStaticImplementation = {
-            import symtab.Flags._
-            classSym.isTrait && !classSym.isImplClass &&
-              erasure.needsImplMethod(methodSym) &&
-              !methodSym.isModule &&
-              !(methodSym hasFlag (ACCESSOR | SUPERACCESSOR))
-          }
-
-          val info = MethodInlineInfo(
-            effectivelyFinal                    = effectivelyFinal,
-            traitMethodWithStaticImplementation = traitMethodWithStaticImplementation,
-            annotatedInline                     = methodSym.hasAnnotation(ScalaInlineClass),
-            annotatedNoInline                   = methodSym.hasAnnotation(ScalaNoInlineClass)
-          )
-          Some((signature, info))
-        }
-    }).toMap
-
-    InlineInfo(traitSelfType, isEffectivelyFinal, sam, methodInlineInfos, warning)
-  }
-}
-
-object BCodeAsmCommon {
-  /**
-   * Valid flags for InnerClass attribute entry.
-   * See http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.6
-   */
-  val INNER_CLASSES_FLAGS = {
-    asm.Opcodes.ACC_PUBLIC   | asm.Opcodes.ACC_PRIVATE   | asm.Opcodes.ACC_PROTECTED  |
-      asm.Opcodes.ACC_STATIC   | asm.Opcodes.ACC_FINAL     | asm.Opcodes.ACC_INTERFACE  |
-      asm.Opcodes.ACC_ABSTRACT | asm.Opcodes.ACC_SYNTHETIC | asm.Opcodes.ACC_ANNOTATION |
-      asm.Opcodes.ACC_ENUM
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
index 58c1d0e497..59d584c370 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
@@ -17,6 +17,7 @@ import scala.tools.asm
 import GenBCode._
 import BackendReporting._
 import scala.tools.asm.tree.MethodInsnNode
+import scala.tools.nsc.backend.jvm.BCodeHelpers.{InvokeStyle, TestOp}
 
 /*
  *
@@ -28,16 +29,12 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
   import global._
   import definitions._
   import bTypes._
-  import bCodeICodeCommon._
   import coreBTypes._
 
   /*
    * Functionality to build the body of ASM MethodNode, except for `synchronized` and `try` expressions.
    */
   abstract class PlainBodyBuilder(cunit: CompilationUnit) extends PlainSkelBuilder(cunit) {
-    import icodes.TestOp
-    import icodes.opcodes.InvokeStyle
-
     /*  If the selector type has a member with the right name,
      *  it is the host class; otherwise the symbol's owner.
      */
@@ -121,7 +118,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           code match {
             case POS => () // nothing
             case NEG => bc.neg(resKind)
-            case NOT => bc.genPrimitiveArithmetic(icodes.NOT, resKind)
+            case NOT => bc.genPrimitiveNot(resKind)
             case _ => abort(s"Unknown unary operation: ${fun.symbol.fullName} code: $code")
           }
 
@@ -582,8 +579,8 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         // to call super constructors explicitly and/or use their 'returned' value.
         // therefore, we can ignore this fact, and generate code that leaves nothing
         // on the stack (contrary to what the type in the AST says).
-        case Apply(fun @ Select(Super(_, mix), _), args) =>
-          val invokeStyle = icodes.opcodes.SuperCall(mix)
+        case Apply(fun @ Select(Super(_, _), _), args) =>
+          val invokeStyle = InvokeStyle.Super
           // if (fun.symbol.isConstructor) Static(true) else SuperCall(mix);
           mnode.visitVarInsn(asm.Opcodes.ALOAD, 0)
           genLoadArguments(args, paramTKs(app))
@@ -629,7 +626,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
               mnode.visitTypeInsn(asm.Opcodes.NEW, rt.internalName)
               bc dup generatedType
               genLoadArguments(args, paramTKs(app))
-              genCallMethod(ctor, icodes.opcodes.Static(onInstance = true), app.pos)
+              genCallMethod(ctor, InvokeStyle.Special, app.pos)
 
             case _ =>
               abort(s"Cannot instantiate $tpt of kind: $generatedType")
@@ -667,9 +664,9 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
             def genNormalMethodCall() {
 
               val invokeStyle =
-                if (sym.isStaticMember) icodes.opcodes.Static(onInstance = false)
-                else if (sym.isPrivate || sym.isClassConstructor) icodes.opcodes.Static(onInstance = true)
-                else icodes.opcodes.Dynamic;
+                if (sym.isStaticMember) InvokeStyle.Static
+                else if (sym.isPrivate || sym.isClassConstructor) InvokeStyle.Special
+                else InvokeStyle.Virtual
 
               if (invokeStyle.hasInstance) {
                 genLoadQualifier(fun)
@@ -696,7 +693,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
 
                 case _ =>
               }
-              if ((targetTypeKind != null) && (sym == definitions.Array_clone) && invokeStyle.isDynamic) {
+              if ((targetTypeKind != null) && (sym == definitions.Array_clone) && invokeStyle.isVirtual) {
                 // An invokevirtual points to a CONSTANT_Methodref_info which in turn points to a
                 // CONSTANT_Class_info of the receiver type.
                 // The JVMS is not explicit about this, but that receiver type may be an array type
@@ -998,8 +995,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         // Optimization for expressions of the form "" + x.  We can avoid the StringBuilder.
         case List(Literal(Constant("")), arg) =>
           genLoad(arg, ObjectRef)
-          genCallMethod(String_valueOf, icodes.opcodes.Static(onInstance = false), arg.pos)
-
+          genCallMethod(String_valueOf, InvokeStyle.Static, arg.pos)
         case concatenations =>
           bc.genStartConcat(tree.pos)
           for (elem <- concatenations) {
@@ -1030,7 +1026,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       // whether to reference the type of the receiver or
       // the type of the method owner
       val useMethodOwner = (
-           style != icodes.opcodes.Dynamic
+           !style.isVirtual
         || hostSymbol.isBottomClass
         || methodOwner == definitions.ObjectClass
       )
@@ -1057,11 +1053,9 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         }
       }
 
-      if (style.isStatic) {
-        if (style.hasInstance) { bc.invokespecial  (jowner, jname, mdescr, pos) }
-        else                   { bc.invokestatic   (jowner, jname, mdescr, pos) }
-      }
-      else if (style.isDynamic) {
+      if (style.isStatic)                 { bc.invokestatic   (jowner, jname, mdescr, pos) }
+      else if (style.isSpecial)           { bc.invokespecial  (jowner, jname, mdescr, pos) }
+      else if (style.isVirtual) {
         if (needsInterfaceCall(receiver)) { bc.invokeinterface(jowner, jname, mdescr, pos) }
         else                              { bc.invokevirtual  (jowner, jname, mdescr, pos) }
       }
@@ -1077,8 +1071,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
     def genScalaHash(tree: Tree, applyPos: Position): BType = {
       genLoadModule(ScalaRunTimeModule) // TODO why load ScalaRunTimeModule if ## has InvokeStyle of Static(false) ?
       genLoad(tree, ObjectRef)
-      genCallMethod(hashMethodSym, icodes.opcodes.Static(onInstance = false), applyPos)
-
+      genCallMethod(hashMethodSym, InvokeStyle.Static, applyPos)
       INT
     }
 
@@ -1107,10 +1100,10 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         (tk: @unchecked) match {
           case LONG   => emit(asm.Opcodes.LCMP)
           case FLOAT  =>
-            if (op == icodes.LT || op == icodes.LE) emit(asm.Opcodes.FCMPG)
+            if (op == TestOp.LT || op == TestOp.LE) emit(asm.Opcodes.FCMPG)
             else emit(asm.Opcodes.FCMPL)
           case DOUBLE =>
-            if (op == icodes.LT || op == icodes.LE) emit(asm.Opcodes.DCMPG)
+            if (op == TestOp.LT || op == TestOp.LE) emit(asm.Opcodes.DCMPG)
             else emit(asm.Opcodes.DCMPL)
         }
         bc.emitIF(op, success)
@@ -1125,8 +1118,8 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       } else if (tk.isRef) { // REFERENCE(_) | ARRAY(_)
         // @unchecked because references aren't compared with GT, GE, LT, LE.
         (op : @unchecked) match {
-          case icodes.EQ => bc emitIFNULL    success
-          case icodes.NE => bc emitIFNONNULL success
+          case TestOp.EQ => bc emitIFNULL    success
+          case TestOp.NE => bc emitIFNONNULL success
         }
       } else {
         (tk: @unchecked) match {
@@ -1135,11 +1128,11 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
             emit(asm.Opcodes.LCMP)
           case FLOAT  =>
             emit(asm.Opcodes.FCONST_0)
-            if (op == icodes.LT || op == icodes.LE) emit(asm.Opcodes.FCMPG)
+            if (op == TestOp.LT || op == TestOp.LE) emit(asm.Opcodes.FCMPG)
             else emit(asm.Opcodes.FCMPL)
           case DOUBLE =>
             emit(asm.Opcodes.DCONST_0)
-            if (op == icodes.LT || op == icodes.LE) emit(asm.Opcodes.DCMPG)
+            if (op == TestOp.LT || op == TestOp.LE) emit(asm.Opcodes.DCMPG)
             else emit(asm.Opcodes.DCMPL)
         }
         bc.emitIF(op, success)
@@ -1147,9 +1140,23 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       bc goTo failure
     }
 
-    val testOpForPrimitive: Array[TestOp] = Array(
-      icodes.EQ, icodes.NE, icodes.EQ, icodes.NE, icodes.LT, icodes.LE, icodes.GE, icodes.GT
-    )
+    def testOpForPrimitive(primitiveCode: Int) = (primitiveCode: @switch) match {
+      case scalaPrimitives.ID => TestOp.EQ
+      case scalaPrimitives.NI => TestOp.NE
+      case scalaPrimitives.EQ => TestOp.EQ
+      case scalaPrimitives.NE => TestOp.NE
+      case scalaPrimitives.LT => TestOp.LT
+      case scalaPrimitives.LE => TestOp.LE
+      case scalaPrimitives.GE => TestOp.GE
+      case scalaPrimitives.GT => TestOp.GT
+    }
+
+    /** Some useful equality helpers. */
+    def isNull(t: Tree) = PartialFunction.cond(t) { case Literal(Constant(null)) => true }
+    def isLiteral(t: Tree) = PartialFunction.cond(t) { case Literal(_) => true }
+    def isNonNullExpr(t: Tree) = isLiteral(t) || ((t.symbol ne null) && t.symbol.isModule)
+    /** If l or r is constant null, returns the other ; otherwise null */
+    def ifOneIsNull(l: Tree, r: Tree) = if (isNull(l)) r else if (isNull(r)) l else null
 
     /*
      * Generate code for conditional expressions.
@@ -1158,7 +1165,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
     private def genCond(tree: Tree, success: asm.Label, failure: asm.Label) {
 
       def genComparisonOp(l: Tree, r: Tree, code: Int) {
-        val op: TestOp = testOpForPrimitive(code - scalaPrimitives.ID)
+        val op: TestOp = testOpForPrimitive(code)
         // special-case reference (in)equality test for null (null eq x, x eq null)
         var nonNullSide: Tree = null
         if (scalaPrimitives.isReferenceEqualityOp(code) &&
@@ -1177,7 +1184,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
 
       def default() = {
         genLoad(tree, BOOL)
-        genCZJUMP(success, failure, icodes.NE, BOOL)
+        genCZJUMP(success, failure, TestOp.NE, BOOL)
       }
 
       lineNumber(tree)
@@ -1254,24 +1261,24 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         }
         genLoad(l, ObjectRef)
         genLoad(r, ObjectRef)
-        genCallMethod(equalsMethod, icodes.opcodes.Static(onInstance = false), pos)
-        genCZJUMP(success, failure, icodes.NE, BOOL)
+        genCallMethod(equalsMethod, InvokeStyle.Static, pos)
+        genCZJUMP(success, failure, TestOp.NE, BOOL)
       }
       else {
         if (isNull(l)) {
           // null == expr -> expr eq null
           genLoad(r, ObjectRef)
-          genCZJUMP(success, failure, icodes.EQ, ObjectRef)
+          genCZJUMP(success, failure, TestOp.EQ, ObjectRef)
         } else if (isNull(r)) {
           // expr == null -> expr eq null
           genLoad(l, ObjectRef)
-          genCZJUMP(success, failure, icodes.EQ, ObjectRef)
+          genCZJUMP(success, failure, TestOp.EQ, ObjectRef)
         } else if (isNonNullExpr(l)) {
           // SI-7852 Avoid null check if L is statically non-null.
           genLoad(l, ObjectRef)
           genLoad(r, ObjectRef)
-          genCallMethod(Object_equals, icodes.opcodes.Dynamic, pos)
-          genCZJUMP(success, failure, icodes.NE, BOOL)
+          genCallMethod(Object_equals, InvokeStyle.Virtual, pos)
+          genCZJUMP(success, failure, TestOp.NE, BOOL)
         } else {
           // l == r -> if (l eq null) r eq null else l.equals(r)
           val eqEqTempLocal = locals.makeLocal(ObjectRef, nme.EQEQ_LOCAL_VAR.toString)
@@ -1282,17 +1289,17 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           genLoad(r, ObjectRef)
           locals.store(eqEqTempLocal)
           bc dup ObjectRef
-          genCZJUMP(lNull, lNonNull, icodes.EQ, ObjectRef)
+          genCZJUMP(lNull, lNonNull, TestOp.EQ, ObjectRef)
 
           markProgramPoint(lNull)
           bc drop ObjectRef
           locals.load(eqEqTempLocal)
-          genCZJUMP(success, failure, icodes.EQ, ObjectRef)
+          genCZJUMP(success, failure, TestOp.EQ, ObjectRef)
 
           markProgramPoint(lNonNull)
           locals.load(eqEqTempLocal)
-          genCallMethod(Object_equals, icodes.opcodes.Dynamic, pos)
-          genCZJUMP(success, failure, icodes.NE, BOOL)
+          genCallMethod(Object_equals, InvokeStyle.Virtual, pos)
+          genCZJUMP(success, failure, TestOp.NE, BOOL)
         }
       }
     }
@@ -1338,7 +1345,13 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
 
   lazy val lambdaMetaFactoryBootstrapHandle =
     new asm.Handle(asm.Opcodes.H_INVOKESTATIC,
-      definitions.LambdaMetaFactory.fullName('/'), sn.AltMetafactory.toString,
-      "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;")
-
+      coreBTypes.jliLambdaMetafactoryRef.internalName, sn.AltMetafactory.toString,
+      MethodBType(
+        List(
+          coreBTypes.jliMethodHandlesLookupRef,
+          coreBTypes.StringRef,
+          coreBTypes.jliMethodTypeRef,
+          ArrayBType(ObjectRef)),
+        coreBTypes.jliCallSiteRef
+      ).descriptor)
 }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
index d501d4239b..1ec9ba8a95 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
@@ -22,8 +22,315 @@ import BackendReporting._
  */
 abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
   import global._
+  import definitions._
   import bTypes._
   import coreBTypes._
+  import BTypes.{InternalName, InlineInfo, MethodInlineInfo}
+
+  /**
+   * True for classes generated by the Scala compiler that are considered top-level in terms of
+   * the InnerClass / EnclosingMethod classfile attributes. See comment in BTypes.
+   */
+  def considerAsTopLevelImplementationArtifact(classSym: Symbol) =
+    classSym.isImplClass || classSym.isSpecialized
+
+  /**
+   * Cache the value of delambdafy == "inline" for each run. We need to query this value many
+   * times, so caching makes sense.
+   */
+  object delambdafyInline {
+    private var runId = -1
+    private var value = false
+
+    def apply(): Boolean = {
+      if (runId != global.currentRunId) {
+        runId = global.currentRunId
+        value = settings.Ydelambdafy.value == "inline"
+      }
+      value
+    }
+  }
+
+  /**
+   * True if `classSym` is an anonymous class or a local class. I.e., false if `classSym` is a
+   * member class. This method is used to decide if we should emit an EnclosingMethod attribute.
+   * It is also used to decide whether the "owner" field in the InnerClass attribute should be
+   * null.
+   */
+  def isAnonymousOrLocalClass(classSym: Symbol): Boolean = {
+    assert(classSym.isClass, s"not a class: $classSym")
+    val r = exitingPickler(classSym.isAnonymousClass) || !classSym.originalOwner.isClass
+    if (r && settings.Ybackend.value == "GenBCode") {
+      // this assertion only holds in GenBCode. lambda lift renames symbols and may accidentally
+      // introduce `$lambda` into a class name, making `isDelambdafyFunction` true. under GenBCode
+      // we prevent this, see `nonAnon` in LambdaLift.
+      // phase travel necessary: after flatten, the name includes the name of outer classes.
+      // if some outer name contains $lambda, a non-lambda class is considered lambda.
+      assert(exitingPickler(!classSym.isDelambdafyFunction), classSym.name)
+    }
+    r
+  }
+
+  /**
+   * The next enclosing definition in the source structure. Includes anonymous function classes
+   * under delambdafy:inline, even though they are only generated during UnCurry.
+   */
+  def nextEnclosing(sym: Symbol): Symbol = {
+    val origOwner = sym.originalOwner
+    // phase travel necessary: after flatten, the name includes the name of outer classes.
+    // if some outer name contains $anon, a non-anon class is considered anon.
+    if (delambdafyInline() && sym.rawowner.isAnonymousFunction) {
+      // SI-9105: special handling for anonymous functions under delambdafy:inline.
+      //
+      //   class C { def t = () => { def f { class Z } } }
+      //
+      //   class C { def t = byNameMethod { def f { class Z } } }
+      //
+      // In both examples, the method f lambda-lifted into the anonfun class.
+      //
+      // In both examples, the enclosing method of Z is f, the enclosing class is the anonfun.
+      // So nextEnclosing needs to return the following chain:  Z - f - anonFunClassSym - ...
+      //
+      // In the first example, the initial owner of f is a TermSymbol named "$anonfun" (note: not the anonFunClassSym!)
+      // In the second, the initial owner of f is t (no anon fun term symbol for by-name args!).
+      //
+      // In both cases, the rawowner of class Z is the anonFunClassSym. So the check in the `if`
+      // above makes sure we don't jump over the anonymous function in the by-name argument case.
+      //
+      // However, we cannot directly return the rawowner: if `sym` is Z, we need to include method f
+      // in the result. This is done by comparing the rawowners (read: lambdalift-targets) of `sym`
+      // and `sym.originalOwner`: if they are the same, then the originalOwner is "in between", and
+      // we need to return it.
+      // If the rawowners are different, the symbol was not in between. In the first example, the
+      // originalOwner of `f` is the anonfun-term-symbol, whose rawowner is C. So the nextEnclosing
+      // of `f` is its rawowner, the anonFunClassSym.
+      //
+      // In delambdafy:method we don't have that problem. The f method is lambda-lifted into C,
+      // not into the anonymous function class. The originalOwner chain is Z - f - C.
+      if (sym.originalOwner.rawowner == sym.rawowner) sym.originalOwner
+      else sym.rawowner
+    } else {
+      origOwner
+    }
+  }
+
+  def nextEnclosingClass(sym: Symbol): Symbol =
+    if (sym.isClass) sym
+    else nextEnclosingClass(nextEnclosing(sym))
+
+  def classOriginallyNestedInClass(nestedClass: Symbol, enclosingClass: Symbol) =
+    nextEnclosingClass(nextEnclosing(nestedClass)) == enclosingClass
+
+  /**
+   * Returns the enclosing method for non-member classes. In the following example
+   *
+   * class A {
+   *   def f = {
+   *     class B {
+   *       class C
+   *     }
+   *   }
+   * }
+   *
+   * the method returns Some(f) for B, but None for C, because C is a member class. For non-member
+   * classes that are not enclosed by a method, it returns None:
+   *
+   * class A {
+   *   { class B }
+   * }
+   *
+   * In this case, for B, we return None.
+   *
+   * The EnclosingMethod attribute needs to be added to non-member classes (see doc in BTypes).
+   * This is a source-level property, so we need to use the originalOwner chain to reconstruct it.
+   */
+  private def enclosingMethodForEnclosingMethodAttribute(classSym: Symbol): Option[Symbol] = {
+    assert(classSym.isClass, classSym)
+
+    def doesNotExist(method: Symbol) = {
+      // (1) SI-9124, some trait methods don't exist in the generated interface. see comment in BTypes.
+      // (2) Value classes. Member methods of value classes exist in the generated box class. However,
+      //     nested methods lifted into a value class are moved to the companion object and don't exist
+      //     in the value class itself. We can identify such nested methods: the initial enclosing class
+      //     is a value class, but the current owner is some other class (the module class).
+      method.owner.isTrait && method.isImplOnly || { // (1)
+        val enclCls = nextEnclosingClass(method)
+        exitingPickler(enclCls.isDerivedValueClass) && method.owner != enclCls // (2)
+      }
+    }
+
+    def enclosingMethod(sym: Symbol): Option[Symbol] = {
+      if (sym.isClass || sym == NoSymbol) None
+      else if (sym.isMethod) {
+        if (doesNotExist(sym)) None else Some(sym)
+      }
+      else enclosingMethod(nextEnclosing(sym))
+    }
+    enclosingMethod(nextEnclosing(classSym))
+  }
+
+  /**
+   * The enclosing class for emitting the EnclosingMethod attribute. Since this is a source-level
+   * property, this method looks at the originalOwner chain. See doc in BTypes.
+   */
+  private def enclosingClassForEnclosingMethodAttribute(classSym: Symbol): Symbol = {
+    assert(classSym.isClass, classSym)
+    val r = nextEnclosingClass(nextEnclosing(classSym))
+    // this should be an assertion, but we are more cautious for now as it was introduced before the 2.11.6 minor release
+    if (considerAsTopLevelImplementationArtifact(r)) devWarning(s"enclosing class of $classSym should not be an implementation artifact class: $r")
+    r
+  }
+
+  final case class EnclosingMethodEntry(owner: String, name: String, methodDescriptor: String)
+
+  /**
+   * Data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not
+   * an anonymous or local class). See doc in BTypes.
+   *
+   * The class is parametrized by two functions to obtain a bytecode class descriptor for a class
+   * symbol, and to obtain a method signature descriptor fro a method symbol. These function depend
+   * on the implementation of GenASM / GenBCode, so they need to be passed in.
+   */
+  def enclosingMethodAttribute(classSym: Symbol, classDesc: Symbol => String, methodDesc: Symbol => String): Option[EnclosingMethodEntry] = {
+    // trait impl classes are always top-level, see comment in BTypes
+    if (isAnonymousOrLocalClass(classSym) && !considerAsTopLevelImplementationArtifact(classSym)) {
+      val enclosingClass = enclosingClassForEnclosingMethodAttribute(classSym)
+      val methodOpt = enclosingMethodForEnclosingMethodAttribute(classSym) match {
+        case some @ Some(m) =>
+          if (m.owner != enclosingClass) {
+            // This should never happen. In case it does, it prevents emitting an invalid
+            // EnclosingMethod attribute: if the attribute specifies an enclosing method,
+            // it needs to exist in the specified enclosing class.
+            devWarning(s"the owner of the enclosing method ${m.locationString} should be the same as the enclosing class $enclosingClass")
+            None
+          } else some
+        case none => none
+      }
+      Some(EnclosingMethodEntry(
+        classDesc(enclosingClass),
+        methodOpt.map(_.javaSimpleName.toString).orNull,
+        methodOpt.map(methodDesc).orNull))
+    } else {
+      None
+    }
+  }
+
+  /**
+   * This is basically a re-implementation of sym.isStaticOwner, but using the originalOwner chain.
+   *
+   * The problem is that we are interested in a source-level property. Various phases changed the
+   * symbol's properties in the meantime, mostly lambdalift modified (destructively) the owner.
+   * Therefore, `sym.isStatic` is not what we want. For example, in
+   *   object T { def f { object U } }
+   * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here.
+   */
+  def isOriginallyStaticOwner(sym: Symbol): Boolean =
+    sym.isPackageClass || sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner)
+
+  /**
+   * This is a hack to work around SI-9111. The completer of `methodSym` may report type errors. We
+   * cannot change the typer context of the completer at this point and make it silent: the context
+   * captured when creating the completer in the namer. However, we can temporarily replace
+   * global.reporter (it's a var) to store errors.
+   */
+  def completeSilentlyAndCheckErroneous(sym: Symbol): Boolean =
+    if (sym.hasCompleteInfo) false
+    else {
+      val originalReporter = global.reporter
+      val storeReporter = new reporters.StoreReporter()
+      global.reporter = storeReporter
+      try {
+        sym.info
+      } finally {
+        global.reporter = originalReporter
+      }
+      sym.isErroneous
+    }
+
+  /**
+   * Build the [[InlineInfo]] for a class symbol.
+   */
+  def buildInlineInfoFromClassSymbol(classSym: Symbol, classSymToInternalName: Symbol => InternalName, methodSymToDescriptor: Symbol => String): InlineInfo = {
+    val traitSelfType = if (classSym.isTrait && !classSym.isImplClass) {
+      // The mixin phase uses typeOfThis for the self parameter in implementation class methods.
+      val selfSym = classSym.typeOfThis.typeSymbol
+      if (selfSym != classSym) Some(classSymToInternalName(selfSym)) else None
+    } else {
+      None
+    }
+
+    val isEffectivelyFinal = classSym.isEffectivelyFinal
+
+    val sam = {
+      if (classSym.isImplClass || classSym.isEffectivelyFinal) None
+      else {
+        // Phase travel necessary. For example, nullary methods (getter of an abstract val) get an
+        // empty parameter list in later phases and would therefore be picked as SAM.
+        val samSym = exitingPickler(definitions.findSam(classSym.tpe))
+        if (samSym == NoSymbol) None
+        else Some(samSym.javaSimpleName.toString + methodSymToDescriptor(samSym))
+      }
+    }
+
+    var warning = Option.empty[ClassSymbolInfoFailureSI9111]
+
+    // Primitive methods cannot be inlined, so there's no point in building a MethodInlineInfo. Also, some
+    // primitive methods (e.g., `isInstanceOf`) have non-erased types, which confuses [[typeToBType]].
+    val methodInlineInfos = classSym.info.decls.iterator.filter(m => m.isMethod && !scalaPrimitives.isPrimitive(m)).flatMap({
+      case methodSym =>
+        if (completeSilentlyAndCheckErroneous(methodSym)) {
+          // Happens due to SI-9111. Just don't provide any MethodInlineInfo for that method, we don't need fail the compiler.
+          if (!classSym.isJavaDefined) devWarning("SI-9111 should only be possible for Java classes")
+          warning = Some(ClassSymbolInfoFailureSI9111(classSym.fullName))
+          None
+        } else {
+          val name      = methodSym.javaSimpleName.toString // same as in genDefDef
+          val signature = name + methodSymToDescriptor(methodSym)
+
+          // Some detours are required here because of changing flags (lateDEFERRED, lateMODULE):
+          // 1. Why the phase travel? Concrete trait methods obtain the lateDEFERRED flag in Mixin.
+          //    This makes isEffectivelyFinalOrNotOverridden false, which would prevent non-final
+          //    but non-overridden methods of sealed traits from being inlined.
+          // 2. Why the special case for `classSym.isImplClass`? Impl class symbols obtain the
+          //    lateMODULE flag during Mixin. During the phase travel to exitingPickler, the late
+          //    flag is ignored. The members are therefore not isEffectivelyFinal (their owner
+          //    is not a module). Since we know that all impl class members are static, we can
+          //    just take the shortcut.
+          val effectivelyFinal = classSym.isImplClass || exitingPickler(methodSym.isEffectivelyFinalOrNotOverridden)
+
+          // Identify trait interface methods that have a static implementation in the implementation
+          // class. Invocations of these methods can be re-wrired directly to the static implementation
+          // if they are final or the receiver is known.
+          //
+          // Using `erasure.needsImplMethod` is not enough: it keeps field accessors, module getters
+          // and super accessors. When AddInterfaces creates the impl class, these methods are
+          // initially added to it.
+          //
+          // The mixin phase later on filters out most of these members from the impl class (see
+          // Mixin.isImplementedStatically). However, accessors for concrete lazy vals remain in the
+          // impl class after mixin. So the filter in mixin is not exactly what we need here (we
+          // want to identify concrete trait methods, not any accessors). So we check some symbol
+          // properties manually.
+          val traitMethodWithStaticImplementation = {
+            import symtab.Flags._
+            classSym.isTrait && !classSym.isImplClass &&
+              erasure.needsImplMethod(methodSym) &&
+              !methodSym.isModule &&
+              !(methodSym hasFlag (ACCESSOR | SUPERACCESSOR))
+          }
+
+          val info = MethodInlineInfo(
+            effectivelyFinal                    = effectivelyFinal,
+            traitMethodWithStaticImplementation = traitMethodWithStaticImplementation,
+            annotatedInline                     = methodSym.hasAnnotation(ScalaInlineClass),
+            annotatedNoInline                   = methodSym.hasAnnotation(ScalaNoInlineClass)
+          )
+          Some((signature, info))
+        }
+    }).toMap
+
+    InlineInfo(traitSelfType, isEffectivelyFinal, sam, methodInlineInfos, warning)
+  }
 
   /*
    * must-single-thread
@@ -35,15 +342,14 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
   /*
    * must-single-thread
    */
-  def getOutFolder(csym: Symbol, cName: String, cunit: CompilationUnit): _root_.scala.tools.nsc.io.AbstractFile = {
-    try {
+  def getOutFolder(csym: Symbol, cName: String, cunit: CompilationUnit): _root_.scala.tools.nsc.io.AbstractFile =
+    _root_.scala.util.Try {
       outputDirectory(csym)
-    } catch {
+    }.recover {
       case ex: Throwable =>
         reporter.error(cunit.body.pos, s"Couldn't create file for class $cName\n${ex.getMessage}")
         null
-    }
-  }
+    }.get
 
   var pickledBytes = 0 // statistics
 
@@ -335,9 +641,79 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
   } // end of trait BCInnerClassGen
 
   trait BCAnnotGen extends BCInnerClassGen {
+    private lazy val AnnotationRetentionPolicyModule       = AnnotationRetentionPolicyAttr.companionModule
+    private lazy val AnnotationRetentionPolicySourceValue  = AnnotationRetentionPolicyModule.tpe.member(TermName("SOURCE"))
+    private lazy val AnnotationRetentionPolicyClassValue   = AnnotationRetentionPolicyModule.tpe.member(TermName("CLASS"))
+    private lazy val AnnotationRetentionPolicyRuntimeValue = AnnotationRetentionPolicyModule.tpe.member(TermName("RUNTIME"))
+
+    /** Whether an annotation should be emitted as a Java annotation
+      * .initialize: if 'annot' is read from pickle, atp might be uninitialized
+      */
+    private def shouldEmitAnnotation(annot: AnnotationInfo) = {
+      annot.symbol.initialize.isJavaDefined &&
+        annot.matches(ClassfileAnnotationClass) &&
+        retentionPolicyOf(annot) != AnnotationRetentionPolicySourceValue &&
+        annot.args.isEmpty
+    }
+
+    private def isRuntimeVisible(annot: AnnotationInfo): Boolean = {
+      annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr) match {
+        case Some(retentionAnnot) =>
+          retentionAnnot.assocs.contains(nme.value -> LiteralAnnotArg(Constant(AnnotationRetentionPolicyRuntimeValue)))
+        case _ =>
+          // SI-8926: if the annotation class symbol doesn't have a @RetentionPolicy annotation, the
+          // annotation is emitted with visibility `RUNTIME`
+          true
+      }
+    }
+
+    private def retentionPolicyOf(annot: AnnotationInfo): Symbol =
+      annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr).map(_.assocs).flatMap(assoc =>
+        assoc.collectFirst {
+          case (`nme`.value, LiteralAnnotArg(Constant(value: Symbol))) => value
+        }).getOrElse(AnnotationRetentionPolicyClassValue)
+
+    def ubytesToCharArray(bytes: Array[Byte]): Array[Char] = {
+      val ca = new Array[Char](bytes.length)
+      var idx = 0
+      while(idx < bytes.length) {
+        val b: Byte = bytes(idx)
+        assert((b & ~0x7f) == 0)
+        ca(idx) = b.asInstanceOf[Char]
+        idx += 1
+      }
 
-    import genASM.{ubytesToCharArray, arrEncode}
-    import bCodeAsmCommon.{shouldEmitAnnotation, isRuntimeVisible}
+      ca
+    }
+
+    final def arrEncode(sb: ScalaSigBytes): Array[String] = {
+      var strs: List[String]  = Nil
+      val bSeven: Array[Byte] = sb.sevenBitsMayBeZero
+      // chop into slices of at most 65535 bytes, counting 0x00 as taking two bytes (as per JVMS 4.4.7 The CONSTANT_Utf8_info Structure)
+      var prevOffset = 0
+      var offset     = 0
+      var encLength  = 0
+      while(offset < bSeven.length) {
+        val deltaEncLength = (if(bSeven(offset) == 0) 2 else 1)
+        val newEncLength = encLength.toLong + deltaEncLength
+        if(newEncLength >= 65535) {
+          val ba     = bSeven.slice(prevOffset, offset)
+          strs     ::= new java.lang.String(ubytesToCharArray(ba))
+          encLength  = 0
+          prevOffset = offset
+        } else {
+          encLength += deltaEncLength
+          offset    += 1
+        }
+      }
+      if(prevOffset < offset) {
+        assert(offset == bSeven.length)
+        val ba = bSeven.slice(prevOffset, offset)
+        strs ::= new java.lang.String(ubytesToCharArray(ba))
+      }
+      assert(strs.size > 1, "encode instead as one String via strEncode()") // TODO too strict?
+      strs.reverse.toArray
+    }
 
     /*
      *  can-multi-thread
@@ -384,7 +760,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
             av.visit(name, strEncode(sb))
           } else {
             val arrAnnotV: asm.AnnotationVisitor = av.visitArray(name)
-            for(arg <- genASM.arrEncode(sb)) { arrAnnotV.visit(name, arg) }
+            for(arg <- arrEncode(sb)) { arrAnnotV.visit(name, arg) }
             arrAnnotV.visitEnd()
           }          // for the lazy val in ScalaSigBytes to be GC'ed, the invoker of emitAnnotations() should hold the ScalaSigBytes in a method-local var that doesn't escape.
 
@@ -469,7 +845,21 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
   trait BCJGenSigGen {
 
-    def getCurrentCUnit(): CompilationUnit
+    // @M don't generate java generics sigs for (members of) implementation
+    // classes, as they are monomorphic (TODO: ok?)
+    private def needsGenericSignature(sym: Symbol) = !(
+      // PP: This condition used to include sym.hasExpandedName, but this leads
+      // to the total loss of generic information if a private member is
+      // accessed from a closure: both the field and the accessor were generated
+      // without it.  This is particularly bad because the availability of
+      // generic information could disappear as a consequence of a seemingly
+      // unrelated change.
+         settings.Ynogenericsig
+      || sym.isArtifact
+      || sym.isLiftedMethod
+      || sym.isBridge
+      || (sym.ownerChain exists (_.isImplClass))
+    )
 
     /* @return
      *   - `null` if no Java signature is to be added (`null` is what ASM expects in these cases).
@@ -477,7 +867,63 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
      *
      * must-single-thread
      */
-    def getGenericSignature(sym: Symbol, owner: Symbol): String = genASM.getGenericSignature(sym, owner, getCurrentCUnit())
+    def getGenericSignature(sym: Symbol, owner: Symbol): String = {
+      val memberTpe = enteringErasure(owner.thisType.memberInfo(sym))
+      getGenericSignature(sym, owner, memberTpe)
+    }
+
+    def getGenericSignature(sym: Symbol, owner: Symbol, memberTpe: Type): String = {
+      if (!needsGenericSignature(sym)) { return null }
+
+      val jsOpt: Option[String] = erasure.javaSig(sym, memberTpe)
+      if (jsOpt.isEmpty) { return null }
+
+      val sig = jsOpt.get
+      log(sig) // This seems useful enough in the general case.
+
+          def wrap(op: => Unit) = {
+            try   { op; true }
+            catch { case _: Throwable => false }
+          }
+
+      if (settings.Xverify) {
+        // Run the signature parser to catch bogus signatures.
+        val isValidSignature = wrap {
+          // Alternative: scala.tools.reflect.SigParser (frontend to sun.reflect.generics.parser.SignatureParser)
+          import scala.tools.asm.util.CheckClassAdapter
+          if (sym.isMethod)    { CheckClassAdapter checkMethodSignature sig } // requires asm-util.jar
+          else if (sym.isTerm) { CheckClassAdapter checkFieldSignature  sig }
+          else                 { CheckClassAdapter checkClassSignature  sig }
+        }
+
+        if(!isValidSignature) {
+          reporter.warning(sym.pos,
+              """|compiler bug: created invalid generic signature for %s in %s
+                 |signature: %s
+                 |if this is reproducible, please report bug at https://issues.scala-lang.org/
+              """.trim.stripMargin.format(sym, sym.owner.skipPackageObject.fullName, sig))
+          return null
+        }
+      }
+
+      if ((settings.check containsName phaseName)) {
+        val normalizedTpe = enteringErasure(erasure.prepareSigMap(memberTpe))
+        val bytecodeTpe = owner.thisType.memberInfo(sym)
+        if (!sym.isType && !sym.isConstructor && !(erasure.erasure(sym)(normalizedTpe) =:= bytecodeTpe)) {
+          reporter.warning(sym.pos,
+              """|compiler bug: created generic signature for %s in %s that does not conform to its erasure
+                 |signature: %s
+                 |original type: %s
+                 |normalized type: %s
+                 |erasure type: %s
+                 |if this is reproducible, please report bug at http://issues.scala-lang.org/
+              """.trim.stripMargin.format(sym, sym.owner.skipPackageObject.fullName, sig, memberTpe, normalizedTpe, bytecodeTpe))
+           return null
+        }
+      }
+
+      sig
+    }
 
   } // end of trait BCJGenSigGen
 
@@ -510,7 +956,23 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
      *
      * must-single-thread
      */
-    private def addForwarder(isRemoteClass: Boolean, jclass: asm.ClassVisitor, module: Symbol, m: Symbol) {
+    private def addForwarder(isRemoteClass: Boolean, jclass: asm.ClassVisitor, module: Symbol, m: Symbol): Unit = {
+      def staticForwarderGenericSignature(sym: Symbol, moduleClass: Symbol): String = {
+        if (sym.isDeferred) null // only add generic signature if method concrete; bug #1745
+        else {
+          // SI-3452 Static forwarder generation uses the same erased signature as the method if forwards to.
+          // By rights, it should use the signature as-seen-from the module class, and add suitable
+          // primitive and value-class boxing/unboxing.
+          // But for now, just like we did in mixin, we just avoid writing a wrong generic signature
+          // (one that doesn't erase to the actual signature). See run/t3452b for a test case.
+          val memberTpe = enteringErasure(moduleClass.thisType.memberInfo(sym))
+          val erasedMemberType = erasure.erasure(sym)(memberTpe)
+          if (erasedMemberType =:= sym.info)
+            getGenericSignature(sym, moduleClass, memberTpe)
+          else null
+        }
+      }
+
       val moduleName     = internalName(module)
       val methodInfo     = module.thisType.memberInfo(m)
       val paramJavaTypes: List[BType] = methodInfo.paramTypes map typeToBType
@@ -527,7 +989,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       )
 
       // TODO needed? for(ann <- m.annotations) { ann.symbol.initialize }
-      val jgensig = genASM.staticForwarderGenericSignature(m, module, getCurrentCUnit())
+      val jgensig = staticForwarderGenericSignature(m, module)
       addRemoteExceptionAnnot(isRemoteClass, hasPublicBitSet(flags), m)
       val (throws, others) = m.annotations partition (_.symbol == definitions.ThrowsClass)
       val thrownExceptions: List[String] = getExceptions(throws)
@@ -582,9 +1044,9 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       }
       debuglog(s"Potentially conflicting names for forwarders: $conflictingNames")
 
-      for (m <- moduleClass.info.membersBasedOnFlags(bCodeAsmCommon.ExcludedForwarderFlags, symtab.Flags.METHOD)) {
+      for (m <- moduleClass.info.membersBasedOnFlags(BCodeHelpers.ExcludedForwarderFlags, symtab.Flags.METHOD)) {
         if (m.isType || m.isDeferred || (m.owner eq definitions.ObjectClass) || m.isConstructor)
-          debuglog(s"No forwarder for '$m' from $jclassName to '$moduleClass'")
+          debuglog(s"No forwarder for '$m' from $jclassName to '$moduleClass': ${m.isType} || ${m.isDeferred} || ${m.owner eq definitions.ObjectClass} || ${m.isConstructor}")
         else if (conflictingNames(m.name))
           log(s"No forwarder for $m due to conflict with ${linkedClass.info.member(m.name)}")
         else if (m.hasAccessBoundary)
@@ -650,9 +1112,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
   /* builder of mirror classes */
   class JMirrorBuilder extends JCommonBuilder {
 
-    private var cunit: CompilationUnit = _
-    def getCurrentCUnit(): CompilationUnit = cunit;
-
     /* Generate a mirror class for a top-level module. A mirror class is a class
      *  containing only static methods that forward to the corresponding method
      *  on the MODULE instance of the given Scala object.  It will only be
@@ -664,7 +1123,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     def genMirrorClass(moduleClass: Symbol, cunit: CompilationUnit): asm.tree.ClassNode = {
       assert(moduleClass.isModuleClass)
       assert(moduleClass.companionClass == NoSymbol, moduleClass)
-      this.cunit = cunit
 
       val bType = mirrorClassClassBType(moduleClass)
       val mirrorClass = new asm.tree.ClassNode
@@ -866,3 +1324,53 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
   } // end of trait JAndroidBuilder
 }
+
+object BCodeHelpers {
+  val ExcludedForwarderFlags = {
+    import scala.tools.nsc.symtab.Flags._
+    // Should include DEFERRED but this breaks findMember.
+    SPECIALIZED | LIFTED | PROTECTED | STATIC | EXPANDEDNAME | BridgeAndPrivateFlags | MACRO
+  }
+
+  /**
+   * Valid flags for InnerClass attribute entry.
+   * See http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.6
+   */
+  val INNER_CLASSES_FLAGS = {
+    asm.Opcodes.ACC_PUBLIC   | asm.Opcodes.ACC_PRIVATE   | asm.Opcodes.ACC_PROTECTED  |
+      asm.Opcodes.ACC_STATIC   | asm.Opcodes.ACC_FINAL     | asm.Opcodes.ACC_INTERFACE  |
+      asm.Opcodes.ACC_ABSTRACT | asm.Opcodes.ACC_SYNTHETIC | asm.Opcodes.ACC_ANNOTATION |
+      asm.Opcodes.ACC_ENUM
+  }
+
+  class TestOp(val op: Int) extends AnyVal {
+    def opcodeIF = asm.Opcodes.IFEQ + op
+    def opcodeIFICMP = asm.Opcodes.IF_ICMPEQ + op
+  }
+
+  object TestOp {
+    val EQ = new TestOp(0)
+    val NE = new TestOp(1)
+    val LT = new TestOp(2)
+    val GE = new TestOp(3)
+    val GT = new TestOp(4)
+    val LE = new TestOp(5)
+  }
+
+  class InvokeStyle(val style: Int) extends AnyVal {
+    import InvokeStyle._
+    def isVirtual: Boolean = this == Virtual
+    def isStatic : Boolean = this == Static
+    def isSpecial: Boolean = this == Special
+    def isSuper  : Boolean = this == Super
+
+    def hasInstance = this != Static
+  }
+
+  object InvokeStyle {
+    val Virtual = new InvokeStyle(0) // InvokeVirtual or InvokeInterface
+    val Static  = new InvokeStyle(1) // InvokeStatic
+    val Special = new InvokeStyle(2) // InvokeSpecial (private methods, constructors)
+    val Super   = new InvokeStyle(3) // InvokeSpecial (super calls)
+  }
+}
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala
deleted file mode 100644
index 50d20921d5..0000000000
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala
+++ /dev/null
@@ -1,25 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2014 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc.backend.jvm
-
-import scala.tools.nsc.Global
-import PartialFunction._
-
-/**
- * This trait contains code shared between GenBCode and GenICode that depends on types defined in
- * the compiler cake (Global).
- */
-final class BCodeICodeCommon[G <: Global](val global: G) {
-  import global._
-
-  /** Some useful equality helpers. */
-  def isNull(t: Tree) = cond(t) { case Literal(Constant(null)) => true }
-  def isLiteral(t: Tree) = cond(t) { case Literal(_) => true }
-  def isNonNullExpr(t: Tree) = isLiteral(t) || ((t.symbol ne null) && t.symbol.isModule)
-
-  /** If l or r is constant null, returns the other ; otherwise null */
-  def ifOneIsNull(l: Tree, r: Tree) = if (isNull(l)) r else if (isNull(r)) l else null
-}
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala
index c78f422bf0..4a10756468 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala
@@ -12,6 +12,7 @@ import scala.annotation.switch
 import scala.collection.mutable
 import GenBCode._
 import scala.tools.asm.tree.MethodInsnNode
+import scala.tools.nsc.backend.jvm.BCodeHelpers.TestOp
 
 /*
  *  A high-level facade to the ASM API for bytecode generation.
@@ -106,41 +107,20 @@ abstract class BCodeIdiomatic extends SubComponent {
     def jmethod: asm.tree.MethodNode
 
     import asm.Opcodes;
-    import icodes.opcodes.{ Static, Dynamic,  SuperCall }
 
     final def emit(opc: Int) { jmethod.visitInsn(opc) }
 
-    /*
-     * can-multi-thread
-     */
-    final def genPrimitiveArithmetic(op: icodes.ArithmeticOp, kind: BType) {
-
-      import icodes.{ ADD, SUB, MUL, DIV, REM, NOT }
-
-      op match {
-
-        case ADD => add(kind)
-        case SUB => sub(kind)
-        case MUL => mul(kind)
-        case DIV => div(kind)
-        case REM => rem(kind)
-
-        case NOT =>
-          if (kind.isIntSizedType) {
-            emit(Opcodes.ICONST_M1)
-            emit(Opcodes.IXOR)
-          } else if (kind == LONG) {
-            jmethod.visitLdcInsn(new java.lang.Long(-1))
-            jmethod.visitInsn(Opcodes.LXOR)
-          } else {
-            abort(s"Impossible to negate an $kind")
-          }
-
-        case _ =>
-          abort(s"Unknown arithmetic primitive $op")
+    final def genPrimitiveNot(bType: BType): Unit = {
+      if (bType.isIntSizedType) {
+        emit(Opcodes.ICONST_M1)
+        emit(Opcodes.IXOR)
+      } else if (bType == LONG) {
+        jmethod.visitLdcInsn(new java.lang.Long(-1))
+        jmethod.visitInsn(Opcodes.LXOR)
+      } else {
+        abort(s"Impossible to negate a $bType")
       }
-
-    } // end of method genPrimitiveArithmetic()
+    }
 
     /*
      * can-multi-thread
@@ -416,13 +396,13 @@ abstract class BCodeIdiomatic extends SubComponent {
     // can-multi-thread
     final def goTo(label: asm.Label) { jmethod.visitJumpInsn(Opcodes.GOTO, label) }
     // can-multi-thread
-    final def emitIF(cond: icodes.TestOp, label: asm.Label)      { jmethod.visitJumpInsn(cond.opcodeIF,     label) }
+    final def emitIF(cond: TestOp, label: asm.Label)      { jmethod.visitJumpInsn(cond.opcodeIF,     label) }
     // can-multi-thread
-    final def emitIF_ICMP(cond: icodes.TestOp, label: asm.Label) { jmethod.visitJumpInsn(cond.opcodeIFICMP, label) }
+    final def emitIF_ICMP(cond: TestOp, label: asm.Label) { jmethod.visitJumpInsn(cond.opcodeIFICMP, label) }
     // can-multi-thread
-    final def emitIF_ACMP(cond: icodes.TestOp, label: asm.Label) {
-      assert((cond == icodes.EQ) || (cond == icodes.NE), cond)
-      val opc = (if (cond == icodes.EQ) Opcodes.IF_ACMPEQ else Opcodes.IF_ACMPNE)
+    final def emitIF_ACMP(cond: TestOp, label: asm.Label) {
+      assert((cond == TestOp.EQ) || (cond == TestOp.NE), cond)
+      val opc = (if (cond == TestOp.EQ) Opcodes.IF_ACMPEQ else Opcodes.IF_ACMPNE)
       jmethod.visitJumpInsn(opc, label)
     }
     // can-multi-thread
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
index 3fe56dd962..7180c25d25 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
@@ -25,7 +25,6 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
   import global._
   import bTypes._
   import coreBTypes._
-  import bCodeAsmCommon._
 
   /*
    * There's a dedicated PlainClassBuilder for each CompilationUnit,
@@ -83,8 +82,6 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
       global synchronized { global.log(msg) }
     }
 
-    override def getCurrentCUnit(): CompilationUnit = { cunit }
-
     /* ---------------- helper utils for generating classes and fields ---------------- */
 
     def genPlainClass(cd: ClassDef) {
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index f1b9e8ea94..c3f6399901 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -126,7 +126,7 @@ abstract class BTypes {
   /**
    * Obtain the BType for a type descriptor or internal name. For class descriptors, the ClassBType
    * is constructed by parsing the corresponding classfile.
-   * 
+   *
    * Some JVM operations use either a full descriptor or only an internal name. Example:
    *   ANEWARRAY java/lang/String    // a new array of strings (internal name for the String class)
    *   ANEWARRAY [Ljava/lang/String; // a new array of array of string (full descriptor for the String class)
@@ -932,7 +932,7 @@ abstract class BTypes {
             // the static flag in the InnerClass table has a special meaning, see InnerClass comment
             i.flags & ~Opcodes.ACC_STATIC,
             if (isStaticNestedClass) Opcodes.ACC_STATIC else 0
-          ) & BCodeAsmCommon.INNER_CLASSES_FLAGS
+          ) & BCodeHelpers.INNER_CLASSES_FLAGS
         )
     })
 
@@ -1192,4 +1192,4 @@ object BTypes {
   // no static way (without symbol table instance) to get to nme.ScalaATTR / ScalaSignatureATTR
   val ScalaAttributeName    = "Scala"
   val ScalaSigAttributeName = "ScalaSig"
-}
\ No newline at end of file
+}
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index 35b84cc4a9..9bfa7dae27 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -28,10 +28,7 @@ import scala.tools.nsc.settings.ScalaSettings
 class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
   import global._
   import definitions._
-
-  val bCodeICodeCommon: BCodeICodeCommon[global.type] = new BCodeICodeCommon(global)
-  val bCodeAsmCommon: BCodeAsmCommon[global.type] = new BCodeAsmCommon(global)
-  import bCodeAsmCommon._
+  import genBCode._
 
   val backendUtils: BackendUtils[this.type] = new BackendUtils(this)
 
@@ -220,7 +217,101 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     assert(!primitiveTypeToBType.contains(sym) || isCompilingPrimitive, sym)
   }
 
+  def implementedInterfaces(classSym: Symbol): List[Symbol] = {
+    // Additional interface parents based on annotations and other cues
+    def newParentForAnnotation(ann: AnnotationInfo): Option[Type] = ann.symbol match {
+      case RemoteAttr => Some(RemoteInterfaceClass.tpe)
+      case _          => None
+    }
+
+    // SI-9393: java annotations are interfaces, but the classfile / java source parsers make them look like classes.
+    def isInterfaceOrTrait(sym: Symbol) = sym.isInterface || sym.isTrait || sym.hasJavaAnnotationFlag
+
+    val classParents = {
+      val parents = classSym.info.parents
+      // SI-9393: the classfile / java source parsers add Annotation and ClassfileAnnotation to the
+      // parents of a java annotations. undo this for the backend (where we need classfile-level information).
+      if (classSym.hasJavaAnnotationFlag) parents.filterNot(c => c.typeSymbol == ClassfileAnnotationClass || c.typeSymbol == AnnotationClass)
+      else parents
+    }
+
+    val allParents = classParents ++ classSym.annotations.flatMap(newParentForAnnotation)
+
+    // We keep the superClass when computing minimizeParents to eliminate more interfaces.
+    // Example: T can be eliminated from D
+    //   trait T
+    //   class C extends T
+    //   class D extends C with T
+    val interfaces = erasure.minimizeParents(allParents) match {
+      case superClass :: ifs if !isInterfaceOrTrait(superClass.typeSymbol) =>
+        ifs
+      case ifs =>
+        // minimizeParents removes the superclass if it's redundant, for example:
+        //  trait A
+        //  class C extends Object with A  // minimizeParents removes Object
+        ifs
+    }
+    interfaces.map(_.typeSymbol)
+  }
+
+  /**
+   * The member classes of a class symbol. Note that the result of this method depends on the
+   * current phase, for example, after lambdalift, all local classes become member of the enclosing
+   * class.
+   *
+   * Impl classes are always considered top-level, see comment in BTypes.
+   */
+  private def memberClassesForInnerClassTable(classSymbol: Symbol): List[Symbol] = classSymbol.info.decls.collect({
+    case sym if sym.isClass && !considerAsTopLevelImplementationArtifact(sym) =>
+      sym
+    case sym if sym.isModule && !considerAsTopLevelImplementationArtifact(sym) => // impl classes get the lateMODULE flag in mixin
+      val r = exitingPickler(sym.moduleClass)
+      assert(r != NoSymbol, sym.fullLocationString)
+      r
+  })(collection.breakOut)
+
   private def setClassInfo(classSym: Symbol, classBType: ClassBType): ClassBType = {
+    /**
+     * Reconstruct the classfile flags from a Java defined class symbol.
+     *
+     * The implementation of this method is slightly different from `javaFlags` in BTypesFromSymbols.
+     * The javaFlags method is primarily used to map Scala symbol flags to sensible classfile flags
+     * that are used in the generated classfiles. For example, all classes emitted by the Scala
+     * compiler have ACC_PUBLIC.
+     *
+     * When building a [[ClassBType]] from a Java class symbol, the flags in the type's `info` have
+     * to correspond exactly to the flags in the classfile. For example, if the class is package
+     * protected (i.e., it doesn't have the ACC_PUBLIC flag), this needs to be reflected in the
+     * ClassBType. For example, the inliner needs the correct flags for access checks.
+     *
+     * Class flags are listed here:
+     *   https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.1-200-E.1
+     */
+    def javaClassfileFlags(classSym: Symbol): Int = {
+      assert(classSym.isJava, s"Expected Java class symbol, got ${classSym.fullName}")
+      import asm.Opcodes._
+      def enumFlags = ACC_ENUM | {
+        // Java enums have the `ACC_ABSTRACT` flag if they have a deferred method.
+        // We cannot trust `hasAbstractFlag`: the ClassfileParser adds `ABSTRACT` and `SEALED` to all
+        // Java enums for exhaustiveness checking.
+        val hasAbstractMethod = classSym.info.decls.exists(s => s.isMethod && s.isDeferred)
+        if (hasAbstractMethod) ACC_ABSTRACT else 0
+      }
+      GenBCode.mkFlags(
+        // SI-9393: the classfile / java source parser make java annotation symbols look like classes.
+        // here we recover the actual classfile flags.
+        if (classSym.hasJavaAnnotationFlag)                        ACC_ANNOTATION | ACC_INTERFACE | ACC_ABSTRACT else 0,
+        if (classSym.isPublic)                                     ACC_PUBLIC    else 0,
+        if (classSym.isFinal)                                      ACC_FINAL     else 0,
+        // see the link above. javac does the same: ACC_SUPER for all classes, but not interfaces.
+        if (classSym.isInterface)                                  ACC_INTERFACE else ACC_SUPER,
+        // for Java enums, we cannot trust `hasAbstractFlag` (see comment in enumFlags)
+        if (!classSym.hasJavaEnumFlag && classSym.hasAbstractFlag) ACC_ABSTRACT  else 0,
+        if (classSym.isArtifact)                                   ACC_SYNTHETIC else 0,
+        if (classSym.hasJavaEnumFlag)                              enumFlags     else 0
+      )
+    }
+
     // Check for isImplClass: trait implementation classes have NoSymbol as superClass
     // Check for hasAnnotationFlag for SI-9393: the classfile / java source parsers add
     // scala.annotation.Annotation as superclass to java annotations. In reality, java
@@ -580,7 +671,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     // Primitives are "abstract final" to prohibit instantiation
     // without having to provide any implementations, but that is an
     // illegal combination of modifiers at the bytecode level so
-    // suppress final if abstract if present.
+    // suppress final if abstract is present.
     import asm.Opcodes._
     GenBCode.mkFlags(
       if (privateFlag) ACC_PRIVATE else ACC_PUBLIC,
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
index 0eaf509133..8bb71a386f 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
@@ -106,6 +106,9 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: Global]](val bTypes: BTFS) {
   lazy val jliSerializedLambdaRef    : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.SerializedLambda])
   lazy val jliMethodHandlesRef       : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.MethodHandles])
   lazy val jliMethodHandlesLookupRef : ClassBType = classBTypeFromSymbol(exitingPickler(getRequiredClass("java.lang.invoke.MethodHandles.Lookup"))) // didn't find a reliable non-stringly-typed way that works for inner classes in the backend
+  lazy val jliMethodTypeRef          : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.MethodType])
+  lazy val jliCallSiteRef            : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.CallSite])
+  lazy val jliLambdaMetafactoryRef   : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.LambdaMetafactory])
   lazy val srLambdaDeserializerRef   : ClassBType = classBTypeFromSymbol(requiredModule[scala.runtime.LambdaDeserializer.type].moduleClass)
   lazy val srBoxesRunTimeRef         : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.BoxesRunTime])
   lazy val srBoxedUnitRef            : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.BoxedUnit])
@@ -350,6 +353,9 @@ final class CoreBTypesProxy[BTFS <: BTypesFromSymbols[_ <: Global]](val bTypes:
   def jliSerializedLambdaRef    : ClassBType = _coreBTypes.jliSerializedLambdaRef
   def jliMethodHandlesRef       : ClassBType = _coreBTypes.jliMethodHandlesRef
   def jliMethodHandlesLookupRef : ClassBType = _coreBTypes.jliMethodHandlesLookupRef
+  def jliMethodTypeRef          : ClassBType = _coreBTypes.jliMethodTypeRef
+  def jliCallSiteRef            : ClassBType = _coreBTypes.jliCallSiteRef
+  def jliLambdaMetafactoryRef   : ClassBType = _coreBTypes.jliLambdaMetafactoryRef
   def srLambdaDeserializerRef   : ClassBType = _coreBTypes.srLambdaDeserializerRef
   def srBoxesRunTimeRef         : ClassBType = _coreBTypes.srBoxesRunTimeRef
   def srBoxedUnitRef            : ClassBType = _coreBTypes.srBoxedUnitRef
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
deleted file mode 100644
index 4424a3796b..0000000000
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ /dev/null
@@ -1,3355 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala
-package tools.nsc
-package backend.jvm
-
-import scala.collection.{ mutable, immutable }
-import scala.reflect.internal.pickling.{ PickleFormat, PickleBuffer }
-import scala.tools.nsc.backend.jvm.opt.InlineInfoAttribute
-import scala.tools.nsc.symtab._
-import scala.tools.asm
-import asm.Label
-import scala.annotation.tailrec
-
-/**
- *  @author  Iulian Dragos (version 1.0, FJBG-based implementation)
- *  @author  Miguel Garcia (version 2.0,  ASM-based implementation)
- *
- * Documentation at http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/2012Q2/GenASM.pdf
- */
-abstract class GenASM extends SubComponent with BytecodeWriters { self =>
-  import global._
-  import icodes._
-  import icodes.opcodes._
-  import definitions._
-
-  val bCodeAsmCommon: BCodeAsmCommon[global.type] = new BCodeAsmCommon(global)
-  import bCodeAsmCommon._
-
-  // Strangely I can't find this in the asm code
-  // 255, but reserving 1 for "this"
-  final val MaximumJvmParameters = 254
-
-  val phaseName = "jvm"
-
-  /** Create a new phase */
-  override def newPhase(p: Phase): Phase = new AsmPhase(p)
-
-  /** From the reference documentation of the Android SDK:
-   *  The `Parcelable` interface identifies classes whose instances can be written to and restored from a `Parcel`.
-   *  Classes implementing the `Parcelable` interface must also have a static field called `CREATOR`,
-   *  which is an object implementing the `Parcelable.Creator` interface.
-   */
-  private val androidFieldName = newTermName("CREATOR")
-
-  private lazy val AndroidParcelableInterface = rootMirror.getClassIfDefined("android.os.Parcelable")
-  private lazy val AndroidCreatorClass        = rootMirror.getClassIfDefined("android.os.Parcelable$Creator")
-
-  /** JVM code generation phase
-   */
-  class AsmPhase(prev: Phase) extends ICodePhase(prev) {
-    def name = phaseName
-    override def erasedTypes = true
-    def apply(cls: IClass) = sys.error("no implementation")
-
-    // An AsmPhase starts and ends within a Run, thus the caches in question will get populated and cleared within a Run, too), SI-7422
-    javaNameCache.clear()
-    javaNameCache ++= List(
-      NothingClass        -> binarynme.RuntimeNothing,
-      RuntimeNothingClass -> binarynme.RuntimeNothing,
-      NullClass           -> binarynme.RuntimeNull,
-      RuntimeNullClass    -> binarynme.RuntimeNull
-    )
-
-    // unlike javaNameCache, reverseJavaName contains entries only for class symbols and their internal names.
-    reverseJavaName.clear()
-    reverseJavaName ++= List(
-      binarynme.RuntimeNothing.toString() -> RuntimeNothingClass, // RuntimeNothingClass is the bytecode-level return type of Scala methods with Nothing return-type.
-      binarynme.RuntimeNull.toString()    -> RuntimeNullClass
-    )
-
-    // Lazy val; can't have eager vals in Phase constructors which may
-    // cause cycles before Global has finished initialization.
-    lazy val BeanInfoAttr = rootMirror.getRequiredClass("scala.beans.BeanInfo")
-
-    private def initBytecodeWriter(entryPoints: List[IClass]): BytecodeWriter = {
-      settings.outputDirs.getSingleOutput match {
-        case Some(f) if f hasExtension "jar" =>
-          // If no main class was specified, see if there's only one
-          // entry point among the classes going into the jar.
-          if (settings.mainClass.isDefault) {
-            entryPoints map (_.symbol fullName '.') match {
-              case Nil      =>
-                log("No Main-Class designated or discovered.")
-              case name :: Nil =>
-                log("Unique entry point: setting Main-Class to " + name)
-                settings.mainClass.value = name
-              case names =>
-                log("No Main-Class due to multiple entry points:\n  " + names.mkString("\n  "))
-            }
-          }
-          else log("Main-Class was specified: " + settings.mainClass.value)
-
-          new DirectToJarfileWriter(f.file)
-
-        case _ => factoryNonJarBytecodeWriter()
-      }
-    }
-
-    private def isJavaEntryPoint(icls: IClass) = {
-      val sym = icls.symbol
-      def fail(msg: String, pos: Position = sym.pos) = {
-        reporter.warning(sym.pos,
-          sym.name + " has a main method with parameter type Array[String], but " + sym.fullName('.') + " will not be a runnable program.\n" +
-            "  Reason: " + msg
-          // TODO: make this next claim true, if possible
-          //   by generating valid main methods as static in module classes
-          //   not sure what the jvm allows here
-          // + "  You can still run the program by calling it as " + sym.javaSimpleName + " instead."
-        )
-        false
-      }
-      def failNoForwarder(msg: String) = {
-        fail(msg + ", which means no static forwarder can be generated.\n")
-      }
-      val possibles = if (sym.hasModuleFlag) (sym.tpe nonPrivateMember nme.main).alternatives else Nil
-      val hasApproximate = possibles exists { m =>
-        m.info match {
-          case MethodType(p :: Nil, _) => p.tpe.typeSymbol == ArrayClass
-          case _                       => false
-        }
-      }
-      // At this point it's a module with a main-looking method, so either succeed or warn that it isn't.
-      hasApproximate && {
-        // Before erasure so we can identify generic mains.
-        enteringErasure {
-          val companion     = sym.linkedClassOfClass
-
-          if (hasJavaMainMethod(companion))
-            failNoForwarder("companion contains its own main method")
-          else if (companion.tpe.member(nme.main) != NoSymbol)
-            // this is only because forwarders aren't smart enough yet
-            failNoForwarder("companion contains its own main method (implementation restriction: no main is allowed, regardless of signature)")
-          else if (companion.isTrait)
-            failNoForwarder("companion is a trait")
-          // Now either succeeed, or issue some additional warnings for things which look like
-          // attempts to be java main methods.
-          else (possibles exists isJavaMainMethod) || {
-            possibles exists { m =>
-              m.info match {
-                case PolyType(_, _) =>
-                  fail("main methods cannot be generic.")
-                case MethodType(params, res) =>
-                  if (res.typeSymbol :: params exists (_.isAbstractType))
-                    fail("main methods cannot refer to type parameters or abstract types.", m.pos)
-                  else
-                    isJavaMainMethod(m) || fail("main method must have exact signature (Array[String])Unit", m.pos)
-                case tp =>
-                  fail("don't know what this is: " + tp, m.pos)
-              }
-            }
-          }
-        }
-      }
-    }
-
-    override def run() {
-
-      if (settings.debug)
-        inform("[running phase " + name + " on icode]")
-
-      if (settings.Xdce) {
-        val classes = icodes.classes.keys.toList // copy to avoid mutating the map while iterating
-        for (sym <- classes if inliner.isClosureClass(sym) && !deadCode.liveClosures(sym)) {
-          log(s"Optimizer eliminated ${sym.fullNameString}")
-          deadCode.elidedClosures += sym
-          icodes.classes -= sym
-        }
-      }
-
-      // For predictably ordered error messages.
-      var sortedClasses = classes.values.toList sortBy (_.symbol.fullName)
-
-      // Warn when classes will overwrite one another on case-insensitive systems.
-      for ((_, v1 :: v2 :: _) <- sortedClasses groupBy (_.symbol.javaClassName.toString.toLowerCase)) {
-        reporter.warning(v1.symbol.pos,
-          s"Class ${v1.symbol.javaClassName} differs only in case from ${v2.symbol.javaClassName}. " +
-          "Such classes will overwrite one another on case-insensitive filesystems.")
-      }
-
-      debuglog(s"Created new bytecode generator for ${classes.size} classes.")
-      val bytecodeWriter  = initBytecodeWriter(sortedClasses filter isJavaEntryPoint)
-      val needsOutfile    = bytecodeWriter.isInstanceOf[ClassBytecodeWriter]
-      val plainCodeGen    = new JPlainBuilder(   bytecodeWriter, needsOutfile)
-      val mirrorCodeGen   = new JMirrorBuilder(  bytecodeWriter, needsOutfile)
-      val beanInfoCodeGen = new JBeanInfoBuilder(bytecodeWriter, needsOutfile)
-
-      def emitFor(c: IClass) {
-        if (isStaticModule(c.symbol) && isTopLevelModule(c.symbol)) {
-          if (c.symbol.companionClass == NoSymbol)
-            mirrorCodeGen genMirrorClass (c.symbol, c.cunit)
-          else
-            log(s"No mirror class for module with linked class: ${c.symbol.fullName}")
-        }
-        plainCodeGen genClass c
-        if (c.symbol hasAnnotation BeanInfoAttr) beanInfoCodeGen genBeanInfoClass c
-      }
-
-      while (!sortedClasses.isEmpty) {
-        val c = sortedClasses.head
-        try emitFor(c)
-        catch {
-          case e: FileConflictException =>
-            reporter.error(c.symbol.pos, s"error writing ${c.symbol}: ${e.getMessage}")
-        }
-        sortedClasses = sortedClasses.tail
-        classes -= c.symbol // GC opportunity
-      }
-
-      bytecodeWriter.close()
-
-      /* don't javaNameCache.clear() because that causes the following tests to fail:
-       *   test/files/run/macro-repl-dontexpand.scala
-       *   test/files/jvm/interpreter.scala
-       * TODO but why? what use could javaNameCache possibly see once GenASM is over?
-       */
-
-      /* TODO After emitting all class files (e.g., in a separate compiler phase) ASM can perform bytecode verification:
-       *
-       * (1) call the asm.util.CheckAdapter.verify() overload:
-       *     public static void verify(ClassReader cr, ClassLoader loader, boolean dump, PrintWriter pw)
-       *
-       * (2) passing a custom ClassLoader to verify inter-dependent classes.
-       *
-       * Alternatively, an offline-bytecode verifier could be used (e.g. Maxine brings one as separate tool).
-       */
-
-    } // end of AsmPhase.run()
-
-  } // end of class AsmPhase
-
-  var pickledBytes = 0 // statistics
-
-  val javaNameCache = perRunCaches.newAnyRefMap[Symbol, Name]()
-
-  // unlike javaNameCache, reverseJavaName contains entries only for class symbols and their internal names.
-  val reverseJavaName = perRunCaches.newAnyRefMap[String, Symbol]()
-
-  private def mkFlags(args: Int*)         = args.foldLeft(0)(_ | _)
-  private def hasPublicBitSet(flags: Int) = (flags & asm.Opcodes.ACC_PUBLIC) != 0
-  private def isRemote(s: Symbol)         = s hasAnnotation RemoteAttr
-
-  /**
-   * Return the Java modifiers for the given symbol.
-   * Java modifiers for classes:
-   *  - public, abstract, final, strictfp (not used)
-   * for interfaces:
-   *  - the same as for classes, without 'final'
-   * for fields:
-   *  - public, private (*)
-   *  - static, final
-   * for methods:
-   *  - the same as for fields, plus:
-   *  - abstract, synchronized (not used), strictfp (not used), native (not used)
-   *
-   *  (*) protected cannot be used, since inner classes 'see' protected members,
-   *      and they would fail verification after lifted.
-   */
-  def javaFlags(sym: Symbol): Int = {
-    // constructors of module classes should be private
-    // PP: why are they only being marked private at this stage and not earlier?
-    val privateFlag =
-      sym.isPrivate || (sym.isPrimaryConstructor && isTopLevelModule(sym.owner))
-
-    // Final: the only fields which can receive ACC_FINAL are eager vals.
-    // Neither vars nor lazy vals can, because:
-    //
-    // Source: http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.5.3
-    // "Another problem is that the specification allows aggressive
-    // optimization of final fields. Within a thread, it is permissible to
-    // reorder reads of a final field with those modifications of a final
-    // field that do not take place in the constructor."
-    //
-    // A var or lazy val which is marked final still has meaning to the
-    // scala compiler. The word final is heavily overloaded unfortunately;
-    // for us it means "not overridable". At present you can't override
-    // vars regardless; this may change.
-    //
-    // The logic does not check .isFinal (which checks flags for the FINAL flag,
-    // and includes symbols marked lateFINAL) instead inspecting rawflags so
-    // we can exclude lateFINAL. Such symbols are eligible for inlining, but to
-    // avoid breaking proxy software which depends on subclassing, we do not
-    // emit ACC_FINAL.
-    // Nested objects won't receive ACC_FINAL in order to allow for their overriding.
-
-    val finalFlag = (
-         (((sym.rawflags & Flags.FINAL) != 0) || isTopLevelModule(sym))
-      && !sym.enclClass.isInterface
-      && !sym.isClassConstructor
-      && !sym.isMutable // lazy vals and vars both
-    )
-
-    // Primitives are "abstract final" to prohibit instantiation
-    // without having to provide any implementations, but that is an
-    // illegal combination of modifiers at the bytecode level so
-    // suppress final if abstract if present.
-    import asm.Opcodes._
-    mkFlags(
-      if (privateFlag) ACC_PRIVATE else ACC_PUBLIC,
-      if (sym.isDeferred || sym.hasAbstractFlag) ACC_ABSTRACT else 0,
-      if (sym.isInterface) ACC_INTERFACE else 0,
-      if (finalFlag && !sym.hasAbstractFlag) ACC_FINAL else 0,
-      if (sym.isStaticMember) ACC_STATIC else 0,
-      if (sym.isBridge) ACC_BRIDGE | ACC_SYNTHETIC else 0,
-      if (sym.isArtifact) ACC_SYNTHETIC else 0,
-      if (sym.isClass && !sym.isInterface) ACC_SUPER else 0,
-      if (sym.hasJavaEnumFlag) ACC_ENUM else 0,
-      if (sym.isVarargsMethod) ACC_VARARGS else 0,
-      if (sym.hasFlag(Flags.SYNCHRONIZED)) ACC_SYNCHRONIZED else 0
-    )
-  }
-
-  def javaFieldFlags(sym: Symbol) = {
-    javaFlags(sym) | mkFlags(
-      if (sym hasAnnotation TransientAttr) asm.Opcodes.ACC_TRANSIENT else 0,
-      if (sym hasAnnotation VolatileAttr)  asm.Opcodes.ACC_VOLATILE  else 0,
-      if (sym.isMutable) 0 else asm.Opcodes.ACC_FINAL
-    )
-  }
-
-  def isTopLevelModule(sym: Symbol): Boolean =
-    exitingPickler { sym.isModuleClass && !sym.isImplClass && !sym.isNestedClass }
-
-  def isStaticModule(sym: Symbol): Boolean = {
-    sym.isModuleClass && !sym.isImplClass && !sym.isLifted
-  }
-
-  // -----------------------------------------------------------------------------------------
-  // finding the least upper bound in agreement with the bytecode verifier (given two internal names handed by ASM)
-  // Background:
-  //  http://gallium.inria.fr/~xleroy/publi/bytecode-verification-JAR.pdf
-  //  http://comments.gmane.org/gmane.comp.java.vm.languages/2293
-  //  https://issues.scala-lang.org/browse/SI-3872
-  // -----------------------------------------------------------------------------------------
-
-  /**
-   * Given an internal name (eg "java/lang/Integer") returns the class symbol for it.
-   *
-   * Better not to need this method (an example where control flow arrives here is welcome).
-   * This method is invoked only upon both (1) and (2) below happening:
-   *   (1) providing an asm.ClassWriter with an internal name by other means than javaName()
-   *   (2) forgetting to track the corresponding class-symbol in reverseJavaName.
-   *
-   * (The first item is already unlikely because we rely on javaName()
-   *  to do the bookkeeping for entries that should go in innerClassBuffer.)
-   *
-   * (We could do completely without this method at the expense of computing stack-map-frames ourselves and
-   *  invoking visitFrame(), but that would require another pass over all instructions.)
-   *
-   * Right now I can't think of any invocation of visitSomething() on MethodVisitor
-   * where we hand an internal name not backed by a reverseJavaName.
-   * However, I'm leaving this note just in case any such oversight is discovered.
-   */
-  def inameToSymbol(iname: String): Symbol = {
-    val name = global.newTypeName(iname)
-    val res0 =
-      if (nme.isModuleName(name)) rootMirror.getModuleByName(name.dropModule)
-      else                        rootMirror.getClassByName(name.replace('/', '.')) // TODO fails for inner classes (but this hasn't been tested).
-    assert(res0 != NoSymbol)
-    val res = jsymbol(res0)
-    res
-  }
-
-  def jsymbol(sym: Symbol): Symbol = {
-    if(sym.isJavaDefined && sym.isModuleClass) sym.linkedClassOfClass
-    else if(sym.isModule) sym.moduleClass
-    else sym // we track only module-classes and plain-classes
-  }
-
-  private def superClasses(s: Symbol): List[Symbol] = {
-    assert(!s.isInterface)
-    s.superClass match {
-      case NoSymbol => List(s)
-      case sc       => s :: superClasses(sc)
-    }
-  }
-
-  private def firstCommonSuffix(as: List[Symbol], bs: List[Symbol]): Symbol = {
-    assert(!(as contains NoSymbol))
-    assert(!(bs contains NoSymbol))
-    var chainA = as
-    var chainB = bs
-    var fcs: Symbol = NoSymbol
-    do {
-      if      (chainB contains chainA.head) fcs = chainA.head
-      else if (chainA contains chainB.head) fcs = chainB.head
-      else {
-        chainA = chainA.tail
-        chainB = chainB.tail
-      }
-    } while(fcs == NoSymbol)
-    fcs
-  }
-
-  private def jvmWiseLUB(a: Symbol, b: Symbol): Symbol = {
-    assert(a.isClass)
-    assert(b.isClass)
-
-    val res = (a.isInterface, b.isInterface) match {
-      case (true, true) =>
-        global.lub(List(a.tpe, b.tpe)).typeSymbol // TODO assert == firstCommonSuffix of resp. parents
-      case (true, false) =>
-        if(b isSubClass a) a else ObjectClass
-      case (false, true) =>
-        if(a isSubClass b) b else ObjectClass
-      case _ =>
-        firstCommonSuffix(superClasses(a), superClasses(b))
-    }
-    assert(res != NoSymbol)
-    res
-  }
-
-  /* The internal name of the least common ancestor of the types given by inameA and inameB.
-     It's what ASM needs to know in order to compute stack map frames, http://asm.ow2.org/doc/developer-guide.html#controlflow */
-  def getCommonSuperClass(inameA: String, inameB: String): String = {
-    val a = reverseJavaName.getOrElseUpdate(inameA, inameToSymbol(inameA))
-    val b = reverseJavaName.getOrElseUpdate(inameB, inameToSymbol(inameB))
-
-    // global.lub(List(a.tpe, b.tpe)).typeSymbol.javaBinaryName.toString()
-    // icodes.lub(icodes.toTypeKind(a.tpe), icodes.toTypeKind(b.tpe)).toType
-    val lcaSym  = jvmWiseLUB(a, b)
-    val lcaName = lcaSym.javaBinaryName.toString // don't call javaName because that side-effects innerClassBuffer.
-    val oldsym  = reverseJavaName.put(lcaName, lcaSym)
-    assert(oldsym.isEmpty || (oldsym.get == lcaSym), "somehow we're not managing to compute common-super-class for ASM consumption")
-    assert(lcaName != "scala/Any")
-
-    lcaName // TODO ASM caches the answer during the lifetime of a ClassWriter. We outlive that. Do some caching.
-  }
-
-  class CClassWriter(flags: Int) extends asm.ClassWriter(flags) {
-    override def getCommonSuperClass(iname1: String, iname2: String): String = {
-      GenASM.this.getCommonSuperClass(iname1, iname2)
-    }
-  }
-
-  // -----------------------------------------------------------------------------------------
-  // constants
-  // -----------------------------------------------------------------------------------------
-
-  private val classfileVersion: Int = settings.target.value match {
-    case "jvm-1.8"     => asm.Opcodes.V1_8
-  }
-
-  private val majorVersion: Int = (classfileVersion & 0xFF)
-  private val emitStackMapFrame = (majorVersion >= 50)
-
-  private val extraProc: Int = mkFlags(
-    asm.ClassWriter.COMPUTE_MAXS,
-    if(emitStackMapFrame) asm.ClassWriter.COMPUTE_FRAMES else 0
-  )
-
-  val JAVA_LANG_OBJECT = asm.Type.getObjectType("java/lang/Object")
-  val JAVA_LANG_STRING = asm.Type.getObjectType("java/lang/String")
-
-  /**
-   *  We call many Java varargs methods from ASM library that expect Arra[asm.Type] as argument so
-   *  we override default (compiler-generated) ClassTag so we can provide specialized newArray implementation.
-   *
-   *  Examples of methods that should pick our definition are: JBuilder.javaType and JPlainBuilder.genMethod.
-   */
-  private implicit val asmTypeTag: scala.reflect.ClassTag[asm.Type] = new scala.reflect.ClassTag[asm.Type] {
-    def runtimeClass: java.lang.Class[asm.Type] = classOf[asm.Type]
-    final override def newArray(len: Int): Array[asm.Type] = new Array[asm.Type](len)
-  }
-
-  /** basic functionality for class file building */
-  abstract class JBuilder(bytecodeWriter: BytecodeWriter, needsOutfile: Boolean) {
-
-    val EMPTY_STRING_ARRAY = Array.empty[String]
-
-    val mdesc_arglessvoid = "()V"
-
-    val CLASS_CONSTRUCTOR_NAME    = "<clinit>"
-    val INSTANCE_CONSTRUCTOR_NAME = "<init>"
-
-    // -----------------------------------------------------------------------------------------
-    // factory methods
-    // -----------------------------------------------------------------------------------------
-
-    /**
-     * Returns a new ClassWriter for the class given by arguments.
-     *
-     * @param access the class's access flags. This parameter also indicates if the class is deprecated.
-     *
-     * @param name the internal name of the class.
-     *
-     * @param signature the signature of this class. May be <tt>null</tt> if
-     *        the class is not a generic one, and does not extend or implement
-     *        generic classes or interfaces.
-     *
-     * @param superName the internal of name of the super class. For interfaces,
-     *        the super class is [[Object]]. May be <tt>null</tt>, but
-     *        only for the [[Object]] class.
-     *
-     * @param interfaces the internal names of the class's interfaces (see
-     *        {@link Type#getInternalName() getInternalName}). May be
-     *        <tt>null</tt>.
-     */
-    def createJClass(access: Int, name: String, signature: String, superName: String, interfaces: Array[String]): asm.ClassWriter = {
-      val cw = new CClassWriter(extraProc)
-      cw.visit(classfileVersion,
-               access, name, signature,
-               superName, interfaces)
-
-      cw
-    }
-
-    def createJAttribute(name: String, b: Array[Byte], offset: Int, len: Int): asm.Attribute = {
-      val dest = new Array[Byte](len)
-      System.arraycopy(b, offset, dest, 0, len)
-      new asm.CustomAttr(name, dest)
-    }
-
-    // -----------------------------------------------------------------------------------------
-    // utilities useful when emitting plain, mirror, and beaninfo classes.
-    // -----------------------------------------------------------------------------------------
-
-    def writeIfNotTooBig(label: String, jclassName: String, jclass: asm.ClassWriter, sym: Symbol) {
-      try {
-        val arr = jclass.toByteArray()
-        val outF: scala.tools.nsc.io.AbstractFile = {
-          if(needsOutfile) getFile(sym, jclassName, ".class") else null
-        }
-        bytecodeWriter.writeClass(label, jclassName, arr, outF)
-      } catch {
-        case e: java.lang.RuntimeException if e.getMessage != null && (e.getMessage contains "too large!") =>
-          reporter.error(sym.pos,
-            s"Could not write class $jclassName because it exceeds JVM code size limits. ${e.getMessage}")
-        case e: java.io.IOException if e.getMessage != null && (e.getMessage contains "File name too long")  =>
-          reporter.error(sym.pos, e.getMessage + "\n" +
-            "This can happen on some encrypted or legacy file systems.  Please see SI-3623 for more details.")
-
-      }
-    }
-
-    /** Specialized array conversion to prevent calling
-     *  java.lang.reflect.Array.newInstance via TraversableOnce.toArray
-     */
-    def mkArray(xs: Traversable[String]):    Array[String]    = { val a = new Array[String](xs.size);   xs.copyToArray(a); a }
-
-    // -----------------------------------------------------------------------------------------
-    // Getters for (JVMS 4.2) internal and unqualified names (represented as JType instances).
-    // These getters track behind the scenes the inner classes referred to in the class being emitted,
-    // so as to build the InnerClasses attribute (JVMS 4.7.6) via `addInnerClasses()`
-    // (which also adds as member classes those inner classes that have been declared,
-    // thus also covering the case of inner classes declared but otherwise not referred).
-    // -----------------------------------------------------------------------------------------
-
-    val innerClassBuffer = mutable.LinkedHashSet[Symbol]()
-
-    /** For given symbol return a symbol corresponding to a class that should be declared as inner class.
-     *
-     *  For example:
-     *  class A {
-     *    class B
-     *    object C
-     *  }
-     *
-     *  then method will return:
-     *    NoSymbol for A,
-     *    the same symbol for A.B (corresponding to A$B class), and
-     *    A$C$ symbol for A.C.
-     */
-    def innerClassSymbolFor(s: Symbol): Symbol =
-      if (s.isClass) s else if (s.isModule) s.moduleClass else NoSymbol
-
-    /** Return the name of this symbol that can be used on the Java platform.  It removes spaces from names.
-     *
-     *  Special handling:
-     *    scala.Nothing erases to scala.runtime.Nothing$
-     *       scala.Null erases to scala.runtime.Null$
-     *
-     *  This is needed because they are not real classes, and they mean
-     *  'abrupt termination upon evaluation of that expression' or null respectively.
-     *  This handling is done already in GenICode, but here we need to remove
-     *  references from method signatures to these types, because such classes
-     *  cannot exist in the classpath: the type checker will be very confused.
-     */
-    def javaName(sym: Symbol): String = {
-
-        /*
-         * Checks if given symbol corresponds to inner class/object and add it to innerClassBuffer
-         *
-         * Note: This method is called recursively thus making sure that we add complete chain
-         * of inner class all until root class.
-         */
-        def collectInnerClass(s: Symbol): Unit = {
-          // TODO: some enteringFlatten { ... } which accounts for
-          // being nested in parameterized classes (if we're going to selectively flatten.)
-          val x = innerClassSymbolFor(s)
-          if(x ne NoSymbol) {
-            assert(x.isClass, "not an inner-class symbol")
-            // impl classes are considered top-level, see comment in BTypes
-            val isInner = !considerAsTopLevelImplementationArtifact(s) && !x.rawowner.isPackageClass
-            if (isInner) {
-              innerClassBuffer += x
-              collectInnerClass(x.rawowner)
-            }
-          }
-        }
-
-      collectInnerClass(sym)
-
-      val hasInternalName = sym.isClass || sym.isModuleNotMethod
-      val cachedJN = javaNameCache.getOrElseUpdate(sym, {
-        if (hasInternalName) { sym.javaBinaryName }
-        else                 { sym.javaSimpleName }
-      })
-
-      if(emitStackMapFrame && hasInternalName) {
-        val internalName = cachedJN.toString()
-        val trackedSym = jsymbol(sym)
-        reverseJavaName.get(internalName) match {
-          case None =>
-            reverseJavaName.put(internalName, trackedSym)
-          case Some(oldsym) =>
-            // TODO: `duplicateOk` seems pretty ad-hoc (a more aggressive version caused SI-9356 because it called oldSym.exists, which failed in the unpickler; see also SI-5031)
-            def duplicateOk = oldsym == NoSymbol || trackedSym == NoSymbol || (syntheticCoreClasses contains oldsym) || (oldsym.isModuleClass && (oldsym.sourceModule == trackedSym.sourceModule))
-            if (oldsym != trackedSym && !duplicateOk)
-              devWarning(s"""|Different class symbols have the same bytecode-level internal name:
-                             |     name: $internalName
-                             |   oldsym: ${oldsym.fullNameString}
-                             |  tracked: ${trackedSym.fullNameString}""".stripMargin)
-        }
-      }
-
-      cachedJN.toString
-    }
-
-    def descriptor(t: Type):     String = { javaType(t).getDescriptor }
-    def descriptor(k: TypeKind): String = { javaType(k).getDescriptor }
-    def descriptor(s: Symbol):   String = { javaType(s).getDescriptor }
-
-    def javaType(tk: TypeKind): asm.Type = {
-      if(tk.isValueType) {
-        if(tk.isIntSizedType) {
-          (tk: @unchecked) match {
-            case BOOL   => asm.Type.BOOLEAN_TYPE
-            case BYTE   => asm.Type.BYTE_TYPE
-            case SHORT  => asm.Type.SHORT_TYPE
-            case CHAR   => asm.Type.CHAR_TYPE
-            case INT    => asm.Type.INT_TYPE
-          }
-        } else {
-          (tk: @unchecked) match {
-            case UNIT   => asm.Type.VOID_TYPE
-            case LONG   => asm.Type.LONG_TYPE
-            case FLOAT  => asm.Type.FLOAT_TYPE
-            case DOUBLE => asm.Type.DOUBLE_TYPE
-          }
-        }
-      } else {
-        assert(!tk.isBoxedType, tk) // documentation (BOXED matches none below anyway)
-        (tk: @unchecked) match {
-          case REFERENCE(cls)  => asm.Type.getObjectType(javaName(cls))
-          case ARRAY(elem)     => javaArrayType(javaType(elem))
-        }
-      }
-    }
-
-    def javaType(t: Type): asm.Type = javaType(toTypeKind(t))
-
-    def javaType(s: Symbol): asm.Type = {
-      if (s.isMethod) {
-        val resT: asm.Type = if (s.isClassConstructor) asm.Type.VOID_TYPE else javaType(s.tpe.resultType)
-        asm.Type.getMethodType( resT, (s.tpe.paramTypes map javaType): _*)
-      } else { javaType(s.tpe) }
-    }
-
-    def javaArrayType(elem: asm.Type): asm.Type = { asm.Type.getObjectType("[" + elem.getDescriptor) }
-
-    def isDeprecated(sym: Symbol): Boolean = { sym.annotations exists (_ matches definitions.DeprecatedAttr) }
-
-    def addInnerClasses(csym: Symbol, jclass: asm.ClassVisitor, isMirror: Boolean = false) {
-      /* The outer name for this inner class. Note that it returns null
-       * when the inner class should not get an index in the constant pool.
-       * That means non-member classes (anonymous). See Section 4.7.5 in the JVMS.
-       */
-      def outerName(innerSym: Symbol): String = {
-        if (isAnonymousOrLocalClass(innerSym))
-          null
-        else {
-          val outerName = javaName(innerSym.rawowner)
-          if (isTopLevelModule(innerSym.rawowner)) "" + TermName(outerName).dropModule
-          else outerName
-        }
-      }
-
-      def innerName(innerSym: Symbol): String = {
-        // phase travel necessary: after flatten, the name includes the name of outer classes.
-        // if some outer name contains $anon, a non-anon class is considered anon.
-        if (exitingPickler(innerSym.isAnonymousClass || innerSym.isAnonymousFunction)) null
-        else innerSym.rawname + innerSym.moduleSuffix
-      }
-
-      val linkedClass = exitingPickler(csym.linkedClassOfClass) // linkedCoC does not work properly in late phases
-
-      innerClassBuffer ++= {
-        val members = exitingPickler(memberClassesForInnerClassTable(csym))
-        // lambdalift makes all classes (also local, anonymous) members of their enclosing class
-        val allNested = exitingPhase(currentRun.lambdaliftPhase)(memberClassesForInnerClassTable(csym))
-        val nested = {
-          // Classes nested in value classes are nested in the companion at this point. For InnerClass /
-          // EnclosingMethod, we use the value class as the outer class. So we remove nested classes
-          // from the companion that were originally nested in the value class.
-          if (exitingPickler(linkedClass.isDerivedValueClass)) allNested.filterNot(classOriginallyNestedInClass(_, linkedClass))
-          else allNested
-        }
-
-        // for the mirror class, we take the members of the companion module class (Java compat, see doc in BTypes.scala).
-        // for module classes, we filter out those members.
-        if (isMirror) members
-        else if (isTopLevelModule(csym)) nested diff members
-        else nested
-      }
-
-      if (!considerAsTopLevelImplementationArtifact(csym)) {
-        // If this is a top-level non-impl class, add members of the companion object. These are the
-        // classes for which we change the InnerClass entry to allow using them from Java.
-        // We exclude impl classes: if the classfile for the impl class exists on the classpath, a
-        // linkedClass symbol is found for which isTopLevelModule is true, so we end up searching
-        // members of that weird impl-class-module-class-symbol. that search probably cannot return
-        // any classes, but it's better to exclude it.
-        if (linkedClass != NoSymbol && isTopLevelModule(linkedClass)) {
-          // phase travel to exitingPickler: this makes sure that memberClassesForInnerClassTable only
-          // sees member classes, not local classes that were lifted by lambdalift.
-          innerClassBuffer ++= exitingPickler(memberClassesForInnerClassTable(linkedClass))
-        }
-
-        // Classes nested in value classes are nested in the companion at this point. For InnerClass /
-        // EnclosingMethod we use the value class as enclosing class. Here we search nested classes
-        // in the companion that were originally nested in the value class, and we add them as nested
-        // in the value class.
-        if (linkedClass != NoSymbol && exitingPickler(csym.isDerivedValueClass)) {
-          val moduleMemberClasses = exitingPhase(currentRun.lambdaliftPhase)(memberClassesForInnerClassTable(linkedClass))
-          innerClassBuffer ++= moduleMemberClasses.filter(classOriginallyNestedInClass(_, csym))
-        }
-      }
-
-      val allInners: List[Symbol] = innerClassBuffer.toList filterNot deadCode.elidedClosures
-
-      if (allInners.nonEmpty) {
-        debuglog(csym.fullName('.') + " contains " + allInners.size + " inner classes.")
-
-        // entries ready to be serialized into the classfile, used to detect duplicates.
-        val entries = mutable.Map.empty[String, String]
-
-        // sort them so inner classes succeed their enclosing class to satisfy the Eclipse Java compiler
-        for (innerSym <- allInners sortBy (_.name.length)) { // TODO why not sortBy (_.name.toString()) ??
-          val flagsWithFinal: Int = mkFlags(
-            // See comment in BTypes, when is a class marked static in the InnerClass table.
-            if (isOriginallyStaticOwner(innerSym.originalOwner)) asm.Opcodes.ACC_STATIC else 0,
-            (if (innerSym.isJava) javaClassfileFlags(innerSym) else javaFlags(innerSym)) & ~asm.Opcodes.ACC_STATIC,
-            if(isDeprecated(innerSym)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo-access flag
-          ) & (BCodeAsmCommon.INNER_CLASSES_FLAGS | asm.Opcodes.ACC_DEPRECATED)
-          val flags = if (innerSym.isModuleClass) flagsWithFinal & ~asm.Opcodes.ACC_FINAL else flagsWithFinal // For SI-5676, object overriding.
-          val jname = javaName(innerSym)  // never null
-          val oname = outerName(innerSym) // null when method-enclosed
-          val iname = innerName(innerSym) // null for anonymous inner class
-
-          // Mimicking javap inner class output
-          debuglog(
-            if (oname == null || iname == null) "//class " + jname
-            else "//%s=class %s of class %s".format(iname, jname, oname)
-          )
-
-          assert(jname != null, "javaName is broken.") // documentation
-          val doAdd = entries.get(jname) match {
-            // TODO is it ok for prevOName to be null? (Someone should really document the invariants of the InnerClasses bytecode attribute)
-            case Some(prevOName) =>
-              // this occurs e.g. when innerClassBuffer contains both class Thread$State, object Thread$State,
-              // i.e. for them it must be the case that oname == java/lang/Thread
-              assert(prevOName == oname, "duplicate")
-              false
-            case None => true
-          }
-
-          if(doAdd) {
-            entries += (jname -> oname)
-            jclass.visitInnerClass(jname, oname, iname, flags)
-          }
-
-          /*
-           * TODO assert (JVMS 4.7.6 The InnerClasses attribute)
-           * If a class file has a version number that is greater than or equal to 51.0, and
-           * has an InnerClasses attribute in its attributes table, then for all entries in the
-           * classes array of the InnerClasses attribute, the value of the
-           * outer_class_info_index item must be zero if the value of the
-           * inner_name_index item is zero.
-           */
-
-        }
-      }
-    }
-
-  } // end of class JBuilder
-
-
-  /** functionality for building plain and mirror classes */
-  abstract class JCommonBuilder(bytecodeWriter: BytecodeWriter, needsOutfile: Boolean) extends JBuilder(bytecodeWriter, needsOutfile) {
-
-    def debugLevel = settings.debuginfo.indexOfChoice
-
-    val emitSource = debugLevel >= 1
-    val emitLines  = debugLevel >= 2
-    val emitVars   = debugLevel >= 3
-
-    // -----------------------------------------------------------------------------------------
-    // more constants
-    // -----------------------------------------------------------------------------------------
-
-    val PublicStatic      = asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC
-    val PublicStaticFinal = asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL
-
-    val strMODULE_INSTANCE_FIELD = nme.MODULE_INSTANCE_FIELD.toString
-
-    // -----------------------------------------------------------------------------------------
-    // Custom attribute (JVMS 4.7.1) "ScalaSig" used as marker only
-    // i.e., the pickle is contained in a custom annotation, see:
-    //   (1) `addAnnotations()`,
-    //   (2) SID # 10 (draft) - Storage of pickled Scala signatures in class files, http://www.scala-lang.org/sid/10
-    //   (3) SID # 5 - Internals of Scala Annotations, http://www.scala-lang.org/sid/5
-    // That annotation in turn is not related to the "java-generic-signature" (JVMS 4.7.9)
-    // other than both ending up encoded as attributes (JVMS 4.7)
-    // (with the caveat that the "ScalaSig" attribute is associated to some classes,
-    // while the "Signature" attribute can be associated to classes, methods, and fields.)
-    // -----------------------------------------------------------------------------------------
-
-    val versionPickle = {
-      val vp = new PickleBuffer(new Array[Byte](16), -1, 0)
-      assert(vp.writeIndex == 0, vp)
-      vp writeNat PickleFormat.MajorVersion
-      vp writeNat PickleFormat.MinorVersion
-      vp writeNat 0
-      vp
-    }
-
-    def pickleMarkerLocal = {
-      createJAttribute(tpnme.ScalaSignatureATTR.toString, versionPickle.bytes, 0, versionPickle.writeIndex)
-    }
-
-    def pickleMarkerForeign = {
-      createJAttribute(tpnme.ScalaATTR.toString, new Array[Byte](0), 0, 0)
-    }
-
-    /** Returns a ScalaSignature annotation if it must be added to this class, none otherwise.
-     *  This annotation must be added to the class' annotations list when generating them.
-     *
-     *  Depending on whether the returned option is defined, it adds to `jclass` one of:
-     *    (a) the ScalaSig marker attribute
-     *        (indicating that a scala-signature-annotation aka pickle is present in this class); or
-     *    (b) the Scala marker attribute
-     *        (indicating that a scala-signature-annotation aka pickle is to be found in another file).
-     *
-     *
-     *  @param jclassName The class file that is being readied.
-     *  @param sym    The symbol for which the signature has been entered in the symData map.
-     *                This is different than the symbol
-     *                that is being generated in the case of a mirror class.
-     *  @return       An option that is:
-     *                - defined and contains an AnnotationInfo of the ScalaSignature type,
-     *                  instantiated with the pickle signature for sym.
-     *                - empty if the jclass/sym pair must not contain a pickle.
-     *
-     */
-    def getAnnotPickle(jclassName: String, sym: Symbol): Option[AnnotationInfo] = {
-      currentRun.symData get sym match {
-        case Some(pickle) if !nme.isModuleName(newTermName(jclassName)) =>
-          val scalaAnnot = {
-            val sigBytes = ScalaSigBytes(pickle.bytes.take(pickle.writeIndex))
-            AnnotationInfo(sigBytes.sigAnnot, Nil, List((nme.bytes, sigBytes)))
-          }
-          pickledBytes += pickle.writeIndex
-          currentRun.symData -= sym
-          currentRun.symData -= sym.companionSymbol
-          Some(scalaAnnot)
-        case _ =>
-          None
-      }
-    }
-
-    /**
-     * Quoting from JVMS 4.7.5 The Exceptions Attribute
-     *   "The Exceptions attribute indicates which checked exceptions a method may throw.
-     *    There may be at most one Exceptions attribute in each method_info structure."
-     *
-     * The contents of that attribute are determined by the `String[] exceptions` argument to ASM's ClassVisitor.visitMethod()
-     * This method returns such list of internal names.
-     */
-    def getExceptions(excs: List[AnnotationInfo]): List[String] =
-      for (ThrownException(tp) <- excs.distinct)
-        yield {
-          val erased = enteringErasure(erasure.erasure(tp.typeSymbol)(tp))
-          javaName(erased.typeSymbol)
-        }
-
-    def getCurrentCUnit(): CompilationUnit
-
-    def getGenericSignature(sym: Symbol, owner: Symbol) = self.getGenericSignature(sym, owner, getCurrentCUnit())
-
-    def emitArgument(av:   asm.AnnotationVisitor,
-                     name: String,
-                     arg:  ClassfileAnnotArg) {
-      (arg: @unchecked) match {
-
-        case LiteralAnnotArg(const) =>
-          if(const.isNonUnitAnyVal) { av.visit(name, const.value) }
-          else {
-            const.tag match {
-              case StringTag  =>
-                assert(const.value != null, const) // TODO this invariant isn't documented in `case class Constant`
-                av.visit(name, const.stringValue)  // `stringValue` special-cases null, but that execution path isn't exercised for a const with StringTag
-              case ClazzTag   => av.visit(name, javaType(const.typeValue))
-              case EnumTag =>
-                val edesc  = descriptor(const.tpe) // the class descriptor of the enumeration class.
-                val evalue = const.symbolValue.name.toString // value the actual enumeration value.
-                av.visitEnum(name, edesc, evalue)
-            }
-          }
-
-        case sb@ScalaSigBytes(bytes) =>
-          // see http://www.scala-lang.org/sid/10 (Storage of pickled Scala signatures in class files)
-          // also JVMS Sec. 4.7.16.1 The element_value structure and JVMS Sec. 4.4.7 The CONSTANT_Utf8_info Structure.
-          if (sb.fitsInOneString)
-            av.visit(name, strEncode(sb))
-          else {
-            val arrAnnotV: asm.AnnotationVisitor = av.visitArray(name)
-            for(arg <- arrEncode(sb)) { arrAnnotV.visit(name, arg) }
-            arrAnnotV.visitEnd()
-          }
-          // for the lazy val in ScalaSigBytes to be GC'ed, the invoker of emitAnnotations() should hold the ScalaSigBytes in a method-local var that doesn't escape.
-
-        case ArrayAnnotArg(args) =>
-          val arrAnnotV: asm.AnnotationVisitor = av.visitArray(name)
-          for(arg <- args) { emitArgument(arrAnnotV, null, arg) }
-          arrAnnotV.visitEnd()
-
-        case NestedAnnotArg(annInfo) =>
-          val AnnotationInfo(typ, args, assocs) = annInfo
-          assert(args.isEmpty, args)
-          val desc = descriptor(typ) // the class descriptor of the nested annotation class
-          val nestedVisitor = av.visitAnnotation(name, desc)
-          emitAssocs(nestedVisitor, assocs)
-      }
-    }
-
-    def emitAssocs(av: asm.AnnotationVisitor, assocs: List[(Name, ClassfileAnnotArg)]) {
-      for ((name, value) <- assocs) {
-        emitArgument(av, name.toString(), value)
-      }
-      av.visitEnd()
-    }
-
-    def emitAnnotations(cw: asm.ClassVisitor, annotations: List[AnnotationInfo]) {
-      for(annot <- annotations; if shouldEmitAnnotation(annot)) {
-        val AnnotationInfo(typ, args, assocs) = annot
-        assert(args.isEmpty, args)
-        val av = cw.visitAnnotation(descriptor(typ), isRuntimeVisible(annot))
-        emitAssocs(av, assocs)
-      }
-    }
-
-    def emitAnnotations(mw: asm.MethodVisitor, annotations: List[AnnotationInfo]) {
-      for(annot <- annotations; if shouldEmitAnnotation(annot)) {
-        val AnnotationInfo(typ, args, assocs) = annot
-        assert(args.isEmpty, args)
-        val av = mw.visitAnnotation(descriptor(typ), isRuntimeVisible(annot))
-        emitAssocs(av, assocs)
-      }
-    }
-
-    def emitAnnotations(fw: asm.FieldVisitor, annotations: List[AnnotationInfo]) {
-      for(annot <- annotations; if shouldEmitAnnotation(annot)) {
-        val AnnotationInfo(typ, args, assocs) = annot
-        assert(args.isEmpty, args)
-        val av = fw.visitAnnotation(descriptor(typ), isRuntimeVisible(annot))
-        emitAssocs(av, assocs)
-      }
-    }
-
-    def emitParamAnnotations(jmethod: asm.MethodVisitor, pannotss: List[List[AnnotationInfo]]) {
-      val annotationss = pannotss map (_ filter shouldEmitAnnotation)
-      if (annotationss forall (_.isEmpty)) return
-      for ((annots, idx) <- annotationss.zipWithIndex;
-           annot <- annots) {
-        val AnnotationInfo(typ, args, assocs) = annot
-        assert(args.isEmpty, args)
-        val pannVisitor: asm.AnnotationVisitor = jmethod.visitParameterAnnotation(idx, descriptor(typ), isRuntimeVisible(annot))
-        emitAssocs(pannVisitor, assocs)
-      }
-    }
-
-    /** Adds a @remote annotation, actual use unknown.
-     *
-     * Invoked from genMethod() and addForwarder().
-     */
-    def addRemoteExceptionAnnot(isRemoteClass: Boolean, isJMethodPublic: Boolean, meth: Symbol) {
-      def hasThrowsRemoteException = meth.annotations.exists {
-        case ThrownException(exc) => exc.typeSymbol == definitions.RemoteExceptionClass
-        case _ => false
-      }
-      val needsAnnotation = (
-        (  isRemoteClass ||
-           isRemote(meth) && isJMethodPublic
-        ) && !hasThrowsRemoteException
-      )
-      if (needsAnnotation) {
-        val c   = Constant(RemoteExceptionClass.tpe)
-        val arg = Literal(c) setType c.tpe
-        meth.addAnnotation(appliedType(ThrowsClass, c.tpe), arg)
-      }
-    }
-
-    // -----------------------------------------------------------------------------------------
-    // Static forwarders (related to mirror classes but also present in
-    // a plain class lacking companion module, for details see `isCandidateForForwarders`).
-    // -----------------------------------------------------------------------------------------
-
-    /** Add a forwarder for method m. Used only from addForwarders(). */
-    private def addForwarder(isRemoteClass: Boolean, jclass: asm.ClassVisitor, module: Symbol, m: Symbol) {
-      val moduleName     = javaName(module)
-      val methodInfo     = module.thisType.memberInfo(m)
-      val paramJavaTypes: List[asm.Type] = methodInfo.paramTypes map javaType
-      // val paramNames     = 0 until paramJavaTypes.length map ("x_" + _)
-
-      /* Forwarders must not be marked final,
-       * as the JVM will not allow redefinition of a final static method,
-       * and we don't know what classes might be subclassing the companion class.  See SI-4827.
-       */
-      // TODO: evaluate the other flags we might be dropping on the floor here.
-      // TODO: ACC_SYNTHETIC ?
-      val flags = PublicStatic | (
-        if (m.isVarargsMethod) asm.Opcodes.ACC_VARARGS else 0
-      )
-
-      // TODO needed? for(ann <- m.annotations) { ann.symbol.initialize }
-      val jgensig = staticForwarderGenericSignature(m, module, getCurrentCUnit())
-      addRemoteExceptionAnnot(isRemoteClass, hasPublicBitSet(flags), m)
-      val (throws, others) = m.annotations partition (_.symbol == ThrowsClass)
-      val thrownExceptions: List[String] = getExceptions(throws)
-
-      val jReturnType = javaType(methodInfo.resultType)
-      val mdesc = asm.Type.getMethodDescriptor(jReturnType, paramJavaTypes: _*)
-      val mirrorMethodName = javaName(m)
-      val mirrorMethod: asm.MethodVisitor = jclass.visitMethod(
-        flags,
-        mirrorMethodName,
-        mdesc,
-        jgensig,
-        mkArray(thrownExceptions)
-      )
-
-      // typestate: entering mode with valid call sequences:
-      //   [ visitAnnotationDefault ] ( visitAnnotation | visitParameterAnnotation | visitAttribute )*
-
-      emitAnnotations(mirrorMethod, others)
-      emitParamAnnotations(mirrorMethod, m.info.params.map(_.annotations))
-
-      // typestate: entering mode with valid call sequences:
-      //   visitCode ( visitFrame | visitXInsn | visitLabel | visitTryCatchBlock | visitLocalVariable | visitLineNumber )* visitMaxs ] visitEnd
-
-      mirrorMethod.visitCode()
-
-      mirrorMethod.visitFieldInsn(asm.Opcodes.GETSTATIC, moduleName, strMODULE_INSTANCE_FIELD, descriptor(module))
-
-      var index = 0
-      for(jparamType <- paramJavaTypes) {
-        mirrorMethod.visitVarInsn(jparamType.getOpcode(asm.Opcodes.ILOAD), index)
-        assert(jparamType.getSort() != asm.Type.METHOD, jparamType)
-        index += jparamType.getSize()
-      }
-
-      mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, javaType(m).getDescriptor, false)
-      mirrorMethod.visitInsn(jReturnType.getOpcode(asm.Opcodes.IRETURN))
-
-      mirrorMethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments
-      mirrorMethod.visitEnd()
-
-    }
-
-    /** Add forwarders for all methods defined in `module` that don't conflict
-     *  with methods in the companion class of `module`. A conflict arises when
-     *  a method with the same name is defined both in a class and its companion object:
-     *  method signature is not taken into account.
-     */
-    def addForwarders(isRemoteClass: Boolean, jclass: asm.ClassVisitor, jclassName: String, moduleClass: Symbol) {
-      assert(moduleClass.isModuleClass, moduleClass)
-      debuglog("Dumping mirror class for object: " + moduleClass)
-
-      val linkedClass  = moduleClass.companionClass
-      lazy val conflictingNames: Set[Name] = {
-        (linkedClass.info.members collect { case sym if sym.name.isTermName => sym.name }).toSet
-      }
-      debuglog("Potentially conflicting names for forwarders: " + conflictingNames)
-
-      for (m <- moduleClass.info.membersBasedOnFlags(ExcludedForwarderFlags, Flags.METHOD)) {
-        if (m.isType || m.isDeferred || (m.owner eq ObjectClass) || m.isConstructor)
-          debuglog(s"No forwarder for '$m' from $jclassName to '$moduleClass'")
-        else if (conflictingNames(m.name))
-          log(s"No forwarder for $m due to conflict with " + linkedClass.info.member(m.name))
-        else if (m.hasAccessBoundary)
-          log(s"No forwarder for non-public member $m")
-        else {
-          debuglog(s"Adding static forwarder for '$m' from $jclassName to '$moduleClass'")
-          addForwarder(isRemoteClass, jclass, moduleClass, m)
-        }
-      }
-    }
-
-  } // end of class JCommonBuilder
-
-
-  trait JAndroidBuilder {
-    self: JPlainBuilder =>
-
-    def isAndroidParcelableClass(sym: Symbol) =
-      (AndroidParcelableInterface != NoSymbol) &&
-      (sym.parentSymbols contains AndroidParcelableInterface)
-
-    /* Typestate: should be called before emitting fields (because it adds an IField to the current IClass). */
-    def addCreatorCode(block: BasicBlock) {
-      val fieldSymbol = (
-        clasz.symbol.newValue(androidFieldName, NoPosition, Flags.STATIC | Flags.FINAL)
-          setInfo AndroidCreatorClass.tpe
-      )
-      val methodSymbol = definitions.getMember(clasz.symbol.companionModule, androidFieldName)
-      clasz addField new IField(fieldSymbol)
-      block emit CALL_METHOD(methodSymbol, Static(onInstance = false))
-      block emit STORE_FIELD(fieldSymbol, isStatic = true)
-    }
-
-    def legacyAddCreatorCode(clinit: asm.MethodVisitor) {
-      val creatorType: asm.Type = javaType(AndroidCreatorClass)
-      val tdesc_creator = creatorType.getDescriptor
-
-      jclass.visitField(
-        PublicStaticFinal,
-        androidFieldName.toString,
-        tdesc_creator,
-        null, // no java-generic-signature
-        null  // no initial value
-      ).visitEnd()
-
-      val moduleName = javaName(clasz.symbol)+"$"
-
-      // GETSTATIC `moduleName`.MODULE$ : `moduleName`;
-      clinit.visitFieldInsn(
-        asm.Opcodes.GETSTATIC,
-        moduleName,
-        strMODULE_INSTANCE_FIELD,
-        asm.Type.getObjectType(moduleName).getDescriptor
-      )
-
-      // INVOKEVIRTUAL `moduleName`.CREATOR() : android.os.Parcelable$Creator;
-      clinit.visitMethodInsn(
-        asm.Opcodes.INVOKEVIRTUAL,
-        moduleName,
-        androidFieldName.toString,
-        asm.Type.getMethodDescriptor(creatorType, Array.empty[asm.Type]: _*),
-        false
-      )
-
-      // PUTSTATIC `thisName`.CREATOR;
-      clinit.visitFieldInsn(
-        asm.Opcodes.PUTSTATIC,
-        thisName,
-        androidFieldName.toString,
-        tdesc_creator
-      )
-    }
-
-  } // end of trait JAndroidBuilder
-
-  /** Map from type kinds to the Java reference types.
-   *  It is used to push class literals onto the operand stack.
-   *  @see Predef.classOf
-   *  @see genConstant()
-   */
-  private val classLiteral = immutable.Map[TypeKind, asm.Type](
-    UNIT   -> asm.Type.getObjectType("java/lang/Void"),
-    BOOL   -> asm.Type.getObjectType("java/lang/Boolean"),
-    BYTE   -> asm.Type.getObjectType("java/lang/Byte"),
-    SHORT  -> asm.Type.getObjectType("java/lang/Short"),
-    CHAR   -> asm.Type.getObjectType("java/lang/Character"),
-    INT    -> asm.Type.getObjectType("java/lang/Integer"),
-    LONG   -> asm.Type.getObjectType("java/lang/Long"),
-    FLOAT  -> asm.Type.getObjectType("java/lang/Float"),
-    DOUBLE -> asm.Type.getObjectType("java/lang/Double")
-  )
-
-  def isNonUnitValueTK(tk: TypeKind): Boolean = { tk.isValueType && tk != UNIT }
-
-  case class MethodNameAndType(mname: String, mdesc: String)
-
-  private val jBoxTo: Map[TypeKind, MethodNameAndType] = {
-    Map(
-      BOOL   -> MethodNameAndType("boxToBoolean",   "(Z)Ljava/lang/Boolean;"  ) ,
-      BYTE   -> MethodNameAndType("boxToByte",      "(B)Ljava/lang/Byte;"     ) ,
-      CHAR   -> MethodNameAndType("boxToCharacter", "(C)Ljava/lang/Character;") ,
-      SHORT  -> MethodNameAndType("boxToShort",     "(S)Ljava/lang/Short;"    ) ,
-      INT    -> MethodNameAndType("boxToInteger",   "(I)Ljava/lang/Integer;"  ) ,
-      LONG   -> MethodNameAndType("boxToLong",      "(J)Ljava/lang/Long;"     ) ,
-      FLOAT  -> MethodNameAndType("boxToFloat",     "(F)Ljava/lang/Float;"    ) ,
-      DOUBLE -> MethodNameAndType("boxToDouble",    "(D)Ljava/lang/Double;"   )
-    )
-  }
-
-  private val jUnboxTo: Map[TypeKind, MethodNameAndType] = {
-    Map(
-      BOOL   -> MethodNameAndType("unboxToBoolean", "(Ljava/lang/Object;)Z") ,
-      BYTE   -> MethodNameAndType("unboxToByte",    "(Ljava/lang/Object;)B") ,
-      CHAR   -> MethodNameAndType("unboxToChar",    "(Ljava/lang/Object;)C") ,
-      SHORT  -> MethodNameAndType("unboxToShort",   "(Ljava/lang/Object;)S") ,
-      INT    -> MethodNameAndType("unboxToInt",     "(Ljava/lang/Object;)I") ,
-      LONG   -> MethodNameAndType("unboxToLong",    "(Ljava/lang/Object;)J") ,
-      FLOAT  -> MethodNameAndType("unboxToFloat",   "(Ljava/lang/Object;)F") ,
-      DOUBLE -> MethodNameAndType("unboxToDouble",  "(Ljava/lang/Object;)D")
-    )
-  }
-
-  case class BlockInteval(start: BasicBlock, end: BasicBlock)
-
-  /** builder of plain classes */
-  class JPlainBuilder(bytecodeWriter: BytecodeWriter, needsOutfile: Boolean)
-    extends JCommonBuilder(bytecodeWriter, needsOutfile)
-    with    JAndroidBuilder {
-
-    val MIN_SWITCH_DENSITY = 0.7
-
-    val StringBuilderClassName = javaName(definitions.StringBuilderClass)
-    val BoxesRunTime = "scala/runtime/BoxesRunTime"
-
-    val StringBuilderType = asm.Type.getObjectType(StringBuilderClassName)
-    val mdesc_toString    = "()Ljava/lang/String;"
-    val mdesc_arrayClone  = "()Ljava/lang/Object;"
-
-    val tdesc_long        = asm.Type.LONG_TYPE.getDescriptor // ie. "J"
-
-    def isParcelableClass = isAndroidParcelableClass(clasz.symbol)
-
-    def serialVUID: Option[Long] = genBCode.serialVUID(clasz.symbol)
-
-    var clasz:    IClass = _           // this var must be assigned only by genClass()
-    var jclass:   asm.ClassWriter = _  // the classfile being emitted
-    var thisName: String = _           // the internal name of jclass
-
-    def thisDescr: String = {
-      assert(thisName != null, "thisDescr invoked too soon.")
-      asm.Type.getObjectType(thisName).getDescriptor
-    }
-
-    def getCurrentCUnit(): CompilationUnit = { clasz.cunit }
-
-    def genClass(c: IClass) {
-      clasz = c
-      innerClassBuffer.clear()
-
-      thisName = javaName(c.symbol) // the internal name of the class being emitted
-
-      val ps = c.symbol.info.parents
-      val superClass: String = if(ps.isEmpty) JAVA_LANG_OBJECT.getInternalName else javaName(ps.head.typeSymbol)
-
-      val ifaces: Array[String] = implementedInterfaces(c.symbol).map(javaName)(collection.breakOut)
-
-      val thisSignature = getGenericSignature(c.symbol, c.symbol.owner)
-      val flags = mkFlags(
-        javaFlags(c.symbol),
-        if(isDeprecated(c.symbol)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag
-      )
-      jclass  = createJClass(flags,
-                             thisName, thisSignature,
-                             superClass, ifaces)
-
-      // typestate: entering mode with valid call sequences:
-      //   [ visitSource ] [ visitOuterClass ] ( visitAnnotation | visitAttribute )*
-
-      if(emitSource) {
-        jclass.visitSource(c.cunit.source.toString,
-                           null /* SourceDebugExtension */)
-      }
-
-      enclosingMethodAttribute(clasz.symbol, javaName, javaType(_).getDescriptor) match {
-        case Some(EnclosingMethodEntry(className, methodName, methodDescriptor)) =>
-          jclass.visitOuterClass(className, methodName, methodDescriptor)
-        case _ => ()
-      }
-
-      // typestate: entering mode with valid call sequences:
-      //   ( visitAnnotation | visitAttribute )*
-
-      val ssa = getAnnotPickle(thisName, c.symbol)
-      jclass.visitAttribute(if(ssa.isDefined) pickleMarkerLocal else pickleMarkerForeign)
-      emitAnnotations(jclass, c.symbol.annotations ++ ssa)
-
-      if (!settings.YskipInlineInfoAttribute.value)
-        jclass.visitAttribute(InlineInfoAttribute(buildInlineInfoFromClassSymbol(c.symbol, javaName, javaType(_).getDescriptor)))
-
-      // typestate: entering mode with valid call sequences:
-      //   ( visitInnerClass | visitField | visitMethod )* visitEnd
-
-      if (isStaticModule(c.symbol) || isParcelableClass) {
-
-        if (isStaticModule(c.symbol)) { addModuleInstanceField() }
-        addStaticInit(c.lookupStaticCtor)
-
-      } else {
-
-        for (constructor <- c.lookupStaticCtor) {
-          addStaticInit(Some(constructor))
-        }
-        val skipStaticForwarders = (c.symbol.isInterface || settings.noForwarders)
-        if (!skipStaticForwarders) {
-          val lmoc = c.symbol.companionModule
-          // add static forwarders if there are no name conflicts; see bugs #363 and #1735
-          if (lmoc != NoSymbol) {
-            // it must be a top level class (name contains no $s)
-            val isCandidateForForwarders = {
-              exitingPickler { !(lmoc.name.toString contains '$') && lmoc.hasModuleFlag && !lmoc.isImplClass && !lmoc.isNestedClass }
-            }
-            if (isCandidateForForwarders) {
-              log("Adding static forwarders from '%s' to implementations in '%s'".format(c.symbol, lmoc))
-              addForwarders(isRemote(clasz.symbol), jclass, thisName, lmoc.moduleClass)
-            }
-          }
-        }
-
-      }
-
-      // add static serialVersionUID field if `clasz` annotated with `@SerialVersionUID(uid: Long)`
-      serialVUID foreach { value =>
-        val fieldName = "serialVersionUID"
-        jclass.visitField(
-          PublicStaticFinal,
-          fieldName,
-          tdesc_long,
-          null, // no java-generic-signature
-          value
-        ).visitEnd()
-      }
-
-      clasz.fields  foreach genField
-      clasz.methods foreach { im => genMethod(im, c.symbol.isInterface) }
-
-      addInnerClasses(clasz.symbol, jclass)
-      jclass.visitEnd()
-      writeIfNotTooBig("" + c.symbol.name, thisName, jclass, c.symbol)
-    }
-
-    def genField(f: IField) {
-      debuglog("Adding field: " + f.symbol.fullName)
-
-      val javagensig = getGenericSignature(f.symbol, clasz.symbol)
-
-      val flags = mkFlags(
-        javaFieldFlags(f.symbol),
-        if(isDeprecated(f.symbol)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag
-      )
-
-      val jfield: asm.FieldVisitor = jclass.visitField(
-        flags,
-        javaName(f.symbol),
-        javaType(f.symbol.tpe).getDescriptor(),
-        javagensig,
-        null // no initial value
-      )
-
-      emitAnnotations(jfield, f.symbol.annotations)
-      jfield.visitEnd()
-    }
-
-    var method:  IMethod = _
-    var jmethod: asm.MethodVisitor = _
-    var jMethodName: String = _
-
-    final def emit(opc: Int) { jmethod.visitInsn(opc) }
-
-    def genMethod(m: IMethod, isJInterface: Boolean) {
-
-        def isClosureApply(sym: Symbol): Boolean = {
-          (sym.name == nme.apply) &&
-          sym.owner.isSynthetic &&
-          sym.owner.tpe.parents.exists { t =>
-            val TypeRef(_, sym, _) = t
-            FunctionClass.seq contains sym
-          }
-        }
-
-      if (m.symbol.isStaticConstructor || definitions.isGetClass(m.symbol)) return
-
-      if (m.params.size > MaximumJvmParameters) {
-        reporter.error(m.symbol.pos, s"Platform restriction: a parameter list's length cannot exceed $MaximumJvmParameters.")
-        return
-      }
-
-      debuglog("Generating method " + m.symbol.fullName)
-      method = m
-      computeLocalVarsIndex(m)
-
-      var resTpe: asm.Type = javaType(m.symbol.tpe.resultType)
-      if (m.symbol.isClassConstructor)
-        resTpe = asm.Type.VOID_TYPE
-      val isAbstractTraitMeth = isJInterface && !m.symbol.hasFlag(Flags.JAVA_DEFAULTMETHOD)
-
-      val flags = mkFlags(
-        javaFlags(m.symbol),
-        if (isAbstractTraitMeth)   asm.Opcodes.ACC_ABSTRACT   else 0,
-        if (m.symbol.isStrictFP)   asm.Opcodes.ACC_STRICT     else 0,
-        if (method.native)         asm.Opcodes.ACC_NATIVE     else 0, // native methods of objects are generated in mirror classes
-        if(isDeprecated(m.symbol)) asm.Opcodes.ACC_DEPRECATED else 0  // ASM pseudo access flag
-      )
-
-      // TODO needed? for(ann <- m.symbol.annotations) { ann.symbol.initialize }
-      val jgensig = getGenericSignature(m.symbol, clasz.symbol)
-      addRemoteExceptionAnnot(isRemote(clasz.symbol), hasPublicBitSet(flags), m.symbol)
-      val (excs, others) = m.symbol.annotations partition (_.symbol == ThrowsClass)
-      val thrownExceptions: List[String] = getExceptions(excs)
-
-      jMethodName = javaName(m.symbol)
-      val mdesc = asm.Type.getMethodDescriptor(resTpe, (m.params map (p => javaType(p.kind))): _*)
-      jmethod = jclass.visitMethod(
-        flags,
-        jMethodName,
-        mdesc,
-        jgensig,
-        mkArray(thrownExceptions)
-      )
-
-      // TODO param names: (m.params map (p => javaName(p.sym)))
-
-      // typestate: entering mode with valid call sequences: (see ASM Guide, 3.2.1)
-      //   [ visitAnnotationDefault ] ( visitAnnotation | visitParameterAnnotation | visitAttribute )*
-
-      emitAnnotations(jmethod, others)
-      emitParamAnnotations(jmethod, m.params.map(_.sym.annotations))
-
-      // typestate: entering mode with valid call sequences:
-      //   [ visitCode ( visitFrame | visitXInsn | visitLabel | visitTryCatchBlock | visitLocalVariable | visitLineNumber )* visitMaxs ] visitEnd
-      // In addition, the visitXInsn and visitLabel methods must be called in the sequential order of the bytecode instructions of the visited code,
-      // visitTryCatchBlock must be called before the labels passed as arguments have been visited, and
-      // the visitLocalVariable and visitLineNumber methods must be called after the labels passed as arguments have been visited.
-
-      val hasAbstractBitSet = ((flags & asm.Opcodes.ACC_ABSTRACT) != 0)
-      val hasCodeAttribute  = (!hasAbstractBitSet && !method.native)
-      if (hasCodeAttribute) {
-
-        jmethod.visitCode()
-
-        if (emitVars && isClosureApply(method.symbol)) {
-          // add a fake local for debugging purposes
-          val outerField = clasz.symbol.info.decl(nme.OUTER_LOCAL)
-          if (outerField != NoSymbol) {
-            log("Adding fake local to represent outer 'this' for closure " + clasz)
-            val _this =
-              new Local(method.symbol.newVariable(nme.FAKE_LOCAL_THIS),
-                        toTypeKind(outerField.tpe),
-                        false)
-            m.locals = m.locals ::: List(_this)
-            computeLocalVarsIndex(m) // since we added a new local, we need to recompute indexes
-            jmethod.visitVarInsn(asm.Opcodes.ALOAD, 0)
-            jmethod.visitFieldInsn(asm.Opcodes.GETFIELD,
-                                   javaName(clasz.symbol), // field owner
-                                   javaName(outerField),   // field name
-                                   descriptor(outerField)  // field descriptor
-            )
-            assert(_this.kind.isReferenceType, _this.kind)
-            jmethod.visitVarInsn(asm.Opcodes.ASTORE, indexOf(_this))
-          }
-        }
-
-        assert( m.locals forall { local => (m.params contains local) == local.arg }, m.locals )
-
-        val hasStaticBitSet = ((flags & asm.Opcodes.ACC_STATIC) != 0)
-        genCode(m, emitVars, hasStaticBitSet)
-
-        // visitMaxs needs to be called according to the protocol. The arguments will be ignored
-        // since maximums (and stack map frames) are computed. See ASM Guide, Section 3.2.1,
-        // section "ClassWriter options"
-        jmethod.visitMaxs(0, 0)
-      }
-
-      jmethod.visitEnd()
-
-    }
-
-    def addModuleInstanceField() {
-      val fv =
-        jclass.visitField(PublicStaticFinal, // TODO confirm whether we really don't want ACC_SYNTHETIC nor ACC_DEPRECATED
-                          strMODULE_INSTANCE_FIELD,
-                          thisDescr,
-                          null, // no java-generic-signature
-                          null  // no initial value
-        )
-
-      // typestate: entering mode with valid call sequences:
-      //   ( visitAnnotation | visitAttribute )* visitEnd.
-
-      fv.visitEnd()
-    }
-
-
-    /* Typestate: should be called before being done with emitting fields (because it invokes addCreatorCode() which adds an IField to the current IClass). */
-    def addStaticInit(mopt: Option[IMethod]) {
-
-      val clinitMethod: asm.MethodVisitor = jclass.visitMethod(
-        PublicStatic, // TODO confirm whether we really don't want ACC_SYNTHETIC nor ACC_DEPRECATED
-        CLASS_CONSTRUCTOR_NAME,
-        mdesc_arglessvoid,
-        null, // no java-generic-signature
-        null  // no throwable exceptions
-      )
-
-      mopt match {
-
-       	case Some(m) =>
-
-          val oldLastBlock = m.lastBlock
-          val lastBlock = m.newBlock()
-          oldLastBlock.replaceInstruction(oldLastBlock.length - 1, JUMP(lastBlock))
-
-          if (isStaticModule(clasz.symbol)) {
-            // call object's private ctor from static ctor
-            lastBlock emit NEW(REFERENCE(m.symbol.enclClass))
-            lastBlock emit CALL_METHOD(m.symbol.enclClass.primaryConstructor, Static(onInstance = true))
-          }
-
-          if (isParcelableClass) { addCreatorCode(lastBlock) }
-
-          lastBlock emit RETURN(UNIT)
-          lastBlock.close()
-
-          method = m
-       	  jmethod = clinitMethod
-          jMethodName = CLASS_CONSTRUCTOR_NAME
-          jmethod.visitCode()
-          computeLocalVarsIndex(m)
-          genCode(m, emitVars = false, isStatic = true)
-          jmethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments
-          jmethod.visitEnd()
-
-       	case None =>
-          clinitMethod.visitCode()
-          legacyStaticInitializer(clinitMethod)
-          clinitMethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments
-          clinitMethod.visitEnd()
-
-      }
-    }
-
-    /* used only from addStaticInit() */
-    private def legacyStaticInitializer(clinit: asm.MethodVisitor) {
-      if (isStaticModule(clasz.symbol)) {
-        clinit.visitTypeInsn(asm.Opcodes.NEW, thisName)
-        clinit.visitMethodInsn(asm.Opcodes.INVOKESPECIAL,
-                               thisName, INSTANCE_CONSTRUCTOR_NAME, mdesc_arglessvoid, false)
-      }
-
-      if (isParcelableClass) { legacyAddCreatorCode(clinit) }
-
-      clinit.visitInsn(asm.Opcodes.RETURN)
-    }
-
-    // -----------------------------------------------------------------------------------------
-    // Emitting bytecode instructions.
-    // -----------------------------------------------------------------------------------------
-
-    private def genConstant(mv: asm.MethodVisitor, const: Constant) {
-      const.tag match {
-
-        case BooleanTag => jcode.boolconst(const.booleanValue)
-
-        case ByteTag    => jcode.iconst(const.byteValue.toInt)
-        case ShortTag   => jcode.iconst(const.shortValue.toInt)
-        case CharTag    => jcode.iconst(const.charValue)
-        case IntTag     => jcode.iconst(const.intValue)
-
-        case LongTag    => jcode.lconst(const.longValue)
-        case FloatTag   => jcode.fconst(const.floatValue)
-        case DoubleTag  => jcode.dconst(const.doubleValue)
-
-        case UnitTag    => ()
-
-        case StringTag  =>
-          assert(const.value != null, const) // TODO this invariant isn't documented in `case class Constant`
-          mv.visitLdcInsn(const.stringValue) // `stringValue` special-cases null, but not for a const with StringTag
-
-        case NullTag    => mv.visitInsn(asm.Opcodes.ACONST_NULL)
-
-        case ClazzTag   =>
-          val kind = toTypeKind(const.typeValue)
-          val toPush: asm.Type =
-            if (kind.isValueType) classLiteral(kind)
-            else javaType(kind)
-          mv.visitLdcInsn(toPush)
-
-        case EnumTag   =>
-          val sym = const.symbolValue
-          mv.visitFieldInsn(
-            asm.Opcodes.GETSTATIC,
-            javaName(sym.owner),
-            javaName(sym),
-            javaType(sym.tpe.underlying).getDescriptor()
-          )
-
-        case _ => abort("Unknown constant value: " + const)
-      }
-    }
-
-    /** Just a namespace for utilities that encapsulate MethodVisitor idioms.
-     *  In the ASM world, org.objectweb.asm.commons.InstructionAdapter plays a similar role,
-     *  but the methods here allow choosing when to transition from ICode to ASM types
-     *  (including not at all, e.g. for performance).
-     */
-    object jcode {
-
-      import asm.Opcodes
-
-      final def boolconst(b: Boolean) { iconst(if(b) 1 else 0) }
-
-      def iconst(cst: Char) { iconst(cst.toInt) }
-      def iconst(cst: Int) {
-        if (cst >= -1 && cst <= 5) {
-          jmethod.visitInsn(Opcodes.ICONST_0 + cst)
-        } else if (cst >= java.lang.Byte.MIN_VALUE && cst <= java.lang.Byte.MAX_VALUE) {
-          jmethod.visitIntInsn(Opcodes.BIPUSH, cst)
-        } else if (cst >= java.lang.Short.MIN_VALUE && cst <= java.lang.Short.MAX_VALUE) {
-          jmethod.visitIntInsn(Opcodes.SIPUSH, cst)
-        } else {
-          jmethod.visitLdcInsn(new Integer(cst))
-        }
-      }
-
-      def lconst(cst: Long) {
-        if (cst == 0L || cst == 1L) {
-          jmethod.visitInsn(Opcodes.LCONST_0 + cst.asInstanceOf[Int])
-        } else {
-          jmethod.visitLdcInsn(new java.lang.Long(cst))
-        }
-      }
-
-      def fconst(cst: Float) {
-        val bits: Int = java.lang.Float.floatToIntBits(cst)
-        if (bits == 0L || bits == 0x3f800000 || bits == 0x40000000) { // 0..2
-          jmethod.visitInsn(Opcodes.FCONST_0 + cst.asInstanceOf[Int])
-        } else {
-          jmethod.visitLdcInsn(new java.lang.Float(cst))
-        }
-      }
-
-      def dconst(cst: Double) {
-        val bits: Long = java.lang.Double.doubleToLongBits(cst)
-        if (bits == 0L || bits == 0x3ff0000000000000L) { // +0.0d and 1.0d
-          jmethod.visitInsn(Opcodes.DCONST_0 + cst.asInstanceOf[Int])
-        } else {
-          jmethod.visitLdcInsn(new java.lang.Double(cst))
-        }
-      }
-
-      def newarray(elem: TypeKind) {
-        if(elem.isRefOrArrayType) {
-          jmethod.visitTypeInsn(Opcodes.ANEWARRAY, javaType(elem).getInternalName)
-        } else {
-          val rand = {
-            if(elem.isIntSizedType) {
-              (elem: @unchecked) match {
-                case BOOL   => Opcodes.T_BOOLEAN
-                case BYTE   => Opcodes.T_BYTE
-                case SHORT  => Opcodes.T_SHORT
-                case CHAR   => Opcodes.T_CHAR
-                case INT    => Opcodes.T_INT
-              }
-            } else {
-              (elem: @unchecked) match {
-                case LONG   => Opcodes.T_LONG
-                case FLOAT  => Opcodes.T_FLOAT
-                case DOUBLE => Opcodes.T_DOUBLE
-              }
-            }
-          }
-          jmethod.visitIntInsn(Opcodes.NEWARRAY, rand)
-        }
-      }
-
-
-      def load( idx: Int, tk: TypeKind) { emitVarInsn(Opcodes.ILOAD,  idx, tk) }
-      def store(idx: Int, tk: TypeKind) { emitVarInsn(Opcodes.ISTORE, idx, tk) }
-
-      def aload( tk: TypeKind) { emitTypeBased(aloadOpcodes,  tk) }
-      def astore(tk: TypeKind) { emitTypeBased(astoreOpcodes, tk) }
-
-      def neg(tk: TypeKind) { emitPrimitive(negOpcodes, tk) }
-      def add(tk: TypeKind) { emitPrimitive(addOpcodes, tk) }
-      def sub(tk: TypeKind) { emitPrimitive(subOpcodes, tk) }
-      def mul(tk: TypeKind) { emitPrimitive(mulOpcodes, tk) }
-      def div(tk: TypeKind) { emitPrimitive(divOpcodes, tk) }
-      def rem(tk: TypeKind) { emitPrimitive(remOpcodes, tk) }
-
-      def invokespecial(owner: String, name: String, desc: String) {
-        jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc, false)
-      }
-      def invokestatic(owner: String, name: String, desc: String) {
-        jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false)
-      }
-      def invokeinterface(owner: String, name: String, desc: String) {
-        jmethod.visitMethodInsn(Opcodes.INVOKEINTERFACE, owner, name, desc, true)
-      }
-      def invokevirtual(owner: String, name: String, desc: String) {
-        jmethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, false)
-      }
-
-      def goTo(label: asm.Label) { jmethod.visitJumpInsn(Opcodes.GOTO, label) }
-      def emitIF(cond: TestOp, label: asm.Label)      { jmethod.visitJumpInsn(cond.opcodeIF(),     label) }
-      def emitIF_ICMP(cond: TestOp, label: asm.Label) { jmethod.visitJumpInsn(cond.opcodeIFICMP(), label) }
-      def emitIF_ACMP(cond: TestOp, label: asm.Label) {
-        assert((cond == EQ) || (cond == NE), cond)
-        val opc = (if(cond == EQ) Opcodes.IF_ACMPEQ else Opcodes.IF_ACMPNE)
-        jmethod.visitJumpInsn(opc, label)
-      }
-      def emitIFNONNULL(label: asm.Label) { jmethod.visitJumpInsn(Opcodes.IFNONNULL, label) }
-      def emitIFNULL   (label: asm.Label) { jmethod.visitJumpInsn(Opcodes.IFNULL,    label) }
-
-      def emitRETURN(tk: TypeKind) {
-        if(tk == UNIT) { jmethod.visitInsn(Opcodes.RETURN) }
-        else           { emitTypeBased(returnOpcodes, tk)      }
-      }
-
-      /** Emits one of tableswitch or lookoupswitch. */
-      def emitSWITCH(keys: Array[Int], branches: Array[asm.Label], defaultBranch: asm.Label, minDensity: Double) {
-        assert(keys.length == branches.length)
-
-        // For empty keys, it makes sense emitting LOOKUPSWITCH with defaultBranch only.
-        // Similar to what javac emits for a switch statement consisting only of a default case.
-        if (keys.length == 0) {
-          jmethod.visitLookupSwitchInsn(defaultBranch, keys, branches)
-          return
-        }
-
-        // sort `keys` by increasing key, keeping `branches` in sync. TODO FIXME use quicksort
-        var i = 1
-        while (i < keys.length) {
-          var j = 1
-          while (j <= keys.length - i) {
-            if (keys(j) < keys(j - 1)) {
-              val tmp     = keys(j)
-              keys(j)     = keys(j - 1)
-              keys(j - 1) = tmp
-              val tmpL        = branches(j)
-              branches(j)     = branches(j - 1)
-              branches(j - 1) = tmpL
-            }
-            j += 1
-          }
-          i += 1
-        }
-
-        // check for duplicate keys to avoid "VerifyError: unsorted lookupswitch" (SI-6011)
-        i = 1
-        while (i < keys.length) {
-          if(keys(i-1) == keys(i)) {
-            abort("duplicate keys in SWITCH, can't pick arbitrarily one of them to evict, see SI-6011.")
-          }
-          i += 1
-        }
-
-        val keyMin = keys(0)
-        val keyMax = keys(keys.length - 1)
-
-        val isDenseEnough: Boolean = {
-          /* Calculate in long to guard against overflow. TODO what overflow??? */
-          val keyRangeD: Double = (keyMax.asInstanceOf[Long] - keyMin + 1).asInstanceOf[Double]
-          val klenD:     Double = keys.length.toDouble
-          val kdensity:  Double = (klenD / keyRangeD)
-
-          kdensity >= minDensity
-        }
-
-        if (isDenseEnough) {
-          // use a table in which holes are filled with defaultBranch.
-          val keyRange    = (keyMax - keyMin + 1)
-          val newBranches = new Array[asm.Label](keyRange)
-          var oldPos = 0
-          var i = 0
-          while(i < keyRange) {
-            val key = keyMin + i
-            if (keys(oldPos) == key) {
-              newBranches(i) = branches(oldPos)
-              oldPos += 1
-            } else {
-              newBranches(i) = defaultBranch
-            }
-            i += 1
-          }
-          assert(oldPos == keys.length, "emitSWITCH")
-          jmethod.visitTableSwitchInsn(keyMin, keyMax, defaultBranch, newBranches: _*)
-        } else {
-          jmethod.visitLookupSwitchInsn(defaultBranch, keys, branches)
-        }
-    }
-
-      // internal helpers -- not part of the public API of `jcode`
-      // don't make private otherwise inlining will suffer
-
-      def emitVarInsn(opc: Int, idx: Int, tk: TypeKind) {
-        assert((opc == Opcodes.ILOAD) || (opc == Opcodes.ISTORE), opc)
-        jmethod.visitVarInsn(javaType(tk).getOpcode(opc), idx)
-      }
-
-      // ---------------- array load and store ----------------
-
-      val aloadOpcodes  = { import Opcodes._; Array(AALOAD,  BALOAD,  SALOAD,  CALOAD,  IALOAD,  LALOAD,  FALOAD,  DALOAD)  }
-      val astoreOpcodes = { import Opcodes._; Array(AASTORE, BASTORE, SASTORE, CASTORE, IASTORE, LASTORE, FASTORE, DASTORE) }
-
-      val returnOpcodes = { import Opcodes._; Array(ARETURN, IRETURN, IRETURN, IRETURN, IRETURN, LRETURN, FRETURN, DRETURN) }
-
-      def emitTypeBased(opcs: Array[Int], tk: TypeKind) {
-        assert(tk != UNIT, tk)
-        val opc = {
-          if(tk.isRefOrArrayType) {   opcs(0) }
-          else if(tk.isIntSizedType) {
-            (tk: @unchecked) match {
-              case BOOL | BYTE     => opcs(1)
-              case SHORT           => opcs(2)
-              case CHAR            => opcs(3)
-              case INT             => opcs(4)
-            }
-          } else {
-            (tk: @unchecked) match {
-              case LONG            => opcs(5)
-              case FLOAT           => opcs(6)
-              case DOUBLE          => opcs(7)
-            }
-          }
-        }
-        jmethod.visitInsn(opc)
-      }
-
-      // ---------------- primitive operations ----------------
-
-      val negOpcodes: Array[Int] = { import Opcodes._; Array(INEG, LNEG, FNEG, DNEG) }
-      val addOpcodes: Array[Int] = { import Opcodes._; Array(IADD, LADD, FADD, DADD) }
-      val subOpcodes: Array[Int] = { import Opcodes._; Array(ISUB, LSUB, FSUB, DSUB) }
-      val mulOpcodes: Array[Int] = { import Opcodes._; Array(IMUL, LMUL, FMUL, DMUL) }
-      val divOpcodes: Array[Int] = { import Opcodes._; Array(IDIV, LDIV, FDIV, DDIV) }
-      val remOpcodes: Array[Int] = { import Opcodes._; Array(IREM, LREM, FREM, DREM) }
-
-      def emitPrimitive(opcs: Array[Int], tk: TypeKind) {
-        val opc = {
-          if(tk.isIntSizedType) { opcs(0) }
-          else {
-            (tk: @unchecked) match {
-              case LONG   => opcs(1)
-              case FLOAT  => opcs(2)
-              case DOUBLE => opcs(3)
-            }
-          }
-        }
-        jmethod.visitInsn(opc)
-      }
-
-    }
-
-    /** Invoked from genMethod() and addStaticInit() */
-    def genCode(m: IMethod,
-                emitVars: Boolean, // this param name hides the instance-level var
-                isStatic: Boolean) {
-
-
-      newNormal.normalize(m)
-
-      // ------------------------------------------------------------------------------------------------------------
-      // Part 1 of genCode(): setting up one-to-one correspondence between ASM Labels and BasicBlocks `linearization`
-      // ------------------------------------------------------------------------------------------------------------
-
-      val linearization: List[BasicBlock] = linearizer.linearize(m)
-      if(linearization.isEmpty) { return }
-
-      var isModuleInitialized = false
-
-      val labels: scala.collection.Map[BasicBlock, asm.Label] = mutable.HashMap(linearization map (_ -> new asm.Label()) : _*)
-
-      val onePastLast = new asm.Label // token for the mythical instruction past the last instruction in the method being emitted
-
-      // maps a BasicBlock b to the Label that corresponds to b's successor in the linearization. The last BasicBlock is mapped to the onePastLast label.
-      val linNext: scala.collection.Map[BasicBlock, asm.Label] = {
-        val result = mutable.HashMap.empty[BasicBlock, asm.Label]
-        var rest = linearization
-        var prev = rest.head
-        rest = rest.tail
-        while(!rest.isEmpty) {
-          result += (prev -> labels(rest.head))
-          prev = rest.head
-          rest = rest.tail
-        }
-        assert(!result.contains(prev))
-        result += (prev -> onePastLast)
-
-        result
-      }
-
-      // ------------------------------------------------------------------------------------------------------------
-      // Part 2 of genCode(): demarcating exception handler boundaries (visitTryCatchBlock() must be invoked before visitLabel() in genBlock())
-      // ------------------------------------------------------------------------------------------------------------
-
-        /* Generate exception handlers for the current method.
-         *
-         * Quoting from the JVMS 4.7.3 The Code Attribute
-         * The items of the Code_attribute structure are as follows:
-         *   . . .
-         *   exception_table[]
-         *     Each entry in the exception_table array describes one
-         *     exception handler in the code array. The order of the handlers in
-         *     the exception_table array is significant.
-         *     Each exception_table entry contains the following four items:
-         *       start_pc, end_pc:
-         *         ... The value of end_pc either must be a valid index into
-         *         the code array of the opcode of an instruction or must be equal to code_length,
-         *         the length of the code array.
-         *       handler_pc:
-         *         The value of the handler_pc item indicates the start of the exception handler
-         *       catch_type:
-         *         ... If the value of the catch_type item is zero,
-         *         this exception handler is called for all exceptions.
-         *         This is used to implement finally
-         */
-        def genExceptionHandlers() {
-
-          /* Return a list of pairs of intervals where the handler is active.
-           * Each interval is closed on both ends, ie. inclusive both in the left and right endpoints: [start, end].
-           * Preconditions:
-           *   - e.covered non-empty
-           * Postconditions for the result:
-           *   - always non-empty
-           *   - intervals are sorted as per `linearization`
-           *   - the argument's `covered` blocks have been grouped into maximally contiguous intervals,
-           *     ie. between any two intervals in the result there is a non-empty gap.
-           *   - each of the `covered` blocks in the argument is contained in some interval in the result
-           */
-          def intervals(e: ExceptionHandler): List[BlockInteval] = {
-            assert(e.covered.nonEmpty, e)
-            var result: List[BlockInteval] = Nil
-            var rest = linearization
-
-            // find intervals
-            while(!rest.isEmpty) {
-              // find interval start
-              var start: BasicBlock = null
-              while(!rest.isEmpty && (start eq null)) {
-                if(e.covered(rest.head)) { start = rest.head }
-                rest = rest.tail
-              }
-              if(start ne null) {
-                // find interval end
-                var end = start // for the time being
-                while(!rest.isEmpty && (e.covered(rest.head))) {
-                  end  = rest.head
-                  rest = rest.tail
-                }
-                result = BlockInteval(start, end) :: result
-              }
-            }
-
-            assert(result.nonEmpty, e)
-
-            result
-          }
-
-          /* TODO test/files/run/exceptions-2.scala displays an ExceptionHandler.covered that contains
-           * blocks not in the linearization (dead-code?). Is that well-formed or not?
-           * For now, we ignore those blocks (after all, that's what `genBlocks(linearization)` in effect does).
-           */
-          for (e <- this.method.exh) {
-            val ignore: Set[BasicBlock] = (e.covered filterNot { b => linearization contains b } )
-            // TODO someday assert(ignore.isEmpty, "an ExceptionHandler.covered contains blocks not in the linearization (dead-code?)")
-            if(ignore.nonEmpty) {
-              e.covered  = e.covered filterNot ignore
-            }
-          }
-
-          // an ExceptionHandler lacking covered blocks doesn't get an entry in the Exceptions table.
-          // TODO in that case, ExceptionHandler.cls doesn't go through javaName(). What if cls is an inner class?
-          for (e <- this.method.exh ; if e.covered.nonEmpty ; p <- intervals(e)) {
-            debuglog("Adding exception handler " + e + "at block: " + e.startBlock + " for " + method +
-                     " from: " + p.start + " to: " + p.end + " catching: " + e.cls)
-            val cls: String = if (e.cls == NoSymbol || e.cls == ThrowableClass) null
-                              else javaName(e.cls)
-            jmethod.visitTryCatchBlock(labels(p.start), linNext(p.end), labels(e.startBlock), cls)
-          }
-        } // end of genCode()'s genExceptionHandlers()
-
-      if (m.exh.nonEmpty) { genExceptionHandlers() }
-
-      // ------------------------------------------------------------------------------------------------------------
-      // Part 3 of genCode(): "Infrastructure" to later emit debug info for local variables and method params (LocalVariablesTable bytecode attribute).
-      // ------------------------------------------------------------------------------------------------------------
-
-        case class LocVarEntry(local: Local, start: asm.Label, end: asm.Label) // start is inclusive while end exclusive.
-
-        case class Interval(lstart: asm.Label, lend: asm.Label) {
-          final def start = lstart.getOffset
-          final def end   = lend.getOffset
-
-          def precedes(that: Interval): Boolean = { this.end < that.start }
-
-          def overlaps(that: Interval): Boolean = { !(this.precedes(that) || that.precedes(this)) }
-
-          def mergeWith(that: Interval): Interval = {
-            val newStart = if(this.start <= that.start) this.lstart else that.lstart
-            val newEnd   = if(this.end   <= that.end)   that.lend   else this.lend
-            Interval(newStart, newEnd)
-          }
-
-          def repOK: Boolean = { start <= end }
-
-        }
-
-        /** Track those instruction ranges where certain locals are in scope. Used to later emit the LocalVariableTable attribute (JVMS 4.7.13) */
-        object scoping {
-
-          private val pending = mutable.Map.empty[Local, mutable.Stack[Label]]
-          private var seen: List[LocVarEntry] = Nil
-
-          private def fuse(ranges: List[Interval], added: Interval): List[Interval] = {
-            assert(added.repOK, added)
-            if(ranges.isEmpty) { return List(added) }
-            // precond: ranges is sorted by increasing start
-            var fused: List[Interval] = Nil
-            var done = false
-            var rest = ranges
-            while(!done && rest.nonEmpty) {
-              val current = rest.head
-              assert(current.repOK, current)
-              rest = rest.tail
-              if(added precedes current) {
-                fused = fused ::: ( added :: current :: rest )
-                done = true
-              } else if(current overlaps added) {
-                fused = fused ::: ( added.mergeWith(current) :: rest )
-                done = true
-              }
-            }
-            if(!done) { fused = fused ::: List(added) }
-            assert(repOK(fused), fused)
-
-            fused
-          }
-
-          def pushScope(lv: Local, start: Label) {
-            val st = pending.getOrElseUpdate(lv, mutable.Stack.empty[Label])
-            st.push(start)
-          }
-          def popScope(lv: Local, end: Label, iPos: Position) {
-            pending.get(lv) match {
-              case Some(st) if st.nonEmpty =>
-                val start = st.pop()
-                seen ::= LocVarEntry(lv, start, end)
-              case _ =>
-                // TODO SI-6049 track down the cause for these.
-                devWarning(s"$iPos: Visited SCOPE_EXIT before visiting corresponding SCOPE_ENTER. SI-6191")
-            }
-          }
-
-          def getMerged(): scala.collection.Map[Local, List[Interval]] = {
-            // TODO should but isn't: unbalanced start(s) of scope(s)
-            val shouldBeEmpty = pending filter { p => val (_, st) = p; st.nonEmpty }
-            val merged = mutable.Map[Local, List[Interval]]()
-            def addToMerged(lv: Local, start: Label, end: Label) {
-              val intv   = Interval(start, end)
-              merged(lv) = if (merged contains lv) fuse(merged(lv), intv) else intv :: Nil
-            }
-            for(LocVarEntry(lv, start, end) <- seen) { addToMerged(lv, start, end) }
-
-            /* for each var with unbalanced start(s) of scope(s):
-                 (a) take the earliest start (among unbalanced and balanced starts)
-                 (b) take the latest end (onePastLast if none available)
-                 (c) merge the thus made-up interval
-             */
-            for((k, st) <- shouldBeEmpty) {
-              var start = st.toList.sortBy(_.getOffset).head
-              if(merged.isDefinedAt(k)) {
-                val balancedStart = merged(k).head.lstart
-                if(balancedStart.getOffset < start.getOffset) {
-                  start = balancedStart
-                }
-              }
-              val endOpt: Option[Label] = for(ranges <- merged.get(k)) yield ranges.last.lend
-              val end = endOpt.getOrElse(onePastLast)
-              addToMerged(k, start, end)
-            }
-
-            merged
-          }
-
-          private def repOK(fused: List[Interval]): Boolean = {
-            fused match {
-              case Nil      => true
-              case h :: Nil => h.repOK
-              case h :: n :: rest =>
-                h.repOK && h.precedes(n) && !h.overlaps(n) && repOK(n :: rest)
-            }
-          }
-
-        }
-
-      def genLocalVariableTable() {
-        // adding `this` and method params.
-        if (!isStatic) {
-          jmethod.visitLocalVariable("this", thisDescr, null, labels(m.startBlock), onePastLast, 0)
-        }
-        for(lv <- m.params) {
-          jmethod.visitLocalVariable(javaName(lv.sym), descriptor(lv.kind), null, labels(m.startBlock), onePastLast, indexOf(lv))
-        }
-        // adding non-param locals
-        var anonCounter = 0
-        var fltnd: List[Tuple3[String, Local, Interval]] = Nil
-        for((local, ranges) <- scoping.getMerged()) {
-          var name = javaName(local.sym)
-          if (name == null) {
-            anonCounter += 1
-            name = "<anon" + anonCounter + ">"
-          }
-          for(intrvl <- ranges) {
-            fltnd ::= (name, local, intrvl)
-          }
-        }
-        // quest for deterministic output that Map.toList doesn't provide (so that ant test.stability doesn't complain).
-        val srtd = fltnd.sortBy { kr =>
-          val (name: String, _, intrvl: Interval) = kr
-
-          (intrvl.start, intrvl.end - intrvl.start, name)  // ie sort by (start, length, name)
-        }
-
-        for((name, local, Interval(start, end)) <- srtd) {
-          jmethod.visitLocalVariable(name, descriptor(local.kind), null, start, end, indexOf(local))
-        }
-        // "There may be no more than one LocalVariableTable attribute per local variable in the Code attribute"
-      }
-
-      // ------------------------------------------------------------------------------------------------------------
-      // Part 4 of genCode(): Bookkeeping (to later emit debug info) of association between line-number and instruction position.
-      // ------------------------------------------------------------------------------------------------------------
-
-      case class LineNumberEntry(line: Int, start: asm.Label)
-      var lastLineNr: Int = -1
-      var lnEntries: List[LineNumberEntry] = Nil
-
-      // ------------------------------------------------------------------------------------------------------------
-      // Part 5 of genCode(): "Utilities" to emit code proper (most prominently: genBlock()).
-      // ------------------------------------------------------------------------------------------------------------
-
-      var nextBlock: BasicBlock = linearization.head
-
-      def genBlocks(l: List[BasicBlock]): Unit = l match {
-        case Nil => ()
-        case x :: Nil => nextBlock = null; genBlock(x)
-        case x :: y :: ys => nextBlock = y; genBlock(x); genBlocks(y :: ys)
-      }
-
-      def genCallMethod(call: CALL_METHOD) {
-        val CALL_METHOD(method, style) = call
-        val siteSymbol  = clasz.symbol
-        val hostSymbol  = call.hostClass
-        val methodOwner = method.owner
-        // info calls so that types are up to date; erasure may add lateINTERFACE to traits
-        hostSymbol.info ; methodOwner.info
-
-        def needsInterfaceCall(sym: Symbol) = (
-             sym.isInterface
-          || sym.isJavaDefined && sym.isNonBottomSubClass(ClassfileAnnotationClass)
-        )
-        // whether to reference the type of the receiver or
-        // the type of the method owner
-        val useMethodOwner = (
-             style != Dynamic
-          || hostSymbol.isBottomClass
-          || methodOwner == ObjectClass
-        )
-        val receiver = if (useMethodOwner) methodOwner else hostSymbol
-        val jowner   = javaName(receiver)
-        val jname    = javaName(method)
-        val jtype    = javaType(method).getDescriptor()
-
-        def dbg(invoke: String) {
-          debuglog("%s %s %s.%s:%s".format(invoke, receiver.accessString, jowner, jname, jtype))
-        }
-
-        def initModule() {
-          // we initialize the MODULE$ field immediately after the super ctor
-          if (isStaticModule(siteSymbol) && !isModuleInitialized &&
-              jMethodName == INSTANCE_CONSTRUCTOR_NAME &&
-              jname == INSTANCE_CONSTRUCTOR_NAME) {
-            isModuleInitialized = true
-            jmethod.visitVarInsn(asm.Opcodes.ALOAD, 0)
-            jmethod.visitFieldInsn(asm.Opcodes.PUTSTATIC, thisName, strMODULE_INSTANCE_FIELD, thisDescr)
-          }
-        }
-
-        style match {
-          case Static(true)                            => dbg("invokespecial");  jcode.invokespecial  (jowner, jname, jtype)
-          case Static(false)                           => dbg("invokestatic");   jcode.invokestatic   (jowner, jname, jtype)
-          case Dynamic if needsInterfaceCall(receiver) => dbg("invokinterface"); jcode.invokeinterface(jowner, jname, jtype)
-          case Dynamic                                 => dbg("invokevirtual");  jcode.invokevirtual  (jowner, jname, jtype)
-          case SuperCall(_)                            =>
-            dbg("invokespecial")
-            jcode.invokespecial(jowner, jname, jtype)
-            initModule()
-        }
-      } // end of genCode()'s genCallMethod()
-
-      def genBlock(b: BasicBlock) {
-        jmethod.visitLabel(labels(b))
-
-        debuglog("Generating code for block: " + b)
-
-        // val lastInstr = b.lastInstruction
-
-        for (instr <- b) {
-
-          if(instr.pos.isDefined) {
-            val iPos = instr.pos
-            val currentLineNr = iPos.line
-            val skip = (currentLineNr == lastLineNr) // if(iPos.isRange) iPos.sameRange(lastPos) else
-            if(!skip) {
-              lastLineNr = currentLineNr
-              val lineLab = new asm.Label
-              jmethod.visitLabel(lineLab)
-              lnEntries ::= LineNumberEntry(iPos.finalPosition.line, lineLab)
-            }
-          }
-
-          genInstr(instr, b)
-
-        }
-
-      }
-
-      def genInstr(instr: Instruction, b: BasicBlock) {
-        import asm.Opcodes
-        (instr.category: @scala.annotation.switch) match {
-
-
-          case icodes.localsCat =>
-          def genLocalInstr() = (instr: @unchecked) match {
-            case THIS(_) => jmethod.visitVarInsn(Opcodes.ALOAD, 0)
-            case LOAD_LOCAL(local) => jcode.load(indexOf(local), local.kind)
-            case STORE_LOCAL(local) => jcode.store(indexOf(local), local.kind)
-            case STORE_THIS(_) =>
-              // this only works for impl classes because the self parameter comes first
-              // in the method signature. If that changes, this code has to be revisited.
-              jmethod.visitVarInsn(Opcodes.ASTORE, 0)
-
-            case SCOPE_ENTER(lv) =>
-              // locals removed by closelim (via CopyPropagation) may have left behind SCOPE_ENTER, SCOPE_EXIT that are to be ignored
-              val relevant = (!lv.sym.isSynthetic && m.locals.contains(lv))
-              if (relevant) { // TODO check: does GenICode emit SCOPE_ENTER, SCOPE_EXIT for synthetic vars?
-                // this label will have DEBUG bit set in its flags (ie ASM ignores it for dataflow purposes)
-                // similarly, these labels aren't tracked in the `labels` map.
-                val start = new asm.Label
-                jmethod.visitLabel(start)
-                scoping.pushScope(lv, start)
-              }
-
-            case SCOPE_EXIT(lv) =>
-              val relevant = (!lv.sym.isSynthetic && m.locals.contains(lv))
-              if (relevant) {
-                // this label will have DEBUG bit set in its flags (ie ASM ignores it for dataflow purposes)
-                // similarly, these labels aren't tracked in the `labels` map.
-                val end = new asm.Label
-                jmethod.visitLabel(end)
-                scoping.popScope(lv, end, instr.pos)
-              }
-          }
-          genLocalInstr()
-
-          case icodes.stackCat =>
-          def genStackInstr() = (instr: @unchecked) match {
-
-            case LOAD_MODULE(module) =>
-              // assert(module.isModule, "Expected module: " + module)
-              debuglog("generating LOAD_MODULE for: " + module + " flags: " + module.flagString)
-              def inStaticMethod = this.method != null && this.method.symbol.isStaticMember
-              if (clasz.symbol == module.moduleClass && jMethodName != nme.readResolve.toString && !inStaticMethod) {
-                jmethod.visitVarInsn(Opcodes.ALOAD, 0)
-              } else {
-                jmethod.visitFieldInsn(
-                  Opcodes.GETSTATIC,
-                  javaName(module) /* + "$" */ ,
-                  strMODULE_INSTANCE_FIELD,
-                  descriptor(module))
-              }
-
-            case DROP(kind) => emit(if (kind.isWideType) Opcodes.POP2 else Opcodes.POP)
-
-            case DUP(kind) => emit(if (kind.isWideType) Opcodes.DUP2 else Opcodes.DUP)
-
-            case LOAD_EXCEPTION(_) => ()
-          }
-          genStackInstr()
-
-          case icodes.constCat => genConstant(jmethod, instr.asInstanceOf[CONSTANT].constant)
-
-          case icodes.arilogCat => genPrimitive(instr.asInstanceOf[CALL_PRIMITIVE].primitive, instr.pos)
-
-          case icodes.castsCat =>
-          def genCastInstr() = (instr: @unchecked) match {
-
-            case IS_INSTANCE(tpe) =>
-              val jtyp: asm.Type =
-                tpe match {
-                  case REFERENCE(cls) => asm.Type.getObjectType(javaName(cls))
-                  case ARRAY(elem) => javaArrayType(javaType(elem))
-                  case _ => abort("Unknown reference type in IS_INSTANCE: " + tpe)
-                }
-              jmethod.visitTypeInsn(Opcodes.INSTANCEOF, jtyp.getInternalName)
-
-            case CHECK_CAST(tpe) =>
-              tpe match {
-
-                case REFERENCE(cls) =>
-                  if (cls != ObjectClass) { // No need to checkcast for Objects
-                    jmethod.visitTypeInsn(Opcodes.CHECKCAST, javaName(cls))
-                  }
-
-                case ARRAY(elem) =>
-                  val iname = javaArrayType(javaType(elem)).getInternalName
-                  jmethod.visitTypeInsn(Opcodes.CHECKCAST, iname)
-
-                case _ => abort("Unknown reference type in IS_INSTANCE: " + tpe)
-              }
-
-          }
-          genCastInstr()
-
-          case icodes.objsCat =>
-          def genObjsInstr() = (instr: @unchecked) match {
-            case BOX(kind) =>
-              val MethodNameAndType(mname, mdesc) = jBoxTo(kind)
-              jcode.invokestatic(BoxesRunTime, mname, mdesc)
-
-            case UNBOX(kind) =>
-              val MethodNameAndType(mname, mdesc) = jUnboxTo(kind)
-              jcode.invokestatic(BoxesRunTime, mname, mdesc)
-
-            case NEW(REFERENCE(cls)) =>
-              val className = javaName(cls)
-              jmethod.visitTypeInsn(Opcodes.NEW, className)
-
-            case MONITOR_ENTER() => emit(Opcodes.MONITORENTER)
-            case MONITOR_EXIT() => emit(Opcodes.MONITOREXIT)
-          }
-          genObjsInstr()
-
-          case icodes.fldsCat =>
-          def genFldsInstr() = (instr: @unchecked) match {
-
-            case lf @ LOAD_FIELD(field, isStatic) =>
-              val owner = javaName(lf.hostClass)
-              debuglog("LOAD_FIELD with owner: " + owner + " flags: " + field.owner.flagString)
-              val fieldJName = javaName(field)
-              val fieldDescr = descriptor(field)
-              val opc = if (isStatic) Opcodes.GETSTATIC else Opcodes.GETFIELD
-              jmethod.visitFieldInsn(opc, owner, fieldJName, fieldDescr)
-
-            case STORE_FIELD(field, isStatic) =>
-              val owner = javaName(field.owner)
-              val fieldJName = javaName(field)
-              val fieldDescr = descriptor(field)
-              val opc = if (isStatic) Opcodes.PUTSTATIC else Opcodes.PUTFIELD
-              jmethod.visitFieldInsn(opc, owner, fieldJName, fieldDescr)
-
-          }
-          genFldsInstr()
-
-          case icodes.mthdsCat =>
-          def genMethodsInstr() = (instr: @unchecked) match {
-
-            /* Special handling to access native Array.clone() */
-            case call @ CALL_METHOD(definitions.Array_clone, Dynamic) =>
-              val target: String = javaType(call.targetTypeKind).getInternalName
-              jcode.invokevirtual(target, "clone", mdesc_arrayClone)
-
-            case call @ CALL_METHOD(method, style) => genCallMethod(call)
-
-          }
-          genMethodsInstr()
-
-          case icodes.arraysCat =>
-          def genArraysInstr() = (instr: @unchecked) match {
-            case LOAD_ARRAY_ITEM(kind) => jcode.aload(kind)
-            case STORE_ARRAY_ITEM(kind) => jcode.astore(kind)
-            case CREATE_ARRAY(elem, 1) => jcode newarray elem
-            case CREATE_ARRAY(elem, dims) => jmethod.visitMultiANewArrayInsn(descriptor(ArrayN(elem, dims)), dims)
-          }
-          genArraysInstr()
-
-          case icodes.jumpsCat =>
-          def genJumpInstr() = (instr: @unchecked) match {
-
-            case sw @ SWITCH(tagss, branches) =>
-              assert(branches.length == tagss.length + 1, sw)
-              val flatSize = sw.flatTagsCount
-              val flatKeys = new Array[Int](flatSize)
-              val flatBranches = new Array[asm.Label](flatSize)
-
-              var restTagss = tagss
-              var restBranches = branches
-              var k = 0 // ranges over flatKeys and flatBranches
-              while (restTagss.nonEmpty) {
-                val currLabel = labels(restBranches.head)
-                for (cTag <- restTagss.head) {
-                  flatKeys(k) = cTag
-                  flatBranches(k) = currLabel
-                  k += 1
-                }
-                restTagss = restTagss.tail
-                restBranches = restBranches.tail
-              }
-              val defaultLabel = labels(restBranches.head)
-              assert(restBranches.tail.isEmpty)
-              debuglog("Emitting SWITCH:\ntags: " + tagss + "\nbranches: " + branches)
-              jcode.emitSWITCH(flatKeys, flatBranches, defaultLabel, MIN_SWITCH_DENSITY)
-
-            case JUMP(whereto) =>
-              if (nextBlock != whereto)
-                jcode goTo labels(whereto)
-                // SI-6102: Determine whether eliding this JUMP results in an empty range being covered by some EH.
-                // If so, emit a NOP in place of the elided JUMP, to avoid "java.lang.ClassFormatError: Illegal exception table range"
-              else if (newNormal.isJumpOnly(b) && m.exh.exists(eh => eh.covers(b))) {
-                devWarning("Had a jump only block that wasn't collapsed")
-                emit(asm.Opcodes.NOP)
-              }
-
-            case CJUMP(success, failure, cond, kind) =>
-              if (kind.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT
-                if (nextBlock == success) {
-                  jcode.emitIF_ICMP(cond.negate(), labels(failure))
-                  // .. and fall through to success label
-                } else {
-                  jcode.emitIF_ICMP(cond, labels(success))
-                  if (nextBlock != failure) { jcode goTo labels(failure) }
-                }
-              } else if (kind.isRefOrArrayType) { // REFERENCE(_) | ARRAY(_)
-                if (nextBlock == success) {
-                  jcode.emitIF_ACMP(cond.negate(), labels(failure))
-                  // .. and fall through to success label
-                } else {
-                  jcode.emitIF_ACMP(cond, labels(success))
-                  if (nextBlock != failure) { jcode goTo labels(failure) }
-                }
-              } else {
-                (kind: @unchecked) match {
-                  case LONG => emit(Opcodes.LCMP)
-                  case FLOAT =>
-                    if (cond == LT || cond == LE) emit(Opcodes.FCMPG)
-                    else emit(Opcodes.FCMPL)
-                  case DOUBLE =>
-                    if (cond == LT || cond == LE) emit(Opcodes.DCMPG)
-                    else emit(Opcodes.DCMPL)
-                }
-                if (nextBlock == success) {
-                  jcode.emitIF(cond.negate(), labels(failure))
-                  // .. and fall through to success label
-                } else {
-                  jcode.emitIF(cond, labels(success))
-                  if (nextBlock != failure) { jcode goTo labels(failure) }
-                }
-              }
-
-            case CZJUMP(success, failure, cond, kind) =>
-              if (kind.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT
-                if (nextBlock == success) {
-                  jcode.emitIF(cond.negate(), labels(failure))
-                } else {
-                  jcode.emitIF(cond, labels(success))
-                  if (nextBlock != failure) { jcode goTo labels(failure) }
-                }
-              } else if (kind.isRefOrArrayType) { // REFERENCE(_) | ARRAY(_)
-                val Success = success
-                val Failure = failure
-                // @unchecked because references aren't compared with GT, GE, LT, LE.
-                ((cond, nextBlock): @unchecked) match {
-                  case (EQ, Success) => jcode emitIFNONNULL labels(failure)
-                  case (NE, Failure) => jcode emitIFNONNULL labels(success)
-                  case (EQ, Failure) => jcode emitIFNULL labels(success)
-                  case (NE, Success) => jcode emitIFNULL labels(failure)
-                  case (EQ, _) =>
-                    jcode emitIFNULL labels(success)
-                    jcode goTo labels(failure)
-                  case (NE, _) =>
-                    jcode emitIFNONNULL labels(success)
-                    jcode goTo labels(failure)
-                }
-              } else {
-                (kind: @unchecked) match {
-                  case LONG =>
-                    emit(Opcodes.LCONST_0)
-                    emit(Opcodes.LCMP)
-                  case FLOAT =>
-                    emit(Opcodes.FCONST_0)
-                    if (cond == LT || cond == LE) emit(Opcodes.FCMPG)
-                    else emit(Opcodes.FCMPL)
-                  case DOUBLE =>
-                    emit(Opcodes.DCONST_0)
-                    if (cond == LT || cond == LE) emit(Opcodes.DCMPG)
-                    else emit(Opcodes.DCMPL)
-                }
-                if (nextBlock == success) {
-                  jcode.emitIF(cond.negate(), labels(failure))
-                } else {
-                  jcode.emitIF(cond, labels(success))
-                  if (nextBlock != failure) { jcode goTo labels(failure) }
-                }
-              }
-
-          }
-          genJumpInstr()
-
-          case icodes.retCat =>
-          def genRetInstr() = (instr: @unchecked) match {
-            case RETURN(kind) => jcode emitRETURN kind
-            case THROW(_) => emit(Opcodes.ATHROW)
-          }
-          genRetInstr()
-        }
-      }
-
-      /*
-       * Emits one or more conversion instructions based on the types given as arguments.
-       *
-       * @param from The type of the value to be converted into another type.
-       * @param to   The type the value will be converted into.
-       */
-      def emitT2T(from: TypeKind, to: TypeKind) {
-        assert(isNonUnitValueTK(from) && isNonUnitValueTK(to), s"Cannot emit primitive conversion from $from to $to")
-
-            def pickOne(opcs: Array[Int]) {
-              val chosen = (to: @unchecked) match {
-                case BYTE   => opcs(0)
-                case SHORT  => opcs(1)
-                case CHAR   => opcs(2)
-                case INT    => opcs(3)
-                case LONG   => opcs(4)
-                case FLOAT  => opcs(5)
-                case DOUBLE => opcs(6)
-              }
-              if(chosen != -1) { emit(chosen) }
-            }
-
-        if(from == to) { return }
-        // the only conversion involving BOOL that is allowed is (BOOL -> BOOL)
-        assert(from != BOOL && to != BOOL, s"inconvertible types : $from -> $to")
-
-        if(from.isIntSizedType) { // BYTE, CHAR, SHORT, and INT. (we're done with BOOL already)
-
-          val fromByte  = { import asm.Opcodes._; Array( -1,  -1, I2C,  -1, I2L, I2F, I2D) } // do nothing for (BYTE -> SHORT) and for (BYTE -> INT)
-          val fromChar  = { import asm.Opcodes._; Array(I2B, I2S,  -1,  -1, I2L, I2F, I2D) } // for (CHAR  -> INT) do nothing
-          val fromShort = { import asm.Opcodes._; Array(I2B,  -1, I2C,  -1, I2L, I2F, I2D) } // for (SHORT -> INT) do nothing
-          val fromInt   = { import asm.Opcodes._; Array(I2B, I2S, I2C,  -1, I2L, I2F, I2D) }
-
-          (from: @unchecked) match {
-            case BYTE  => pickOne(fromByte)
-            case SHORT => pickOne(fromShort)
-            case CHAR  => pickOne(fromChar)
-            case INT   => pickOne(fromInt)
-          }
-
-        } else { // FLOAT, LONG, DOUBLE
-
-          (from: @unchecked) match {
-            case FLOAT           =>
-              import asm.Opcodes.{ F2L, F2D, F2I }
-              (to: @unchecked) match {
-                case LONG    => emit(F2L)
-                case DOUBLE  => emit(F2D)
-                case _       => emit(F2I); emitT2T(INT, to)
-              }
-
-            case LONG            =>
-              import asm.Opcodes.{ L2F, L2D, L2I }
-              (to: @unchecked) match {
-                case FLOAT   => emit(L2F)
-                case DOUBLE  => emit(L2D)
-                case _       => emit(L2I); emitT2T(INT, to)
-              }
-
-            case DOUBLE          =>
-              import asm.Opcodes.{ D2L, D2F, D2I }
-              (to: @unchecked) match {
-                case FLOAT   => emit(D2F)
-                case LONG    => emit(D2L)
-                case _       => emit(D2I); emitT2T(INT, to)
-              }
-          }
-        }
-      } // end of genCode()'s emitT2T()
-
-      def genPrimitive(primitive: Primitive, pos: Position) {
-
-        import asm.Opcodes
-
-        primitive match {
-
-          case Negation(kind) => jcode.neg(kind)
-
-          case Arithmetic(op, kind) =>
-            def genArith() = {
-            op match {
-
-              case ADD => jcode.add(kind)
-              case SUB => jcode.sub(kind)
-              case MUL => jcode.mul(kind)
-              case DIV => jcode.div(kind)
-              case REM => jcode.rem(kind)
-
-              case NOT =>
-                if(kind.isIntSizedType) {
-                  emit(Opcodes.ICONST_M1)
-                  emit(Opcodes.IXOR)
-                } else if(kind == LONG) {
-                  jmethod.visitLdcInsn(new java.lang.Long(-1))
-                  jmethod.visitInsn(Opcodes.LXOR)
-                } else {
-                  abort("Impossible to negate an " + kind)
-                }
-
-              case _ =>
-                abort("Unknown arithmetic primitive " + primitive)
-            }
-            }
-            genArith()
-
-          // TODO Logical's 2nd elem should be declared ValueTypeKind, to better approximate its allowed values (isIntSized, its comments appears to convey)
-          // TODO GenICode uses `toTypeKind` to define that elem, `toValueTypeKind` would be needed instead.
-          // TODO How about adding some asserts to Logical and similar ones to capture the remaining constraint (UNIT not allowed).
-          case Logical(op, kind) =>
-            def genLogical() = op match {
-              case AND =>
-                kind match {
-                  case LONG => emit(Opcodes.LAND)
-                  case INT  => emit(Opcodes.IAND)
-                  case _    =>
-                    emit(Opcodes.IAND)
-                    if (kind != BOOL) { emitT2T(INT, kind) }
-                }
-              case OR =>
-                kind match {
-                  case LONG => emit(Opcodes.LOR)
-                  case INT  => emit(Opcodes.IOR)
-                  case _ =>
-                    emit(Opcodes.IOR)
-                    if (kind != BOOL) { emitT2T(INT, kind) }
-                }
-              case XOR =>
-                kind match {
-                  case LONG => emit(Opcodes.LXOR)
-                  case INT  => emit(Opcodes.IXOR)
-                  case _ =>
-                    emit(Opcodes.IXOR)
-                    if (kind != BOOL) { emitT2T(INT, kind) }
-                }
-            }
-            genLogical()
-
-          case Shift(op, kind) =>
-            def genShift() = op match {
-              case LSL =>
-                kind match {
-                  case LONG => emit(Opcodes.LSHL)
-                  case INT  => emit(Opcodes.ISHL)
-                  case _ =>
-                    emit(Opcodes.ISHL)
-                    emitT2T(INT, kind)
-                }
-              case ASR =>
-                kind match {
-                  case LONG => emit(Opcodes.LSHR)
-                  case INT  => emit(Opcodes.ISHR)
-                  case _ =>
-                    emit(Opcodes.ISHR)
-                    emitT2T(INT, kind)
-                }
-              case LSR =>
-                kind match {
-                  case LONG => emit(Opcodes.LUSHR)
-                  case INT  => emit(Opcodes.IUSHR)
-                  case  _ =>
-                    emit(Opcodes.IUSHR)
-                    emitT2T(INT, kind)
-                }
-            }
-            genShift()
-
-          case Comparison(op, kind) =>
-            def genCompare() = op match {
-              case CMP =>
-                (kind: @unchecked) match {
-                  case LONG =>  emit(Opcodes.LCMP)
-                }
-              case CMPL =>
-                (kind: @unchecked) match {
-                  case FLOAT  => emit(Opcodes.FCMPL)
-                  case DOUBLE => emit(Opcodes.DCMPL)
-                }
-              case CMPG =>
-                (kind: @unchecked) match {
-                  case FLOAT  => emit(Opcodes.FCMPG)
-                  case DOUBLE => emit(Opcodes.DCMPL) // TODO bug? why not DCMPG? http://docs.oracle.com/javase/specs/jvms/se6/html/Instructions2.doc3.html
-
-                }
-            }
-            genCompare()
-
-          case Conversion(src, dst) =>
-            debuglog("Converting from: " + src + " to: " + dst)
-            emitT2T(src, dst)
-
-          case ArrayLength(_) => emit(Opcodes.ARRAYLENGTH)
-
-          case StartConcat =>
-            jmethod.visitTypeInsn(Opcodes.NEW, StringBuilderClassName)
-            jmethod.visitInsn(Opcodes.DUP)
-            jcode.invokespecial(
-              StringBuilderClassName,
-              INSTANCE_CONSTRUCTOR_NAME,
-              mdesc_arglessvoid
-            )
-
-          case StringConcat(el) =>
-            val jtype = el match {
-              case REFERENCE(_) | ARRAY(_) => JAVA_LANG_OBJECT
-              case _ => javaType(el)
-            }
-            jcode.invokevirtual(
-              StringBuilderClassName,
-              "append",
-              asm.Type.getMethodDescriptor(StringBuilderType, Array(jtype): _*)
-            )
-
-          case EndConcat =>
-            jcode.invokevirtual(StringBuilderClassName, "toString", mdesc_toString)
-
-          case _ => abort("Unimplemented primitive " + primitive)
-        }
-      } // end of genCode()'s genPrimitive()
-
-      // ------------------------------------------------------------------------------------------------------------
-      // Part 6 of genCode(): the executable part of genCode() starts here.
-      // ------------------------------------------------------------------------------------------------------------
-
-      genBlocks(linearization)
-
-      jmethod.visitLabel(onePastLast)
-
-      if(emitLines) {
-        for(LineNumberEntry(line, start) <- lnEntries.sortBy(_.start.getOffset)) { jmethod.visitLineNumber(line, start) }
-      }
-      if(emitVars)  { genLocalVariableTable() }
-
-    } // end of BytecodeGenerator.genCode()
-
-
-    ////////////////////// local vars ///////////////////////
-
-    def sizeOf(k: TypeKind): Int = if(k.isWideType) 2 else 1
-
-    final def indexOf(local: Local): Int = {
-      assert(local.index >= 0, "Invalid index for: " + local + "{" + local.## + "}: ")
-      local.index
-    }
-
-    /**
-     * Compute the indexes of each local variable of the given method.
-     * *Does not assume the parameters come first!*
-     */
-    def computeLocalVarsIndex(m: IMethod) {
-      var idx = if (m.symbol.isStaticMember) 0 else 1
-
-      for (l <- m.params) {
-        debuglog("Index value for " + l + "{" + l.## + "}: " + idx)
-        l.index = idx
-        idx += sizeOf(l.kind)
-      }
-
-      for (l <- m.locals if !l.arg) {
-        debuglog("Index value for " + l + "{" + l.## + "}: " + idx)
-        l.index = idx
-        idx += sizeOf(l.kind)
-      }
-    }
-
-  } // end of class JPlainBuilder
-
-
-  /** builder of mirror classes */
-  class JMirrorBuilder(bytecodeWriter: BytecodeWriter, needsOutfile: Boolean) extends JCommonBuilder(bytecodeWriter, needsOutfile) {
-
-    private var cunit: CompilationUnit = _
-    def getCurrentCUnit(): CompilationUnit = cunit
-
-    /** Generate a mirror class for a top-level module. A mirror class is a class
-     *  containing only static methods that forward to the corresponding method
-     *  on the MODULE instance of the given Scala object.  It will only be
-     *  generated if there is no companion class: if there is, an attempt will
-     *  instead be made to add the forwarder methods to the companion class.
-     */
-    def genMirrorClass(modsym: Symbol, cunit: CompilationUnit) {
-      assert(modsym.companionClass == NoSymbol, modsym)
-      innerClassBuffer.clear()
-      this.cunit = cunit
-      val moduleName = javaName(modsym) // + "$"
-      val mirrorName = moduleName.substring(0, moduleName.length() - 1)
-
-      val flags = (asm.Opcodes.ACC_SUPER | asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_FINAL)
-      val mirrorClass = createJClass(flags,
-                                     mirrorName,
-                                     null /* no java-generic-signature */,
-                                     JAVA_LANG_OBJECT.getInternalName,
-                                     EMPTY_STRING_ARRAY)
-
-      log(s"Dumping mirror class for '$mirrorName'")
-
-      // typestate: entering mode with valid call sequences:
-      //   [ visitSource ] [ visitOuterClass ] ( visitAnnotation | visitAttribute )*
-
-      if(emitSource) {
-        mirrorClass.visitSource("" + cunit.source,
-                                null /* SourceDebugExtension */)
-      }
-
-      val ssa = getAnnotPickle(mirrorName, modsym.companionSymbol)
-      mirrorClass.visitAttribute(if(ssa.isDefined) pickleMarkerLocal else pickleMarkerForeign)
-      emitAnnotations(mirrorClass, modsym.annotations ++ ssa)
-
-      // typestate: entering mode with valid call sequences:
-      //   ( visitInnerClass | visitField | visitMethod )* visitEnd
-
-      addForwarders(isRemote(modsym), mirrorClass, mirrorName, modsym)
-
-      addInnerClasses(modsym, mirrorClass, isMirror = true)
-      mirrorClass.visitEnd()
-      writeIfNotTooBig("" + modsym.name, mirrorName, mirrorClass, modsym)
-    }
-  } // end of class JMirrorBuilder
-
-
-  /** builder of bean info classes */
-  class JBeanInfoBuilder(bytecodeWriter: BytecodeWriter, needsOutfile: Boolean) extends JBuilder(bytecodeWriter, needsOutfile) {
-
-    /**
-     * Generate a bean info class that describes the given class.
-     *
-     * @author Ross Judson (ross.judson@soletta.com)
-     */
-    def genBeanInfoClass(clasz: IClass) {
-
-      // val BeanInfoSkipAttr    = definitions.getRequiredClass("scala.beans.BeanInfoSkip")
-      // val BeanDisplayNameAttr = definitions.getRequiredClass("scala.beans.BeanDisplayName")
-      // val BeanDescriptionAttr = definitions.getRequiredClass("scala.beans.BeanDescription")
-      // val description = c.symbol getAnnotation BeanDescriptionAttr
-      // informProgress(description.toString)
-      innerClassBuffer.clear()
-
-      val flags = mkFlags(
-        javaFlags(clasz.symbol),
-        if(isDeprecated(clasz.symbol)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag
-      )
-
-      val beanInfoName = (javaName(clasz.symbol) + "BeanInfo")
-      val beanInfoClass = createJClass(
-            flags,
-            beanInfoName,
-            null, // no java-generic-signature
-            "scala/beans/ScalaBeanInfo",
-            EMPTY_STRING_ARRAY
-      )
-
-      // beanInfoClass typestate: entering mode with valid call sequences:
-      //   [ visitSource ] [ visitOuterClass ] ( visitAnnotation | visitAttribute )*
-
-      beanInfoClass.visitSource(
-        clasz.cunit.source.toString,
-        null /* SourceDebugExtension */
-      )
-
-      var fieldList = List[String]()
-
-      for (f <- clasz.fields if f.symbol.hasGetter;
-                 g = f.symbol.getterIn(clasz.symbol);
-                 s = f.symbol.setterIn(clasz.symbol)
-           if g.isPublic && !(f.symbol.name startsWith "$")
-          ) {
-             // inserting $outer breaks the bean
-             fieldList = javaName(f.symbol) :: javaName(g) :: (if (s != NoSymbol) javaName(s) else null) :: fieldList
-      }
-
-      val methodList: List[String] =
-	     for (m <- clasz.methods
-	          if !m.symbol.isConstructor &&
-	          m.symbol.isPublic &&
-	          !(m.symbol.name startsWith "$") &&
-	          !m.symbol.isGetter &&
-	          !m.symbol.isSetter)
-       yield javaName(m.symbol)
-
-      // beanInfoClass typestate: entering mode with valid call sequences:
-      //   ( visitInnerClass | visitField | visitMethod )* visitEnd
-
-      val constructor = beanInfoClass.visitMethod(
-        asm.Opcodes.ACC_PUBLIC,
-        INSTANCE_CONSTRUCTOR_NAME,
-        mdesc_arglessvoid,
-        null, // no java-generic-signature
-        EMPTY_STRING_ARRAY // no throwable exceptions
-      )
-
-      // constructor typestate: entering mode with valid call sequences:
-      //   [ visitAnnotationDefault ] ( visitAnnotation | visitParameterAnnotation | visitAttribute )*
-
-      val stringArrayJType: asm.Type = javaArrayType(JAVA_LANG_STRING)
-      val conJType: asm.Type =
-        asm.Type.getMethodType(
-          asm.Type.VOID_TYPE,
-          Array(javaType(ClassClass), stringArrayJType, stringArrayJType): _*
-        )
-
-      def push(lst: List[String]) {
-        var fi = 0
-        for (f <- lst) {
-          constructor.visitInsn(asm.Opcodes.DUP)
-          constructor.visitLdcInsn(new java.lang.Integer(fi))
-          if (f == null) { constructor.visitInsn(asm.Opcodes.ACONST_NULL) }
-          else           { constructor.visitLdcInsn(f) }
-          constructor.visitInsn(JAVA_LANG_STRING.getOpcode(asm.Opcodes.IASTORE))
-          fi += 1
-        }
-      }
-
-      // constructor typestate: entering mode with valid call sequences:
-      //   [ visitCode ( visitFrame | visitXInsn | visitLabel | visitTryCatchBlock | visitLocalVariable | visitLineNumber )* visitMaxs ] visitEnd
-
-      constructor.visitCode()
-
-      constructor.visitVarInsn(asm.Opcodes.ALOAD, 0)
-      // push the class
-      constructor.visitLdcInsn(javaType(clasz.symbol))
-
-      // push the string array of field information
-      constructor.visitLdcInsn(new java.lang.Integer(fieldList.length))
-      constructor.visitTypeInsn(asm.Opcodes.ANEWARRAY, JAVA_LANG_STRING.getInternalName)
-      push(fieldList)
-
-      // push the string array of method information
-      constructor.visitLdcInsn(new java.lang.Integer(methodList.length))
-      constructor.visitTypeInsn(asm.Opcodes.ANEWARRAY, JAVA_LANG_STRING.getInternalName)
-      push(methodList)
-
-      // invoke the superclass constructor, which will do the
-      // necessary java reflection and create Method objects.
-      constructor.visitMethodInsn(asm.Opcodes.INVOKESPECIAL, "scala/beans/ScalaBeanInfo", INSTANCE_CONSTRUCTOR_NAME, conJType.getDescriptor, false)
-      constructor.visitInsn(asm.Opcodes.RETURN)
-
-      constructor.visitMaxs(0, 0) // just to follow protocol, dummy arguments
-      constructor.visitEnd()
-
-      addInnerClasses(clasz.symbol, beanInfoClass)
-      beanInfoClass.visitEnd()
-
-      writeIfNotTooBig("BeanInfo ", beanInfoName, beanInfoClass, clasz.symbol)
-    }
-
-  } // end of class JBeanInfoBuilder
-
-  /** A namespace for utilities to normalize the code of an IMethod, over and beyond what IMethod.normalize() strives for.
-   * In particular, IMethod.normalize() doesn't collapseJumpChains().
-   *
-   * TODO Eventually, these utilities should be moved to IMethod and reused from normalize() (there's nothing JVM-specific about them).
-   */
-  object newNormal {
-    /**
-     * True if a block is "jump only" which is defined
-     * as being a block that consists only of 0 or more instructions that
-     * won't make it to the JVM followed by a JUMP.
-     */
-    def isJumpOnly(b: BasicBlock): Boolean = {
-      val nonICode = firstNonIcodeOnlyInstructions(b)
-      // by definition a block has to have a jump, conditional jump, return, or throw
-      assert(nonICode.hasNext, "empty block")
-      nonICode.next.isInstanceOf[JUMP]
-    }
-
-    /**
-     * Returns the list of instructions in a block that follow all ICode only instructions,
-     * where an ICode only instruction is one that won't make it to the JVM
-     */
-    private def firstNonIcodeOnlyInstructions(b: BasicBlock): Iterator[Instruction] = {
-	  def isICodeOnlyInstruction(i: Instruction) = i match {
-	    case LOAD_EXCEPTION(_) | SCOPE_ENTER(_) | SCOPE_EXIT(_) => true
-	    case _ => false
-	  }
-	  b.iterator dropWhile isICodeOnlyInstruction
-    }
-
-    /**
-     * Returns the target of a block that is "jump only" which is defined
-     * as being a block that consists only of 0 or more instructions that
-     * won't make it to the JVM followed by a JUMP.
-     *
-     * @param b The basic block to examine
-     * @return Some(target) if b is a "jump only" block or None if it's not
-     */
-    private def getJumpOnlyTarget(b: BasicBlock): Option[BasicBlock] = {
-      val nonICode = firstNonIcodeOnlyInstructions(b)
-              // by definition a block has to have a jump, conditional jump, return, or throw
-      assert(nonICode.nonEmpty, "empty block")
-      nonICode.next match {
-        case JUMP(whereto) =>
-          assert(!nonICode.hasNext, "A block contains instructions after JUMP (looks like enterIgnoreMode() was itself ignored.)")
-          Some(whereto)
-        case _ => None
-      }
-    }
-
-    /**
-     * Collapse a chain of "jump-only" blocks such as:
-     *
-     *      JUMP b1;
-     *  b1: JUMP b2;
-     *  b2: JUMP ... etc.
-     *
-     *  by re-wiring predecessors to target directly the "final destination".
-     *  Even if covered by an exception handler, a "non-self-loop jump-only block" can always be removed.
-
-     *  Returns true if any replacement was made, false otherwise.
-     *
-     *  In more detail:
-     *    Starting at each of the entry points (m.startBlock, the start block of each exception handler)
-     *    rephrase those control-flow instructions targeting a jump-only block (which jumps to a final destination D) to target D.
-     *    The blocks thus skipped become eligible to removed by the reachability analyzer
-     *
-     *  Rationale for this normalization:
-     *    test/files/run/private-inline.scala after -optimize is chock full of
-     *    BasicBlocks containing just JUMP(whereto), where no exception handler straddles them.
-     *    They should be collapsed by IMethod.normalize() but aren't.
-     *    That was fine in FJBG times when by the time the exception table was emitted,
-     *    it already contained "anchored" labels (ie instruction offsets were known)
-     *    and thus ranges with identical (start, end) (i.e, identical after GenJVM omitted the JUMPs in question)
-     *    could be weeded out to avoid "java.lang.ClassFormatError: Illegal exception table range"
-     *    Now that visitTryCatchBlock() must be called before Labels are resolved,
-     *    renders the BasicBlocks described above (to recap, consisting of just a JUMP) unreachable.
-     */
-    private def collapseJumpOnlyBlocks(m: IMethod) {
-      assert(m.hasCode, "code-less method")
-
-      def rephraseGotos(detour: mutable.Map[BasicBlock, BasicBlock]) {
-        def lookup(b: BasicBlock) = detour.getOrElse(b, b)
-
-        m.code.startBlock = lookup(m.code.startBlock)
-
-        for(eh <- m.exh)
-          eh.setStartBlock(lookup(eh.startBlock))
-
-        for (b <- m.blocks) {
-          def replaceLastInstruction(i: Instruction) = {
-            if (b.lastInstruction != i) {
-              val idxLast = b.size - 1
-	          debuglog(s"In block $b, replacing last instruction ${b.lastInstruction} with ${i}")
-	          b.replaceInstruction(idxLast, i)
-            }
-          }
-
-          b.lastInstruction match {
-            case JUMP(whereto) =>
-              replaceLastInstruction(JUMP(lookup(whereto)))
-            case CJUMP(succ, fail, cond, kind) =>
-              replaceLastInstruction(CJUMP(lookup(succ), lookup(fail), cond, kind))
-            case CZJUMP(succ, fail, cond, kind)  =>
-              replaceLastInstruction(CZJUMP(lookup(succ), lookup(fail), cond, kind))
-            case SWITCH(tags, labels) =>
-              val newLabels = (labels map lookup)
-              replaceLastInstruction(SWITCH(tags, newLabels))
-            case _ => ()
-          }
-        }
-      }
-
-      /*
-       * Computes a mapping from jump only block to its
-       * final destination which is either a non-jump-only
-       * block or, if it's in a jump-only block cycle, is
-       * itself
-       */
-      def computeDetour: mutable.Map[BasicBlock, BasicBlock] = {
-        // fetch the jump only blocks and their immediate destinations
-        val pairs = for {
-          block <- m.blocks.toIterator
-          target <- getJumpOnlyTarget(block)
-        } yield(block, target)
-
-        // mapping from a jump-only block to our current knowledge of its
-        // final destination. Initially it's just jump block to immediate jump
-        // target
-        val detour = mutable.Map[BasicBlock, BasicBlock](pairs.toSeq:_*)
-
-        // for each jump-only block find its final destination
-        // taking advantage of the destinations we found for previous
-        // blocks
-        for (key <- detour.keySet) {
-          // we use the Robert Floyd's classic Tortoise and Hare algorithm
-          @tailrec
-          def findDestination(tortoise: BasicBlock, hare: BasicBlock): BasicBlock = {
-            if (tortoise == hare)
-              // cycle detected, map key to key
-              key
-            else if (detour contains hare) {
-              // advance hare once
-              val hare1 = detour(hare)
-              // make sure we can advance hare a second time
-              if (detour contains hare1)
-                // advance tortoise once and hare a second time
-                findDestination(detour(tortoise), detour(hare1))
-              else
-                // hare1 is not in the map so it's not a jump-only block, it's the destination
-                hare1
-            } else
-              // hare is not in the map so it's not a jump-only block, it's the destination
-              hare
-          }
-          // update the mapping for key based on its final destination
-          detour(key) = findDestination(key, detour(key))
-        }
-        detour
-      }
-
-      val detour = computeDetour
-      rephraseGotos(detour)
-
-      if (settings.debug) {
-        val (remappings, cycles) = detour partition {case (source, target) => source != target}
-        for ((source, target) <- remappings) {
-		   debuglog(s"Will elide jump only block $source because it can be jumped around to get to $target.")
-                   if (m.startBlock == source) devWarning("startBlock should have been re-wired by now")
-        }
-        val sources = remappings.keySet
-        val targets = remappings.values.toSet
-        val intersection = sources intersect targets
-
-        if (intersection.nonEmpty) devWarning(s"contradiction: we seem to have some source and target overlap in blocks ${intersection.mkString}. Map was ${detour.mkString}")
-
-        for ((source, _) <- cycles) {
-          debuglog(s"Block $source is in a do-nothing infinite loop. Did the user write 'while(true){}'?")
-        }
-      }
-    }
-
-    /**
-     * Removes all blocks that are unreachable in a method using a standard reachability analysis.
-     */
-    def elimUnreachableBlocks(m: IMethod) {
-      assert(m.hasCode, "code-less method")
-
-      // assume nothing is reachable until we prove it can be reached
-      val reachable = mutable.Set[BasicBlock]()
-
-      // the set of blocks that we know are reachable but have
-      // yet to be  marked reachable, initially only the start block
-      val worklist = mutable.Set(m.startBlock)
-
-      while (worklist.nonEmpty) {
-        val block = worklist.head
-        worklist remove block
-        // we know that one is reachable
-        reachable add block
-        // so are its successors, so go back around and add the ones we still
-        // think are unreachable
-        worklist ++= (block.successors filterNot reachable)
-      }
-
-      // exception handlers need to be told not to cover unreachable blocks
-      // and exception handlers that no longer cover any blocks need to be
-      // removed entirely
-      val unusedExceptionHandlers = mutable.Set[ExceptionHandler]()
-      for (exh <- m.exh) {
-        exh.covered = exh.covered filter reachable
-        if (exh.covered.isEmpty) {
-          unusedExceptionHandlers += exh
-        }
-      }
-
-      // remove the unused exception handler references
-      if (settings.debug)
-        for (exh <- unusedExceptionHandlers) debuglog(s"eliding exception handler $exh because it does not cover any reachable blocks")
-      m.exh = m.exh filterNot unusedExceptionHandlers
-
-      // everything not in the reachable set is unreachable, unused, and unloved. buh bye
-      for (b <- m.blocks filterNot reachable) {
-    	  debuglog(s"eliding block $b because it is unreachable")
-    	  m.code removeBlock b
-      }
-    }
-
-    def normalize(m: IMethod) {
-      if(!m.hasCode) { return }
-      collapseJumpOnlyBlocks(m)
-      if (settings.optimise)
-        elimUnreachableBlocks(m)
-      icodes checkValid m
-    }
-
-  }
-
-  // @M don't generate java generics sigs for (members of) implementation
-  // classes, as they are monomorphic (TODO: ok?)
-  private def needsGenericSignature(sym: Symbol) = !(
-    // PP: This condition used to include sym.hasExpandedName, but this leads
-    // to the total loss of generic information if a private member is
-    // accessed from a closure: both the field and the accessor were generated
-    // without it.  This is particularly bad because the availability of
-    // generic information could disappear as a consequence of a seemingly
-    // unrelated change.
-       settings.Ynogenericsig
-    || sym.isArtifact
-    || sym.isLiftedMethod
-    || sym.isBridge
-    || (sym.ownerChain exists (_.isImplClass))
-  )
-
-  final def staticForwarderGenericSignature(sym: Symbol, moduleClass: Symbol, unit: CompilationUnit): String = {
-    if (sym.isDeferred) null // only add generic signature if method concrete; bug #1745
-    else {
-      // SI-3452 Static forwarder generation uses the same erased signature as the method if forwards to.
-      // By rights, it should use the signature as-seen-from the module class, and add suitable
-      // primitive and value-class boxing/unboxing.
-      // But for now, just like we did in mixin, we just avoid writing a wrong generic signature
-      // (one that doesn't erase to the actual signature). See run/t3452b for a test case.
-      val memberTpe = enteringErasure(moduleClass.thisType.memberInfo(sym))
-      val erasedMemberType = erasure.erasure(sym)(memberTpe)
-      if (erasedMemberType =:= sym.info)
-        getGenericSignature(sym, moduleClass, memberTpe, unit)
-      else null
-    }
-  }
-
-  /** @return
-   *   - `null` if no Java signature is to be added (`null` is what ASM expects in these cases).
-   *   - otherwise the signature in question
-   */
-  def getGenericSignature(sym: Symbol, owner: Symbol, unit: CompilationUnit): String = {
-    val memberTpe = enteringErasure(owner.thisType.memberInfo(sym))
-    getGenericSignature(sym, owner, memberTpe, unit)
-  }
-  def getGenericSignature(sym: Symbol, owner: Symbol, memberTpe: Type, unit: CompilationUnit): String = {
-    if (!needsGenericSignature(sym)) { return null }
-
-    val jsOpt: Option[String] = erasure.javaSig(sym, memberTpe)
-    if (jsOpt.isEmpty) { return null }
-
-    val sig = jsOpt.get
-    log(sig) // This seems useful enough in the general case.
-
-        def wrap(op: => Unit) = {
-          try   { op; true }
-          catch { case _: Throwable => false }
-        }
-
-    if (settings.Xverify) {
-      // Run the signature parser to catch bogus signatures.
-      val isValidSignature = wrap {
-        // Alternative: scala.tools.reflect.SigParser (frontend to sun.reflect.generics.parser.SignatureParser)
-        import scala.tools.asm.util.CheckClassAdapter
-        if (sym.isMethod)    { CheckClassAdapter checkMethodSignature sig } // requires asm-util.jar
-        else if (sym.isTerm) { CheckClassAdapter checkFieldSignature  sig }
-        else                 { CheckClassAdapter checkClassSignature  sig }
-      }
-
-      if(!isValidSignature) {
-        reporter.warning(sym.pos,
-            """|compiler bug: created invalid generic signature for %s in %s
-               |signature: %s
-               |if this is reproducible, please report bug at https://issues.scala-lang.org/
-            """.trim.stripMargin.format(sym, sym.owner.skipPackageObject.fullName, sig))
-        return null
-      }
-    }
-
-    if ((settings.check containsName phaseName)) {
-      val normalizedTpe = enteringErasure(erasure.prepareSigMap(memberTpe))
-      val bytecodeTpe = owner.thisType.memberInfo(sym)
-      if (!sym.isType && !sym.isConstructor && !(erasure.erasure(sym)(normalizedTpe) =:= bytecodeTpe)) {
-        reporter.warning(sym.pos,
-            """|compiler bug: created generic signature for %s in %s that does not conform to its erasure
-               |signature: %s
-               |original type: %s
-               |normalized type: %s
-               |erasure type: %s
-               |if this is reproducible, please report bug at http://issues.scala-lang.org/
-            """.trim.stripMargin.format(sym, sym.owner.skipPackageObject.fullName, sig, memberTpe, normalizedTpe, bytecodeTpe))
-         return null
-      }
-    }
-
-    sig
-  }
-
-  def ubytesToCharArray(bytes: Array[Byte]): Array[Char] = {
-    val ca = new Array[Char](bytes.length)
-    var idx = 0
-    while(idx < bytes.length) {
-      val b: Byte = bytes(idx)
-      assert((b & ~0x7f) == 0)
-      ca(idx) = b.asInstanceOf[Char]
-      idx += 1
-    }
-
-    ca
-  }
-
-  final def arrEncode(sb: ScalaSigBytes): Array[String] = {
-    var strs: List[String]  = Nil
-    val bSeven: Array[Byte] = sb.sevenBitsMayBeZero
-    // chop into slices of at most 65535 bytes, counting 0x00 as taking two bytes (as per JVMS 4.4.7 The CONSTANT_Utf8_info Structure)
-    var prevOffset = 0
-    var offset     = 0
-    var encLength  = 0
-    while(offset < bSeven.length) {
-      val deltaEncLength = (if(bSeven(offset) == 0) 2 else 1)
-      val newEncLength = encLength.toLong + deltaEncLength
-      if(newEncLength >= 65535) {
-        val ba     = bSeven.slice(prevOffset, offset)
-        strs     ::= new java.lang.String(ubytesToCharArray(ba))
-        encLength  = 0
-        prevOffset = offset
-      } else {
-        encLength += deltaEncLength
-        offset    += 1
-      }
-    }
-    if(prevOffset < offset) {
-      assert(offset == bSeven.length)
-      val ba = bSeven.slice(prevOffset, offset)
-      strs ::= new java.lang.String(ubytesToCharArray(ba))
-    }
-    assert(strs.size > 1, "encode instead as one String via strEncode()") // TODO too strict?
-    strs.reverse.toArray
-  }
-
-  private def strEncode(sb: ScalaSigBytes): String = {
-    val ca = ubytesToCharArray(sb.sevenBitsMayBeZero)
-    new java.lang.String(ca)
-    // debug val bvA = new asm.ByteVector; bvA.putUTF8(s)
-    // debug val enc: Array[Byte] = scala.reflect.internal.pickling.ByteCodecs.encode(bytes)
-    // debug assert(enc(idx) == bvA.getByte(idx + 2))
-    // debug assert(bvA.getLength == enc.size + 2)
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
deleted file mode 100644
index a866173a88..0000000000
--- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
+++ /dev/null
@@ -1,235 +0,0 @@
- /* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Iulian Dragos
- */
-
-package scala.tools.nsc
-package backend.opt
-
-import scala.tools.nsc.backend.icode.analysis.LubException
-
-/**
- *  @author Iulian Dragos
- */
-abstract class ClosureElimination extends SubComponent {
-  import global._
-  import icodes._
-  import icodes.opcodes._
-
-  val phaseName = "closelim"
-
-  override val enabled: Boolean = settings.Xcloselim
-
-  /** Create a new phase */
-  override def newPhase(p: Phase) = new ClosureEliminationPhase(p)
-
-  /** A simple peephole optimizer. */
-  val peephole = new PeepholeOpt {
-
-    def peep(bb: BasicBlock, i1: Instruction, i2: Instruction) = (i1, i2) match {
-      case (CONSTANT(c), DROP(_)) =>
-        if (c.tag == UnitTag) Some(List(i2)) else Some(Nil)
-
-      case (LOAD_LOCAL(x), STORE_LOCAL(y)) =>
-        if (x eq y) Some(Nil) else None
-
-      case (STORE_LOCAL(x), LOAD_LOCAL(y)) if (x == y) =>
-        var liveOut = liveness.out(bb)
-        if (!liveOut(x)) {
-          debuglog("store/load to a dead local? " + x)
-          val instrs = bb.getArray
-          var idx = instrs.length - 1
-          while (idx > 0 && (instrs(idx) ne i2)) {
-            liveOut = liveness.interpret(liveOut, instrs(idx))
-            idx -= 1
-          }
-          if (!liveOut(x)) {
-            log("Removing dead store/load of " + x.sym.initialize.defString)
-            Some(Nil)
-          } else None
-        } else
-          Some(List(DUP(x.kind), STORE_LOCAL(x)))
-
-      case (LOAD_LOCAL(_), DROP(_)) | (DUP(_), DROP(_)) =>
-        Some(Nil)
-
-      case (BOX(t1), UNBOX(t2)) if (t1 == t2) =>
-        Some(Nil)
-
-      case (LOAD_FIELD(sym, /* isStatic */false), DROP(_)) if !sym.hasAnnotation(definitions.VolatileAttr) && inliner.isClosureClass(sym.owner) =>
-        Some(DROP(REFERENCE(definitions.ObjectClass)) :: Nil)
-
-      case _ => None
-    }
-  }
-
-  /** The closure elimination phase.
-   */
-  class ClosureEliminationPhase(prev: Phase) extends ICodePhase(prev) {
-
-    def name = phaseName
-    val closser = new ClosureElim
-
-    override def apply(c: IClass): Unit = {
-      if (closser ne null)
-        closser analyzeClass c
-    }
-  }
-
-  /**
-   * Remove references to the environment through fields of a closure object.
-   * This has to be run after an 'apply' method has been inlined, but it still
-   * references the closure object.
-   *
-   */
-  class ClosureElim {
-    def analyzeClass(cls: IClass): Unit = if (settings.Xcloselim) {
-      log(s"Analyzing ${cls.methods.size} methods in $cls.")
-      cls.methods foreach { m =>
-        analyzeMethod(m)
-        peephole(m)
-     }}
-
-    val cpp = new copyPropagation.CopyAnalysis
-
-    import copyPropagation._
-
-    /* Some embryonic copy propagation. */
-    def analyzeMethod(m: IMethod): Unit = try {if (m.hasCode) {
-      cpp.init(m)
-      cpp.run()
-
-      m.linearizedBlocks() foreach { bb =>
-        var info = cpp.in(bb)
-        debuglog("Cpp info at entry to block " + bb + ": " + info)
-
-        for (i <- bb) {
-          i match {
-            case LOAD_LOCAL(l) if info.bindings isDefinedAt LocalVar(l) =>
-              val t = info.getBinding(l)
-              t match {
-              	case Deref(This) | Const(_) =>
-                  bb.replaceInstruction(i, valueToInstruction(t))
-                  debuglog(s"replaced $i with $t")
-
-                case _ =>
-                  val t = info.getAlias(l)
-                  bb.replaceInstruction(i, LOAD_LOCAL(t))
-                  debuglog(s"replaced $i with $t")
-              }
-
-            case LOAD_FIELD(f, false) /* if accessible(f, m.symbol) */ =>
-              def replaceFieldAccess(r: Record) {
-                val Record(cls, _) = r
-                info.getFieldNonRecordValue(r, f) foreach { v =>
-                        bb.replaceInstruction(i, DROP(REFERENCE(cls)) :: valueToInstruction(v) :: Nil)
-                        debuglog(s"replaced $i with $v")
-                }
-              }
-
-              info.stack(0) match {
-                case r @ Record(_, bindings) if bindings isDefinedAt f =>
-                  replaceFieldAccess(r)
-
-                case Deref(LocalVar(l)) =>
-                  info.getBinding(l) match {
-                    case r @ Record(_, bindings) if bindings isDefinedAt f =>
-                      replaceFieldAccess(r)
-                    case _ =>
-                  }
-                case Deref(Field(r1, f1)) =>
-                  info.getFieldValue(r1, f1) match {
-                    case Some(r @ Record(_, bindings)) if bindings isDefinedAt f =>
-                      replaceFieldAccess(r)
-                    case _ =>
-                  }
-
-                case _ =>
-              }
-
-            case UNBOX(boxType) =>
-              info.stack match {
-                case Deref(LocalVar(loc1)) :: _ if info.bindings isDefinedAt LocalVar(loc1) =>
-                  val value = info.getBinding(loc1)
-                  value match {
-                    case Boxed(LocalVar(loc2)) if loc2.kind == boxType =>
-                      bb.replaceInstruction(i, DROP(icodes.ObjectReference) :: valueToInstruction(info.getBinding(loc2)) :: Nil)
-                      debuglog("replaced " + i + " with " + info.getBinding(loc2))
-                    case _ =>
-                      ()
-                  }
-                case Boxed(LocalVar(loc1)) :: _ if loc1.kind == boxType =>
-                  val loc2 = info.getAlias(loc1)
-                  bb.replaceInstruction(i, DROP(icodes.ObjectReference) :: valueToInstruction(Deref(LocalVar(loc2))) :: Nil)
-                  debuglog("replaced " + i + " with " + LocalVar(loc2))
-                case _ =>
-              }
-
-            case _ =>
-          }
-          info = cpp.interpret(info, i)
-        }
-      }
-    }} catch {
-      case e: LubException =>
-        Console.println("In method: " + m)
-        Console.println(e)
-        e.printStackTrace
-    }
-
-    /* Partial mapping from values to instructions that load them. */
-    def valueToInstruction(v: Value): Instruction = (v: @unchecked) match {
-      case Deref(LocalVar(v)) =>
-        LOAD_LOCAL(v)
-      case Const(k) =>
-        CONSTANT(k)
-      case Deref(This) =>
-        THIS(definitions.ObjectClass)
-      case Boxed(LocalVar(v)) =>
-        LOAD_LOCAL(v)
-    }
-  } /* class ClosureElim */
-
-
-  /** Peephole optimization. */
-  abstract class PeepholeOpt {
-    /** Concrete implementations will perform their optimizations here */
-    def peep(bb: BasicBlock, i1: Instruction, i2: Instruction): Option[List[Instruction]]
-
-    var liveness: global.icodes.liveness.LivenessAnalysis = null
-
-    def apply(m: IMethod): Unit = if (m.hasCode) {
-      liveness = new global.icodes.liveness.LivenessAnalysis
-      liveness.init(m)
-      liveness.run()
-      m foreachBlock transformBlock
-    }
-
-    def transformBlock(b: BasicBlock): Unit = if (b.size >= 2) {
-      var newInstructions: List[Instruction] = b.toList
-      var redo = false
-
-      do {
-        var h = newInstructions.head
-        var t = newInstructions.tail
-        var seen: List[Instruction] = Nil
-        redo = false
-
-        while (t != Nil) {
-          peep(b, h, t.head) match {
-            case Some(newInstrs) =>
-              newInstructions = seen reverse_::: newInstrs ::: t.tail
-              redo = true
-            case None =>
-            	()
-          }
-          seen = h :: seen
-          h = t.head
-          t = t.tail
-        }
-      } while (redo)
-      b fromList newInstructions
-    }
-  }
-
-} /* class ClosureElimination */
diff --git a/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala b/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala
deleted file mode 100644
index fb1799e092..0000000000
--- a/src/compiler/scala/tools/nsc/backend/opt/ConstantOptimization.scala
+++ /dev/null
@@ -1,626 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  James Iry
- */
-
-package scala
-package tools.nsc
-package backend.opt
-
-import scala.annotation.tailrec
-
-/**
- * ConstantOptimization uses abstract interpretation to approximate for
- * each instruction what constants a variable or stack slot might hold
- * or cannot hold. From this it will eliminate unreachable conditionals
- * where only one branch is reachable, e.g. to eliminate unnecessary
- * null checks.
- *
- * With some more work it could be extended to
- * - cache stable values (final fields, modules) in locals
- * - replace the copy propagation in ClosureElimination
- * - fold constants
- * - eliminate unnecessary stores and loads
- * - propagate knowledge gathered from conditionals for further optimization
- */
-abstract class ConstantOptimization extends SubComponent {
-  import global._
-  import icodes._
-  import icodes.opcodes._
-
-  val phaseName = "constopt"
-
-  /** Create a new phase */
-  override def newPhase(p: Phase) = new ConstantOptimizationPhase(p)
-
-  override val enabled: Boolean = settings.YconstOptimization
-
-  /**
-   * The constant optimization phase.
-   */
-  class ConstantOptimizationPhase(prev: Phase) extends ICodePhase(prev) {
-
-    def name = phaseName
-
-    override def apply(c: IClass) {
-      if (settings.YconstOptimization) {
-        val analyzer = new ConstantOptimizer
-        analyzer optimizeClass c
-      }
-    }
-  }
-
-  class ConstantOptimizer {
-    def optimizeClass(cls: IClass) {
-      log(s"Analyzing ${cls.methods.size} methods in $cls.")
-      cls.methods foreach { m =>
-        optimizeMethod(m)
-      }
-    }
-
-    def optimizeMethod(m: IMethod) {
-      if (m.hasCode) {
-        log(s"Analyzing ${m.symbol}")
-        val replacementInstructions = interpretMethod(m)
-        for (block <- m.blocks) {
-          if (replacementInstructions contains block) {
-            val instructions = replacementInstructions(block)
-            block.replaceInstruction(block.lastInstruction, instructions)
-          }
-        }
-      }
-    }
-
-    /**
-     * A single possible (or impossible) datum that can be held in Contents
-     */
-    private sealed abstract class Datum
-    /**
-     * A constant datum
-     */
-    private case class Const(c: Constant) extends Datum {
-      def isIntAssignable = c.tag >= BooleanTag && c.tag <= IntTag
-      def toInt = c.tag match {
-        case BooleanTag => if (c.booleanValue) 1 else 0
-        case _ => c.intValue
-      }
-
-      /**
-       * True if this constant would compare to other as true under primitive eq
-       */
-      override def equals(other: Any) = other match {
-        case oc @ Const(o) => (this eq oc) || (if (this.isIntAssignable && oc.isIntAssignable) this.toInt == oc.toInt else c.value == o.value)
-        case _ => false
-      }
-
-      /**
-       * Hash code consistent with equals
-       */
-      override def hashCode = if (this.isIntAssignable) this.toInt else c.hashCode
-
-    }
-    /**
-     * A datum that has been Boxed via a BOX instruction
-     */
-    private case class Boxed(c: Datum) extends Datum
-
-    /**
-     * The knowledge we have about the abstract state of one location in terms
-     * of what constants it might or cannot hold. Forms a lower
-     * lattice where lower elements in the lattice indicate less knowledge.
-     *
-     * With the following partial ordering (where '>' indicates more precise knowledge)
-     *
-     * Possible(xs) > Possible(xs + y)
-     * Possible(xs) > Impossible(ys)
-     * Impossible(xs + y) > Impossible(xs)
-     *
-     * and the following merges, which indicate merging knowledge from two paths through
-     * the code,
-     *
-     * // left must be 1 or 2, right must be 2 or 3 then we must have a 1, 2 or 3
-     * Possible(xs) merge Possible(ys) => Possible(xs union ys)
-     *
-     * // Left says can't be 2 or 3, right says can't be 3 or 4
-     * // then it's not 3 (it could be 2 from the right or 4 from the left)
-     * Impossible(xs) merge Impossible(ys) => Impossible(xs intersect ys)
-     *
-     * // Left says it can't be 2 or 3, right says it must be 3 or 4, then
-     * // it can't be 2 (left rules out 4 and right says 3 is possible)
-     * Impossible(xs) merge Possible(ys) => Impossible(xs -- ys)
-     *
-     * Intuitively, Possible(empty) says that a location can't hold anything,
-     * it's uninitialized. However, Possible(empty) never appears in the code.
-     *
-     * Conversely, Impossible(empty) says nothing is impossible, it could be
-     * anything. Impossible(empty) is given a synonym UNKNOWN and is used
-     * for, e.g., the result of an arbitrary method call.
-     */
-    private sealed abstract class Contents {
-      /**
-       * Join this Contents with another coming from another path. Join enforces
-       * the lattice structure. It is symmetrical and never moves upward in the
-       * lattice
-       */
-      final def merge(other: Contents): Contents = if (this eq other) this else (this, other) match {
-        case (Possible(possible1), Possible(possible2)) =>
-          Possible(possible1 union possible2)
-        case (Impossible(impossible1), Impossible(impossible2)) =>
-          Impossible(impossible1 intersect impossible2)
-        case (Impossible(impossible), Possible(possible)) =>
-          Impossible(impossible -- possible)
-        case (Possible(possible), Impossible(impossible)) =>
-          Impossible(impossible -- possible)
-      }
-      // TODO we could have more fine-grained knowledge, e.g. know that 0 < x < 3. But for now equality/inequality is a good start.
-      def mightEqual(other: Contents): Boolean
-      def mightNotEqual(other: Contents): Boolean
-    }
-    private def SingleImpossible(x: Datum) = new Impossible(Set(x))
-
-    /**
-     * The location is known to have one of a set of values.
-     */
-    private case class Possible(possible: Set[Datum]) extends Contents {
-      assert(possible.nonEmpty, "Contradiction: had an empty possible set indicating an uninitialized location")
-      def mightEqual(other: Contents): Boolean = (this eq other) || (other match {
-        // two Possibles might be equal if they have any possible members in common
-        case Possible(possible2) => (possible intersect possible2).nonEmpty
-        // a possible can be equal to an impossible if the impossible doesn't rule
-        // out all the possibilities
-        case Impossible(possible2) => (possible -- possible2).nonEmpty
-      })
-      def mightNotEqual(other: Contents): Boolean = (other match {
-        case Possible(possible2) =>
-          // two Possibles must equal if each is known to be of the same, single value
-          val mustEqual = possible.size == 1 && possible == possible2
-          !mustEqual
-        case Impossible(_) => true
-      })
-    }
-    private def SinglePossible(x: Datum) = new Possible(Set(x))
-
-    /**
-     * The location is known to not have any of a set of values value (e.g null).
-     */
-    private case class Impossible(impossible: Set[Datum]) extends Contents {
-      def mightEqual(other: Contents): Boolean = (this eq other) || (other match {
-        case Possible(_) => other mightEqual this
-        case _ => true
-      })
-      def mightNotEqual(other: Contents): Boolean = (this eq other) || (other match {
-        case Possible(_) => other mightNotEqual this
-        case _ => true
-      })
-    }
-
-    /**
-     * Our entire knowledge about the contents of all variables and the stack. It forms
-     * a lattice primarily driven by the lattice structure of Contents.
-     *
-     * In addition to the rules of contents, State has the following properties:
-     * - The merge of two sets of locals holds the merges of locals found in the intersection
-     * of the two sets of locals. Locals not found in a
-     * locals map are thus possibly uninitialized and attempting to load them results
-     * in an error.
-     * - The stack heights of two states must match otherwise it's an error to merge them
-     *
-     * State is immutable in order to aid in structure sharing of local maps and stacks
-     */
-    private case class State(locals: Map[Local, Contents], stack: List[Contents]) {
-      def mergeLocals(olocals: Map[Local, Contents]): Map[Local, Contents] = if (locals eq olocals) locals else Map((for {
-        key <- (locals.keySet intersect olocals.keySet).toSeq
-      } yield (key, locals(key) merge olocals(key))): _*)
-
-      def merge(other: State): State = if (this eq other) this else {
-        @tailrec def mergeStacks(l: List[Contents], r: List[Contents], out: List[Contents]): List[Contents] = (l, r) match {
-          case (Nil, Nil) => out.reverse
-          case (l, r) if l eq r => out.reverse ++ l
-          case (lhead :: ltail, rhead :: rtail) => mergeStacks(ltail, rtail, (lhead merge rhead) :: out)
-          case _ => sys.error("Mismatched stack heights")
-        }
-
-        val newLocals = mergeLocals(other.locals)
-
-        val newStack = if (stack eq other.stack) stack else mergeStacks(stack, other.stack, Nil)
-        State(newLocals, newStack)
-      }
-
-      /**
-       * Peek at the top of the stack without modifying it. Error if the stack is empty
-       */
-      def peek(n: Int): Contents = stack(n)
-      /**
-       * Push contents onto a stack
-       */
-      def push(contents: Contents): State = this copy (stack = contents :: stack)
-      /**
-       * Drop n elements from the stack
-       */
-      def drop(number: Int): State = this copy (stack = stack drop number)
-      /**
-       * Store the top of the stack into the specified local. An error if the stack
-       * is empty
-       */
-      def store(variable: Local): State = {
-        val contents = stack.head
-        val newVariables = locals + ((variable, contents))
-        new State(newVariables, stack.tail)
-      }
-      /**
-       * Load the specified local onto the top of the stack. An error the the local is uninitialized.
-       */
-      def load(variable: Local): State = {
-        val contents: Contents = locals.getOrElse(variable, sys.error(s"$variable is not initialized"))
-        push(contents)
-      }
-      /**
-       * A copy of this State with an empty stack
-       */
-      def cleanStack: State = if (stack.isEmpty) this else this copy (stack = Nil)
-    }
-
-    // some precomputed constants
-    private val NULL = Const(Constant(null: Any))
-    private val UNKNOWN = Impossible(Set.empty)
-    private val NOT_NULL = SingleImpossible(NULL)
-    private val CONST_UNIT = SinglePossible(Const(Constant(())))
-    private val CONST_FALSE = SinglePossible(Const(Constant(false)))
-    private val CONST_ZERO_BYTE = SinglePossible(Const(Constant(0: Byte)))
-    private val CONST_ZERO_SHORT = SinglePossible(Const(Constant(0: Short)))
-    private val CONST_ZERO_CHAR = SinglePossible(Const(Constant(0: Char)))
-    private val CONST_ZERO_INT = SinglePossible(Const(Constant(0: Int)))
-    private val CONST_ZERO_LONG = SinglePossible(Const(Constant(0: Long)))
-    private val CONST_ZERO_FLOAT = SinglePossible(Const(Constant(0.0f)))
-    private val CONST_ZERO_DOUBLE = SinglePossible(Const(Constant(0.0d)))
-    private val CONST_NULL = SinglePossible(NULL)
-
-    /**
-     * Given a TypeKind, figure out what '0' for it means in order to interpret CZJUMP
-     */
-    private def getZeroOf(k: TypeKind): Contents = k match {
-      case UNIT => CONST_UNIT
-      case BOOL => CONST_FALSE
-      case BYTE => CONST_ZERO_BYTE
-      case SHORT => CONST_ZERO_SHORT
-      case CHAR => CONST_ZERO_CHAR
-      case INT => CONST_ZERO_INT
-      case LONG => CONST_ZERO_LONG
-      case FLOAT => CONST_ZERO_FLOAT
-      case DOUBLE => CONST_ZERO_DOUBLE
-      case REFERENCE(_) => CONST_NULL
-      case ARRAY(_) => CONST_NULL
-      case BOXED(_) => CONST_NULL
-      case ConcatClass => abort("no zero of ConcatClass")
-    }
-
-    // normal locals can't be null, so we use null to mean the magic 'this' local
-    private val THIS_LOCAL: Local = null
-
-    /**
-     * interpret a single instruction to find its impact on the abstract state
-     */
-    private def interpretInst(in: State, inst: Instruction): State = {
-      // pop the consumed number of values off the `in` state's stack, producing a new state
-      def dropConsumed: State = in drop inst.consumed
-
-      inst match {
-        case THIS(_) =>
-          in load THIS_LOCAL
-
-        case CONSTANT(k) =>
-          // treat NaN as UNKNOWN because NaN must never equal NaN
-          val const = if (k.isNaN) UNKNOWN
-          else SinglePossible(Const(k))
-          in push const
-
-        case LOAD_ARRAY_ITEM(_) | LOAD_FIELD(_, _) | CALL_PRIMITIVE(_) =>
-          dropConsumed push UNKNOWN
-
-        case LOAD_LOCAL(local) =>
-          // TODO if a local is known to hold a constant then we can replace this instruction with a push of that constant
-          in load local
-
-        case STORE_LOCAL(local) =>
-          in store local
-
-        case STORE_THIS(_) =>
-          // if a local is already known to have a constant and we're replacing with the same constant then we can
-          // replace this with a drop
-          in store THIS_LOCAL
-
-        case CALL_METHOD(_, _) =>
-          // TODO we could special case implementations of equals that are known, e.g. String#equals
-          // We could turn Possible(string constants).equals(Possible(string constants) into an eq check
-          // We could turn nonConstantString.equals(constantString) into constantString.equals(nonConstantString)
-          //  and eliminate the null check that likely precedes this call
-          val initial = dropConsumed
-          (0 until inst.produced).foldLeft(initial) { case (know, _) => know push UNKNOWN }
-
-        case BOX(_) =>
-          val value = in peek 0
-          // we simulate boxing by, um, boxing the possible/impossible contents
-          // so if we have Possible(1,2) originally then we'll end up with
-          // a Possible(Boxed(1), Boxed(2))
-          // Similarly, if we know the input is not a 0 then we'll know the
-          // output is not a Boxed(0)
-          val newValue = value match {
-            case Possible(values) => Possible(values map Boxed)
-            case Impossible(values) => Impossible(values map Boxed)
-          }
-          dropConsumed push newValue
-
-        case UNBOX(_) =>
-          val value = in peek 0
-          val newValue = value match {
-            // if we have a Possible, then all the possibilities
-            // should themselves be Boxes. In that
-            // case we can merge them to figure out what the UNBOX will produce
-            case Possible(inners) =>
-              assert(inners.nonEmpty, "Empty possible set indicating an uninitialized location")
-              val sanitized: Set[Contents] = (inners map {
-                case Boxed(content) => SinglePossible(content)
-                case _ => UNKNOWN
-              })
-              sanitized reduce (_ merge _)
-            // if we have an impossible then the thing that's impossible
-            // should be a box. We'll unbox that to see what we get
-            case unknown@Impossible(inners) =>
-              if (inners.isEmpty) {
-                unknown
-              } else {
-                val sanitized: Set[Contents] = (inners map {
-                  case Boxed(content) => SingleImpossible(content)
-                  case _ => UNKNOWN
-                })
-                sanitized reduce (_ merge _)
-              }
-          }
-          dropConsumed push newValue
-
-        case LOAD_MODULE(_) | NEW(_) | LOAD_EXCEPTION(_) =>
-          in push NOT_NULL
-
-        case CREATE_ARRAY(_, _) =>
-          dropConsumed push NOT_NULL
-
-        case IS_INSTANCE(_) =>
-          // TODO IS_INSTANCE is going to be followed by a C(Z)JUMP
-          // and if IS_INSTANCE/C(Z)JUMP the branch for "true" can
-          // know that whatever was checked was not a null
-          // see the TODO on CJUMP for more information about propagating null
-          // information
-          // TODO if the top of stack is guaranteed null then we can eliminate this IS_INSTANCE check and
-          // replace with a constant false, but how often is a knowable null checked for instanceof?
-          // TODO we could track type information and statically know to eliminate IS_INSTANCE
-          // which might be a nice win under specialization
-          dropConsumed push UNKNOWN // it's actually a Possible(true, false) but since the following instruction
-        // will be a conditional jump comparing to true or false there
-        // nothing to be gained by being more precise
-
-        case CHECK_CAST(_) =>
-          // TODO we could track type information and statically know to eliminate CHECK_CAST
-          // but that's probably not a huge win
-          in
-
-        case DUP(_) =>
-          val value = in peek 0
-          in push value
-
-        case DROP(_) | MONITOR_ENTER() | MONITOR_EXIT() | STORE_ARRAY_ITEM(_) | STORE_FIELD(_, _) =>
-          dropConsumed
-
-        case SCOPE_ENTER(_) | SCOPE_EXIT(_) =>
-          in
-
-        case JUMP(_) | CJUMP(_, _, _, _) | CZJUMP(_, _, _, _) | RETURN(_) | THROW(_) | SWITCH(_, _) =>
-          dumpClassesAndAbort("Unexpected block ending instruction: " + inst)
-      }
-    }
-    /**
-     * interpret the last instruction of a block which will be jump, a conditional branch, a throw, or a return.
-     * It will result in a map from target blocks to the input state computed for that block. It
-     * also computes a replacement list of instructions
-     */
-    private def interpretLast(in: State, inst: Instruction): (Map[BasicBlock, State], List[Instruction]) = {
-      def canSwitch(in1: Contents, tagSet: List[Int]) = {
-        in1 mightEqual Possible(tagSet.toSet map { tag: Int => Const(Constant(tag)) })
-      }
-
-      /* common code for interpreting CJUMP and CZJUMP */
-      def interpretConditional(kind: TypeKind, val1: Contents, val2: Contents, success: BasicBlock, failure: BasicBlock, cond: TestOp): (Map[BasicBlock, State], List[Instruction]) = {
-        // TODO use reaching analysis to update the state in the two branches
-        // e.g. if the comparison was checking null equality on local x
-        // then the in the success branch we know x is null and
-        // on the failure branch we know it is not
-        // in fact, with copy propagation we could propagate that knowledge
-        // back through a chain of locations
-        //
-        // TODO if we do all that we need to be careful in the
-        // case that success and failure are the same target block
-        // because we're using a Map and don't want one possible state to clobber the other
-        // alternative maybe we should just replace the conditional with a jump if both targets are the same
-
-        def mightEqual = val1 mightEqual val2
-        def mightNotEqual = val1 mightNotEqual val2
-        def guaranteedEqual = mightEqual && !mightNotEqual
-
-        def succPossible = cond match {
-          case EQ => mightEqual
-          case NE => mightNotEqual
-          case LT | GT => !guaranteedEqual // if the two are guaranteed to be equal then they can't be LT/GT
-          case LE | GE => true
-        }
-
-        def failPossible = cond match {
-          case EQ => mightNotEqual
-          case NE => mightEqual
-          case LT | GT => true
-          case LE | GE => !guaranteedEqual // if the two are guaranteed to be equal then they must be LE/GE
-        }
-
-        val out = in drop inst.consumed
-
-        var result = Map[BasicBlock, State]()
-        if (succPossible) {
-          result += ((success, out))
-        }
-
-        if (failPossible) {
-          result += ((failure, out))
-        }
-
-        val replacements = if (result.size == 1) List.fill(inst.consumed)(DROP(kind)) :+ JUMP(result.keySet.head)
-        else inst :: Nil
-
-        (result, replacements)
-      }
-
-      inst match {
-        case JUMP(whereto) =>
-          (Map((whereto, in)), inst :: Nil)
-
-        case CJUMP(success, failure, cond, kind) =>
-          val in1 = in peek 0
-          val in2 = in peek 1
-          interpretConditional(kind, in1, in2, success, failure, cond)
-
-        case CZJUMP(success, failure, cond, kind) =>
-          val in1 = in peek 0
-          val in2 = getZeroOf(kind)
-          interpretConditional(kind, in1, in2, success, failure, cond)
-
-        case SWITCH(tags, labels) =>
-          val in1 = in peek 0
-          val reachableNormalLabels = tags zip labels collect { case (tagSet, label) if canSwitch(in1, tagSet) => label }
-          val reachableLabels = if (tags.isEmpty) {
-            assert(labels.size == 1, s"When SWITCH node has empty array of tags it should have just one (default) label: $labels")
-            labels
-          } else if (labels.lengthCompare(tags.length) > 0) {
-            // if we've got an extra label then it's the default
-            val defaultLabel = labels.last
-            // see if the default is reachable by seeing if the input might be out of the set
-            // of all tags
-            val allTags = Possible(tags.flatten.toSet map { tag: Int => Const(Constant(tag)) })
-            if (in1 mightNotEqual allTags) {
-              reachableNormalLabels :+ defaultLabel
-            } else {
-              reachableNormalLabels
-            }
-          } else {
-            reachableNormalLabels
-          }
-          // TODO similar to the comment in interpretConditional, we should update our the State going into each
-          // branch based on which tag is being matched. Also, just like interpretConditional, if target blocks
-          // are the same we need to merge State rather than clobber
-
-          // alternative, maybe we should simplify the SWITCH to not have same target labels
-          val newState = in drop inst.consumed
-          val result = Map(reachableLabels map { label => (label, newState) }: _*)
-          if (reachableLabels.size == 1) (result, DROP(INT) :: JUMP(reachableLabels.head) :: Nil)
-          else (result, inst :: Nil)
-
-        // these instructions don't have target blocks
-        // (exceptions are assumed to be reachable from all instructions)
-        case RETURN(_) | THROW(_) =>
-          (Map.empty, inst :: Nil)
-
-        case _ =>
-          dumpClassesAndAbort("Unexpected non-block ending instruction: " + inst)
-      }
-    }
-
-    /**
-     * Analyze a single block to find how it transforms an input state into a states for its successor blocks
-     * Also computes a list of instructions to be used to replace its last instruction
-     */
-    private def interpretBlock(in: State, block: BasicBlock): (Map[BasicBlock, State], Map[BasicBlock, State], List[Instruction]) = {
-      debuglog(s"interpreting block $block")
-      // number of instructions excluding the last one
-      val normalCount = block.size - 1
-
-      val exceptionState = in.cleanStack
-      var normalExitState = in
-      var idx = 0
-      while (idx < normalCount) {
-        val inst = block(idx)
-        normalExitState = interpretInst(normalExitState, inst)
-        if (normalExitState.locals ne exceptionState.locals)
-          exceptionState.copy(locals = exceptionState mergeLocals normalExitState.locals)
-        idx += 1
-      }
-
-      val pairs = block.exceptionSuccessors map { b => (b, exceptionState) }
-      val exceptionMap = Map(pairs: _*)
-
-      val (normalExitMap, newInstructions) = interpretLast(normalExitState, block.lastInstruction)
-
-      (normalExitMap, exceptionMap, newInstructions)
-    }
-
-    /**
-     * Analyze a single method to find replacement instructions
-     */
-    private def interpretMethod(m: IMethod): Map[BasicBlock, List[Instruction]] = {
-      import scala.collection.mutable.{ Set => MSet, Map => MMap }
-
-      debuglog(s"interpreting method $m")
-      var iterations = 0
-
-      // initially we know that 'this' is not null and the params are initialized to some unknown value
-      val initThis: Iterator[(Local, Contents)] = if (m.isStatic) Iterator.empty else Iterator.single((THIS_LOCAL, NOT_NULL))
-      val initOtherLocals: Iterator[(Local, Contents)] = m.params.iterator map { param => (param, UNKNOWN) }
-      val initialLocals: Map[Local, Contents] = Map((initThis ++ initOtherLocals).toSeq: _*)
-      val initialState = State(initialLocals, Nil)
-
-      // worklist of basic blocks to process, initially the start block
-      val worklist = MSet(m.startBlock)
-      // worklist of exception basic blocks. They're kept in a separate set so they can be
-      // processed after normal flow basic blocks. That's because exception basic blocks
-      // are more likely to have multiple predecessors and queueing them for later
-      // increases the chances that they'll only need to be interpreted once
-      val exceptionlist = MSet[BasicBlock]()
-      // our current best guess at what the input state is for each block
-      // initially we only know about the start block
-      val inputState = MMap[BasicBlock, State]((m.startBlock, initialState))
-
-      // update the inputState map based on new information from interpreting a block
-      // When the input state of a block changes, add it back to the work list to be
-      // reinterpreted
-      def updateInputStates(outputStates: Map[BasicBlock, State], worklist: MSet[BasicBlock]) {
-        for ((block, newState) <- outputStates) {
-          val oldState = inputState get block
-          val updatedState = oldState map (x => x merge newState) getOrElse newState
-          if (oldState != Some(updatedState)) {
-            worklist add block
-            inputState(block) = updatedState
-          }
-        }
-      }
-
-      // the instructions to be used as the last instructions on each block
-      val replacements = MMap[BasicBlock, List[Instruction]]()
-
-      while (worklist.nonEmpty || exceptionlist.nonEmpty) {
-        if (worklist.isEmpty) {
-          // once the worklist is empty, start processing exception blocks
-          val block = exceptionlist.head
-          exceptionlist remove block
-          worklist add block
-        } else {
-          iterations += 1
-          val block = worklist.head
-          worklist remove block
-          val (normalExitMap, exceptionMap, newInstructions) = interpretBlock(inputState(block), block)
-
-          updateInputStates(normalExitMap, worklist)
-          updateInputStates(exceptionMap, exceptionlist)
-          replacements(block) = newInstructions
-        }
-      }
-
-      debuglog(s"method $m with ${m.blocks.size} reached fixpoint in $iterations iterations")
-      replacements.toMap
-    }
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
deleted file mode 100644
index 8911a3a28c..0000000000
--- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
+++ /dev/null
@@ -1,450 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Iulian Dragos
- */
-
-
-package scala.tools.nsc
-package backend.opt
-
-import scala.collection.{ mutable, immutable }
-
-/**
- */
-abstract class DeadCodeElimination extends SubComponent {
-  import global._
-  import icodes._
-  import icodes.opcodes._
-  import definitions.RuntimePackage
-
-  /** The block and index where an instruction is located */
-  type InstrLoc = (BasicBlock, Int)
-
-  val phaseName = "dce"
-
-  override val enabled: Boolean = settings.Xdce
-
-  /** Create a new phase */
-  override def newPhase(p: Phase) = new DeadCodeEliminationPhase(p)
-
-  /** Dead code elimination phase.
-   */
-  class DeadCodeEliminationPhase(prev: Phase) extends ICodePhase(prev) {
-
-    def name = phaseName
-    val dce = new DeadCode()
-
-    override def apply(c: IClass) {
-      if (settings.Xdce && (dce ne null))
-        dce.analyzeClass(c)
-    }
-  }
-
-  /** closures that are instantiated at least once, after dead code elimination */
-  val liveClosures = perRunCaches.newSet[Symbol]()
-
-  /** closures that are eliminated, populated by GenASM.AsmPhase.run()
-   *  these class symbols won't have a .class physical file, thus shouldn't be included in InnerClasses JVM attribute,
-   *  otherwise some tools get confused or slow (SI-6546)
-   * */
-  val elidedClosures = perRunCaches.newSet[Symbol]()
-
-  /** Remove dead code.
-   */
-  class DeadCode {
-
-    def analyzeClass(cls: IClass) {
-      log(s"Analyzing ${cls.methods.size} methods in $cls.")
-      cls.methods.foreach { m =>
-        this.method = m
-        dieCodeDie(m)
-        global.closureElimination.peephole(m)
-      }
-    }
-
-    val rdef = new reachingDefinitions.ReachingDefinitionsAnalysis
-
-    /** Use-def chain: give the reaching definitions at the beginning of given instruction. */
-    var defs: immutable.Map[InstrLoc, immutable.Set[rdef.lattice.Definition]] = immutable.HashMap.empty
-
-    /** Useful instructions which have not been scanned yet. */
-    val worklist: mutable.Set[InstrLoc] = new mutable.LinkedHashSet
-
-    /** what instructions have been marked as useful? */
-    val useful: mutable.Map[BasicBlock, mutable.BitSet] = perRunCaches.newMap()
-
-    /** what local variables have been accessed at least once? */
-    var accessedLocals: List[Local] = Nil
-
-    /** Map from a local and a basic block to the instructions that store to that local in that basic block */
-    val localStores = mutable.Map[(Local, BasicBlock), mutable.BitSet]() withDefault {_ => mutable.BitSet()}
-
-    /** Stores that clobber previous stores to array or ref locals. See SI-5313 */
-    val clobbers = mutable.Set[InstrLoc]()
-
-    /** the current method. */
-    var method: IMethod = _
-
-    /** Map instructions who have a drop on some control path, to that DROP instruction. */
-    val dropOf: mutable.Map[InstrLoc, List[InstrLoc]] = perRunCaches.newMap()
-
-    def dieCodeDie(m: IMethod) {
-      if (m.hasCode) {
-        debuglog("dead code elimination on " + m)
-        dropOf.clear()
-        localStores.clear()
-        clobbers.clear()
-        m.code.blocks.clear()
-        m.code.touched = true
-        accessedLocals = m.params.reverse
-        m.code.blocks ++= linearizer.linearize(m)
-        m.code.touched = true
-        collectRDef(m)
-        mark()
-        sweep(m)
-        accessedLocals = accessedLocals.distinct
-        val diff = m.locals diff accessedLocals
-        if (diff.nonEmpty) {
-          val msg = diff.map(_.sym.name)mkString(", ")
-          log(s"Removed ${diff.size} dead locals: $msg")
-          m.locals = accessedLocals.reverse
-        }
-      }
-    }
-
-    /** collect reaching definitions and initial useful instructions for this method. */
-    def collectRDef(m: IMethod): Unit = if (m.hasCode) {
-      defs = immutable.HashMap.empty; worklist.clear(); useful.clear()
-      rdef.init(m)
-      rdef.run()
-
-      m foreachBlock { bb =>
-        useful(bb) = new mutable.BitSet(bb.size)
-        var rd = rdef.in(bb)
-        for ((i, idx) <- bb.toList.zipWithIndex) {
-
-          // utility for adding to worklist
-          def moveToWorkList() = moveToWorkListIf(cond = true)
-
-          // utility for (conditionally) adding to worklist
-          def moveToWorkListIf(cond: Boolean) =
-            if (cond) {
-              debuglog("in worklist:     " + i)
-              worklist += ((bb, idx))
-            } else {
-              debuglog("not in worklist: " + i)
-            }
-
-          // instruction-specific logic
-          i match {
-
-            case LOAD_LOCAL(_) =>
-              defs = defs + (((bb, idx), rd.vars))
-              moveToWorkListIf(cond = false)
-
-            case STORE_LOCAL(l) =>
-              /* SI-4935 Check whether a module is stack top, if so mark the instruction that loaded it
-               * (otherwise any side-effects of the module's constructor go lost).
-               *   (a) The other two cases where a module's value is stored (STORE_FIELD and STORE_ARRAY_ITEM)
-               *       are already marked (case clause below).
-               *   (b) A CALL_METHOD targeting a method `m1` where the receiver is potentially a module (case clause below)
-               *       will have the module's load marked provided `isSideEffecting(m1)`.
-               *       TODO check for purity (the ICode?) of the module's constructor (besides m1's purity).
-               *       See also https://github.com/paulp/scala/blob/topic/purity-analysis/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala
-               */
-              val necessary = rdef.findDefs(bb, idx, 1) exists { p =>
-                val (bb1, idx1) = p
-                bb1(idx1) match {
-                  case LOAD_MODULE(module) => isLoadNeeded(module)
-                  case _                   => false
-                }
-              }
-              moveToWorkListIf(necessary)
-
-              // add it to the localStores map
-              val key = (l, bb)
-              val set = localStores(key)
-              set += idx
-              localStores(key) = set
-
-            case RETURN(_) | JUMP(_) | CJUMP(_, _, _, _) | CZJUMP(_, _, _, _) | STORE_FIELD(_, _) |
-                 THROW(_)   | LOAD_ARRAY_ITEM(_) | STORE_ARRAY_ITEM(_) | SCOPE_ENTER(_) | SCOPE_EXIT(_) | STORE_THIS(_) |
-                 LOAD_EXCEPTION(_) | SWITCH(_, _) | MONITOR_ENTER() | MONITOR_EXIT() | CHECK_CAST(_) | CREATE_ARRAY(_, _) =>
-              moveToWorkList()
-
-            case LOAD_FIELD(sym, isStatic) if isStatic || !inliner.isClosureClass(sym.owner) =>
-              // static load may trigger static initialization.
-              // non-static load can throw NPE (but we know closure fields can't be accessed via a
-              // null reference.
-              moveToWorkList()
-            case CALL_METHOD(m1, _) if isSideEffecting(m1) =>
-              moveToWorkList()
-
-            case CALL_METHOD(m1, SuperCall(_)) =>
-              moveToWorkList() // super calls to constructor
-
-            case DROP(_) =>
-              val necessary = rdef.findDefs(bb, idx, 1) exists { p =>
-                val (bb1, idx1) = p
-                bb1(idx1) match {
-                  case CALL_METHOD(m1, _) if isSideEffecting(m1) => true
-                  case LOAD_EXCEPTION(_) | DUP(_) | LOAD_MODULE(_) => true
-                  case _ =>
-                    dropOf((bb1, idx1)) = (bb,idx) :: dropOf.getOrElse((bb1, idx1), Nil)
-                    debuglog("DROP is inessential: " + i + " because of: " + bb1(idx1) + " at " + bb1 + ":" + idx1)
-                    false
-                }
-              }
-              moveToWorkListIf(necessary)
-            case LOAD_MODULE(sym) if isLoadNeeded(sym) =>
-              moveToWorkList() // SI-4859 Module initialization might side-effect.
-            case CALL_PRIMITIVE(Arithmetic(DIV | REM, INT | LONG) | ArrayLength(_)) =>
-              moveToWorkList() // SI-8601 Might divide by zero
-            case _ => ()
-              moveToWorkListIf(cond = false)
-          }
-          rd = rdef.interpret(bb, idx, rd)
-        }
-      }
-    }
-
-    private def isLoadNeeded(module: Symbol): Boolean = {
-      module.info.member(nme.CONSTRUCTOR).filter(isSideEffecting) != NoSymbol
-    }
-
-    /** Mark useful instructions. Instructions in the worklist are each inspected and their
-     *  dependencies are marked useful too, and added to the worklist.
-     */
-    def mark() {
-//      log("Starting with worklist: " + worklist)
-      while (!worklist.isEmpty) {
-        val (bb, idx) = worklist.head
-        worklist -= ((bb, idx))
-        debuglog("Marking instr: \tBB_" + bb + ": " + idx + " " + bb(idx))
-
-        val instr = bb(idx)
-        // adds the instructions that define the stack values about to be consumed to the work list to
-        // be marked useful
-        def addDefs() = for ((bb1, idx1) <- rdef.findDefs(bb, idx, instr.consumed) if !useful(bb1)(idx1)) {
-          debuglog(s"\t${bb1(idx1)} is consumed by $instr")
-          worklist += ((bb1, idx1))
-        }
-
-        // DROP logic -- if an instruction is useful, its drops are also useful
-        // and we don't mark the DROPs as useful directly but add them to the
-        // worklist so we also mark their reaching defs as useful - see SI-7060
-        if (!useful(bb)(idx)) {
-          useful(bb) += idx
-          dropOf.get((bb, idx)) foreach {
-            for ((bb1, idx1) <- _) {
-              /*
-               * SI-7060: A drop that we now mark as useful can be reached via several paths,
-               * so we should follow by marking all its reaching definition as useful too:
-               */
-              debuglog("\tAdding: " + bb1(idx1) + " to the worklist, as a useful DROP.")
-              worklist += ((bb1, idx1))
-            }
-          }
-
-          // per-instruction logic
-          instr match {
-            case LOAD_LOCAL(l1) =>
-              for ((l2, bb1, idx1) <- defs((bb, idx)) if l1 == l2; if !useful(bb1)(idx1)) {
-                debuglog("\tAdding " + bb1(idx1))
-                worklist += ((bb1, idx1))
-              }
-
-            case STORE_LOCAL(l1) if l1.kind.isRefOrArrayType =>
-              addDefs()
-              // see SI-5313
-              // search for clobbers of this store if we aren't doing l1 = null
-              // this doesn't catch the second store in x=null;l1=x; but in practice this catches
-              // a lot of null stores very cheaply
-              if (idx == 0 || bb(idx - 1) != CONSTANT(Constant(null)))
-                 findClobbers(l1, bb, idx + 1)
-
-            case nw @ NEW(REFERENCE(sym)) =>
-              assert(nw.init ne null, "null new.init at: " + bb + ": " + idx + "(" + instr + ")")
-              worklist += findInstruction(bb, nw.init)
-              if (inliner.isClosureClass(sym)) {
-                liveClosures += sym
-              }
-
-            // it may be better to move static initializers from closures to
-            // the enclosing class, to allow the optimizer to remove more closures.
-            // right now, the only static fields in closures are created when caching
-            // 'symbol literals.
-            case LOAD_FIELD(sym, true) if inliner.isClosureClass(sym.owner) =>
-              log("added closure class for field " + sym)
-              liveClosures += sym.owner
-
-            case LOAD_EXCEPTION(_) =>
-              ()
-
-            case _ =>
-              addDefs()
-          }
-        }
-      }
-    }
-
-    /**
-     * Finds and marks all clobbers of the given local starting in the given
-     * basic block at the given index
-     *
-     * Storing to local variables of reference or array type may be indirectly
-     * observable because it may remove a reference to an object which may allow the object
-     * to be gc'd. See SI-5313. In this code I call the LOCAL_STORE(s) that immediately follow a
-     * LOCAL_STORE and that store to the same local "clobbers." If a LOCAL_STORE is marked
-     * useful then its clobbers must go into the set of clobbers, which will be
-     * compensated for later
-     */
-    def findClobbers(l: Local, bb: BasicBlock, idx: Int) {
-        // previously visited blocks tracked to prevent searching forever in a cycle
-        val inspected = mutable.Set[BasicBlock]()
-        // our worklist of blocks that still need to be checked
-        val blocksToBeInspected = mutable.Set[BasicBlock]()
-
-        // Tries to find the next clobber of l1 in bb1 starting at idx1.
-        // if it finds one it adds the clobber to clobbers set for later
-        // handling. If not it adds the direct successor blocks to
-        // the uninspectedBlocks to try to find clobbers there. Either way
-        // it adds the exception successor blocks for further search
-        def findClobberInBlock(idx1: Int, bb1: BasicBlock) {
-          val key = ((l, bb1))
-          val foundClobber = (localStores contains key) && {
-            def minIdx(s : mutable.BitSet) = if(s.isEmpty) -1 else s.min
-
-            // find the smallest index greater than or equal to idx1
-            val clobberIdx = minIdx(localStores(key) dropWhile (_ < idx1))
-            if (clobberIdx == -1)
-              false
-            else {
-              debuglog(s"\t${bb1(clobberIdx)} is a clobber of ${bb(idx)}")
-              clobbers += ((bb1, clobberIdx))
-              true
-            }
-          }
-
-          // always need to look into the exception successors for additional clobbers
-          // because we don't know when flow might enter an exception handler
-          blocksToBeInspected ++= (bb1.exceptionSuccessors filterNot inspected)
-          // If we didn't find a clobber here then we need to look at successor blocks.
-          // if we found a clobber then we don't need to search in the direct successors
-          if (!foundClobber) {
-            blocksToBeInspected ++= (bb1.directSuccessors filterNot inspected)
-          }
-        }
-
-        // first search starting at the current index
-        // note we don't put bb in the inspected list yet because a loop may later force
-        // us back around to search from the beginning of bb
-        findClobberInBlock(idx, bb)
-        // then loop until we've exhausted the set of uninspected blocks
-        while(!blocksToBeInspected.isEmpty) {
-          val bb1 = blocksToBeInspected.head
-          blocksToBeInspected -= bb1
-          inspected += bb1
-          findClobberInBlock(0, bb1)
-        }
-    }
-
-    def sweep(m: IMethod) {
-      val compensations = computeCompensations(m)
-
-      debuglog("Sweeping: " + m)
-
-      m foreachBlock { bb =>
-        debuglog(bb + ":")
-        val oldInstr = bb.toList
-        bb.open()
-        bb.clear()
-        for ((i, idx) <- oldInstr.zipWithIndex) {
-          if (useful(bb)(idx)) {
-            debuglog(" * " + i + " is useful")
-            bb.emit(i, i.pos)
-            compensations.get((bb, idx)) match {
-              case Some(is) => is foreach bb.emit
-              case None => ()
-            }
-            // check for accessed locals
-            i match {
-              case LOAD_LOCAL(l) if !l.arg =>
-                accessedLocals = l :: accessedLocals
-              case STORE_LOCAL(l) if !l.arg =>
-                accessedLocals = l :: accessedLocals
-              case _ => ()
-            }
-          } else {
-            i match {
-              case NEW(REFERENCE(sym)) =>
-                log(s"Eliminated instantiation of $sym inside $m")
-              case STORE_LOCAL(l) if clobbers contains ((bb, idx)) =>
-                // if an unused instruction was a clobber of a used store to a reference or array type
-                // then we'll replace it with the store of a null to make sure the reference is
-                // eliminated. See SI-5313
-                bb emit CONSTANT(Constant(null))
-                bb emit STORE_LOCAL(l)
-              case _ => ()
-            }
-            debuglog("   " + i + " [swept]")
-          }
-        }
-
-        if (bb.nonEmpty) bb.close()
-        else log(s"empty block encountered in $m")
-      }
-    }
-
-    private def computeCompensations(m: IMethod): mutable.Map[InstrLoc, List[Instruction]] = {
-      val compensations: mutable.Map[InstrLoc, List[Instruction]] = new mutable.HashMap
-
-      m foreachBlock { bb =>
-        assert(bb.closed, "Open block in computeCompensations")
-        foreachWithIndex(bb.toList) { (i, idx) =>
-          if (!useful(bb)(idx)) {
-            foreachWithIndex(i.consumedTypes.reverse) { (consumedType, depth) =>
-              debuglog("Finding definitions of: " + i + "\n\t" + consumedType + " at depth: " + depth)
-              val defs = rdef.findDefs(bb, idx, 1, depth)
-              for (d <- defs) {
-                val (bb, idx) = d
-                debuglog("rdef: "+ bb(idx))
-                bb(idx) match {
-                  case DUP(_) if idx > 0 =>
-                    bb(idx - 1) match {
-                      case nw @ NEW(_) =>
-                        val init = findInstruction(bb, nw.init)
-                        log("Moving DROP to after <init> call: " + nw.init)
-                        compensations(init) = List(DROP(consumedType))
-                      case _ =>
-                        compensations(d) = List(DROP(consumedType))
-                    }
-                  case _ =>
-                    compensations(d) = List(DROP(consumedType))
-                }
-              }
-            }
-          }
-        }
-      }
-      compensations
-    }
-
-    private def findInstruction(bb: BasicBlock, i: Instruction): InstrLoc = {
-      for (b <- linearizer.linearizeAt(method, bb)) {
-        val idx = b.toList indexWhere (_ eq i)
-        if (idx != -1)
-          return (b, idx)
-      }
-      abort("could not find init in: " + method)
-    }
-
-    private def isPure(sym: Symbol) = (
-         (sym.isGetter && sym.isEffectivelyFinalOrNotOverridden && !sym.isLazy)
-      || (sym.isPrimaryConstructor && (sym.enclosingPackage == RuntimePackage || inliner.isClosureClass(sym.owner)))
-    )
-    /** Is 'sym' a side-effecting method? TODO: proper analysis.  */
-    private def isSideEffecting(sym: Symbol) = !isPure(sym)
-
-  } /* DeadCode */
-}
diff --git a/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala b/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala
deleted file mode 100644
index 9f6883f03f..0000000000
--- a/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala
+++ /dev/null
@@ -1,392 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- */
-
-package scala.tools.nsc
-package backend.opt
-
-import java.util.concurrent.TimeUnit
-
-/**
-  * This optimization phase inlines the exception handlers so that further phases can optimize the code better
-  *
-  * {{{
-  * try {
-  *   ...
-  *   if (condition)
-  *     throw IllegalArgumentException("sth")
-  * } catch {
-  *   case e: IllegalArgumentException => <handler code>
-  *   case e: ... => ...
-  * }
-  * }}}
-  *
-  * will inline the exception handler code to:
-  *
-  * {{{
-  * try {
-  *   ...
-  *   if (condition)
-  *     <handler code> // + jump to the end of the catch statement
-  * } catch {
-  *   case e: IllegalArgumentException => <handler code>
-  *   case e: ... => ...
-  * }
-  * }}}
-  *
-  * Q: How does the inlining work, ICode level?
-  * A: if a block contains a THROW(A) instruction AND there is a handler that takes A or a superclass of A we do:
-  *    1. We duplicate the handler code such that we can transform THROW into a JUMP
-  *    2. We analyze the handler to see what local it expects the exception to be placed in
-  *    3. We place the exception that is thrown in the correct "local variable" slot and clean up the stack
-  *    4. We finally JUMP to the duplicate handler
- *    All the above logic is implemented in InlineExceptionHandlersPhase.apply(bblock: BasicBlock)
-  *
-  * Q: Why do we need to duplicate the handler?
-  * A: An exception might be thrown in a method that we invoke in the function and we cannot see that THROW command
-  * directly. In order to catch such exceptions, we keep the exception handler in place and duplicate it in order
-  * to inline its code.
-  *
-  * @author Vlad Ureche
-  */
-abstract class InlineExceptionHandlers extends SubComponent {
-  import global._
-  import icodes._
-  import icodes.opcodes._
-
-  val phaseName = "inlinehandlers"
-
-  /** Create a new phase */
-  override def newPhase(p: Phase) = new InlineExceptionHandlersPhase(p)
-
-  override def enabled = settings.inlineHandlers
-
-  /**
-    * Inlining Exception Handlers
-    */
-  class InlineExceptionHandlersPhase(prev: Phase) extends ICodePhase(prev) {
-    def name = phaseName
-
-    /* This map is used to keep track of duplicated exception handlers
-     * explanation: for each exception handler basic block, there is a copy of it
-     * -some exception handler basic blocks might not be duplicated because they have an unknown format => Option[(...)]
-     * -some exception handler duplicates expect the exception on the stack while others expect it in a local
-     *   => Option[Local]
-     */
-    private val handlerCopies = perRunCaches.newMap[BasicBlock, Option[(Option[Local], BasicBlock)]]()
-    /* This map is the inverse of handlerCopies, used to compute the stack of duplicate blocks */
-    private val handlerCopiesInverted = perRunCaches.newMap[BasicBlock, (BasicBlock, TypeKind)]()
-    private def handlerLocal(bb: BasicBlock): Option[Local] =
-      for (v <- handlerCopies get bb ; (local, block) <- v ; l <- local) yield l
-
-    /* Type Flow Analysis */
-    private val tfa: analysis.MethodTFA = new analysis.MethodTFA()
-    private var tfaCache: Map[Int, tfa.lattice.Elem] = Map.empty
-    private var analyzedMethod: IMethod = NoIMethod
-
-    /* Blocks that need to be analyzed */
-    private var todoBlocks: List[BasicBlock] = Nil
-
-    /* Used only for warnings */
-    private var currentClass: IClass = null
-
-    /** Apply exception handler inlining to a class */
-    override def apply(c: IClass): Unit =
-      if (settings.inlineHandlers) {
-        val startTime = System.nanoTime()
-        currentClass = c
-
-        debuglog("Starting InlineExceptionHandlers on " + c)
-        c.methods foreach applyMethod
-        debuglog("Finished InlineExceptionHandlers on " + c + "... " + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) + "ms")
-        currentClass = null
-      }
-
-    /**
-      * Apply exception handler inlining to a method
-      *
-      * Note: for each exception handling block, we (might) create duplicates. Therefore we iterate until we get to a
-      * fixed point where all the possible handlers have been inlined.
-      *
-      * TODO: Should we have an inlining depth limit? A nested sequence of n try-catch blocks can lead to at most 2n
-      * inlined blocks, so worst case scenario we double the size of the code
-      */
-    private def applyMethod(method: IMethod): Unit = {
-      if (method.hasCode) {
-        // create the list of starting blocks
-        todoBlocks = global.icodes.linearizer.linearize(method)
-
-        while (todoBlocks.nonEmpty) {
-          val levelBlocks = todoBlocks
-          todoBlocks = Nil
-          levelBlocks foreach applyBasicBlock // new blocks will be added to todoBlocks
-        }
-      }
-
-      // Cleanup the references after we finished the file
-      handlerCopies.clear()
-      handlerCopiesInverted.clear()
-      todoBlocks = Nil
-
-      // Type flow analysis cleanup
-      analyzedMethod = NoIMethod
-      tfaCache = Map.empty
-      //TODO: Need a way to clear tfa structures
-    }
-
-    /** Apply exception handler inlining to a basic block  */
-    private def applyBasicBlock(bblock: BasicBlock): Unit = {
-      /*
-       * The logic of this entire method:
-       *  - for each basic block, we look at each instruction until we find a THROW instruction
-       *  - once we found a THROW instruction, we decide if it is DECIDABLE which of handler will catch the exception
-       *  (see method findExceptionHandler for more details)
-       *  - if we decided there is a handler that will catch the exception, we need to replace the THROW instruction by
-       *  a set of equivalent instructions:
-       *    * we need to compute the static types of the stack slots
-       *    * we need to clear the stack, everything but the exception instance on top (or in a local variable slot)
-       *    * we need to JUMP to the duplicate exception handler
-       *  - we compute the static types of the stack slots in function getTypesAtInstruction
-       *  - we duplicate the exception handler (and we get back the information of whether the duplicate expects the
-       *  exception instance on top of the stack or in a local variable slot)
-       *  - we compute the necessary code to put the exception in its place, clear the stack and JUMP
-       *  - we change the THROW exception to the new Clear stack + JUMP code
-       */
-      for {
-        (instr @ THROW(clazz), index) <- bblock.iterator.zipWithIndex
-        // Decide if any handler fits this exception
-        // If not, then nothing to do, we cannot determine statically which handler will catch the exception
-        (handler, caughtException)    <- findExceptionHandler(toTypeKind(clazz.tpe), bblock.exceptionSuccessors)
-      } {
-        log("   Replacing " + instr + " in " + bblock + " to new handler")
-
-        // Solve the stack and drop the element that we already stored, which should be the exception
-        // needs to be done here to be the first thing before code becomes altered
-        val typeInfo = getTypesAtInstruction(bblock, index)
-
-        // Duplicate exception handler
-        duplicateExceptionHandlerCache(handler) match {
-          case None =>
-            log("   Could not duplicate handler for " + instr + " in " + bblock)
-
-          case Some((exceptionLocalOpt, newHandler)) =>
-            val onStackException = typeInfo.head
-            val thrownException  = toTypeKind(clazz.tpe)
-
-            // A couple of sanity checks, to make sure we don't touch code we can't safely handle
-            val canReplaceHandler = (
-                  typeInfo.nonEmpty
-              && (index == bblock.length - 1)
-              && (onStackException <:< thrownException)
-            )
-            // in other words: what's on the stack MUST conform to what's in the THROW(..)!
-
-            if (!canReplaceHandler) {
-              reporter.warning(NoPosition, "Unable to inline the exception handler inside incorrect" +
-                " block:\n" + bblock.iterator.mkString("\n") + "\nwith stack: " + typeInfo + " just " +
-                "before instruction index " + index)
-            }
-            else {
-              // Prepare the new code to replace the THROW instruction
-              val newCode = exceptionLocalOpt match {
-                // the handler duplicate expects the exception in a local: easy one :)
-                case Some(local) =>
-                  // in the first cycle we remove the exception Type
-                  STORE_LOCAL(local) +: typeInfo.tail.map(x => DROP(x)) :+ JUMP(newHandler)
-
-                // we already have the exception on top of the stack, only need to JUMP
-                case None if typeInfo.length == 1 =>
-                  JUMP(newHandler) :: Nil
-
-                // we have the exception on top of the stack but we have other stuff on the stack
-                // create a local, load exception, clear the stack and finally store the exception on the stack
-                case _ =>
-                  val exceptionType = typeInfo.head
-                  // Here we could create a single local for all exceptions of a certain type. TODO: try that.
-                  val localName   = currentClass.cunit.freshTermName("exception$")
-                  val localType   = exceptionType
-                  val localSymbol = bblock.method.symbol.newValue(localName).setInfo(localType.toType)
-                  val local       = new Local(localSymbol, localType, false)
-
-                  bblock.method.addLocal(local)
-
-                  // Save the exception, drop the stack and place back the exception
-                  STORE_LOCAL(local) :: typeInfo.tail.map(x => DROP(x)) ::: List(LOAD_LOCAL(local), JUMP(newHandler))
-              }
-              // replace THROW by the new code
-              bblock.replaceInstruction(instr, newCode)
-
-              // notify the successors changed for the current block
-              // notify the predecessors changed for the inlined handler block
-              bblock.touched = true
-              newHandler.touched = true
-
-              log("   Replaced  " + instr + " in " + bblock + " to new handler")
-              log("OPTIMIZED class " + currentClass + " method " +
-                bblock.method + " block " + bblock + " newhandler " +
-                newHandler + ":\n\t\t" + onStackException + " <:< " +
-                thrownException + " <:< " + caughtException)
-
-          }
-        }
-      }
-    }
-
-    /**
-      * Gets the types on the stack at a certain point in the program. Note that we want to analyze the method lazily
-      * and therefore use the analyzedMethod variable
-      */
-    private def getTypesAtInstruction(bblock: BasicBlock, index: Int): List[TypeKind] = {
-      // get the stack at the block entry
-      var typeInfo = getTypesAtBlockEntry(bblock)
-
-      // perform tfa to the current instruction
-      log("         stack at the beginning of block " + bblock + " in function " +
-        bblock.method + ": " + typeInfo.stack)
-      for (i <- 0 to (index - 1)) {
-        typeInfo = tfa.interpret(typeInfo, bblock(i))
-        log("         stack after interpret: " + typeInfo.stack + " after instruction " +
-          bblock(i))
-      }
-      log("         stack before instruction " + index + " of block " + bblock + " in function " +
-        bblock.method + ": " + typeInfo.stack)
-
-      // return the result
-      typeInfo.stack.types
-    }
-
-    /**
-      * Gets the stack at the block entry. Normally the typeFlowAnalysis should be run again, but we know how to compute
-      * the stack for handler duplicates. For the locals, it's safe to assume the info from the original handler is
-      * still valid (a more precise analysis can be done, but it's not necessary)
-      */
-    private def getTypesAtBlockEntry(bblock: BasicBlock): tfa.lattice.Elem = {
-      // lazily perform tfa, because it's expensive
-      // cache results by block label, as rewriting the code messes up the block's hashCode
-      if (analyzedMethod eq NoIMethod) {
-        analyzedMethod = bblock.method
-        tfa.init(bblock.method)
-        tfa.run()
-        log("      performed tfa on method: " + bblock.method)
-
-        for (block <- bblock.method.blocks.sortBy(_.label))
-          tfaCache += block.label -> tfa.in(block)
-      }
-
-      log("         getting typeinfo at the beginning of block " + bblock)
-
-      tfaCache.getOrElse(bblock.label, {
-        // this block was not analyzed, but it's a copy of some other block so its stack should be the same
-        log("         getting typeinfo at the beginning of block " + bblock + " as a copy of " +
-          handlerCopiesInverted(bblock))
-        val (origBlock, exception) = handlerCopiesInverted(bblock)
-        val typeInfo               = getTypesAtBlockEntry(origBlock)
-        val stack                  =
-          if (handlerLocal(origBlock).nonEmpty) Nil   // empty stack, the handler copy expects an empty stack
-          else List(exception)                        // one slot on the stack for the exception
-
-        // If we use the mutability property, it crashes the analysis
-        tfa.lattice.IState(new analysis.VarBinding(typeInfo.vars), new icodes.TypeStack(stack))
-      })
-    }
-
-    /**
-      * Finds the first exception handler that matches the current exception
-      *
-      * Note the following code:
-      * {{{
-      * try {
-      *   throw new IllegalArgumentException("...")
-      * } catch {
-      *   case e: RuntimeException => log("RuntimeException")
-      *   case i: IllegalArgumentException => log("IllegalArgumentException")
-      * }
-      * }}}
-      *
-      * will print "RuntimeException" => we need the *first* valid handler
-      *
-      * There's a hidden catch here: say we have the following code:
-      * {{{
-      * try {
-      *   val exception: Throwable =
-      *     if (scala.util.Random.nextInt % 2 == 0)
-      *       new IllegalArgumentException("even")
-      *     else
-      *       new StackOverflowError("odd")
-      *   throw exception
-      * } catch {
-      *   case e: IllegalArgumentException =>
-      *     println("Correct, IllegalArgumentException")
-      *   case e: StackOverflowError =>
-      *     println("Correct, StackOverflowException")
-      *   case t: Throwable =>
-      *     println("WROOOONG, not Throwable!")
-      * }
-      * }}}
-      *
-      * We don't want to select a handler if there's at least one that's more specific!
-      */
-    def findExceptionHandler(thrownException: TypeKind, handlers: List[BasicBlock]): Option[(BasicBlock, TypeKind)] = {
-      for (handler <- handlers ; LOAD_EXCEPTION(clazz) <- handler take 1) {
-        val caughtException = toTypeKind(clazz.tpe)
-        // we'll do inlining here: createdException <:< thrownException <:< caughtException, good!
-        if (thrownException <:< caughtException)
-          return Some((handler, caughtException))
-        // we can't do inlining here, the handling mechanism is more precise than we can reason about
-        if (caughtException <:< thrownException)
-          return None
-        // no result yet, look deeper in the handler stack
-      }
-      None
-    }
-
-    /**
-      * This function takes care of duplicating the basic block code for inlining the handler
-      *
-      * Note: This function does not duplicate the same basic block twice. It will contain a map of the duplicated
-      * basic blocks
-      */
-    private def duplicateExceptionHandlerCache(handler: BasicBlock) =
-      handlerCopies.getOrElseUpdate(handler, duplicateExceptionHandler(handler))
-
-    /** This function takes care of actual duplication */
-    private def duplicateExceptionHandler(handler: BasicBlock): Option[(Option[Local], BasicBlock)] = {
-      log("      duplicating handler block " + handler)
-
-      handler take 2 match {
-        case Seq(LOAD_EXCEPTION(caughtClass), next) =>
-          val (dropCount, exceptionLocal) = next match {
-            case STORE_LOCAL(local) => (2, Some(local)) // we drop both LOAD_EXCEPTION and STORE_LOCAL
-            case _                  => (1, None)        // we only drop the LOAD_EXCEPTION and expect the exception on the stack
-          }
-          val caughtException = toTypeKind(caughtClass.tpe)
-          // copy the exception handler code once again, dropping the LOAD_EXCEPTION
-          val copy = handler.code.newBlock()
-          copy.emitOnly((handler.iterator drop dropCount).toSeq: _*)
-
-          // extend the handlers of the handler to the copy
-          for (parentHandler <- handler.method.exh ; if parentHandler covers handler) {
-            parentHandler.addCoveredBlock(copy)
-            // notify the parent handler that the successors changed
-            parentHandler.startBlock.touched = true
-          }
-
-          // notify the successors of the inlined handler might have changed
-          copy.touched    = true
-          handler.touched = true
-          log("      duplicated  handler block " + handler + " to " + copy)
-
-          // announce the duplicate handler
-          handlerCopiesInverted(copy) = ((handler, caughtException))
-          todoBlocks ::= copy
-
-          Some((exceptionLocal, copy))
-
-        case _ =>
-          reporter.warning(NoPosition, "Unable to inline the exception handler due to incorrect format:\n" +
-            handler.iterator.mkString("\n"))
-          None
-      }
-    }
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
deleted file mode 100644
index 8cd2a14066..0000000000
--- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
+++ /dev/null
@@ -1,1075 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Iulian Dragos
- */
-
-
-package scala.tools.nsc
-package backend.opt
-
-import scala.collection.mutable
-import scala.tools.nsc.symtab._
-import scala.reflect.internal.util.NoSourceFile
-
-/**
- * Inliner balances two competing goals:
- *   (a) aggressive inlining of:
- *       (a.1) the apply methods of anonymous closures, so that their anon-classes can be eliminated;
- *       (a.2) higher-order-methods defined in an external library, e.g. `Range.foreach()` among many others.
- *   (b) circumventing the barrier to inter-library inlining that private accesses in the callee impose.
- *
- * Summing up the discussion in SI-5442 and SI-5891,
- * the current implementation achieves to a large degree both goals above, and
- * overcomes a problem exhibited by previous versions:
- *
- *   (1) Problem: Attempting to access a private member `p` at runtime resulting in an `IllegalAccessError`,
- *                where `p` is defined in a library L, and is accessed from a library C (for Client),
- *                where C was compiled against L', an optimized version of L where the inliner made `p` public at the bytecode level.
- *                The only such members are fields, either synthetic or isParamAccessor, and thus having a dollar sign in their name
- *                (the accessibility of methods and constructors isn't touched by the inliner).
- *
- * Thus we add one more goal to our list:
- *   (c) Compile C (either optimized or not) against any of L or L',
- *       so that it runs with either L or L' (in particular, compile against L' and run with L).
- *
- * The chosen strategy is described in some detail in the comments for `accessRequirements()` and `potentiallyPublicized()`.
- * Documentation at http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/2011Q4/Inliner.pdf
- *
- *  @author Iulian Dragos
- */
-abstract class Inliners extends SubComponent {
-  import global._
-  import icodes._
-  import icodes.opcodes._
-  import definitions.{
-    NullClass, NothingClass, ObjectClass,
-    PredefModule, RuntimePackage, ScalaInlineClass, ScalaNoInlineClass,
-    isFunctionType, isByNameParamType
-  }
-
-  val phaseName = "inliner"
-
-  override val enabled: Boolean = settings.inline
-
-  /** Debug - for timing the inliner. */
-  /****
-  private def timed[T](s: String, body: => T): T = {
-    val t1 = System.currentTimeMillis()
-    val res = body
-    val t2 = System.currentTimeMillis()
-    val ms = (t2 - t1).toInt
-    if (ms >= MAX_INLINE_MILLIS)
-      println("%s: %d milliseconds".format(s, ms))
-
-    res
-  }
-  ****/
-
-  /** Look up implementation of method 'sym in 'clazz'.
-   */
-  def lookupImplFor(sym: Symbol, clazz: Symbol): Symbol = {
-    // TODO: verify that clazz.superClass is equivalent here to clazz.tpe.parents(0).typeSymbol (.tpe vs .info)
-    def needsLookup = (
-         (clazz != NoSymbol)
-      && (clazz != sym.owner)
-      && !sym.isEffectivelyFinalOrNotOverridden
-      && clazz.isEffectivelyFinalOrNotOverridden
-    )
-    def lookup(clazz: Symbol): Symbol = {
-      // println("\t\tlooking up " + meth + " in " + clazz.fullName + " meth.owner = " + meth.owner)
-      assert(clazz != NoSymbol, "Walked up past Object.superClass looking for " + sym +
-                                ", most likely this reveals the TFA at fault (receiver and callee don't match).")
-      if (sym.owner == clazz || isBottomType(clazz)) sym
-      else sym.overridingSymbol(clazz) orElse (
-        if (sym.owner.isTrait) sym
-        else lookup(clazz.superClass)
-      )
-    }
-    if (needsLookup) {
-      val concreteMethod = lookup(clazz)
-      debuglog("\tlooked up method: " + concreteMethod.fullName)
-
-      concreteMethod
-    }
-    else sym
-  }
-
-  /* A warning threshold */
-  private final val MAX_INLINE_MILLIS = 2000
-
-  /** The maximum size in basic blocks of methods considered for inlining. */
-  final val MAX_INLINE_SIZE = 16
-
-  /** Maximum loop iterations. */
-  final val MAX_INLINE_RETRY = 15
-
-  /** Small method size (in blocks) */
-  val SMALL_METHOD_SIZE = 1
-
-  /** Create a new phase */
-  override def newPhase(p: Phase) = new InliningPhase(p)
-
-  /** The Inlining phase.
-   */
-  class InliningPhase(prev: Phase) extends ICodePhase(prev) {
-    def name = phaseName
-    val inliner = new Inliner
-
-    object iclassOrdering extends Ordering[IClass] {
-      def compare(a: IClass, b: IClass) = {
-        val sourceNamesComparison = (a.cunit.toString() compare b.cunit.toString())
-        if(sourceNamesComparison != 0) sourceNamesComparison
-        else {
-          val namesComparison = (a.toString() compare b.toString())
-          if(namesComparison != 0) namesComparison
-          else {
-            a.symbol.id compare b.symbol.id
-          }
-        }
-      }
-    }
-    val queue = new mutable.PriorityQueue[IClass]()(iclassOrdering)
-
-    override def apply(c: IClass) { queue += c }
-
-    override def run() {
-      knownLacksInline.clear()
-      knownHasInline.clear()
-      try {
-        super.run()
-        for(c <- queue) { inliner analyzeClass c }
-      } finally {
-        inliner.clearCaches()
-        knownLacksInline.clear()
-        knownHasInline.clear()
-      }
-    }
-  }
-
-  def isBottomType(sym: Symbol) = sym == NullClass || sym == NothingClass
-
-  /** Is the given class a closure? */
-  def isClosureClass(cls: Symbol): Boolean =
-    cls.isFinal && cls.isSynthetic && !cls.isModuleClass && cls.isAnonymousFunction
-
-  /*
-      TODO now that Inliner runs faster we could consider additional "monadic methods" (in the limit, all those taking a closure as last arg)
-      Any "monadic method" occurring in a given caller C that is not `isMonadicMethod()` will prevent CloseElim from eliminating
-      any anonymous-closure-class any whose instances are given as argument to C invocations.
-   */
-  def isMonadicMethod(sym: Symbol) = {
-    nme.unspecializedName(sym.name) match {
-      case nme.foreach | nme.filter | nme.withFilter | nme.map | nme.flatMap => true
-      case _                                                                 => false
-    }
-  }
-
-  val knownLacksInline = mutable.Set.empty[Symbol] // cache to avoid multiple inliner.hasInline() calls.
-  val knownHasInline   = mutable.Set.empty[Symbol] // as above. Motivated by the need to warn on "inliner failures".
-
-  def hasInline(sym: Symbol)    = {
-    if     (knownLacksInline(sym)) false
-    else if(knownHasInline(sym))   true
-    else {
-      val b = (sym hasAnnotation ScalaInlineClass)
-      if(b) { knownHasInline   += sym }
-      else  { knownLacksInline += sym }
-
-      b
-    }
-  }
-
-  def hasNoInline(sym: Symbol)  = sym hasAnnotation ScalaNoInlineClass
-
-  /**
-   * Simple inliner.
-   */
-  class Inliner {
-    object NonPublicRefs extends Enumeration {
-      val Private, Protected, Public = Value
-
-      /** Cache whether a method calls private members. */
-      val usesNonPublics = mutable.Map.empty[IMethod, Value]
-    }
-    import NonPublicRefs._
-
-    /** The current iclass */
-    private var currentIClazz: IClass = _
-    private def warn(pos: Position, msg: String) = currentRun.reporting.inlinerWarning(pos, msg)
-
-    private def ownedName(sym: Symbol): String = exitingUncurry {
-      val count = (
-        if (!sym.isMethod) 1
-        else if (sym.owner.isAnonymousFunction) 3
-        else 2
-      )
-      (sym.ownerChain take count filterNot (_.isPackageClass)).reverseMap(_.nameString).mkString(".")
-    }
-    private def inlineLog(what: String, main: => String, comment: => String) {
-      def cstr = comment match {
-        case ""   => ""
-        case str  => " // " + str
-      }
-      val width = if (currentIClazz eq null) 40 else currentIClazz.symbol.enclosingPackage.fullName.length + 25
-      val fmt = "%8s  %-" + width + "s" + cstr
-      log(fmt.format(what, main))
-    }
-    private def inlineLog(what: String, main: Symbol, comment: => String) {
-      inlineLog(what, ownedName(main), comment)
-    }
-
-    val recentTFAs = mutable.Map.empty[Symbol, Tuple2[Boolean, analysis.MethodTFA]]
-
-    private def getRecentTFA(incm: IMethod, forceable: Boolean): (Boolean, analysis.MethodTFA) = {
-
-        def containsRETURN(blocks: List[BasicBlock]) = blocks exists { bb => bb.lastInstruction.isInstanceOf[RETURN] }
-
-      val opt = recentTFAs.get(incm.symbol)
-      if(opt.isDefined) {
-        // FYI val cachedBBs = opt.get._2.in.keySet
-        // FYI assert(incm.blocks.toSet == cachedBBs)
-        // incm.code.touched plays no role here
-        return opt.get
-      }
-
-      val hasRETURN = containsRETURN(incm.code.blocksList) || (incm.exh exists { eh => containsRETURN(eh.blocks) })
-      var a: analysis.MethodTFA = null
-      if(hasRETURN) { a = new analysis.MethodTFA(incm); a.run() }
-
-      if(forceable) { recentTFAs.put(incm.symbol, (hasRETURN, a)) }
-
-      (hasRETURN, a)
-    }
-
-    def clearCaches() {
-      // methods
-      NonPublicRefs.usesNonPublics.clear()
-      recentTFAs.clear()
-      tfa.knownUnsafe.clear()
-      tfa.knownSafe.clear()
-      tfa.knownNever.clear()
-      // basic blocks
-      tfa.preCandidates.clear()
-      tfa.relevantBBs.clear()
-      // callsites
-      tfa.remainingCALLs.clear()
-      tfa.isOnWatchlist.clear()
-    }
-
-    object imethodOrdering extends Ordering[IMethod] {
-      def compare(a: IMethod, b: IMethod) = {
-        val namesComparison = (a.toString() compare b.toString())
-        if(namesComparison != 0) namesComparison
-        else {
-          a.symbol.id compare b.symbol.id
-        }
-      }
-    }
-
-    def analyzeClass(cls: IClass): Unit =
-      if (settings.inline) {
-        inlineLog("class", s"${cls.symbol.decodedName}", s"analyzing ${cls.methods.size} methods in $cls")
-
-        this.currentIClazz = cls
-        val ms = cls.methods sorted imethodOrdering
-        ms foreach { im =>
-          if (hasInline(im.symbol)) {
-            inlineLog("skip", im.symbol, "no inlining into @inline methods")
-          }
-          else if(im.hasCode && !im.symbol.isBridge) {
-            analyzeMethod(im)
-          }
-        }
-      }
-
-    val tfa   = new analysis.MTFAGrowable()
-    tfa.stat  = global.settings.YstatisticsEnabled
-    val staleOut      = new mutable.ListBuffer[BasicBlock]
-    val splicedBlocks = mutable.Set.empty[BasicBlock]
-    val staleIn       = mutable.Set.empty[BasicBlock]
-
-    /**
-     * A transformation local to the body of the IMethod received as argument.
-     * An inlining decision consists in replacing a callsite with the body of the callee.
-     * Please notice that, because `analyzeMethod()` itself may modify a method body,
-     * the particular callee bodies that end up being inlined depend on the particular order in which methods are visited
-     * (no topological sorting over the call-graph is attempted).
-     *
-     * Making an inlining decision requires type-flow information for both caller and callee.
-     * Regarding the caller, such information is needed only for basic blocks containing inlining candidates
-     * (and their transitive predecessors). This observation leads to using a custom type-flow analysis (MTFAGrowable)
-     * that can be re-inited, i.e. that reuses lattice elements (type-flow information computed in a previous iteration)
-     * as starting point for faster convergence in a new iteration.
-     *
-     * The mechanics of inlining are iterative for a given invocation of `analyzeMethod(m)`,
-     * and are affected by inlinings from previous iterations
-     * (ie, "heuristic" rules are based on statistics tracked for that purpose):
-     *
-     *   (1) before the iterations proper start, so-called preinlining is performed.
-     *       Those callsites whose (receiver, concreteMethod) are both known statically
-     *       can be analyzed for inlining before computing a type-flow. Details in `preInline()`
-     *
-     *   (2) the first iteration computes type-flow information for basic blocks containing inlining candidates
-     *       (and their transitive predecessors), so called `relevantBBs` basic blocks.
-     *       The ensuing analysis of each candidate (performed by `analyzeInc()`)
-     *       may result in a CFG isomorphic to that of the callee being inserted in place of the callsite
-     *       (i.e. a CALL_METHOD instruction is replaced with a single-entry single-exit CFG,
-     *        a substitution we call "successful inlining").
-     *
-     *   (3) following iterations have `relevantBBs` updated to focus on the inlined basic blocks and their successors only.
-     *       Details in `MTFAGrowable.reinit()`
-     * */
-    def analyzeMethod(m: IMethod): Unit = {
-      // m.normalize
-      if (settings.debug)
-        inlineLog("caller", ownedName(m.symbol), "in " + m.symbol.owner.fullName)
-
-      val sizeBeforeInlining  = m.code.blockCount
-      val instrBeforeInlining = m.code.instructionCount
-      var retry = false
-      var count = 0
-
-      // fresh name counter
-      val fresh = mutable.HashMap.empty[String, Int] withDefaultValue 0
-      // how many times have we already inlined this method here?
-      val inlinedMethodCount = mutable.HashMap.empty[Symbol, Int] withDefaultValue 0
-      val caller = new IMethodInfo(m)
-      def analyzeMessage = s"Analyzing ${caller.length} blocks of $m for inlining sites."
-
-      def preInline(isFirstRound: Boolean): Int = {
-        val inputBlocks = caller.m.linearizedBlocks()
-        val callsites: Function1[BasicBlock, List[opcodes.CALL_METHOD]] = {
-          if(isFirstRound) tfa.conclusives else tfa.knownBeforehand
-        }
-        inlineWithoutTFA(inputBlocks, callsites)
-      }
-
-      /*
-       *  Inline straightforward callsites (those that can be inlined without a TFA).
-       *
-       *  To perform inlining, all we need to know is listed as formal params in `analyzeInc()`:
-       *    - callsite and block containing it
-       *    - actual (ie runtime) class of the receiver
-       *    - actual (ie runtime) method being invoked
-       *    - stack length just before the callsite (to check whether enough arguments have been pushed).
-       *  The assert below lists the conditions under which "no TFA is needed"
-       *  (the statically known receiver and method are both final, thus, at runtime they can't be any others than those).
-       *
-       */
-      def inlineWithoutTFA(inputBlocks: Traversable[BasicBlock], callsites: Function1[BasicBlock, List[opcodes.CALL_METHOD]]): Int = {
-        var inlineCount = 0
-        import scala.util.control.Breaks._
-        for(x <- inputBlocks; easyCake = callsites(x); if easyCake.nonEmpty) {
-          breakable {
-            for(ocm <- easyCake) {
-              assert(ocm.method.isEffectivelyFinalOrNotOverridden && ocm.method.owner.isEffectivelyFinalOrNotOverridden)
-              if(analyzeInc(ocm, x, ocm.method.owner, -1, ocm.method)) {
-                inlineCount += 1
-                break()
-              }
-            }
-          }
-        }
-
-        inlineCount
-      }
-
-      /*
-       *  Decides whether it's feasible and desirable to inline the body of the method given by `concreteMethod`
-       *  at the program point given by `i` (a callsite). The boolean result indicates whether inlining was performed.
-       *
-       */
-      def analyzeInc(i: CALL_METHOD, bb: BasicBlock, receiver: Symbol, stackLength: Int, concreteMethod: Symbol): Boolean = {
-        assert(bb.toList contains i, "Candidate callsite does not belong to BasicBlock.")
-        val shouldWarn = hasInline(i.method)
-
-        def warnNoInline(reason: String): Boolean = {
-          def msg = "Could not inline required method %s because %s.".format(i.method.unexpandedName.decode, reason)
-          if (settings.debug)
-            inlineLog("fail", i.method.fullName, reason)
-          if (shouldWarn)
-            warn(i.pos, msg)
-
-          false
-        }
-
-        var isAvailable = icodes available concreteMethod.enclClass
-
-        if (!isAvailable && shouldLoadImplFor(concreteMethod, receiver)) {
-          // Until r22824 this line was:
-          //   icodes.icode(concreteMethod.enclClass, true)
-          //
-          // Changing it to
-          //   icodes.load(concreteMethod.enclClass)
-          // was the proximate cause for SI-3882:
-          //   error: Illegal index: 0 overlaps List((variable par1,LONG))
-          //   error: Illegal index: 0 overlaps List((variable par1,LONG))
-          isAvailable = icodes.load(concreteMethod.enclClass)
-        }
-
-        def isCandidate = (
-             isClosureClass(receiver)
-          || concreteMethod.isEffectivelyFinalOrNotOverridden
-          || receiver.isEffectivelyFinalOrNotOverridden
-        )
-
-        def isApply     = concreteMethod.name == nme.apply
-
-        def isCountable = !(
-             isClosureClass(receiver)
-          || isApply
-          || isMonadicMethod(concreteMethod)
-          || receiver.enclosingPackage == definitions.RuntimePackage
-        )   // only count non-closures
-
-        debuglog("Treating " + i
-              + "\n\treceiver: " + receiver
-              + "\n\ticodes.available: " + isAvailable
-              + "\n\tconcreteMethod.isEffectivelyFinalOrNotOverridden: " + concreteMethod.isEffectivelyFinalOrNotOverridden)
-
-        if (!isCandidate) warnNoInline("it can be overridden")
-        else if (!isAvailable) warnNoInline("bytecode unavailable")
-        else lookupIMethod(concreteMethod, receiver) filter (callee => callee.hasCode || warnNoInline("callee has no code")) exists { callee =>
-          val inc   = new IMethodInfo(callee)
-          val pair  = new CallerCalleeInfo(caller, inc, fresh, inlinedMethodCount)
-
-          if (inc.hasHandlers && (stackLength == -1)) {
-            // no inlining is done, yet don't warn about it, stackLength == -1 indicates we're trying to inlineWithoutTFA.
-            // Shortly, a TFA will be computed and an error message reported if indeed inlining not possible.
-            false
-          }
-          else {
-            val isSafe = pair isStampedForInlining stackLength match {
-              case DontInlineHere(msg)                       => warnNoInline(msg)
-              case NeverSafeToInline                         => false
-              case InlineableAtThisCaller                    => true
-              case FeasibleInline(required, toPublicize)     =>
-                for (f <- toPublicize) {
-                  inlineLog("access", f, "making public")
-                  f setFlag Flags.notPRIVATE
-                  f setFlag Flags.notPROTECTED
-                }
-                // only add to `knownSafe` after all `toPublicize` fields actually made public.
-                if (required == NonPublicRefs.Public)
-                  tfa.knownSafe += inc.sym
-
-                true
-            }
-            isSafe && {
-               retry   = true
-               if (isCountable) count += 1
-               pair.doInline(bb, i)
-               if (!pair.isInlineForced || inc.isMonadic) caller.inlinedCalls += 1
-               inlinedMethodCount(inc.sym) += 1
-
-               // Remove the caller from the cache (this inlining might have changed its calls-private relation).
-               usesNonPublics -= m
-               recentTFAs     -= m.symbol
-               true
-            }
-          }
-        }
-      }
-
-      /* Pre-inlining consists in invoking the usual inlining subroutine with (receiver class, concrete method) pairs as input
-       * where both method and receiver are final, which implies that the receiver computed via TFA will always match `concreteMethod.owner`.
-       *
-       * As with any invocation of `analyzeInc()` the inlining outcome is based on heuristics which favor inlining an isMonadicMethod before other methods.
-       * That's why preInline() is invoked twice: any inlinings downplayed by the heuristics during the first round get an opportunity to rank higher during the second.
-       *
-       * As a whole, both `preInline()` invocations amount to priming the inlining process,
-       * so that the first TFA that is run afterwards is able to gain more information as compared to a cold-start.
-       */
-      /*val totalPreInlines = */ { // Val name commented out to emphasize it is never used
-        val firstRound = preInline(isFirstRound = true)
-        if(firstRound == 0) 0 else (firstRound + preInline(isFirstRound = false))
-      }
-      staleOut.clear()
-      splicedBlocks.clear()
-      staleIn.clear()
-
-      do {
-        retry = false
-        debuglog(analyzeMessage)
-
-        /* it's important not to inline in unreachable basic blocks. linearizedBlocks() returns only reachable ones. */
-        tfa.callerLin = caller.m.linearizedBlocks()
-           /* TODO Do we really want to inline inside exception handlers?
-           *  Seems counterproductive (the larger the method the less likely it will be JITed).
-            * The alternative would be `linearizer.linearizeAt(caller.m, caller.m.startBlock)`.
-            * And, we would cut down on TFA iterations, too.
-            * See also comment on the same topic in TypeFlowAnalysis. */
-
-        tfa.reinit(m, staleOut.toList, splicedBlocks, staleIn)
-        tfa.run
-
-        staleOut.clear()
-        splicedBlocks.clear()
-        staleIn.clear()
-
-        import scala.util.control.Breaks._
-        for(bb <- tfa.callerLin; if tfa.preCandidates(bb)) {
-          val cms = bb.toList collect { case cm : CALL_METHOD => cm }
-          breakable {
-            for (cm <- cms; if tfa.remainingCALLs.isDefinedAt(cm)) {
-              val analysis.CallsiteInfo(_, receiver, stackLength, concreteMethod) = tfa.remainingCALLs(cm)
-              if (analyzeInc(cm, bb, receiver, stackLength, concreteMethod)) {
-                break()
-              }
-            }
-          }
-        }
-
-        /* As part of inlining, some instructions are moved to a new block.
-         *     In detail: the instructions moved to a new block originally appeared after a (by now inlined) callsite.
-         *     Their new home is an `afterBlock` created by `doInline()` to that effect.
-         *     Each block in staleIn is one such `afterBlock`.
-         *
-         * Some of those instructions may be CALL_METHOD possibly tracked in `remainingCALLs`
-         * (with an entry still noting the old containing block). However, that causes no problem:
-         *
-         *   (1) such callsites won't be analyzed for inlining by `analyzeInc()` (*in this iteration*)
-         *       because of the `break` that abandons the original basic block where it was contained.
-         *
-         *   (2) Additionally, its new containing block won't be visited either (*in this iteration*)
-         *       because the new blocks don't show up in the linearization computed before inlinings started:
-         *       `for(bb <- tfa.callerLin; if tfa.preCandidates(bb)) {`
-         *
-         * For a next iteration, the new home of any instructions that have moved
-         * will be tracked properly in `remainingCALLs` after `MTFAGrowable.reinit()` puts on radar their new homes.
-         *
-         */
-        if(retry) {
-          for(afterBlock <- staleIn) {
-            val justCALLsAfter = afterBlock.toList collect { case c : opcodes.CALL_METHOD => c }
-            for(ia <- justCALLsAfter) { tfa.remainingCALLs.remove(ia) }
-          }
-        }
-
-        /*
-        if(splicedBlocks.nonEmpty) { // TODO explore (saves time but leads to slightly different inlining decisions)
-          // opportunistically perform straightforward inlinings before the next typeflow round
-          val savedRetry = retry
-          val savedStaleOut = staleOut.toSet; staleOut.clear()
-          val savedStaleIn  = staleIn.toSet ; staleIn.clear()
-          val howmany = inlineWithoutTFA(splicedBlocks, tfa.knownBeforehand)
-          splicedBlocks ++= staleIn
-          staleOut.clear(); staleOut ++= savedStaleOut;
-          staleIn.clear();  staleIn  ++= savedStaleIn;
-          retry = savedRetry
-        }
-        */
-
-        if (tfa.stat)
-          log(m.symbol.fullName + " iterations: " + tfa.iterations + " (size: " + caller.length + ")")
-      }
-      while (retry && count < MAX_INLINE_RETRY)
-
-      for(inlFail <- tfa.warnIfInlineFails) {
-        warn(inlFail.pos, "At the end of the day, could not inline @inline-marked method " + inlFail.method.unexpandedName.decode)
-      }
-
-      m.normalize()
-      if (sizeBeforeInlining > 0) {
-        val instrAfterInlining = m.code.instructionCount
-        val inlinings = caller.inlinedCalls
-        if (inlinings > 0) {
-          val s1      = s"instructions $instrBeforeInlining -> $instrAfterInlining"
-          val s2      = if (sizeBeforeInlining == m.code.blockCount) "" else s", blocks $sizeBeforeInlining -> ${m.code.blockCount}"
-          val callees = inlinedMethodCount.toList map { case (k, v) => k.fullNameString + ( if (v == 1) "" else "/" + v ) }
-
-          inlineLog("inlined", m.symbol.fullName, callees.sorted.mkString(inlinings + " inlined: ", ", ", ""))
-          inlineLog("<<tldr>>", m.symbol.fullName, s"${m.symbol.nameString}: $s1$s2")
-        }
-      }
-    }
-
-    private def isHigherOrderMethod(sym: Symbol) = (
-         sym.isMethod
-      && enteringExplicitOuter(sym.info.paramTypes exists isFunctionType) // was "at erasurePhase.prev"
-    )
-
-    /** Should method 'sym' being called in 'receiver' be loaded from disk? */
-    def shouldLoadImplFor(sym: Symbol, receiver: Symbol): Boolean = {
-      def alwaysLoad    = (receiver.enclosingPackage == RuntimePackage) || (receiver == PredefModule.moduleClass)
-      def loadCondition = sym.isEffectivelyFinalOrNotOverridden && isMonadicMethod(sym) && isHigherOrderMethod(sym)
-
-      val res = hasInline(sym) || alwaysLoad || loadCondition
-      debuglog("shouldLoadImplFor: " + receiver + "." + sym + ": " + res)
-      res
-    }
-
-    class IMethodInfo(val m: IMethod) {
-      override def toString = m.toString
-
-      val sym           = m.symbol
-      def owner         = sym.owner
-      def paramTypes    = sym.info.paramTypes
-      def minimumStack  = paramTypes.length + 1
-
-      def isBridge      = sym.isBridge
-      val isInClosure   = isClosureClass(owner)
-      val isHigherOrder = isHigherOrderMethod(sym)
-      def isMonadic     = isMonadicMethod(sym)
-
-      def handlers      = m.exh
-      def blocks        = m.blocks
-      def locals        = m.locals
-      def length        = blocks.length
-      def openBlocks    = blocks filterNot (_.closed)
-      def instructions  = m.code.instructions
-
-      def isSmall         = (length <= SMALL_METHOD_SIZE) && blocks(0).length < 10
-      def isLarge         = length > MAX_INLINE_SIZE
-      def isRecursive     = m.recursive
-      def hasHandlers     = handlers.nonEmpty || m.bytecodeHasEHs
-
-      def isSynchronized         = sym.hasFlag(Flags.SYNCHRONIZED)
-      def hasNonFinalizerHandler = handlers exists {
-        case _: Finalizer => true
-        case _            => false
-      }
-
-      // the number of inlined calls in 'm', used by 'isScoreOK'
-      var inlinedCalls = 0
-
-      def addLocals(ls: List[Local])  = m.locals ++= ls
-      def addLocal(l: Local)          = addLocals(List(l))
-      def addHandlers(exhs: List[ExceptionHandler]) = m.exh = exhs ::: m.exh
-
-      /**
-       * This method inspects the callee's instructions, finding out the most restrictive accessibility implied by them.
-       *
-       * Rather than giving up upon encountering an access to a private field `p`, it provisorily admits `p` as "can-be-made-public", provided:
-       *   - `p` is being compiled as part of this compilation run, and
-       *   - `p` is synthetic or param-accessor.
-       *
-       * This method is side-effect free, in particular it lets the invoker decide
-       * whether the accessibility of the `toBecomePublic` fields should be changed or not.
-       */
-      def accessRequirements: AccessReq = {
-
-        var toBecomePublic: List[Symbol] = Nil
-
-        def check(sym: Symbol, cond: Boolean) =
-          if (cond) Private
-          else if (sym.isProtected) Protected
-          else Public
-
-        def canMakePublic(f: Symbol): Boolean =
-          (m.sourceFile ne NoSourceFile) &&
-          (f.isSynthetic || f.isParamAccessor) &&
-          { toBecomePublic = f :: toBecomePublic; true }
-
-        /* A safety check to consider as private, for the purposes of inlining, a public field that:
-         *   (1) is defined in an external library, and
-         *   (2) can be presumed synthetic (due to a dollar sign in its name).
-         * Such field was made public by `doMakePublic()` and we don't want to rely on that,
-         * because under other compilation conditions (ie no -optimize) that won't be the case anymore.
-         *
-         * This allows aggressive intra-library inlining (making public if needed)
-         * that does not break inter-library scenarios (see comment for `Inliners`).
-         *
-         * TODO handle more robustly the case of a trait var changed at the source-level from public to private[this]
-         *      (eg by having ICodeReader use unpickler, see SI-5442).
-
-         DISABLED
-
-        def potentiallyPublicized(f: Symbol): Boolean = {
-          (m.sourceFile eq NoSourceFile) && f.name.containsChar('$')
-        }
-        */
-
-
-        def isPrivateForInlining(sym: Symbol): Boolean = {
-          if (sym.isJavaDefined) {
-            def check(sym: Symbol) = !(sym.isPublic || sym.isProtected)
-            check(sym) || check(sym.owner) // SI-7582 Must check the enclosing class *and* the symbol for Java.
-          }
-          else sym.isPrivate // Scala never emits package-private bytecode
-        }
-
-        def checkField(f: Symbol)   = check(f, isPrivateForInlining(f) && !canMakePublic(f))
-        def checkSuper(n: Symbol)   = check(n, isPrivateForInlining(n) || !n.isClassConstructor)
-        def checkMethod(n: Symbol)  = check(n, isPrivateForInlining(n))
-
-        def getAccess(i: Instruction) = i match {
-          case CALL_METHOD(n, SuperCall(_)) => checkSuper(n)
-          case CALL_METHOD(n, _)            => checkMethod(n)
-          case LOAD_FIELD(f, _)             => checkField(f)
-          case STORE_FIELD(f, _)            => checkField(f)
-          case _                            => Public
-        }
-
-        var seen = Public
-        val iter = instructions.iterator
-        while((seen ne Private) && iter.hasNext) {
-          val i = iter.next()
-          getAccess(i) match {
-            case Private    =>
-              inlineLog("access", s"instruction $i requires private access", "pos=" + i.pos)
-              toBecomePublic = Nil
-              seen = Private
-            case Protected  => seen = Protected
-            case _          => ()
-          }
-        }
-
-        AccessReq(seen, toBecomePublic)
-      }
-
-    }
-
-    /**
-     * Classifies a pair (caller, callee) into one of four categories:
-     *
-     *   (a) inlining should be performed, classified in turn into:
-     *       (a.1) `InlineableAtThisCaller`: unconditionally at this caller
-     *       (a.2) `FeasibleInline`: it only remains for certain access requirements to be met (see `IMethodInfo.accessRequirements()`)
-     *
-     *   (b) inlining shouldn't be performed, classified in turn into:
-     *       (b.1) `DontInlineHere`: indicates that this particular occurrence of the callee at the caller shouldn't be inlined.
-     *                - Nothing is said about the outcome for other callers, or for other occurrences of the callee for the same caller.
-     *                - In particular inlining might be possible, but heuristics gave a low score for it.
-     *       (b.2) `NeverSafeToInline`: the callee can't be inlined anywhere, irrespective of caller.
-     *
-     * The classification above is computed by `isStampedForInlining()` based on which `analyzeInc()` goes on to:
-     *   - either log the reason for failure --- case (b) ---,
-     *   - or perform inlining --- case (a) ---.
-     */
-    sealed abstract class InlineSafetyInfo
-    case object NeverSafeToInline           extends InlineSafetyInfo
-    case object InlineableAtThisCaller      extends InlineSafetyInfo
-    case class  DontInlineHere(msg: String) extends InlineSafetyInfo
-    case class  FeasibleInline(accessNeeded: NonPublicRefs.Value, toBecomePublic: List[Symbol]) extends InlineSafetyInfo
-
-    case class AccessReq(
-      accessNeeded:   NonPublicRefs.Value,
-      toBecomePublic: List[Symbol]
-    )
-
-    final class CallerCalleeInfo(val caller: IMethodInfo, val inc: IMethodInfo, fresh: mutable.Map[String, Int], inlinedMethodCount: scala.collection.Map[Symbol, Int]) {
-
-      assert(!caller.isBridge && inc.m.hasCode,
-             "A guard in Inliner.analyzeClass() should have prevented from getting here.")
-
-      def isLargeSum  = caller.length + inc.length - 1 > SMALL_METHOD_SIZE
-
-      private def freshName(s: String): TermName = {
-        fresh(s) += 1
-        newTermName(s + fresh(s))
-      }
-
-      private def isKnownToInlineSafely: Boolean = { tfa.knownSafe(inc.sym) }
-
-      val isInlineForced    = hasInline(inc.sym)
-      val isInlineForbidden = hasNoInline(inc.sym)
-      assert(!(isInlineForced && isInlineForbidden), "method ("+inc.m+") marked both @inline and @noinline.")
-
-      /** Inline 'inc' into 'caller' at the given block and instruction.
-       *  The instruction must be a CALL_METHOD.
-       */
-      def doInline(block: BasicBlock, instr: CALL_METHOD) {
-
-        staleOut += block
-
-        tfa.remainingCALLs.remove(instr) // this bookkeeping is done here and not in MTFAGrowable.reinit due to (1st) convenience and (2nd) necessity.
-        tfa.isOnWatchlist.remove(instr)  // ditto
-        tfa.warnIfInlineFails.remove(instr)
-
-        val targetPos = instr.pos
-
-        def blockEmit(i: Instruction) = block.emit(i, targetPos)
-        def newLocal(baseName: String, kind: TypeKind) =
-          new Local(caller.sym.newVariable(freshName(baseName), targetPos) setInfo kind.toType, kind, false)
-
-        val (hasRETURN, a) = getRecentTFA(inc.m, isInlineForced)
-
-        /* The exception handlers that are active at the current block. */
-        val activeHandlers = caller.handlers filter (_ covered block)
-
-        /* Map 'original' blocks to the ones inlined in the caller. */
-        val inlinedBlock = mutable.Map[BasicBlock, BasicBlock]()
-
-        val varsInScope = mutable.HashSet[Local]() ++= block.varsInScope
-
-        /* Side effects varsInScope when it sees SCOPE_ENTERs. */
-        def instrBeforeFilter(i: Instruction): Boolean = {
-          i match { case SCOPE_ENTER(l) => varsInScope += l ; case _ => () }
-          i ne instr
-        }
-        val instrBefore = block.toList takeWhile instrBeforeFilter
-        val instrAfter  = block.toList drop (instrBefore.length + 1)
-
-        assert(!instrAfter.isEmpty, "CALL_METHOD cannot be the last instruction in block!")
-
-        // store the '$this' into the special local
-        val inlinedThis = newLocal("$inlThis", REFERENCE(ObjectClass))
-
-        /* buffer for the returned value */
-        val retVal = inc.m.returnType match {
-          case UNIT  => null
-          case x     => newLocal("$retVal", x)
-        }
-
-        val inlinedLocals = mutable.HashMap.empty[Local, Local]
-
-        /* Add a new block in the current context. */
-        def newBlock() = {
-          val b = caller.m.code.newBlock()
-          activeHandlers foreach (_ addCoveredBlock b)
-          if (retVal ne null) b.varsInScope += retVal
-          b.varsInScope += inlinedThis
-          b.varsInScope ++= varsInScope
-          b
-        }
-
-        def translateExh(e: ExceptionHandler) = {
-          val handler: ExceptionHandler = e.dup
-          handler.covered = handler.covered map inlinedBlock
-          handler setStartBlock inlinedBlock(e.startBlock)
-          handler
-        }
-
-        /* alfa-rename `l` in caller's context. */
-        def dupLocal(l: Local): Local = {
-          val sym = caller.sym.newVariable(freshName(l.sym.name.toString), l.sym.pos)
-          // sym.setInfo(l.sym.tpe)
-          val dupped = new Local(sym, l.kind, false)
-          inlinedLocals(l) = dupped
-          dupped
-        }
-
-        val afterBlock = newBlock()
-
-        /* Map from nw.init instructions to their matching NEW call */
-        val pending: mutable.Map[Instruction, NEW] = new mutable.HashMap
-
-        /* Map an instruction from the callee to one suitable for the caller. */
-        def map(i: Instruction): Instruction = {
-          def assertLocal(l: Local) = {
-            assert(caller.locals contains l, "Could not find local '" + l + "' in locals, nor in inlinedLocals: " + inlinedLocals)
-            i
-          }
-          def isInlined(l: Local) = inlinedLocals isDefinedAt l
-
-          val newInstr = i match {
-            case THIS(clasz)                    => LOAD_LOCAL(inlinedThis)
-            case STORE_THIS(_)                  => STORE_LOCAL(inlinedThis)
-            case JUMP(whereto)                  => JUMP(inlinedBlock(whereto))
-            case CJUMP(succ, fail, cond, kind)  => CJUMP(inlinedBlock(succ), inlinedBlock(fail), cond, kind)
-            case CZJUMP(succ, fail, cond, kind) => CZJUMP(inlinedBlock(succ), inlinedBlock(fail), cond, kind)
-            case SWITCH(tags, labels)           => SWITCH(tags, labels map inlinedBlock)
-            case RETURN(_)                      => JUMP(afterBlock)
-            case LOAD_LOCAL(l) if isInlined(l)  => LOAD_LOCAL(inlinedLocals(l))
-            case STORE_LOCAL(l) if isInlined(l) => STORE_LOCAL(inlinedLocals(l))
-            case LOAD_LOCAL(l)                  => assertLocal(l)
-            case STORE_LOCAL(l)                 => assertLocal(l)
-            case SCOPE_ENTER(l) if isInlined(l) => SCOPE_ENTER(inlinedLocals(l))
-            case SCOPE_EXIT(l) if isInlined(l)  => SCOPE_EXIT(inlinedLocals(l))
-
-            case nw @ NEW(sym) =>
-              val r = NEW(sym)
-              pending(nw.init) = r
-              r
-
-            case CALL_METHOD(meth, Static(true)) if meth.isClassConstructor =>
-              CALL_METHOD(meth, Static(onInstance = true))
-
-            case _ => i.clone()
-          }
-          // check any pending NEW's
-          pending remove i foreach (_.init = newInstr.asInstanceOf[CALL_METHOD])
-          newInstr
-        }
-
-        caller addLocals (inc.locals map dupLocal)
-        caller addLocal inlinedThis
-
-        if (retVal ne null)
-          caller addLocal retVal
-
-        inc.m foreachBlock { b =>
-          inlinedBlock += (b -> newBlock())
-          inlinedBlock(b).varsInScope ++= (b.varsInScope map inlinedLocals)
-        }
-
-        // re-emit the instructions before the call
-        block.open()
-        block.clear()
-        block emit instrBefore
-
-        // store the arguments into special locals
-        inc.m.params.reverse foreach (p => blockEmit(STORE_LOCAL(inlinedLocals(p))))
-        blockEmit(STORE_LOCAL(inlinedThis))
-
-        // jump to the start block of the callee
-        blockEmit(JUMP(inlinedBlock(inc.m.startBlock)))
-        block.close()
-
-        // duplicate the other blocks in the callee
-        val calleeLin = inc.m.linearizedBlocks()
-        calleeLin foreach { bb =>
-          var info = if(hasRETURN) (a in bb) else null
-          def emitInlined(i: Instruction) = inlinedBlock(bb).emit(i, targetPos)
-          def emitDrops(toDrop: Int)      = info.stack.types drop toDrop foreach (t => emitInlined(DROP(t)))
-
-          for (i <- bb) {
-            i match {
-              case RETURN(UNIT) => emitDrops(0)
-              case RETURN(kind) =>
-                if (info.stack.length > 1) {
-                  emitInlined(STORE_LOCAL(retVal))
-                  emitDrops(1)
-                  emitInlined(LOAD_LOCAL(retVal))
-                }
-              case _            => ()
-            }
-            emitInlined(map(i))
-            info = if(hasRETURN) a.interpret(info, i) else null
-          }
-          inlinedBlock(bb).close()
-        }
-
-        afterBlock emit instrAfter
-        afterBlock.close()
-
-        staleIn        += afterBlock
-        splicedBlocks ++= (calleeLin map inlinedBlock)
-
-        // add exception handlers of the callee
-        caller addHandlers (inc.handlers map translateExh)
-        assert(pending.isEmpty, "Pending NEW elements: " + pending)
-        if (settings.debug) icodes.checkValid(caller.m)
-      }
-
-      def isStampedForInlining(stackLength: Int): InlineSafetyInfo = {
-
-        if(tfa.blackballed(inc.sym)) { return NeverSafeToInline }
-
-        if(!isKnownToInlineSafely) {
-
-          if(inc.openBlocks.nonEmpty) {
-            val msg = ("Encountered " + inc.openBlocks.size + " open block(s) in isSafeToInline: this indicates a bug in the optimizer!\n" +
-                       "  caller = " + caller.m + ", callee = " + inc.m)
-            warn(inc.sym.pos, msg)
-            tfa.knownNever += inc.sym
-            return DontInlineHere("Open blocks in " + inc.m)
-          }
-
-          val reasonWhyNever: String = {
-            var rs: List[String] = Nil
-            if(inc.isRecursive)    { rs ::= "is recursive"           }
-            if(isInlineForbidden)  { rs ::= "is annotated @noinline" }
-            if(inc.isSynchronized) { rs ::= "is synchronized method" }
-            if(inc.m.bytecodeHasEHs) { rs ::= "bytecode contains exception handlers / finally clause" } // SI-6188
-            if(inc.m.bytecodeHasInvokeDynamic) { rs ::= "bytecode contains invoke dynamic" }
-            if(rs.isEmpty) null else rs.mkString("", ", and ", "")
-          }
-
-          if(reasonWhyNever != null) {
-            tfa.knownNever += inc.sym
-            inlineLog("never", inc.sym, reasonWhyNever)
-            // next time around NeverSafeToInline is returned, thus skipping (duplicate) msg, this is intended.
-            return DontInlineHere(inc.m + " " + reasonWhyNever)
-          }
-
-          if(sameSymbols) { // TODO but this also amounts to recursive, ie should lead to adding to tfa.knownNever, right?
-            tfa.knownUnsafe += inc.sym
-            return DontInlineHere("sameSymbols (ie caller == callee)")
-          }
-
-        }
-
-        /*
-         * From here on, two main categories of checks remain, (a) and (b) below:
-         *   (a.1) either the scoring heuristics give green light; or
-         *   (a.2) forced as candidate due to @inline.
-         * After that, safety proper is checked:
-         *   (b.1) the callee does not contain calls to private methods when called from another class
-         *   (b.2) the callee is not going to be inlined into a position with non-empty stack,
-         *         while having a top-level finalizer (see liftedTry problem)
-         * As a result of (b), some synthetic private members can be chosen to become public.
-         */
-
-        val score    = inlinerScore
-        val scoreStr = if (score > 0) "+" + score else "" + score
-        val what     = if (score > 0) "ok to" else "don't"
-        inlineLog(scoreStr, inc.m.symbol, s"$what inline into ${ownedName(caller.m.symbol)}")
-
-        if (!isInlineForced && score <= 0) {
-          // During inlining retry, a previous caller-callee pair that scored low may pass.
-          // Thus, adding the callee to tfa.knownUnsafe isn't warranted.
-          return DontInlineHere(s"inliner heuristic")
-        }
-
-        if(inc.hasHandlers && (stackLength > inc.minimumStack)) {
-          return DontInlineHere("callee contains exception handlers / finally clause, and is invoked with non-empty operand stack") // SI-6157
-        }
-
-        if(isKnownToInlineSafely) { return InlineableAtThisCaller }
-
-        if(stackLength > inc.minimumStack && inc.hasNonFinalizerHandler) {
-          val msg = "method " + inc.sym + " is used on a non-empty stack with finalizer."
-          debuglog(msg)
-          // FYI: not reason enough to add inc.sym to tfa.knownUnsafe (because at other callsite in this caller, inlining might be ok)
-          return DontInlineHere(msg)
-        }
-
-        val accReq = inc.accessRequirements
-        if(!canAccess(accReq.accessNeeded)) {
-          tfa.knownUnsafe += inc.sym
-          val msg = "access level required by callee not matched by caller"
-          inlineLog("fail", inc.sym, msg)
-          return DontInlineHere(msg)
-        }
-
-        FeasibleInline(accReq.accessNeeded, accReq.toBecomePublic)
-
-      }
-
-      def canAccess(level: NonPublicRefs.Value) = level match {
-        case Private    => caller.owner == inc.owner
-        case Protected  => caller.owner.tpe <:< inc.owner.tpe
-        case Public     => true
-      }
-      private def sameSymbols = caller.sym == inc.sym
-
-      /** Gives green light for inlining (which may still be vetoed later). Heuristics:
-       *   - it's bad to make the caller larger (> SMALL_METHOD_SIZE) if it was small
-       *   - it's bad to inline large methods
-       *   - it's good to inline higher order functions
-       *   - it's good to inline closures functions.
-       *   - it's bad (useless) to inline inside bridge methods
-       */
-      def inlinerScore: Int = {
-        var score = 0
-
-        // better not inline inside closures, but hope that the closure itself is repeatedly inlined
-        if (caller.isInClosure)           score -= 2
-        else if (caller.inlinedCalls < 1) score -= 1 // only monadic methods can trigger the first inline
-
-        if (inc.isSmall) score += 1
-        // if (inc.hasClosureParam) score += 2
-        if (inc.isLarge) score -= 1
-        if (caller.isSmall && isLargeSum) {
-          score -= 1
-          debuglog(s"inliner score decreased to $score because small caller $caller would become large")
-        }
-
-        if (inc.isMonadic)          score += 3
-        else if (inc.isHigherOrder) score += 1
-
-        if (inc.isInClosure)                 score += 2
-        if (inlinedMethodCount(inc.sym) > 2) score -= 2
-        score
-      }
-    }
-
-    def lookupIMethod(meth: Symbol, receiver: Symbol): Option[IMethod] = {
-      def tryParent(sym: Symbol) = icodes icode sym flatMap (_ lookupMethod meth)
-
-      (receiver.info.baseClasses.iterator map tryParent find (_.isDefined)).flatten
-    }
-  } /* class Inliner */
-} /* class Inliners */
diff --git a/src/compiler/scala/tools/nsc/classpath/FlatClassPathFactory.scala b/src/compiler/scala/tools/nsc/classpath/FlatClassPathFactory.scala
index 7f67381d4d..d8ca325885 100644
--- a/src/compiler/scala/tools/nsc/classpath/FlatClassPathFactory.scala
+++ b/src/compiler/scala/tools/nsc/classpath/FlatClassPathFactory.scala
@@ -5,7 +5,6 @@ package scala.tools.nsc.classpath
 
 import scala.tools.nsc.Settings
 import scala.tools.nsc.io.AbstractFile
-import scala.tools.nsc.util.ClassPath
 import FileUtils.AbstractFileOps
 
 /**
diff --git a/src/compiler/scala/tools/nsc/io/Jar.scala b/src/compiler/scala/tools/nsc/io/Jar.scala
index efb026cdff..779f546f69 100644
--- a/src/compiler/scala/tools/nsc/io/Jar.scala
+++ b/src/compiler/scala/tools/nsc/io/Jar.scala
@@ -6,11 +6,12 @@
 package scala.tools.nsc
 package io
 
-import java.io.{ InputStream, OutputStream, IOException, FileNotFoundException, FileInputStream, DataOutputStream }
+import scala.language.postfixOps
+
+import java.io.{ InputStream, OutputStream, DataOutputStream }
 import java.util.jar._
 import scala.collection.JavaConverters._
 import Attributes.Name
-import scala.language.{ implicitConversions, postfixOps }
 
 // Attributes.Name instances:
 //
diff --git a/src/compiler/scala/tools/nsc/io/Socket.scala b/src/compiler/scala/tools/nsc/io/Socket.scala
index a803e4121a..a17517da2e 100644
--- a/src/compiler/scala/tools/nsc/io/Socket.scala
+++ b/src/compiler/scala/tools/nsc/io/Socket.scala
@@ -8,7 +8,7 @@ package io
 
 import java.io.{ IOException, InputStreamReader, BufferedReader, PrintWriter, Closeable }
 import java.io.{ BufferedOutputStream, BufferedReader }
-import java.net.{ ServerSocket, SocketException, SocketTimeoutException, InetAddress, Socket => JSocket }
+import java.net.{ InetAddress, Socket => JSocket }
 import scala.io.Codec
 
 /** A skeletal only-as-much-as-I-need Socket wrapper.
diff --git a/src/compiler/scala/tools/nsc/io/SourceReader.scala b/src/compiler/scala/tools/nsc/io/SourceReader.scala
index 3220c2e2b2..b84c509a32 100644
--- a/src/compiler/scala/tools/nsc/io/SourceReader.scala
+++ b/src/compiler/scala/tools/nsc/io/SourceReader.scala
@@ -7,7 +7,7 @@
 package scala.tools.nsc
 package io
 
-import java.io.{ FileInputStream, InputStream, IOException }
+import java.io.{ FileInputStream, IOException }
 import java.nio.{ByteBuffer, CharBuffer}
 import java.nio.channels.{ ReadableByteChannel, Channels }
 import java.nio.charset.{CharsetDecoder, CoderResult}
diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
index eb25eb6e06..7224523a41 100644
--- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
+++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala
@@ -800,16 +800,10 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
       val superclazz =
         AppliedTypeTree(javaLangDot(tpnme.Enum), List(enumType))
       val finalFlag = if (enumIsFinal) Flags.FINAL else 0l
-      val abstractFlag = {
-        // javac adds `ACC_ABSTRACT` to enum classes with deferred members
-        val hasAbstractMember = body exists {
-          case d: DefDef => d.mods.isDeferred
-          case _         => false
-        }
-        if (hasAbstractMember) Flags.ABSTRACT else 0l
-      }
       addCompanionObject(consts ::: statics ::: predefs, atPos(pos) {
-        ClassDef(mods | Flags.JAVA_ENUM | finalFlag | abstractFlag, name, List(),
+        // Marking the enum class SEALED | ABSTRACT enables exhaustiveness checking. See also ClassfileParser.
+        // This is a bit of a hack and requires excluding the ABSTRACT flag in the backend, see method javaClassfileFlags.
+        ClassDef(mods | Flags.JAVA_ENUM | Flags.SEALED | Flags.ABSTRACT | finalFlag, name, List(),
                  makeTemplate(superclazz :: interfaces, body))
       })
     }
diff --git a/src/compiler/scala/tools/nsc/plugins/Plugin.scala b/src/compiler/scala/tools/nsc/plugins/Plugin.scala
index dd17750cd4..5caf7e41bf 100644
--- a/src/compiler/scala/tools/nsc/plugins/Plugin.scala
+++ b/src/compiler/scala/tools/nsc/plugins/Plugin.scala
@@ -6,14 +6,12 @@
 package scala.tools.nsc
 package plugins
 
-import scala.tools.nsc.io.{ Jar }
+import scala.tools.nsc.io.Jar
 import scala.reflect.internal.util.ScalaClassLoader
 import scala.reflect.io.{ Directory, File, Path }
 import java.io.InputStream
-import java.util.zip.ZipException
 
 import scala.collection.mutable
-import mutable.ListBuffer
 import scala.util.{ Try, Success, Failure }
 
 /** Information about a plugin loaded from a jar file.
diff --git a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala
index 4bf92fd1fb..9b9d94bb0f 100644
--- a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala
+++ b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala
@@ -7,7 +7,7 @@ package scala
 package tools.nsc
 package reporters
 
-import java.io.{ BufferedReader, IOException, PrintWriter }
+import java.io.{ BufferedReader, PrintWriter }
 import scala.reflect.internal.util._
 import StringOps._
 
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index 1bb1943c0c..d6ca0125ea 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -119,7 +119,6 @@ trait ScalaSettings extends AbsScalaSettings
   val require            = MultiStringSetting  ("-Xplugin-require", "plugin", "Abort if a named plugin is not loaded.")
   val pluginsDir         = StringSetting       ("-Xpluginsdir", "path", "Path to search for plugin archives.", Defaults.scalaPluginPath)
   val Xprint             = PhasesSetting       ("-Xprint", "Print out program after")
-  val writeICode         = PhasesSetting       ("-Xprint-icode", "Log internal icode to *.icode files after", "icode")
   val Xprintpos          = BooleanSetting      ("-Xprint-pos", "Print tree positions, as offsets.")
   val printtypes         = BooleanSetting      ("-Xprint-types", "Print tree types (debugging option).")
   val prompt             = BooleanSetting      ("-Xprompt", "Display a prompt after each error (debugging option).")
@@ -222,8 +221,6 @@ trait ScalaSettings extends AbsScalaSettings
   val exposeEmptyPackage = BooleanSetting ("-Yexpose-empty-package", "Internal only: expose the empty package.").internalOnly()
   val Ydelambdafy        = ChoiceSetting  ("-Ydelambdafy", "strategy", "Strategy used for translating lambdas into JVM code.", List("inline", "method"), "method")
 
-  val YskipInlineInfoAttribute = BooleanSetting("-Yskip-inline-info-attribute", "Do not add the ScalaInlineInfo attribute to classfiles generated by -Ybackend:GenASM")
-
   object YoptChoices extends MultiChoiceEnumeration {
     val unreachableCode         = Choice("unreachable-code",          "Eliminate unreachable code, exception handlers guarding no instructions, redundant metadata (debug information, line numbers).")
     val simplifyJumps           = Choice("simplify-jumps",            "Simplify branching instructions, eliminate unnecessary ones.")
@@ -369,7 +366,7 @@ trait ScalaSettings extends AbsScalaSettings
    * Settings motivated by GenBCode
    */
   val Ybackend = ChoiceSetting ("-Ybackend", "choice of bytecode emitter", "Choice of bytecode emitter.",
-                                List("GenASM", "GenBCode"),
+                                List("GenBCode"),
                                 "GenBCode")
   // Feature extensions
   val XmacroSettings          = MultiStringSetting("-Xmacro-settings", "option", "Custom settings for macros.")
diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala
index 59cc13c64e..f570037760 100644
--- a/src/compiler/scala/tools/nsc/settings/Warnings.scala
+++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala
@@ -49,7 +49,7 @@ trait Warnings {
     val NullaryOverride        = LintWarning("nullary-override",          "Warn when non-nullary `def f()' overrides nullary `def f'.",                true)
     val InferAny               = LintWarning("infer-any",                 "Warn when a type argument is inferred to be `Any`.",                        true)
     val MissingInterpolator    = LintWarning("missing-interpolator",      "A string literal appears to be missing an interpolator id.")
-    val DocDetached            = LintWarning("doc-detached",              "A ScalaDoc comment appears to be detached from its element.")
+    val DocDetached            = LintWarning("doc-detached",              "A Scaladoc comment appears to be detached from its element.")
     val PrivateShadow          = LintWarning("private-shadow",            "A private field (or class parameter) shadows a superclass field.")
     val TypeParameterShadow    = LintWarning("type-parameter-shadow",     "A local type parameter shadows a type already in scope.")
     val PolyImplicitOverload   = LintWarning("poly-implicit-overload",    "Parameterized overloaded implicit methods are not visible as view bounds.")
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index 99e61d2482..406411f21f 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -542,7 +542,7 @@ abstract class ClassfileParser {
             devWarning(s"no linked class for java enum $sym in ${sym.owner}. A referencing class file might be missing an InnerClasses entry.")
           case linked =>
             if (!linked.isSealed)
-              // Marking the enum class SEALED | ABSTRACT enables exhaustiveness checking.
+              // Marking the enum class SEALED | ABSTRACT enables exhaustiveness checking. See also JavaParsers.
               // This is a bit of a hack and requires excluding the ABSTRACT flag in the backend, see method javaClassfileFlags.
               linked setFlag (SEALED | ABSTRACT)
             linked addChild sym
diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
deleted file mode 100644
index b2f5a4119d..0000000000
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala
+++ /dev/null
@@ -1,1130 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author Iulian Dragos
- */
-
-package scala
-package tools.nsc
-package symtab
-package classfile
-
-import scala.collection.{ mutable, immutable }
-import mutable.ListBuffer
-import ClassfileConstants._
-import scala.reflect.internal.JavaAccFlags
-
-/** ICode reader from Java bytecode.
- *
- *  @author Iulian Dragos
- *  @version 1.0
- */
-abstract class ICodeReader extends ClassfileParser {
-  val global: Global
-  val symbolTable: global.type
-  val loaders: global.loaders.type
-  import global._
-  import icodes._
-
-  var instanceCode: IClass = null          // the ICode class for the current symbol
-  var staticCode:   IClass = null          // the ICode class static members
-  var method: IMethod = NoIMethod          // the current IMethod
-  var isScalaModule = false
-
-  override protected type ThisConstantPool = ICodeConstantPool
-  override protected def newConstantPool = new ICodeConstantPool
-
-  /** Try to force the chain of enclosing classes for the given name. Otherwise
-   *  flatten would not lift classes that were not referenced in the source code.
-   */
-  def forceMangledName(name: Name, module: Boolean): Symbol = {
-    val parts = name.decode.toString.split(Array('.', '$'))
-    var sym: Symbol = rootMirror.RootClass
-
-    // was "at flatten.prev"
-    enteringFlatten {
-      for (part0 <- parts; if !(part0 == ""); part = newTermName(part0)) {
-        val sym1 = enteringIcode {
-          sym.linkedClassOfClass.info
-          sym.info.decl(part.encode)
-        }//.suchThat(module == _.isModule)
-
-        sym = sym1 orElse sym.info.decl(part.encode.toTypeName)
-      }
-    }
-    sym
-  }
-
-  protected class ICodeConstantPool extends ConstantPool {
-    /** Return the symbol of the class member at `index`.
-     *  The following special cases exist:
-     *   - If the member refers to special `MODULE$` static field, return
-     *  the symbol of the corresponding module.
-     *   - If the member is a field, and is not found with the given name,
-     *     another try is made by appending `nme.LOCAL_SUFFIX_STRING`
-     *   - If no symbol is found in the right tpe, a new try is made in the
-     *     companion class, in case the owner is an implementation class.
-     */
-    def getMemberSymbol(index: Int, static: Boolean): Symbol = {
-      if (index <= 0 || len <= index) errorBadIndex(index)
-      var f = values(index).asInstanceOf[Symbol]
-      if (f eq null) {
-        val start = starts(index)
-        val first = in.buf(start).toInt
-        if (first != CONSTANT_FIELDREF &&
-            first != CONSTANT_METHODREF &&
-            first != CONSTANT_INTFMETHODREF) errorBadTag(start)
-        val ownerTpe = getClassOrArrayType(in.getChar(start + 1).toInt)
-        debuglog("getMemberSymbol(static: " + static + "): owner type: " + ownerTpe + " " + ownerTpe.typeSymbol.unexpandedName)
-        val (name0, tpe0) = getNameAndType(in.getChar(start + 3).toInt, ownerTpe)
-        debuglog("getMemberSymbol: name and tpe: " + name0 + ": " + tpe0)
-
-        forceMangledName(tpe0.typeSymbol.name, module = false)
-        val (name, tpe) = getNameAndType(in.getChar(start + 3).toInt, ownerTpe)
-        if (name == nme.MODULE_INSTANCE_FIELD) {
-          val index = in.getChar(start + 1).toInt
-          val name = getExternalName(in.getChar(starts(index).toInt + 1).toInt)
-          //assert(name.endsWith("$"), "Not a module class: " + name)
-          f = forceMangledName(name dropRight 1, module = true)
-          if (f == NoSymbol)
-            f = rootMirror.getModuleByName(name dropRight 1)
-        } else {
-          val origName = nme.unexpandedName(name)
-          val owner = if (static) ownerTpe.typeSymbol.linkedClassOfClass else ownerTpe.typeSymbol
-          f = owner.info.findMember(origName, 0, 0, stableOnly = false).suchThat(_.tpe.widen =:= tpe)
-          if (f == NoSymbol)
-            f = owner.info.findMember(newTermName(origName + nme.LOCAL_SUFFIX_STRING), 0, 0, stableOnly = false).suchThat(_.tpe =:= tpe)
-          if (f == NoSymbol) {
-            // if it's an impl class, try to find it's static member inside the class
-            if (ownerTpe.typeSymbol.isImplClass) {
-              f = ownerTpe.findMember(origName, 0, 0, stableOnly = false).suchThat(_.tpe =:= tpe)
-            } else {
-              log("Couldn't find " + name + ": " + tpe + " inside: \n" + ownerTpe)
-              f = tpe match {
-                case MethodType(_, _) => owner.newMethod(name.toTermName, owner.pos)
-                case _                => owner.newVariable(name.toTermName, owner.pos)
-              }
-              f setInfo tpe
-              log("created fake member " + f.fullName)
-            }
-          }
-        }
-        assert(f != NoSymbol,
-          s"could not find $name: $tpe in $ownerTpe" + (
-            if (settings.debug.value) ownerTpe.members.mkString(", members are:\n  ", "\n  ", "") else ""
-          )
-        )
-        values(index) = f
-      }
-      f
-    }
-  }
-
-  /** Read back bytecode for the given class symbol. It returns
-   *  two IClass objects, one for static members and one
-   *  for non-static members.
-   */
-  def readClass(cls: Symbol): (IClass, IClass) = {
-    cls.info // ensure accurate type information
-
-    isScalaModule = cls.isModule && !cls.isJavaDefined
-    log("ICodeReader reading " + cls)
-    val name = cls.javaClassName
-
-    classFileLookup.findClassFile(name) match {
-      case Some(classFile) => parse(classFile, cls)
-      case _               => MissingRequirementError.notFound("Could not find bytecode for " + cls)
-    }
-
-    (staticCode, instanceCode)
-  }
-
-  override def parseClass() {
-    this.instanceCode = new IClass(clazz)
-    this.staticCode   = new IClass(staticModule)
-
-    u2
-    pool getClassSymbol u2
-    parseInnerClasses()
-
-    in.skip(2)               // super class
-    in.skip(2 * u2) // interfaces
-    val fieldCount = u2
-    for (i <- 0 until fieldCount) parseField()
-    val methodCount = u2
-    for (i <- 0 until methodCount) parseMethod()
-    instanceCode.methods = instanceCode.methods.reverse
-    staticCode.methods = staticCode.methods.reverse
-  }
-
-  override def parseField() {
-    val (jflags, sym) = parseMember(field = true)
-    getCode(jflags) addField new IField(sym)
-    skipAttributes()
-  }
-
-  private def parseMember(field: Boolean): (JavaAccFlags, Symbol) = {
-    val jflags   = JavaAccFlags(u2)
-    val name     = pool getName u2
-    /*  If we're parsing a scala module, the owner of members is always
-     *  the module symbol.
-     */
-    val owner = (
-      if (isScalaModule) staticModule
-      else if (jflags.isStatic) moduleClass
-      else clazz
-    )
-    val dummySym = owner.newMethod(name.toTermName, owner.pos, jflags.toScalaFlags)
-
-    try {
-      val ch  = u2
-      val tpe = pool.getType(dummySym, ch)
-
-      if ("<clinit>" == name.toString)
-        (jflags, NoSymbol)
-      else {
-        var sym = owner.info.findMember(name, 0, 0, stableOnly = false).suchThat(old => sameType(old.tpe, tpe))
-        if (sym == NoSymbol)
-          sym = owner.info.findMember(newTermName(name + nme.LOCAL_SUFFIX_STRING), 0, 0, stableOnly = false).suchThat(_.tpe =:= tpe)
-        if (sym == NoSymbol) {
-          sym = if (field) owner.newValue(name.toTermName, owner.pos, jflags.toScalaFlags) else dummySym
-          sym setInfoAndEnter tpe
-          log(s"ICodeReader could not locate ${name.decode} in $owner.  Created ${sym.defString}.")
-        }
-        (jflags, sym)
-      }
-    } catch {
-      case e: MissingRequirementError =>
-        (jflags, NoSymbol)
-    }
-  }
-
-  /** Checks if `tp1` is the same type as `tp2`, modulo implicit methods.
-   *  We don't care about the distinction between implicit and explicit
-   *  methods as this point, and we can't get back the information from
-   *  bytecode anyway.
-   */
-  private def sameType(tp1: Type, tp2: Type): Boolean = (tp1, tp2) match {
-    case (mt1 @ MethodType(args1, resTpe1), mt2 @ MethodType(args2, resTpe2)) if mt1.isImplicit || mt2.isImplicit =>
-      MethodType(args1, resTpe1) =:= MethodType(args2, resTpe2)
-    case _ =>
-      tp1 =:= tp2
-  }
-
-  override def parseMethod() {
-    val (jflags, sym) = parseMember(field = false)
-    val beginning = in.bp
-    try {
-      if (sym != NoSymbol) {
-        this.method = new IMethod(sym)
-        this.method.returnType = toTypeKind(sym.tpe.resultType)
-        getCode(jflags).addMethod(this.method)
-        if (jflags.isNative)
-          this.method.native = true
-        val attributeCount = u2
-        for (i <- 0 until attributeCount) parseAttribute()
-      } else {
-        debuglog("Skipping non-existent method.")
-        skipAttributes()
-      }
-    } catch {
-      case e: MissingRequirementError =>
-        in.bp = beginning; skipAttributes()
-        debuglog("Skipping non-existent method. " + e.msg)
-    }
-  }
-
-  def parseAttribute() {
-    val attrName = pool.getName(u2).toTypeName
-    val attrLen = u4
-    attrName match {
-      case tpnme.CodeATTR =>
-        parseByteCode()
-      case _ =>
-        in.skip(attrLen)
-    }
-  }
-
-  override def classNameToSymbol(name: Name) = {
-    val sym = if (name == fulltpnme.RuntimeNothing)
-      definitions.NothingClass
-    else if (name == fulltpnme.RuntimeNull)
-      definitions.NullClass
-    else if (nme.isImplClassName(name)) {
-      val iface = rootMirror.getClassByName(tpnme.interfaceName(name))
-      log("forcing " + iface.owner + " at phase: " + phase + " impl: " + iface.implClass)
-      iface.owner.info // force the mixin type-transformer
-      rootMirror.getClassByName(name)
-    }
-    else if (nme.isModuleName(name)) {
-      val strippedName = name.dropModule
-      forceMangledName(newTermName(strippedName.decode), module = true) orElse rootMirror.getModuleByName(strippedName)
-    }
-    else {
-      forceMangledName(name, module = false)
-      exitingFlatten(rootMirror.getClassByName(name.toTypeName))
-    }
-    if (sym.isModule)
-      sym.moduleClass
-    else
-      sym
-  }
-
-
-  var maxStack: Int = _
-  var maxLocals: Int = _
-  val JVM = ClassfileConstants // shorter, uppercase alias for use in case patterns
-
-  def toUnsignedByte(b: Byte): Int = b.toInt & 0xff
-  var pc = 0
-
-  /** Parse java bytecode into ICode */
-  def parseByteCode() {
-    maxStack = u2
-    maxLocals = u2
-    val codeLength = u4
-    val code = new LinearCode
-
-    def parseInstruction() {
-      import opcodes._
-      import code._
-      var size = 1 // instruction size
-
-      /* Parse 16 bit jump target. */
-      def parseJumpTarget = {
-        size += 2
-        val offset = u2.toShort
-        val target = pc + offset
-        assert(target >= 0 && target < codeLength, "Illegal jump target: " + target)
-        target
-      }
-
-      /* Parse 32 bit jump target. */
-      def parseJumpTargetW: Int = {
-        size += 4
-        val offset = u4
-        val target = pc + offset
-        assert(target >= 0 && target < codeLength, "Illegal jump target: " + target + "pc: " + pc + " offset: " + offset)
-        target
-      }
-
-      u1 match {
-        case JVM.nop => parseInstruction()
-        case JVM.aconst_null => code emit CONSTANT(Constant(null))
-        case JVM.iconst_m1   => code emit CONSTANT(Constant(-1))
-        case JVM.iconst_0    => code emit CONSTANT(Constant(0))
-        case JVM.iconst_1    => code emit CONSTANT(Constant(1))
-        case JVM.iconst_2    => code emit CONSTANT(Constant(2))
-        case JVM.iconst_3    => code emit CONSTANT(Constant(3))
-        case JVM.iconst_4    => code emit CONSTANT(Constant(4))
-        case JVM.iconst_5    => code emit CONSTANT(Constant(5))
-
-        case JVM.lconst_0    => code emit CONSTANT(Constant(0l))
-        case JVM.lconst_1    => code emit CONSTANT(Constant(1l))
-        case JVM.fconst_0    => code emit CONSTANT(Constant(0.0f))
-        case JVM.fconst_1    => code emit CONSTANT(Constant(1.0f))
-        case JVM.fconst_2    => code emit CONSTANT(Constant(2.0f))
-        case JVM.dconst_0    => code emit CONSTANT(Constant(0.0))
-        case JVM.dconst_1    => code emit CONSTANT(Constant(1.0))
-
-        case JVM.bipush      => code.emit(CONSTANT(Constant(s1))); size += 1
-        case JVM.sipush      => code.emit(CONSTANT(Constant(s2))); size += 2
-        case JVM.ldc         => code.emit(CONSTANT(pool.getConstant(u1))); size += 1
-        case JVM.ldc_w       => code.emit(CONSTANT(pool.getConstant(u2))); size += 2
-        case JVM.ldc2_w      => code.emit(CONSTANT(pool.getConstant(u2))); size += 2
-        case JVM.iload       => code.emit(LOAD_LOCAL(code.getLocal(u1, INT)));    size += 1
-        case JVM.lload       => code.emit(LOAD_LOCAL(code.getLocal(u1, LONG)));   size += 1
-        case JVM.fload       => code.emit(LOAD_LOCAL(code.getLocal(u1, FLOAT)));  size += 1
-        case JVM.dload       => code.emit(LOAD_LOCAL(code.getLocal(u1, DOUBLE))); size += 1
-        case JVM.aload       =>
-          val local = u1.toInt; size += 1
-          if (local == 0 && !method.isStatic)
-            code.emit(THIS(method.symbol.owner))
-          else
-            code.emit(LOAD_LOCAL(code.getLocal(local, ObjectReference)))
-
-        case JVM.iload_0     => code.emit(LOAD_LOCAL(code.getLocal(0, INT)))
-        case JVM.iload_1     => code.emit(LOAD_LOCAL(code.getLocal(1, INT)))
-        case JVM.iload_2     => code.emit(LOAD_LOCAL(code.getLocal(2, INT)))
-        case JVM.iload_3     => code.emit(LOAD_LOCAL(code.getLocal(3, INT)))
-        case JVM.lload_0     => code.emit(LOAD_LOCAL(code.getLocal(0, LONG)))
-        case JVM.lload_1     => code.emit(LOAD_LOCAL(code.getLocal(1, LONG)))
-        case JVM.lload_2     => code.emit(LOAD_LOCAL(code.getLocal(2, LONG)))
-        case JVM.lload_3     => code.emit(LOAD_LOCAL(code.getLocal(3, LONG)))
-        case JVM.fload_0     => code.emit(LOAD_LOCAL(code.getLocal(0, FLOAT)))
-        case JVM.fload_1     => code.emit(LOAD_LOCAL(code.getLocal(1, FLOAT)))
-        case JVM.fload_2     => code.emit(LOAD_LOCAL(code.getLocal(2, FLOAT)))
-        case JVM.fload_3     => code.emit(LOAD_LOCAL(code.getLocal(3, FLOAT)))
-        case JVM.dload_0     => code.emit(LOAD_LOCAL(code.getLocal(0, DOUBLE)))
-        case JVM.dload_1     => code.emit(LOAD_LOCAL(code.getLocal(1, DOUBLE)))
-        case JVM.dload_2     => code.emit(LOAD_LOCAL(code.getLocal(2, DOUBLE)))
-        case JVM.dload_3     => code.emit(LOAD_LOCAL(code.getLocal(3, DOUBLE)))
-        case JVM.aload_0     =>
-          if (!method.isStatic)
-            code.emit(THIS(method.symbol.owner))
-          else
-            code.emit(LOAD_LOCAL(code.getLocal(0, ObjectReference)))
-        case JVM.aload_1     => code.emit(LOAD_LOCAL(code.getLocal(1, ObjectReference)))
-        case JVM.aload_2     => code.emit(LOAD_LOCAL(code.getLocal(2, ObjectReference)))
-        case JVM.aload_3     => code.emit(LOAD_LOCAL(code.getLocal(3, ObjectReference)))
-
-        case JVM.iaload      => code.emit(LOAD_ARRAY_ITEM(INT))
-        case JVM.laload      => code.emit(LOAD_ARRAY_ITEM(LONG))
-        case JVM.faload      => code.emit(LOAD_ARRAY_ITEM(FLOAT))
-        case JVM.daload      => code.emit(LOAD_ARRAY_ITEM(DOUBLE))
-        case JVM.aaload      => code.emit(LOAD_ARRAY_ITEM(ObjectReference))
-        case JVM.baload      => code.emit(LOAD_ARRAY_ITEM(BYTE))
-        case JVM.caload      => code.emit(LOAD_ARRAY_ITEM(CHAR))
-        case JVM.saload      => code.emit(LOAD_ARRAY_ITEM(SHORT))
-
-        case JVM.istore      => code.emit(STORE_LOCAL(code.getLocal(u1, INT)));    size += 1
-        case JVM.lstore      => code.emit(STORE_LOCAL(code.getLocal(u1, LONG)));   size += 1
-        case JVM.fstore      => code.emit(STORE_LOCAL(code.getLocal(u1, FLOAT)));  size += 1
-        case JVM.dstore      => code.emit(STORE_LOCAL(code.getLocal(u1, DOUBLE))); size += 1
-        case JVM.astore      => code.emit(STORE_LOCAL(code.getLocal(u1, ObjectReference))); size += 1
-        case JVM.istore_0    => code.emit(STORE_LOCAL(code.getLocal(0, INT)))
-        case JVM.istore_1    => code.emit(STORE_LOCAL(code.getLocal(1, INT)))
-        case JVM.istore_2    => code.emit(STORE_LOCAL(code.getLocal(2, INT)))
-        case JVM.istore_3    => code.emit(STORE_LOCAL(code.getLocal(3, INT)))
-        case JVM.lstore_0    => code.emit(STORE_LOCAL(code.getLocal(0, LONG)))
-        case JVM.lstore_1    => code.emit(STORE_LOCAL(code.getLocal(1, LONG)))
-        case JVM.lstore_2    => code.emit(STORE_LOCAL(code.getLocal(2, LONG)))
-        case JVM.lstore_3    => code.emit(STORE_LOCAL(code.getLocal(3, LONG)))
-        case JVM.fstore_0    => code.emit(STORE_LOCAL(code.getLocal(0, FLOAT)))
-        case JVM.fstore_1    => code.emit(STORE_LOCAL(code.getLocal(1, FLOAT)))
-        case JVM.fstore_2    => code.emit(STORE_LOCAL(code.getLocal(2, FLOAT)))
-        case JVM.fstore_3    => code.emit(STORE_LOCAL(code.getLocal(3, FLOAT)))
-        case JVM.dstore_0    => code.emit(STORE_LOCAL(code.getLocal(0, DOUBLE)))
-        case JVM.dstore_1    => code.emit(STORE_LOCAL(code.getLocal(1, DOUBLE)))
-        case JVM.dstore_2    => code.emit(STORE_LOCAL(code.getLocal(2, DOUBLE)))
-        case JVM.dstore_3    => code.emit(STORE_LOCAL(code.getLocal(3, DOUBLE)))
-        case JVM.astore_0    =>
-          if (method.isStatic)
-            code.emit(STORE_LOCAL(code.getLocal(0, ObjectReference)))
-          else
-            code.emit(STORE_THIS(ObjectReference))
-        case JVM.astore_1    => code.emit(STORE_LOCAL(code.getLocal(1, ObjectReference)))
-        case JVM.astore_2    => code.emit(STORE_LOCAL(code.getLocal(2, ObjectReference)))
-        case JVM.astore_3    => code.emit(STORE_LOCAL(code.getLocal(3, ObjectReference)))
-        case JVM.iastore     => code.emit(STORE_ARRAY_ITEM(INT))
-        case JVM.lastore     => code.emit(STORE_ARRAY_ITEM(LONG))
-        case JVM.fastore     => code.emit(STORE_ARRAY_ITEM(FLOAT))
-        case JVM.dastore     => code.emit(STORE_ARRAY_ITEM(DOUBLE))
-        case JVM.aastore     => code.emit(STORE_ARRAY_ITEM(ObjectReference))
-        case JVM.bastore     => code.emit(STORE_ARRAY_ITEM(BYTE))
-        case JVM.castore     => code.emit(STORE_ARRAY_ITEM(CHAR))
-        case JVM.sastore     => code.emit(STORE_ARRAY_ITEM(SHORT))
-
-        case JVM.pop         => code.emit(DROP(INT))   // any 1-word type would do
-        case JVM.pop2        => code.emit(DROP(LONG))  // any 2-word type would do
-        case JVM.dup         => code.emit(DUP(ObjectReference)) // TODO: Is the kind inside DUP ever needed?
-        case JVM.dup_x1      => code.emit(DUP_X1)      // sys.error("Unsupported JVM bytecode: dup_x1")
-        case JVM.dup_x2      => code.emit(DUP_X2)      // sys.error("Unsupported JVM bytecode: dup_x2")
-        case JVM.dup2        => code.emit(DUP(LONG))   // TODO: Is the kind inside DUP ever needed?
-        case JVM.dup2_x1     => code.emit(DUP2_X1)     // sys.error("Unsupported JVM bytecode: dup2_x1")
-        case JVM.dup2_x2     => code.emit(DUP2_X2)     // sys.error("Unsupported JVM bytecode: dup2_x2")
-        case JVM.swap        => sys.error("Unsupported JVM bytecode: swap")
-
-        case JVM.iadd        => code.emit(CALL_PRIMITIVE(Arithmetic(ADD, INT)))
-        case JVM.ladd        => code.emit(CALL_PRIMITIVE(Arithmetic(ADD, LONG)))
-        case JVM.fadd        => code.emit(CALL_PRIMITIVE(Arithmetic(ADD, FLOAT)))
-        case JVM.dadd        => code.emit(CALL_PRIMITIVE(Arithmetic(ADD, DOUBLE)))
-        case JVM.isub        => code.emit(CALL_PRIMITIVE(Arithmetic(SUB, INT)))
-        case JVM.lsub        => code.emit(CALL_PRIMITIVE(Arithmetic(SUB, LONG)))
-        case JVM.fsub        => code.emit(CALL_PRIMITIVE(Arithmetic(SUB, FLOAT)))
-        case JVM.dsub        => code.emit(CALL_PRIMITIVE(Arithmetic(SUB, DOUBLE)))
-        case JVM.imul        => code.emit(CALL_PRIMITIVE(Arithmetic(MUL, INT)))
-        case JVM.lmul        => code.emit(CALL_PRIMITIVE(Arithmetic(MUL, LONG)))
-        case JVM.fmul        => code.emit(CALL_PRIMITIVE(Arithmetic(MUL, FLOAT)))
-        case JVM.dmul        => code.emit(CALL_PRIMITIVE(Arithmetic(MUL, DOUBLE)))
-        case JVM.idiv        => code.emit(CALL_PRIMITIVE(Arithmetic(DIV, INT)))
-        case JVM.ldiv        => code.emit(CALL_PRIMITIVE(Arithmetic(DIV, LONG)))
-        case JVM.fdiv        => code.emit(CALL_PRIMITIVE(Arithmetic(DIV, FLOAT)))
-        case JVM.ddiv        => code.emit(CALL_PRIMITIVE(Arithmetic(DIV, DOUBLE)))
-        case JVM.irem        => code.emit(CALL_PRIMITIVE(Arithmetic(REM, INT)))
-        case JVM.lrem        => code.emit(CALL_PRIMITIVE(Arithmetic(REM, LONG)))
-        case JVM.frem        => code.emit(CALL_PRIMITIVE(Arithmetic(REM, FLOAT)))
-        case JVM.drem        => code.emit(CALL_PRIMITIVE(Arithmetic(REM, DOUBLE)))
-
-        case JVM.ineg        => code.emit(CALL_PRIMITIVE(Negation(INT)))
-        case JVM.lneg        => code.emit(CALL_PRIMITIVE(Negation(LONG)))
-        case JVM.fneg        => code.emit(CALL_PRIMITIVE(Negation(FLOAT)))
-        case JVM.dneg        => code.emit(CALL_PRIMITIVE(Negation(DOUBLE)))
-
-        case JVM.ishl        => code.emit(CALL_PRIMITIVE(Shift(LSL, INT)))
-        case JVM.lshl        => code.emit(CALL_PRIMITIVE(Shift(LSL, LONG)))
-        case JVM.ishr        => code.emit(CALL_PRIMITIVE(Shift(LSR, INT)))
-        case JVM.lshr        => code.emit(CALL_PRIMITIVE(Shift(LSR, LONG)))
-        case JVM.iushr       => code.emit(CALL_PRIMITIVE(Shift(ASR, INT)))
-        case JVM.lushr       => code.emit(CALL_PRIMITIVE(Shift(ASR, LONG)))
-        case JVM.iand        => code.emit(CALL_PRIMITIVE(Logical(AND, INT)))
-        case JVM.land        => code.emit(CALL_PRIMITIVE(Logical(AND, LONG)))
-        case JVM.ior         => code.emit(CALL_PRIMITIVE(Logical(OR, INT)))
-        case JVM.lor         => code.emit(CALL_PRIMITIVE(Logical(OR, LONG)))
-        case JVM.ixor        => code.emit(CALL_PRIMITIVE(Logical(XOR, INT)))
-        case JVM.lxor        => code.emit(CALL_PRIMITIVE(Logical(XOR, LONG)))
-        case JVM.iinc        =>
-          size += 2
-          val local = code.getLocal(u1, INT)
-          code.emit(LOAD_LOCAL(local))
-          code.emit(CONSTANT(Constant(s1)))
-          code.emit(CALL_PRIMITIVE(Arithmetic(ADD, INT)))
-          code.emit(STORE_LOCAL(local))
-
-        case JVM.i2l         => code.emit(CALL_PRIMITIVE(Conversion(INT, LONG)))
-        case JVM.i2f         => code.emit(CALL_PRIMITIVE(Conversion(INT, FLOAT)))
-        case JVM.i2d         => code.emit(CALL_PRIMITIVE(Conversion(INT, DOUBLE)))
-        case JVM.l2i         => code.emit(CALL_PRIMITIVE(Conversion(LONG, INT)))
-        case JVM.l2f         => code.emit(CALL_PRIMITIVE(Conversion(LONG, FLOAT)))
-        case JVM.l2d         => code.emit(CALL_PRIMITIVE(Conversion(LONG, DOUBLE)))
-        case JVM.f2i         => code.emit(CALL_PRIMITIVE(Conversion(FLOAT, INT)))
-        case JVM.f2l         => code.emit(CALL_PRIMITIVE(Conversion(FLOAT, LONG)))
-        case JVM.f2d         => code.emit(CALL_PRIMITIVE(Conversion(FLOAT, DOUBLE)))
-        case JVM.d2i         => code.emit(CALL_PRIMITIVE(Conversion(DOUBLE, INT)))
-        case JVM.d2l         => code.emit(CALL_PRIMITIVE(Conversion(DOUBLE, LONG)))
-        case JVM.d2f         => code.emit(CALL_PRIMITIVE(Conversion(DOUBLE, FLOAT)))
-        case JVM.i2b         => code.emit(CALL_PRIMITIVE(Conversion(INT, BYTE)))
-        case JVM.i2c         => code.emit(CALL_PRIMITIVE(Conversion(INT, CHAR)))
-        case JVM.i2s         => code.emit(CALL_PRIMITIVE(Conversion(INT, SHORT)))
-
-        case JVM.lcmp        => code.emit(CALL_PRIMITIVE(Comparison(CMP, LONG)))
-        case JVM.fcmpl       => code.emit(CALL_PRIMITIVE(Comparison(CMPL, FLOAT)))
-        case JVM.fcmpg       => code.emit(CALL_PRIMITIVE(Comparison(CMPG, FLOAT)))
-        case JVM.dcmpl       => code.emit(CALL_PRIMITIVE(Comparison(CMPL, DOUBLE)))
-        case JVM.dcmpg       => code.emit(CALL_PRIMITIVE(Comparison(CMPG, DOUBLE)))
-
-        case JVM.ifeq        => code.emit(LCZJUMP(parseJumpTarget, pc + size, EQ, INT))
-        case JVM.ifne        => code.emit(LCZJUMP(parseJumpTarget, pc + size, NE, INT))
-        case JVM.iflt        => code.emit(LCZJUMP(parseJumpTarget, pc + size, LT, INT))
-        case JVM.ifge        => code.emit(LCZJUMP(parseJumpTarget, pc + size, GE, INT))
-        case JVM.ifgt        => code.emit(LCZJUMP(parseJumpTarget, pc + size, GT, INT))
-        case JVM.ifle        => code.emit(LCZJUMP(parseJumpTarget, pc + size, LE, INT))
-
-        case JVM.if_icmpeq   => code.emit(LCJUMP(parseJumpTarget, pc + size, EQ, INT))
-        case JVM.if_icmpne   => code.emit(LCJUMP(parseJumpTarget, pc + size, NE, INT))
-        case JVM.if_icmplt   => code.emit(LCJUMP(parseJumpTarget, pc + size, LT, INT))
-        case JVM.if_icmpge   => code.emit(LCJUMP(parseJumpTarget, pc + size, GE, INT))
-        case JVM.if_icmpgt   => code.emit(LCJUMP(parseJumpTarget, pc + size, GT, INT))
-        case JVM.if_icmple   => code.emit(LCJUMP(parseJumpTarget, pc + size, LE, INT))
-        case JVM.if_acmpeq   => code.emit(LCJUMP(parseJumpTarget, pc + size, EQ, ObjectReference))
-        case JVM.if_acmpne   => code.emit(LCJUMP(parseJumpTarget, pc + size, NE, ObjectReference))
-
-        case JVM.goto        => emit(LJUMP(parseJumpTarget))
-        case JVM.jsr         => sys.error("Cannot handle jsr/ret")
-        case JVM.ret         => sys.error("Cannot handle jsr/ret")
-        case JVM.tableswitch =>
-          val padding = if ((pc + size) % 4 != 0) 4 - ((pc + size) % 4) else 0
-          size += padding
-          in.bp += padding
-          assert((pc + size % 4) != 0, pc)
-/*          var byte1 = u1; size += 1;
-          while (byte1 == 0) { byte1 = u1; size += 1; }
-          val default = byte1 << 24 | u1 << 16 | u1 << 8 | u1;
-          size = size + 3
-       */
-          val default = pc + u4; size += 4
-          val low  = u4
-          val high = u4
-          size += 8
-          assert(low <= high, "Value low not <= high for tableswitch.")
-
-          val tags = List.tabulate(high - low + 1)(n => List(low + n))
-          val targets = for (_ <- tags) yield parseJumpTargetW
-          code.emit(LSWITCH(tags, targets ::: List(default)))
-
-        case JVM.lookupswitch =>
-          val padding = if ((pc + size) % 4 != 0) 4 - ((pc + size) % 4) else 0
-          size += padding
-          in.bp += padding
-          assert((pc + size % 4) != 0, pc)
-          val default = pc + u4; size += 4
-          val npairs = u4; size += 4
-          var tags: List[List[Int]] = Nil
-          var targets: List[Int] = Nil
-          var i = 0
-          while (i < npairs) {
-            tags = List(u4) :: tags; size += 4
-            targets = parseJumpTargetW :: targets; // parseJumpTargetW updates 'size' itself
-            i += 1
-          }
-          targets = default :: targets
-          code.emit(LSWITCH(tags.reverse, targets.reverse))
-
-        case JVM.ireturn     => code.emit(RETURN(INT))
-        case JVM.lreturn     => code.emit(RETURN(LONG))
-        case JVM.freturn     => code.emit(RETURN(FLOAT))
-        case JVM.dreturn     => code.emit(RETURN(DOUBLE))
-        case JVM.areturn     => code.emit(RETURN(ObjectReference))
-        case JVM.return_     => code.emit(RETURN(UNIT))
-
-        case JVM.getstatic    =>
-          val field = pool.getMemberSymbol(u2, static = true); size += 2
-          if (field.hasModuleFlag)
-            code emit LOAD_MODULE(field)
-          else
-            code emit LOAD_FIELD(field, isStatic = true)
-        case JVM.putstatic   =>
-          val field = pool.getMemberSymbol(u2, static = true); size += 2
-          code.emit(STORE_FIELD(field, isStatic = true))
-        case JVM.getfield    =>
-          val field = pool.getMemberSymbol(u2, static = false); size += 2
-          code.emit(LOAD_FIELD(field, isStatic = false))
-        case JVM.putfield    =>
-          val field = pool.getMemberSymbol(u2, static = false); size += 2
-          code.emit(STORE_FIELD(field, isStatic = false))
-
-        case JVM.invokevirtual =>
-          val m = pool.getMemberSymbol(u2, static = false); size += 2
-          code.emit(CALL_METHOD(m, Dynamic))
-          method.updateRecursive(m)
-        case JVM.invokeinterface  =>
-          val m = pool.getMemberSymbol(u2, static = false); size += 4
-          in.skip(2)
-          code.emit(CALL_METHOD(m, Dynamic))
-          // invokeinterface can't be recursive
-        case JVM.invokespecial   =>
-          val m = pool.getMemberSymbol(u2, static = false); size += 2
-          val style = if (m.name == nme.CONSTRUCTOR || m.isPrivate) Static(onInstance = true)
-                      else SuperCall(m.owner.name)
-          code.emit(CALL_METHOD(m, style))
-          method.updateRecursive(m)
-        case JVM.invokestatic    =>
-          val m = pool.getMemberSymbol(u2, static = true); size += 2
-          if (isBox(m))
-            code.emit(BOX(toTypeKind(m.info.paramTypes.head)))
-          else if (isUnbox(m))
-            code.emit(UNBOX(toTypeKind(m.info.resultType)))
-          else {
-            code.emit(CALL_METHOD(m, Static(onInstance = false)))
-            method.updateRecursive(m)
-          }
-        case JVM.invokedynamic  =>
-          // TODO, this is just a place holder. A real implementation must parse the class constant entry
-          debuglog("Found JVM invokedynamic instruction, inserting place holder ICode INVOKE_DYNAMIC.")
-          containsInvokeDynamic = true
-          val poolEntry = in.nextChar.toInt
-          in.skip(2)
-          code.emit(INVOKE_DYNAMIC(poolEntry))
-
-        case JVM.new_          =>
-          code.emit(NEW(REFERENCE(pool.getClassSymbol(u2))))
-          size += 2
-        case JVM.newarray      =>
-          val kind = u1 match {
-            case T_BOOLEAN => BOOL
-            case T_CHAR    => CHAR
-            case T_FLOAT   => FLOAT
-            case T_DOUBLE  => DOUBLE
-            case T_BYTE    => BYTE
-            case T_SHORT   => SHORT
-            case T_INT     => INT
-            case T_LONG    => LONG
-          }
-          size += 1
-          code.emit(CREATE_ARRAY(kind, 1))
-
-        case JVM.anewarray     =>
-          val tpe = pool.getClassOrArrayType(u2); size += 2
-          code.emit(CREATE_ARRAY(toTypeKind(tpe), 1))
-
-        case JVM.arraylength   => code.emit(CALL_PRIMITIVE(ArrayLength(ObjectReference))); // the kind does not matter
-        case JVM.athrow        => code.emit(THROW(definitions.ThrowableClass))
-        case JVM.checkcast     =>
-          code.emit(CHECK_CAST(toTypeKind(pool.getClassOrArrayType(u2)))); size += 2
-        case JVM.instanceof    =>
-          code.emit(IS_INSTANCE(toTypeKind(pool.getClassOrArrayType(u2)))); size += 2
-        case JVM.monitorenter  => code.emit(MONITOR_ENTER())
-        case JVM.monitorexit   => code.emit(MONITOR_EXIT())
-        case JVM.wide          =>
-          size += 1
-          u1 match {
-            case JVM.iload  => code.emit(LOAD_LOCAL(code.getLocal(u2, INT)));    size += 2
-            case JVM.lload  => code.emit(LOAD_LOCAL(code.getLocal(u2, LONG)));   size += 2
-            case JVM.fload  => code.emit(LOAD_LOCAL(code.getLocal(u2, FLOAT)));  size += 2
-            case JVM.dload  => code.emit(LOAD_LOCAL(code.getLocal(u2, DOUBLE))); size += 2
-            case JVM.aload  => code.emit(LOAD_LOCAL(code.getLocal(u2, ObjectReference))); size += 2
-            case JVM.istore => code.emit(STORE_LOCAL(code.getLocal(u2, INT)));    size += 2
-            case JVM.lstore => code.emit(STORE_LOCAL(code.getLocal(u2, LONG)));   size += 2
-            case JVM.fstore => code.emit(STORE_LOCAL(code.getLocal(u2, FLOAT)));  size += 2
-            case JVM.dstore => code.emit(STORE_LOCAL(code.getLocal(u2, DOUBLE))); size += 2
-            case JVM.astore => code.emit(STORE_LOCAL(code.getLocal(u2, ObjectReference))); size += 2
-            case JVM.ret => sys.error("Cannot handle jsr/ret")
-            case JVM.iinc =>
-              size += 4
-              val local = code.getLocal(u2, INT)
-              code.emit(CONSTANT(Constant(u2)))
-              code.emit(CALL_PRIMITIVE(Arithmetic(ADD, INT)))
-              code.emit(STORE_LOCAL(local))
-            case _ => sys.error("Invalid 'wide' operand")
-          }
-
-        case JVM.multianewarray =>
-          size += 3
-          val tpe = toTypeKind(pool getClassOrArrayType u2)
-          val dim = u1
-//          assert(dim == 1, "Cannot handle multidimensional arrays yet.")
-          code emit CREATE_ARRAY(tpe, dim)
-
-        case JVM.ifnull    => code emit LCZJUMP(parseJumpTarget, pc + size, EQ, ObjectReference)
-        case JVM.ifnonnull => code emit LCZJUMP(parseJumpTarget, pc + size, NE, ObjectReference)
-        case JVM.goto_w    => code emit LJUMP(parseJumpTargetW)
-        case JVM.jsr_w     => sys.error("Cannot handle jsr/ret")
-
-//        case _ => sys.error("Unknown bytecode")
-      }
-      pc += size
-    }
-
-    // add parameters
-    var idx = if (method.isStatic) 0 else 1
-    for (t <- method.symbol.tpe.paramTypes) {
-      val kind = toTypeKind(t)
-      this.method addParam code.enterParam(idx, kind)
-      val width = if (kind.isWideType) 2 else 1
-      idx += width
-    }
-
-    pc = 0
-    while (pc < codeLength) parseInstruction()
-
-    val exceptionEntries = u2.toInt
-    code.containsEHs = (exceptionEntries != 0)
-    var i = 0
-    while (i < exceptionEntries) {
-      // skip start end PC
-      in.skip(4)
-      // read the handler PC
-      code.jmpTargets += u2
-      // skip the exception type
-      in.skip(2)
-      i += 1
-    }
-    skipAttributes()
-
-    code.toBasicBlock
-    assert(method.hasCode, method)
-    // reverse parameters, as they were prepended during code generation
-    method.params = method.params.reverse
-
-    if (code.containsDUPX)
-      code.resolveDups()
-
-    if (code.containsNEW)
-      code.resolveNEWs()
-  }
-
-  /** Note: these methods are different from the methods of the same name found
-   *  in Definitions.  These test whether a symbol represents one of the boxTo/unboxTo
-   *  methods found in BoxesRunTime.  The others test whether a symbol represents a
-   *  synthetic method from one of the fake companion classes of the primitive types,
-   *  such as Int.box(5).
-   */
-  def isBox(m: Symbol): Boolean =
-    (m.owner == definitions.BoxesRunTimeClass
-        && m.name.startsWith("boxTo"))
-
-  def isUnbox(m: Symbol): Boolean =
-    (m.owner == definitions.BoxesRunTimeClass
-        && m.name.startsWith("unboxTo"))
-
-  /** Return the icode class that should include members with the given flags.
-   *  There are two possible classes, the static part and the instance part.
-   */
-  def getCode(flags: JavaAccFlags): IClass =
-    if (isScalaModule || flags.isStatic) staticCode else instanceCode
-
-  class LinearCode {
-    val instrs: ListBuffer[(Int, Instruction)] = new ListBuffer
-    val jmpTargets: mutable.Set[Int] = perRunCaches.newSet[Int]()
-    val locals: mutable.Map[Int, List[(Local, TypeKind)]] = perRunCaches.newMap()
-
-    var containsDUPX = false
-    var containsNEW  = false
-    var containsEHs  = false
-    var containsInvokeDynamic = false
-
-    def emit(i: Instruction) {
-      instrs += ((pc, i))
-      if (i.isInstanceOf[DupX])
-        containsDUPX = true
-      if (i.isInstanceOf[opcodes.NEW])
-        containsNEW = true
-    }
-
-    /** Break this linear code in basic block representation
-     *  As a side effect, it sets the `code` field of the current
-     */
-    def toBasicBlock: Code = {
-      import opcodes._
-
-      val code = new Code(method)
-      method.setCode(code)
-      method.bytecodeHasEHs = containsEHs
-      method.bytecodeHasInvokeDynamic = containsInvokeDynamic
-      var bb = code.startBlock
-
-      def makeBasicBlocks: mutable.Map[Int, BasicBlock] =
-        mutable.Map(jmpTargets.toSeq map (_ -> code.newBlock): _*)
-
-      val blocks = makeBasicBlocks
-      var otherBlock: BasicBlock = NoBasicBlock
-
-      for ((pc, instr) <- instrs.iterator) {
-//        Console.println("> " + pc + ": " + instr);
-        if (jmpTargets(pc)) {
-          otherBlock = blocks(pc)
-          if (!bb.closed && otherBlock != bb) {
-            bb.emit(JUMP(otherBlock))
-            bb.close()
-//            Console.println("\t> closing bb: " + bb)
-          }
-          bb = otherBlock
-//          Console.println("\t> entering bb: " + bb)
-        }
-
-        if (bb.closed) {
-          // the basic block is closed, i.e. the previous instruction was a jump, return or throw,
-          // but the next instruction is not a jump target. this means that the next instruction is
-          // dead code. we can therefore advance until the next jump target.
-          debuglog(s"ICode reader skipping dead instruction $instr in classfile $instanceCode")
-        } else {
-          instr match {
-            case LJUMP(target) =>
-              otherBlock = blocks(target)
-              bb.emitOnly(JUMP(otherBlock))
-
-            case LCJUMP(success, failure, cond, kind) =>
-              otherBlock = blocks(success)
-              val failBlock = blocks(failure)
-              bb.emitOnly(CJUMP(otherBlock, failBlock, cond, kind))
-
-            case LCZJUMP(success, failure, cond, kind) =>
-              otherBlock = blocks(success)
-              val failBlock = blocks(failure)
-              bb.emitOnly(CZJUMP(otherBlock, failBlock, cond, kind))
-
-            case LSWITCH(tags, targets) =>
-              bb.emitOnly(SWITCH(tags, targets map blocks))
-
-            case RETURN(_) =>
-              bb emitOnly instr
-
-            case THROW(clasz) =>
-              bb emitOnly instr
-
-            case _ =>
-              bb emit instr
-          }
-        }
-      }
-
-      method.code
-    }
-
-    def resolveDups() {
-      import opcodes._
-
-      val tfa = new analysis.MethodTFA() {
-        import analysis._
-
-        /** Abstract interpretation for one instruction. */
-        override def mutatingInterpret(out: typeFlowLattice.Elem, i: Instruction): typeFlowLattice.Elem = {
-          val stack = out.stack
-          import stack.push
-          i match {
-            case DUP_X1 =>
-              val (one, two) = stack.pop2
-              push(one); push(two); push(one)
-
-            case DUP_X2 =>
-              val (one, two, three) = stack.pop3
-              push(one); push(three); push(two); push(one)
-
-            case DUP2_X1 =>
-              val (one, two) = stack.pop2
-              if (one.isWideType) {
-                push(one); push(two); push(one)
-              } else {
-                val three = stack.pop
-                push(two); push(one); push(three); push(two); push(one)
-              }
-
-            case DUP2_X2 =>
-              val (one, two) = stack.pop2
-              if (one.isWideType && two.isWideType) {
-                push(one); push(two); push(one)
-              } else if (one.isWideType) {
-                val three = stack.pop
-                assert(!three.isWideType, "Impossible")
-                push(one); push(three); push(two); push(one)
-              } else {
-                val three = stack.pop
-                if (three.isWideType) {
-                  push(two); push(one); push(one); push(three); push(two); push(one)
-                } else {
-                  val four = stack.pop
-                  push(two); push(one); push(four); push(one); push(three); push(two); push(one)
-                }
-              }
-
-            case _ =>
-              super.mutatingInterpret(out, i)
-          }
-          out
-        }
-      }
-
-//      method.dump
-      tfa.init(method)
-      tfa.run()
-      for (bb <- linearizer.linearize(method)) {
-        var info = tfa.in(bb)
-        for (i <- bb.toList) {
-          i match {
-            case DUP_X1 =>
-              val one = info.stack.types(0)
-              val two = info.stack.types(1)
-              assert(!one.isWideType, "DUP_X1 expects values of size 1 on top of stack " + info.stack)
-              val tmp1 = freshLocal(one)
-              val tmp2 = freshLocal(two)
-              bb.replaceInstruction(i, List(STORE_LOCAL(tmp1),
-                  STORE_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1),
-                  LOAD_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1)))
-
-            case DUP_X2 =>
-              val one = info.stack.types(0)
-              val two = info.stack.types(1)
-              assert (!one.isWideType, "DUP_X2 expects values of size 1 on top of stack " + info.stack)
-              val tmp1 = freshLocal(one)
-              val tmp2 = freshLocal(two)
-              if (two.isWideType)
-                bb.replaceInstruction(i, List(STORE_LOCAL(tmp1),
-                  STORE_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1),
-                  LOAD_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1)))
-              else {
-                val tmp3 = freshLocal(info.stack.types(2))
-                bb.replaceInstruction(i, List(STORE_LOCAL(tmp1),
-                  STORE_LOCAL(tmp2),
-                  STORE_LOCAL(tmp3),
-                  LOAD_LOCAL(tmp1),
-                  LOAD_LOCAL(tmp3),
-                  LOAD_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1)))
-              }
-
-            case DUP2_X1 =>
-              val one = info.stack.types(0)
-              val two = info.stack.types(1)
-              val tmp1 = freshLocal(one)
-              val tmp2 = freshLocal(two)
-              if (one.isWideType) {
-                assert(!two.isWideType, "Impossible")
-                bb.replaceInstruction(i, List(STORE_LOCAL(tmp1),
-                  STORE_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1),
-                  LOAD_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1)))
-              } else {
-                val tmp3 = freshLocal(info.stack.types(2))
-                bb.replaceInstruction(i, List(STORE_LOCAL(tmp1),
-                  STORE_LOCAL(tmp2),
-                  STORE_LOCAL(tmp3),
-                  LOAD_LOCAL(tmp1),
-                  LOAD_LOCAL(tmp3),
-                  LOAD_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1)))
-              }
-
-            case DUP2_X2 =>
-              val one = info.stack.types(0)
-              val two = info.stack.types(1)
-              val tmp1 = freshLocal(one)
-              val tmp2 = freshLocal(two)
-              if (one.isWideType && two.isWideType) {
-                bb.replaceInstruction(i, List(STORE_LOCAL(tmp1),
-                  STORE_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1),
-                  LOAD_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1)))
-              } else if (one.isWideType) {
-                val three = info.stack.types(2)
-                assert(!two.isWideType && !three.isWideType, "Impossible")
-                val tmp3 = freshLocal(three)
-                bb.replaceInstruction(i, List(STORE_LOCAL(tmp1),
-                  STORE_LOCAL(tmp2),
-                  STORE_LOCAL(tmp3),
-                  LOAD_LOCAL(tmp1),
-                  LOAD_LOCAL(tmp3),
-                  LOAD_LOCAL(tmp2),
-                  LOAD_LOCAL(tmp1)))
-              } else {
-                val three = info.stack.types(2)
-                val tmp3 = freshLocal(three)
-                if (three.isWideType) {
-                  bb.replaceInstruction(i, List(STORE_LOCAL(tmp1),
-                      STORE_LOCAL(tmp2),
-                      STORE_LOCAL(tmp3),
-                      LOAD_LOCAL(tmp2),
-                      LOAD_LOCAL(tmp1),
-                      LOAD_LOCAL(tmp3),
-                      LOAD_LOCAL(tmp2),
-                      LOAD_LOCAL(tmp1)))
-                } else {
-                  val four = info.stack.types(3)
-                  val tmp4 = freshLocal(three)
-                  assert(!four.isWideType, "Impossible")
-                  bb.replaceInstruction(i, List(STORE_LOCAL(tmp1),
-                      STORE_LOCAL(tmp2),
-                      STORE_LOCAL(tmp3),
-                      STORE_LOCAL(tmp4),
-                      LOAD_LOCAL(tmp2),
-                      LOAD_LOCAL(tmp1),
-                      LOAD_LOCAL(tmp4),
-                      LOAD_LOCAL(tmp3),
-                      LOAD_LOCAL(tmp2),
-                      LOAD_LOCAL(tmp1)))
-                }
-              }
-            case _ =>
-          }
-          info = tfa.interpret(info, i)
-        }
-      }
-    }
-
-    /** Recover def-use chains for NEW and initializers. */
-    def resolveNEWs() {
-      import opcodes._
-      val rdef = new reachingDefinitions.ReachingDefinitionsAnalysis
-      rdef.init(method)
-      rdef.run()
-
-      for (bb <- method.code.blocks ; (i, idx) <- bb.toList.zipWithIndex) i match {
-        case cm @ CALL_METHOD(m, Static(true)) if m.isClassConstructor =>
-          def loop(bb0: BasicBlock, idx0: Int, depth: Int): Unit = {
-            rdef.findDefs(bb0, idx0, 1, depth) match {
-              case ((bb1, idx1)) :: _ =>
-                bb1(idx1) match {
-                  case _: DUP   => loop(bb1, idx1, 0)
-                  case x: NEW   => x.init = cm
-                  case _: THIS  => () // super constructor call
-                  case producer => dumpMethodAndAbort(method, "producer: " + producer)
-                }
-              case _ => ()
-            }
-          }
-          loop(bb, idx, m.info.paramTypes.length)
-
-        case _ => ()
-      }
-    }
-
-    /** Return the local at given index, with the given type. */
-    def getLocal(idx: Char, kind: TypeKind): Local = getLocal(idx.toInt, kind)
-    def getLocal(idx: Int, kind: TypeKind): Local = {
-      assert(idx < maxLocals, "Index too large for local variable.")
-
-      def checkValidIndex() {
-        locals.get(idx - 1) match {
-          case Some(others) if others exists (_._2.isWideType) =>
-            global.globalError("Illegal index: " + idx + " points in the middle of another local")
-          case _ => ()
-        }
-        kind match {
-          case LONG | DOUBLE if (locals.isDefinedAt(idx + 1)) =>
-            global.globalError("Illegal index: " + idx + " overlaps " + locals(idx + 1) + "\nlocals: " + locals)
-          case _ => ()
-        }
-      }
-
-      locals.get(idx) match {
-        case Some(ls) =>
-          val l = ls find { loc => loc._2 isAssignabledTo kind }
-          l match {
-            case Some((loc, _)) => loc
-            case None =>
-              val l = freshLocal(kind)
-              locals(idx) = (l, kind) :: locals(idx)
-              log("Expected kind " + kind + " for local " + idx +
-                " but only " + ls + " found. Added new local.")
-              l
-          }
-        case None =>
-          checkValidIndex()
-          val l = freshLocal(idx, kind, isArg = false)
-          debuglog("Added new local for idx " + idx + ": " + kind)
-          locals += (idx -> List((l, kind)))
-          l
-      }
-    }
-
-    override def toString(): String = instrs.toList.mkString("", "\n", "")
-
-    /** Return a fresh Local variable for the given index.
-     */
-    private def freshLocal(idx: Int, kind: TypeKind, isArg: Boolean) = {
-      val sym = method.symbol.newVariable(newTermName("loc" + idx)).setInfo(kind.toType)
-      val l = new Local(sym, kind, isArg)
-      method.addLocal(l)
-      l
-    }
-
-    private var count = 0
-
-    /** Invent a new local, with a new index value outside the range of
-     *  the original method. */
-    def freshLocal(kind: TypeKind): Local = {
-      count += 1
-      freshLocal(maxLocals + count, kind, isArg = false)
-    }
-
-    /** add a method param with the given index. */
-    def enterParam(idx: Int, kind: TypeKind) = {
-      val sym = method.symbol.newVariable(newTermName("par" + idx)).setInfo(kind.toType)
-      val l = new Local(sym, kind, true)
-      assert(!locals.isDefinedAt(idx), locals(idx))
-      locals += (idx -> List((l, kind)))
-      l
-    }
-
-    /** Base class for branch instructions that take addresses. */
-    abstract class LazyJump(pc: Int) extends Instruction {
-      override def toString() = "LazyJump " + pc
-      jmpTargets += pc
-    }
-
-    case class LJUMP(pc: Int) extends LazyJump(pc)
-
-    case class LCJUMP(success: Int, failure: Int, cond: TestOp, kind: TypeKind)
-      extends LazyJump(success) {
-      override def toString(): String = "LCJUMP (" + kind + ") " + success + " : " + failure
-
-      jmpTargets += failure
-    }
-
-    case class LCZJUMP(success: Int, failure: Int, cond: TestOp, kind: TypeKind)
-      extends LazyJump(success) {
-      override def toString(): String = "LCZJUMP (" + kind + ") " + success + " : " + failure
-
-      jmpTargets += failure
-    }
-
-    case class LSWITCH(tags: List[List[Int]], targets: List[Int]) extends LazyJump(targets.head) {
-      override def toString(): String = "LSWITCH (tags: " + tags + ") targets: " + targets
-
-      jmpTargets ++= targets.tail
-    }
-
-    /** Duplicate and exchange pseudo-instruction. Should be later
-     *  replaced by proper ICode */
-    abstract class DupX extends Instruction
-
-    case object DUP_X1 extends DupX
-    case object DUP_X2 extends DupX
-    case object DUP2_X1 extends DupX
-    case object DUP2_X2 extends DupX
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
index 82e7c76409..085a814c6b 100644
--- a/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
+++ b/src/compiler/scala/tools/nsc/transform/AddInterfaces.scala
@@ -242,20 +242,18 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
     }
   }
 
-  private def createMemberDef(tree: Tree, isForInterface: Boolean)(create: Tree => Tree) = {
-    val isInterfaceTree = tree.isDef && isInterfaceMember(tree.symbol)
-    if (isInterfaceTree && needsImplMethod(tree.symbol))
-      create(tree)
-    else if (isInterfaceTree == isForInterface)
-      tree
-    else
-      EmptyTree
-  }
-  private def implMemberDef(tree: Tree): Tree  = createMemberDef(tree, false)(implMethodDef)
-  private def ifaceMemberDef(tree: Tree): Tree = createMemberDef(tree, true)(t => DefDef(t.symbol, EmptyTree))
+  private def isInterfaceTree(tree: Tree) = tree.isDef && isInterfaceMember(tree.symbol)
+
+  private def deriveMemberForImplClass(tree: Tree): Tree  =
+    if (isInterfaceTree(tree)) if (needsImplMethod(tree.symbol)) implMethodDef(tree)            else EmptyTree
+    else tree
+
+  private def deriveMemberForInterface(tree: Tree): Tree =
+    if (isInterfaceTree(tree)) if (needsImplMethod(tree.symbol)) DefDef(tree.symbol, EmptyTree) else tree
+    else EmptyTree
 
   private def ifaceTemplate(templ: Template): Template =
-    treeCopy.Template(templ, templ.parents, noSelfType, templ.body map ifaceMemberDef)
+    treeCopy.Template(templ, templ.parents, noSelfType, templ.body map deriveMemberForInterface)
 
   /** Transforms the member tree containing the implementation
    *  into a member of the impl class.
@@ -286,7 +284,7 @@ abstract class AddInterfaces extends InfoTransform { self: Erasure =>
 
   private def implTemplate(clazz: Symbol, templ: Template): Template = atPos(templ.pos) {
     val templ1 = (
-      Template(templ.parents, noSelfType, addMixinConstructorDef(clazz, templ.body map implMemberDef))
+      Template(templ.parents, noSelfType, addMixinConstructorDef(clazz, templ.body map deriveMemberForImplClass))
         setSymbol clazz.newLocalDummy(templ.pos)
     )
     templ1.changeOwner(templ.symbol.owner -> clazz, templ.symbol -> templ1.symbol)
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
index c29826551b..1d98b5da31 100644
--- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala
+++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -49,7 +49,9 @@ abstract class CleanUp extends Statics with Transform with ast.TreeDSL {
       clearStatics()
       val newBody = transformTrees(body)
       val templ   = deriveTemplate(tree)(_ => transformTrees(newStaticMembers.toList) ::: newBody)
-      try addStaticInits(templ, newStaticInits, localTyper) // postprocess to include static ctors
+      try
+        if (newStaticInits.isEmpty) templ
+        else deriveTemplate(templ)(body => staticConstructor(body, localTyper, templ.pos)(newStaticInits.toList) :: body)
       finally clearStatics()
     }
     private def mkTerm(prefix: String): TermName = unit.freshTermName(prefix)
diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index 48eb878e2a..aef2817db7 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -6,8 +6,7 @@
 package scala.tools.nsc
 package transform
 
-import scala.collection.{ mutable, immutable }
-import scala.collection.mutable.ListBuffer
+import scala.collection.mutable
 import scala.reflect.internal.util.ListOfNil
 import symtab.Flags._
 
@@ -28,7 +27,6 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
   private val ctorParams: mutable.Map[Symbol, List[Symbol]] = perRunCaches.newMap[Symbol, List[Symbol]]()
 
   class ConstructorTransformer(unit: CompilationUnit) extends Transformer {
-
     /*
      * Inspect for obvious out-of-order initialization; concrete, eager vals or vars, declared in this class,
      * for which a reference to the member precedes its definition.
@@ -121,15 +119,15 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
    * What trees can be visited at this point?
    * To recap, by the time the constructors phase runs, local definitions have been hoisted out of their original owner.
    * Moreover, by the time elision is about to happen, the `intoConstructors` rewriting
-   * of template-level statements has taken place (the resulting trees can be found in `constrStatBuf`).
+   * of template-level statements has taken place (the resulting trees can be found in `constructorStats`).
    *
    * That means:
    *
-   *   - nested classes are to be found in `defBuf`
+   *   - nested classes are to be found in `defs`
    *
-   *   - value and method definitions are also in `defBuf` and none of them contains local methods or classes.
+   *   - value and method definitions are also in `defs` and none of them contains local methods or classes.
    *
-   *   - auxiliary constructors are to be found in `auxConstructorBuf`
+   *   - auxiliary constructors are to be found in `auxConstructors`
    *
    * Coming back to the question which trees may contain accesses:
    *
@@ -148,70 +146,56 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
    * (the primary constructor) into a dedicated synthetic method that an anon-closure may invoke, as required by DelayedInit.
    *
    */
-  private trait OmittablesHelper { self: TemplateTransformer =>
-
-    /*
-     * Initially populated with all elision candidates.
-     * Trees are traversed, and those candidates are removed which are actually needed.
-     * After that, `omittables` doesn't shrink anymore: each symbol it contains can be unlinked from clazz.info.decls.
-     */
-    val omittables = mutable.Set.empty[Symbol]
-
-    def populateOmittables() {
-
-      omittables.clear()
-
-      if(isDelayedInitSubclass) {
-        return
-      }
+  private trait OmittablesHelper {
+    def computeOmittableAccessors(clazz: Symbol, defs: List[Tree], auxConstructors: List[Tree]): Set[Symbol] = {
+      val decls = clazz.info.decls.toSet
+      val isEffectivelyFinal = clazz.isEffectivelyFinal
 
+      // Initially populated with all elision candidates.
+      // Trees are traversed, and those candidates are removed which are actually needed.
+      // After that, `omittables` doesn't shrink anymore: each symbol it contains can be unlinked from clazz.info.decls.
+      //
       // Note: elision of outer reference is based on a class-wise analysis, if a class might have subclasses,
       //       it doesn't work. For example, `LocalParent` retains the outer reference in:
       //
       //   class Outer { def test = {class LocalParent; class LocalChild extends LocalParent } }
       //
       // See run/t9408.scala for related test cases.
-      val isEffectivelyFinal = clazz.isEffectivelyFinal
-      def isParamCandidateForElision(sym: Symbol) = (sym.isParamAccessor && sym.isPrivateLocal)
-      def isOuterCandidateForElision(sym: Symbol) = (sym.isOuterAccessor && isEffectivelyFinal && !sym.isOverridingSymbol)
-
-      val decls = clazz.info.decls.toSet
-      val paramCandidatesForElision: Set[ /*Field*/  Symbol] = (decls filter isParamCandidateForElision)
-      val outerCandidatesForElision: Set[ /*Method*/ Symbol] = (decls filter isOuterCandidateForElision)
-
-      omittables ++= paramCandidatesForElision
-      omittables ++= outerCandidatesForElision
-
-      val bodyOfOuterAccessor: Map[Symbol, DefDef] =
-        defBuf.collect { case dd: DefDef if outerCandidatesForElision(dd.symbol) => dd.symbol -> dd }.toMap
+      def omittableParamAcc(sym: Symbol) = sym.isParamAccessor && sym.isPrivateLocal
+      def omittableOuterAcc(sym: Symbol) = isEffectivelyFinal && sym.isOuterAccessor && !sym.isOverridingSymbol
+      val omittables = mutable.Set.empty[Symbol] ++ (decls filter (sym => omittableParamAcc(sym) || omittableOuterAcc(sym))) // the closure only captures isEffectivelyFinal
 
       // no point traversing further once omittables is empty, all candidates ruled out already.
       object detectUsages extends Traverser {
-        private def markUsage(sym: Symbol) {
-          omittables -= debuglogResult("omittables -= ")(sym)
-          // recursive call to mark as needed the field supporting the outer-accessor-method.
-          bodyOfOuterAccessor get sym foreach (this traverse _.rhs)
-        }
-        override def traverse(tree: Tree): Unit = if (omittables.nonEmpty) {
-          def sym = tree.symbol
-          tree match {
-            // don't mark as "needed" the field supporting this outer-accessor, ie not just yet.
-            case _: DefDef if outerCandidatesForElision(sym) => ()
-            case _: Select if omittables(sym)                => markUsage(sym) ; super.traverse(tree)
-            case _                                           => super.traverse(tree)
+        lazy val bodyOfOuterAccessor = defs.collect{ case dd: DefDef if omittableOuterAcc(dd.symbol) => dd.symbol -> dd.rhs }.toMap
+
+        override def traverse(tree: Tree): Unit =
+          if (omittables.nonEmpty) {
+            def sym = tree.symbol
+            tree match {
+              case _: DefDef if (sym.owner eq clazz) && omittableOuterAcc(sym) => // don't mark as "needed" the field supporting this outer-accessor (not just yet)
+              case _: Select if omittables(sym) => omittables -= sym // mark usage
+                bodyOfOuterAccessor get sym foreach traverse // recurse to mark as needed the field supporting the outer-accessor-method
+                super.traverse(tree)
+              case _ => super.traverse(tree)
+            }
           }
-        }
-        def walk(xs: Seq[Tree]) = xs.iterator foreach traverse
       }
-      if (omittables.nonEmpty) {
-        detectUsages walk defBuf
-        detectUsages walk auxConstructorBuf
-      }
-    }
-    def mustBeKept(sym: Symbol) = !omittables(sym)
 
+      if (omittables.nonEmpty)
+        (defs.iterator ++ auxConstructors.iterator) foreach detectUsages.traverse
+
+      omittables.toSet
+    }
   } // OmittablesHelper
 
+  trait ConstructorTransformerBase {
+    def unit: CompilationUnit
+    def impl: Template
+    def clazz: Symbol
+    def localTyper: analyzer.Typer
+  }
+
   /*
    *  TemplateTransformer rewrites DelayedInit subclasses.
    *  The list of statements that will end up in the primary constructor can be split into:
@@ -256,10 +240,8 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
    *  @return the DefDef for (c) above
    *
    * */
-  private trait DelayedInitHelper { self: TemplateTransformer =>
-
+  private trait DelayedInitHelper extends ConstructorTransformerBase {
     private def delayedEndpointDef(stats: List[Tree]): DefDef = {
-
       val methodName = currentUnit.freshTermName("delayedEndpoint$" + clazz.fullNameAsName('$').toString + "$")
       val methodSym  = clazz.newMethod(methodName, impl.pos, SYNTHETIC | FINAL)
       methodSym setInfoAndEnter MethodType(Nil, UnitTpe)
@@ -318,36 +300,30 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
       satelliteClass.asInstanceOf[ClassDef]
     }
 
-    private def delayedInitCall(closure: Tree) = localTyper.typedPos(impl.pos) {
-      gen.mkMethodCall(This(clazz), delayedInitMethod, Nil, List(New(closure.symbol.tpe, This(clazz))))
-    }
+    /** For a DelayedInit subclass, wrap remainingConstrStats into a DelayedInit closure. */
+    def delayedInitDefsAndConstrStats(defs: List[Tree], remainingConstrStats: List[Tree]): (List[Tree], List[Tree]) = {
+      val delayedHook     = delayedEndpointDef(remainingConstrStats)
+      val delayedHookSym  = delayedHook.symbol.asInstanceOf[MethodSymbol]
 
-    def rewriteDelayedInit() {
-      /* XXX This is not correct: remainingConstrStats.nonEmpty excludes too much,
-       * but excluding it includes too much.  The constructor sequence being mimicked
-       * needs to be reproduced with total fidelity.
-       *
-       * See test case files/run/bug4680.scala, the output of which is wrong in many
-       * particulars.
-       */
-      val needsDelayedInit = (isDelayedInitSubclass && remainingConstrStats.nonEmpty)
-
-      if (needsDelayedInit) {
-        val delayedHook: DefDef = delayedEndpointDef(remainingConstrStats)
-        defBuf += delayedHook
-        val hookCallerClass = {
-          // transform to make the closure-class' default constructor assign the the outer instance to its param-accessor field.
-          val drillDown = new ConstructorTransformer(unit)
-          drillDown transform delayedInitClosure(delayedHook.symbol.asInstanceOf[MethodSymbol])
-        }
-        defBuf += hookCallerClass
-        remainingConstrStats = delayedInitCall(hookCallerClass) :: Nil
+      // transform to make the closure-class' default constructor assign the the outer instance to its param-accessor field.
+      val hookCallerClass = (new ConstructorTransformer(unit)) transform delayedInitClosure(delayedHookSym)
+      val delayedInitCall = localTyper.typedPos(impl.pos) {
+        gen.mkMethodCall(This(clazz), delayedInitMethod, Nil, List(New(hookCallerClass.symbol.tpe, This(clazz))))
       }
+
+      (List(delayedHook, hookCallerClass), List(delayedInitCall))
     }
 
   } // DelayedInitHelper
 
-  private trait GuardianOfCtorStmts { self: TemplateTransformer =>
+  private trait GuardianOfCtorStmts extends ConstructorTransformerBase {
+    def primaryConstrParams: List[Symbol]
+    def usesSpecializedField: Boolean
+
+    lazy val hasSpecializedFieldsSym   = clazz.info.decl(nme.SPECIALIZED_INSTANCE)
+    // The constructor of a non-specialized class that has specialized subclasses
+    // should use `q"${hasSpecializedFieldsSym}()"` to guard the initialization of specialized fields.
+    lazy val guardSpecializedFieldInit = (hasSpecializedFieldsSym != NoSymbol) && !clazz.hasFlag(SPECIALIZED)
 
     /* Return a single list of statements, merging the generic class constructor with the
      * specialized stats. The original statements are retyped in the current class, and
@@ -355,7 +331,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
      * `specializedStats` are replaced by the specialized assignment.
      */
     private def mergeConstructors(genericClazz: Symbol, originalStats: List[Tree], specializedStats: List[Tree]): List[Tree] = {
-      val specBuf = new ListBuffer[Tree]
+      val specBuf = new mutable.ListBuffer[Tree]
       specBuf ++= specializedStats
 
       def specializedAssignFor(sym: Symbol): Option[Tree] =
@@ -383,7 +359,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
       }
 
       log("merging: " + originalStats.mkString("\n") + "\nwith\n" + specializedStats.mkString("\n"))
-      val res = for (s <- originalStats; stat = s.duplicate) yield {
+      for (s <- originalStats; stat = s.duplicate) yield {
         log("merge: looking at " + stat)
         val stat1 = stat match {
           case Assign(sel @ Select(This(_), field), _) =>
@@ -413,9 +389,8 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
         } else
           stat1
       }
-      if (specBuf.nonEmpty)
-        println("residual specialized constructor statements: " + specBuf)
-      res
+//      if (specBuf.nonEmpty)
+//        println("residual specialized constructor statements: " + specBuf)
     }
 
     /* Add an 'if' around the statements coming after the super constructor. This
@@ -435,7 +410,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
       //   postfix = postfix.tail
       // }
 
-      if (guardSpecializedFieldInit && intoConstructor.usesSpecializedField && stats.nonEmpty) {
+      if (guardSpecializedFieldInit && usesSpecializedField && stats.nonEmpty) {
         // save them for duplication in the specialized subclass
         guardedCtorStats(clazz) = stats
         ctorParams(clazz) = primaryConstrParams
@@ -472,24 +447,23 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
     with    OmittablesHelper
     with    GuardianOfCtorStmts {
 
-    val clazz = impl.symbol.owner  // the transformed class
-    val stats = impl.body          // the transformed template body
-    val localTyper = typer.atOwner(impl, clazz)
-
-    val hasSpecializedFieldsSym   = clazz.info.decl(nme.SPECIALIZED_INSTANCE)
-    // The constructor of a non-specialized class that has specialized subclasses
-    // should use `q"${hasSpecializedFieldsSym}()"` to guard the initialization of specialized fields.
-    val guardSpecializedFieldInit = (hasSpecializedFieldsSym != NoSymbol) && !clazz.hasFlag(SPECIALIZED)
+    val clazz         = impl.symbol.owner  // the transformed class
+    val localTyper    = typer.atOwner(impl, clazz)
 
     val isDelayedInitSubclass = clazz isSubClass DelayedInitClass
 
+    private val stats = impl.body          // the transformed template body
+
     // find and dissect primary constructor
-    val (primaryConstr, primaryConstrParams, primaryConstrBody) = stats collectFirst {
+    private val (primaryConstr, _primaryConstrParams, primaryConstrBody) = stats collectFirst {
       case dd@DefDef(_, _, _, vps :: Nil, _, rhs: Block) if dd.symbol.isPrimaryConstructor => (dd, vps map (_.symbol), rhs)
-    } getOrElse abort("no constructor in template: impl = " + impl)
+    } getOrElse {
+      abort("no constructor in template: impl = " + impl)
+    }
 
-    // The parameter accessor fields which are members of the class
-    val paramAccessors = clazz.constrParamAccessors
+
+    def primaryConstrParams  = _primaryConstrParams
+    def usesSpecializedField = intoConstructor.usesSpecializedField
 
     // The constructor parameter corresponding to an accessor
     def parameter(acc: Symbol): Symbol = parameterNamed(acc.unexpandedName.getterName)
@@ -564,15 +538,17 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
           super.transform(tree)
       }
 
-      // Move tree into constructor, take care of changing owner from `oldowner` to constructor symbol
-      def apply(oldowner: Symbol, tree: Tree) =
+      // Move tree into constructor, take care of changing owner from `oldOwner` to `newOwner` (the primary constructor symbol)
+      def apply(oldOwner: Symbol, newOwner: Symbol)(tree: Tree) =
         if (tree eq EmptyTree) tree
-        else transform(tree.changeOwner(oldowner -> primaryConstr.symbol))
+        else transform(tree.changeOwner(oldOwner -> newOwner))
     }
 
     // Create an assignment to class field `to` with rhs `from`
     def mkAssign(to: Symbol, from: Tree): Tree =
-      localTyper.typedPos(to.pos) { Assign(Select(This(clazz), to), from) }
+      localTyper.typedPos(to.pos) {
+        Assign(Select(This(clazz), to), from)
+      }
 
     // Create code to copy parameter to parameter accessor field.
     // If parameter is $outer, check that it is not null so that we NPE
@@ -582,73 +558,58 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
       val result = mkAssign(to, Ident(from))
 
       if (from.name != nme.OUTER ||
-          from.tpe.typeSymbol.isPrimitiveValueClass) result
+        from.tpe.typeSymbol.isPrimitiveValueClass) result
       else localTyper.typedPos(to.pos) {
         // `throw null` has the same effect as `throw new NullPointerException`, see JVM spec on instruction `athrow`
-        IF (from OBJ_EQ NULL) THEN Throw(gen.mkZero(ThrowableTpe)) ELSE result
+        IF(from OBJ_EQ NULL) THEN Throw(gen.mkZero(ThrowableTpe)) ELSE result
       }
     }
 
-    // The list of definitions that go into class
-    val defBuf = new ListBuffer[Tree]
-
-    // The auxiliary constructors, separate from the defBuf since they should
-    // follow the primary constructor
-    val auxConstructorBuf = new ListBuffer[Tree]
-
-    // The list of statements that go into the constructor after and including the superclass constructor call
-    val constrStatBuf = new ListBuffer[Tree]
-
-    // The list of early initializer statements that go into constructor before the superclass constructor call
-    val constrPrefixBuf = new ListBuffer[Tree]
+    // Constant typed vals are not memoized.
+    def memoizeValue(sym: Symbol) = !sym.info.isInstanceOf[ConstantType]
 
-    // The early initialized field definitions of the class (these are the class members)
-    val presupers = treeInfo.preSuperFields(stats)
+    /** Triage definitions and statements in this template into the following categories.
+      * The primary constructor is treated separately, as it is assembled in part from these pieces.
+      *
+      * - `defs`:           definitions that go into class
+      * - `auxConstrs`:     auxiliary constructors, separate from the defs as they should follow the primary constructor
+      * - `constrPrefix`:   early initializer statements that go into constructor before the superclass constructor call
+      * - `constrStats`:    statements that go into the constructor after and including the superclass constructor call
+      * - `classInitStats`: statements that go into the class initializer
+      */
+    def triageStats = {
+      val defBuf, auxConstructorBuf, constrPrefixBuf, constrStatBuf, classInitStatBuf = new mutable.ListBuffer[Tree]
 
-    // The list of statements that go into the class initializer
-    val classInitStatBuf = new ListBuffer[Tree]
+      // The early initialized field definitions of the class (these are the class members)
+      val presupers = treeInfo.preSuperFields(stats)
 
-    // generate code to copy pre-initialized fields
-    for (stat <- primaryConstrBody.stats) {
-      constrStatBuf += stat
-      stat match {
-        case ValDef(mods, name, _, _) if mods hasFlag PRESUPER =>
-          // stat is the constructor-local definition of the field value
-          val fields = presupers filter (_.getterName == name)
-          assert(fields.length == 1)
-          val to = fields.head.symbol
-          if (!to.tpe.isInstanceOf[ConstantType])
-            constrStatBuf += mkAssign(to, Ident(stat.symbol))
-        case _ =>
+      // generate code to copy pre-initialized fields
+      for (stat <- primaryConstrBody.stats) {
+        constrStatBuf += stat
+        stat match {
+          case ValDef(mods, name, _, _) if mods hasFlag PRESUPER =>
+            // stat is the constructor-local definition of the field value
+            val fields = presupers filter (_.getterName == name)
+            assert(fields.length == 1, s"expected exactly one field by name $name in $presupers of $clazz's early initializers")
+            val to = fields.head.symbol
+
+            if (memoizeValue(to)) constrStatBuf += mkAssign(to, Ident(stat.symbol))
+          case _ =>
+        }
       }
-    }
-
-
-    for (stat <- stats) {
-      val statSym = stat.symbol
-
-      stat match {
-        // recurse on class definition, store in defBuf
-        case _: ClassDef => defBuf += new ConstructorTransformer(unit).transform(stat)
-
-        // methods (except primary constructor) go into template
-        // (non-primary ctors --> auxConstructorBuf / regular defs --> defBuf)
-        case _: DefDef if statSym.isPrimaryConstructor => ()
-        case _: DefDef if statSym.isConstructor        => auxConstructorBuf += stat
-        case _: DefDef                                 => defBuf += stat
 
-        // val defs with constant right-hand sides are eliminated.
-        case _: ValDef if statSym.info.isInstanceOf[ConstantType] => ()
-
-        // For all other val defs, an empty valdef goes into the template.
-        // Additionally, non-lazy vals are initialized by an assignment in:
-        //   - the class initializer (static),
-        //   - the constructor, before the super call (early initialized or a parameter accessor),
-        //   - the constructor, after the super call (regular val).
-        case ValDef(mods, _, _, rhs) =>
+      for (stat <- stats) {
+        val statSym = stat.symbol
+
+        // Move the RHS of a ValDef to the appropriate part of the ctor.
+        // If the val is an early initialized or a parameter accessor,
+        // it goes before the superclass constructor call, otherwise it goes after.
+        // A lazy val's effect is not moved to the constructor, as it is delayed.
+        // Returns `true` when a `ValDef` is needed.
+        def moveEffectToCtor(mods: Modifiers, rhs: Tree, assignSym: Symbol): Unit = {
           val initializingRhs =
-            if (statSym.isLazy) EmptyTree
-            else if (!mods.hasStaticFlag) intoConstructor(statSym, rhs)
+            if ((assignSym eq NoSymbol) || statSym.isLazy) EmptyTree // not memoized, or effect delayed (for lazy val)
+            else if (!mods.hasStaticFlag) intoConstructor(statSym, primaryConstr.symbol)(rhs)
             else rhs
 
           if (initializingRhs ne EmptyTree) {
@@ -657,68 +618,120 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL {
               else if (mods hasFlag PRESUPER | PARAMACCESSOR) constrPrefixBuf
               else constrStatBuf
 
-            initPhase += mkAssign(statSym, initializingRhs)
+            initPhase += mkAssign(assignSym, initializingRhs)
           }
+        }
 
-          defBuf += deriveValDef(stat)(_ => EmptyTree)
-
-        // all other statements go into the constructor
-        case _ => constrStatBuf += intoConstructor(impl.symbol, stat)
+        stat match {
+          // recurse on class definition, store in defBuf
+          case _: ClassDef => defBuf += new ConstructorTransformer(unit).transform(stat)
+
+          // Triage methods -- they all end up in the template --
+          // regular ones go to `defBuf`, secondary contructors go to `auxConstructorBuf`.
+          // The primary constructor is dealt with separately (we're massaging it here).
+          case _: DefDef if statSym.isPrimaryConstructor => ()
+          case _: DefDef if statSym.isConstructor => auxConstructorBuf += stat
+          case _: DefDef => defBuf += stat
+
+          // If a val needs a field, an empty valdef goes into the template.
+          // Except for lazy and ConstantTyped vals, the field is initialized by an assignment in:
+          //   - the class initializer (static),
+          //   - the constructor, before the super call (early initialized or a parameter accessor),
+          //   - the constructor, after the super call (regular val).
+          case ValDef(mods, _, _, rhs) =>
+            if (rhs ne EmptyTree) {
+              val emitField = memoizeValue(statSym)
+              moveEffectToCtor(mods, rhs, if (emitField) statSym else NoSymbol)
+              if (emitField) defBuf += deriveValDef(stat)(_ => EmptyTree)
+            } else defBuf += stat
+
+          // all other statements go into the constructor
+          case _ => constrStatBuf += intoConstructor(impl.symbol, primaryConstr.symbol)(stat)
+        }
       }
-    }
-
-    populateOmittables()
-
-    // Initialize all parameters fields that must be kept.
-    val paramInits = paramAccessors filter mustBeKept map { acc =>
-      // Check for conflicting symbol amongst parents: see bug #1960.
-      // It would be better to mangle the constructor parameter name since
-      // it can only be used internally, but I think we need more robust name
-      // mangling before we introduce more of it.
-      val conflict = clazz.info.nonPrivateMember(acc.name) filter (s => s.isGetter && !s.isOuterField && s.enclClass.isTrait)
-      if (conflict ne NoSymbol)
-        reporter.error(acc.pos, "parameter '%s' requires field but conflicts with %s".format(acc.name, conflict.fullLocationString))
 
-      copyParam(acc, parameter(acc))
+      (defBuf.toList, auxConstructorBuf.toList, constrPrefixBuf.toList, constrStatBuf.toList, classInitStatBuf.toList)
     }
 
-    /* Return a pair consisting of (all statements up to and including superclass and trait constr calls, rest) */
-    def splitAtSuper(stats: List[Tree]) = {
-      def isConstr(tree: Tree): Boolean = tree match {
-        case Block(_, expr) => isConstr(expr)  // SI-6481 account for named argument blocks
-        case _              => (tree.symbol ne null) && tree.symbol.isConstructor
+    def transformed = {
+      val (defs, auxConstructors, constructorPrefix, constructorStats, classInitStats) = triageStats
+
+      // omit unused outers
+      val omittableAccessor: Set[Symbol] =
+        if (isDelayedInitSubclass) Set.empty
+        else computeOmittableAccessors(clazz, defs, auxConstructors)
+
+      // TODO: this should omit fields for non-memoized (constant-typed, unit-typed vals need no storage --
+      // all the action is in the getter)
+      def omittableSym(sym: Symbol) = omittableAccessor(sym)
+      def omittableStat(stat: Tree) = omittableSym(stat.symbol)
+
+      // The parameter accessor fields which are members of the class
+      val paramAccessors = clazz.constrParamAccessors
+
+      // Initialize all parameters fields that must be kept.
+      val paramInits = paramAccessors filterNot omittableSym map { acc =>
+        // Check for conflicting symbol amongst parents: see bug #1960.
+        // It would be better to mangle the constructor parameter name since
+        // it can only be used internally, but I think we need more robust name
+        // mangling before we introduce more of it.
+        val conflict = clazz.info.nonPrivateMember(acc.name) filter (s => s.isGetter && !s.isOuterField && s.enclClass.isTrait)
+        if (conflict ne NoSymbol)
+          reporter.error(acc.pos, "parameter '%s' requires field but conflicts with %s".format(acc.name, conflict.fullLocationString))
+
+        copyParam(acc, parameter(acc))
       }
-      val (pre, rest0) = stats span (!isConstr(_))
-      val (supercalls, rest) = rest0 span (isConstr(_))
-      (pre ::: supercalls, rest)
-    }
-
-    val (uptoSuperStats, remainingConstrStats0) = splitAtSuper(constrStatBuf.toList)
-    var remainingConstrStats = remainingConstrStats0
-
-    rewriteDelayedInit()
-
-    // Assemble final constructor
-    defBuf += deriveDefDef(primaryConstr)(_ =>
-      treeCopy.Block(
-        primaryConstrBody,
-        paramInits ::: constrPrefixBuf.toList ::: uptoSuperStats :::
-          guardSpecializedInitializer(remainingConstrStats),
-        primaryConstrBody.expr))
 
-    // Followed by any auxiliary constructors
-    defBuf ++= auxConstructorBuf
-
-    // Unlink all fields that can be dropped from class scope
-    for (sym <- clazz.info.decls ; if !mustBeKept(sym))
-      clazz.info.decls unlink sym
-
-    // Eliminate all field definitions that can be dropped from template
-    val templateWithoutOmittables: Template = deriveTemplate(impl)(_ => defBuf.toList filter (stat => mustBeKept(stat.symbol)))
+      // Return a pair consisting of (all statements up to and including superclass and trait constr calls, rest)
+      def splitAtSuper(stats: List[Tree]) = {
+        def isConstr(tree: Tree): Boolean = tree match {
+          case Block(_, expr) => isConstr(expr) // SI-6481 account for named argument blocks
+          case _              => (tree.symbol ne null) && tree.symbol.isConstructor
+        }
+        val (pre, rest0)       = stats span (!isConstr(_))
+        val (supercalls, rest) = rest0 span (isConstr(_))
+        (pre ::: supercalls, rest)
+      }
 
-    //  Add the static initializers
-    val transformed: Template = addStaticInits(templateWithoutOmittables, classInitStatBuf, localTyper)
+      val (uptoSuperStats, remainingConstrStats) = splitAtSuper(constructorStats)
 
+      /* TODO: XXX This condition (`isDelayedInitSubclass && remainingConstrStats.nonEmpty`) is not correct:
+      * remainingConstrStats.nonEmpty excludes too much,
+      * but excluding it includes too much.  The constructor sequence being mimicked
+      * needs to be reproduced with total fidelity.
+      *
+      * See test case files/run/bug4680.scala, the output of which is wrong in many
+      * particulars.
+      */
+      val (delayedHookDefs, remainingConstrStatsDelayedInit) =
+        if (isDelayedInitSubclass && remainingConstrStats.nonEmpty) delayedInitDefsAndConstrStats(defs, remainingConstrStats)
+        else (Nil, remainingConstrStats)
+
+      // Assemble final constructor
+      val primaryConstructor = deriveDefDef(primaryConstr)(_ => {
+        treeCopy.Block(
+          primaryConstrBody,
+          paramInits ::: constructorPrefix ::: uptoSuperStats ::: guardSpecializedInitializer(remainingConstrStatsDelayedInit),
+          primaryConstrBody.expr)
+      })
+
+      val constructors = primaryConstructor :: auxConstructors
+
+      // Unlink all fields that can be dropped from class scope
+      // Iterating on toList is cheaper (decls.filter does a toList anyway)
+      val decls = clazz.info.decls
+      decls.toList.filter(omittableSym).foreach(decls.unlink)
+
+      // Eliminate all field/accessor definitions that can be dropped from template
+      // We never eliminate delayed hooks or the constructors, so, only filter `defs`.
+      val prunedStats = (defs filterNot omittableStat) ::: delayedHookDefs ::: constructors
+
+      //  Add the static initializers
+      if (classInitStats.isEmpty) deriveTemplate(impl)(_ => prunedStats)
+      else {
+        val staticCtor = staticConstructor(prunedStats, localTyper, impl.pos)(classInitStats)
+        deriveTemplate(impl)(_ => staticCtor :: prunedStats)
+      }
+    }
   } // TemplateTransformer
-
 }
diff --git a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
index 33fd5d0461..f15d05f7df 100644
--- a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
+++ b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
@@ -4,8 +4,6 @@ package transform
 import symtab._
 import Flags._
 import scala.collection._
-import scala.language.postfixOps
-import scala.reflect.internal.Symbols
 import scala.collection.mutable.LinkedHashMap
 
 /**
@@ -294,6 +292,7 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
         val name = unit.freshTypeName(s"$oldClassPart$suffix".replace("$anon", "$nestedInAnon"))
 
         val lambdaClass = pkg newClassSymbol(name, originalFunction.pos, FINAL | SYNTHETIC) addAnnotation SerialVersionUIDAnnotation
+        lambdaClass.associatedFile = unit.source.file
         // make sure currentRun.compiles(lambdaClass) is true (AddInterfaces does the same for trait impl classes)
         currentRun.symSource(lambdaClass) = funOwner.sourceFile
         lambdaClass setInfo ClassInfoType(parents, newScope, lambdaClass)
diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala
index 747d20a441..266a422c53 100644
--- a/src/compiler/scala/tools/nsc/transform/Erasure.scala
+++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala
@@ -253,7 +253,7 @@ abstract class Erasure extends AddInterfaces
     // Anything which could conceivably be a module (i.e. isn't known to be
     // a type parameter or similar) must go through here or the signature is
     // likely to end up with Foo<T>.Empty where it needs Foo<T>.Empty$.
-    def fullNameInSig(sym: Symbol) = "L" + enteringIcode(sym.javaBinaryName)
+    def fullNameInSig(sym: Symbol) = "L" + enteringJVM(sym.javaBinaryName)
 
     def jsig(tp0: Type, existentiallyBound: List[Symbol] = Nil, toplevel: Boolean = false, primitiveOK: Boolean = true): String = {
       val tp = tp0.dealias
diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
index f12f6c4e18..1a0b4cdec0 100644
--- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
@@ -9,9 +9,7 @@ package transform
 
 import symtab._
 import Flags.{ CASE => _, _ }
-import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
-import scala.tools.nsc.settings.ScalaVersion
 
 /** This class ...
  *
@@ -159,19 +157,24 @@ abstract class ExplicitOuter extends InfoTransform
    *  elides outer pointers.
    */
   def transformInfo(sym: Symbol, tp: Type): Type = tp match {
-    case MethodType(params, restpe1) =>
-      val restpe = transformInfo(sym, restpe1)
-      if (sym.owner.isTrait && ((sym hasFlag (ACCESSOR | SUPERACCESSOR)) || sym.isModule)) { // 5
-        sym.makeNotPrivate(sym.owner)
+    case MethodType(params, resTp) =>
+      val resTpTransformed = transformInfo(sym, resTp)
+
+      // juggle flags (and mangle names) after transforming info
+      if (sym.owner.isTrait) {
+        // TODO: I don't believe any private accessors remain after the fields phase
+        if ((sym hasFlag (ACCESSOR | SUPERACCESSOR)) || sym.isModule) sym.makeNotPrivate(sym.owner) // 5
+        if (sym.isProtected) sym setFlag notPROTECTED // 6
       }
-      if (sym.owner.isTrait && sym.isProtected) sym setFlag notPROTECTED // 6
-      if (sym.isClassConstructor && isInner(sym.owner)) { // 1
-        val p = sym.newValueParameter(innerClassConstructorParamName, sym.pos)
-                   .setInfo(sym.owner.outerClass.thisType)
-        MethodType(p :: params, restpe)
-      } else if (restpe ne restpe1)
-        MethodType(params, restpe)
+
+      val paramsWithOuter =
+        if (sym.isClassConstructor && isInner(sym.owner)) // 1
+          sym.newValueParameter(innerClassConstructorParamName, sym.pos).setInfo(sym.owner.outerClass.thisType) :: params
+        else params
+
+      if ((resTpTransformed ne resTp) || (paramsWithOuter ne params)) MethodType(paramsWithOuter, resTpTransformed)
       else tp
+
     case ClassInfoType(parents, decls, clazz) =>
       var decls1 = decls
       if (isInner(clazz) && !clazz.isInterface) {
diff --git a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
index 6349fc3fb9..d83cf68b38 100644
--- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
@@ -7,7 +7,7 @@ package transform
 
 import symtab._
 import Flags._
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 
 /**
  * Perform Step 1 in the inline classes SIP: Creates extension methods for all
diff --git a/src/compiler/scala/tools/nsc/transform/InlineErasure.scala b/src/compiler/scala/tools/nsc/transform/InlineErasure.scala
deleted file mode 100644
index 1bbe1b8410..0000000000
--- a/src/compiler/scala/tools/nsc/transform/InlineErasure.scala
+++ /dev/null
@@ -1,11 +0,0 @@
-package scala.tools.nsc
-package transform
-
-trait InlineErasure {
-  self: Erasure =>
-
-/*
-  import global._
-  import definitions._
- */
-}
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index 43f698d7ba..f6e2dd68f0 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -8,7 +8,7 @@ package transform
 
 import symtab._
 import Flags._
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import scala.collection.mutable.{ LinkedHashMap, LinkedHashSet, TreeSet }
 
 abstract class LambdaLift extends InfoTransform {
@@ -143,7 +143,7 @@ abstract class LambdaLift extends InfoTransform {
      *  }
      */
     private def markFree(sym: Symbol, enclosure: Symbol): Boolean = {
-      debuglog("mark free: " + sym.fullLocationString + " marked free in " + enclosure)
+//      println(s"mark free: ${sym.fullLocationString} marked free in $enclosure")
       (enclosure == sym.owner.logicallyEnclosingMember) || {
         debuglog("%s != %s".format(enclosure, sym.owner.logicallyEnclosingMember))
         if (enclosure.isPackageClass || !markFree(sym, enclosure.skipConstructor.owner.logicallyEnclosingMember)) false
@@ -153,7 +153,7 @@ abstract class LambdaLift extends InfoTransform {
             ss += sym
             renamable += sym
             changedFreeVars = true
-            debuglog("" + sym + " is free in " + enclosure)
+            debuglog(s"$sym is free in $enclosure")
             if (sym.isVariable) sym setFlag CAPTURED
           }
           !enclosure.isClass
@@ -162,7 +162,7 @@ abstract class LambdaLift extends InfoTransform {
     }
 
     private def markCalled(sym: Symbol, owner: Symbol) {
-      debuglog("mark called: " + sym + " of " + sym.owner + " is called by " + owner)
+//      println(s"mark called: $sym of ${sym.owner} is called by $owner")
       symSet(called, owner) += sym
       if (sym.enclClass != owner.enclClass) calledFromInner += sym
     }
@@ -170,7 +170,7 @@ abstract class LambdaLift extends InfoTransform {
     /** The traverse function */
     private val freeVarTraverser = new Traverser {
       override def traverse(tree: Tree) {
-       try { //debug
+//       try { //debug
         val sym = tree.symbol
         tree match {
           case ClassDef(_, _, _, _) =>
@@ -217,11 +217,11 @@ abstract class LambdaLift extends InfoTransform {
           case _ =>
         }
         super.traverse(tree)
-       } catch {//debug
-         case ex: Throwable =>
-           Console.println(s"$ex while traversing $tree")
-           throw ex
-       }
+//       } catch {//debug
+//         case ex: Throwable =>
+//           Console.println(s"$ex while traversing $tree")
+//           throw ex
+//       }
       }
     }
 
@@ -235,7 +235,7 @@ abstract class LambdaLift extends InfoTransform {
 
       do {
         changedFreeVars = false
-        for (caller <- called.keys ; callee <- called(caller) ; fvs <- free get callee ; fv <- fvs)
+        for ((caller, callees) <- called ; callee <- callees ; fvs <- free get callee ; fv <- fvs)
           markFree(fv, caller)
       } while (changedFreeVars)
 
@@ -303,11 +303,14 @@ abstract class LambdaLift extends InfoTransform {
 
       afterOwnPhase {
         for ((owner, freeValues) <- free.toList) {
-          val newFlags = SYNTHETIC | ( if (owner.isClass) PARAMACCESSOR | PrivateLocal else PARAM )
-          debuglog("free var proxy: %s, %s".format(owner.fullLocationString, freeValues.toList.mkString(", ")))
+          val newFlags = SYNTHETIC | (
+            if (owner.isClass) PARAMACCESSOR | PrivateLocal
+            else PARAM)
+
           proxies(owner) =
             for (fv <- freeValues.toList) yield {
               val proxyName = proxyNames.getOrElse(fv, fv.name)
+              debuglog(s"new proxy ${proxyName} in ${owner.fullLocationString}")
               val proxy = owner.newValue(proxyName.toTermName, owner.pos, newFlags.toLong) setInfo fv.info
               if (owner.isClass) owner.info.decls enter proxy
               proxy
@@ -337,31 +340,31 @@ abstract class LambdaLift extends InfoTransform {
 
     private def memberRef(sym: Symbol): Tree = {
       val clazz = sym.owner.enclClass
-      //Console.println("memberRef from "+currentClass+" to "+sym+" in "+clazz)
-      def prematureSelfReference() {
+      // println(s"memberRef from $currentClass to $sym in $clazz (currentClass=$currentClass)")
+      def prematureSelfReference(): Tree = {
         val what =
           if (clazz.isStaticOwner) clazz.fullLocationString
           else s"the unconstructed `this` of ${clazz.fullLocationString}"
         val msg = s"Implementation restriction: access of ${sym.fullLocationString} from ${currentClass.fullLocationString}, would require illegal premature access to $what"
         reporter.error(curTree.pos, msg)
+        EmptyTree
       }
-      val qual =
+      def qual =
         if (clazz == currentClass) gen.mkAttributedThis(clazz)
         else {
           sym resetFlag (LOCAL | PRIVATE)
-          if (isUnderConstruction(clazz)) {
-            prematureSelfReference()
-            EmptyTree
-          }
+          if (isUnderConstruction(clazz)) prematureSelfReference()
           else if (clazz.isStaticOwner) gen.mkAttributedQualifier(clazz.thisType)
-          else {
-            outerValue match {
-              case EmptyTree => prematureSelfReference(); return EmptyTree
-              case o         => outerPath(o, currentClass.outerClass, clazz)
-            }
+          else outerValue match {
+            case EmptyTree => prematureSelfReference()
+            case o         => outerPath(o, currentClass.outerClass, clazz)
           }
         }
-      Select(qual, sym) setType sym.tpe
+
+      qual match {
+        case EmptyTree => EmptyTree
+        case qual      => Select(qual, sym) setType sym.tpe
+      }
     }
 
     private def proxyRef(sym: Symbol) = {
@@ -369,41 +372,45 @@ abstract class LambdaLift extends InfoTransform {
       if (psym.isLocalToBlock) gen.mkAttributedIdent(psym) else memberRef(psym)
     }
 
-    private def addFreeArgs(pos: Position, sym: Symbol, args: List[Tree]) = {
-      free get sym match {
-        case Some(fvs) => addFree(sym, free = fvs.toList map (fv => atPos(pos)(proxyRef(fv))), original = args)
-        case _         => args
+    def freeArgsOrNil(sym: Symbol) = free.getOrElse(sym, Nil).toList
+
+    private def freeArgs(sym: Symbol): List[Symbol] =
+      freeArgsOrNil(sym)
+
+    private def addFreeArgs(pos: Position, sym: Symbol, args: List[Tree]) =
+      freeArgs(sym) match {
+        case Nil => args
+        case fvs => addFree(sym, free = fvs map (fv => atPos(pos)(proxyRef(fv))), original = args)
       }
-    }
 
-    private def addFreeParams(tree: Tree, sym: Symbol): Tree = proxies.get(sym) match {
-      case Some(ps) =>
-        val freeParams = ps map (p => ValDef(p) setPos tree.pos setType NoType)
-        tree match {
-          case DefDef(_, _, _, vparams :: _, _, _) =>
-            val addParams = cloneSymbols(ps).map(_.setFlag(PARAM))
-            sym.updateInfo(
-              lifted(MethodType(addFree(sym, free = addParams, original = sym.info.params), sym.info.resultType)))
+    def proxiesOrNil(sym: Symbol) = proxies.getOrElse(sym, Nil)
+
+    private def freeParams(sym: Symbol): List[Symbol] =
+      proxiesOrNil(sym)
+
+    private def addFreeParams(tree: Tree, sym: Symbol): Tree =
+      tree match {
+        case DefDef(_, _, _, vparams :: _, _, _) =>
+          val ps = freeParams(sym)
+
+          if (ps.isEmpty) tree
+          else {
+            val paramSyms = cloneSymbols(ps).map(_.setFlag(PARAM))
+            val paramDefs = ps map (p => ValDef(p) setPos tree.pos setType NoType)
+
+            sym.updateInfo(lifted(MethodType(addFree(sym, free = paramSyms, original = sym.info.params), sym.info.resultType)))
+            copyDefDef(tree)(vparamss = List(addFree(sym, free = paramDefs, original = vparams)))
+          }
+
+        case ClassDef(_, _, _, _) =>
+          val freeParamDefs = freeParams(sym) map (p => ValDef(p) setPos tree.pos setType NoType)
+
+          if (freeParamDefs.isEmpty) tree
+          else deriveClassDef(tree)(impl => deriveTemplate(impl)(_ ::: freeParamDefs))
+
+        case _ => tree
+      }
 
-            copyDefDef(tree)(vparamss = List(addFree(sym, free = freeParams, original = vparams)))
-          case ClassDef(_, _, _, _) =>
-            // SI-6231
-            // Disabled attempt to to add getters to freeParams
-            // this does not work yet. Problem is that local symbols need local names
-            // and references to local symbols need to be transformed into
-            // method calls to setters.
-            // def paramGetter(param: Symbol): Tree = {
-            //   val getter = param.newGetter setFlag TRANS_FLAG resetFlag PARAMACCESSOR // mark because we have to add them to interface
-            //   sym.info.decls.enter(getter)
-            //   val rhs = Select(gen.mkAttributedThis(sym), param) setType param.tpe
-            //   DefDef(getter, rhs) setPos tree.pos setType NoType
-            // }
-            // val newDefs = if (sym.isTrait) freeParams ::: (ps map paramGetter) else freeParams
-            deriveClassDef(tree)(impl => deriveTemplate(impl)(_ ::: freeParams))
-        }
-      case None =>
-        tree
-    }
 
 /*  SI-6231: Something like this will be necessary to eliminate the implementation
  *  restriction from paramGetter above:
@@ -446,7 +453,7 @@ abstract class LambdaLift extends InfoTransform {
            // See neg/t1909-object.scala
            def msg = s"SI-1909 Unable to STATICally lift $sym, which is defined in the self- or super-constructor call of ${sym.owner.owner}. A VerifyError is likely."
            devWarning(tree.pos, msg)
-          } else sym setFlag STATIC
+         } else sym setFlag STATIC
       }
 
       sym.owner = sym.owner.enclClass
@@ -463,12 +470,11 @@ abstract class LambdaLift extends InfoTransform {
     private def postTransform(tree: Tree, isBoxedRef: Boolean = false): Tree = {
       val sym = tree.symbol
       tree match {
-        case ClassDef(_, _, _, _) =>
-          val tree1 = addFreeParams(tree, sym)
-          if (sym.isLocalToBlock) liftDef(tree1) else tree1
-        case DefDef(_, _, _, _, _, _) =>
-          val tree1 = addFreeParams(tree, sym)
-          if (sym.isLocalToBlock) liftDef(tree1) else tree1
+        case _: ClassDef | _: DefDef =>
+          val withFreeParams = addFreeParams(tree, sym)
+          if (sym.isLocalToBlock) liftDef(withFreeParams)
+          else withFreeParams
+
         case ValDef(mods, name, tpt, rhs) =>
           if (sym.isCapturedVariable) {
             val tpt1 = TypeTree(sym.tpe) setPos tpt.pos
diff --git a/src/compiler/scala/tools/nsc/transform/LazyVals.scala b/src/compiler/scala/tools/nsc/transform/LazyVals.scala
index b6695efb0b..8a0086dbdd 100644
--- a/src/compiler/scala/tools/nsc/transform/LazyVals.scala
+++ b/src/compiler/scala/tools/nsc/transform/LazyVals.scala
@@ -1,14 +1,14 @@
 package scala.tools.nsc
 package transform
 
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 
 abstract class LazyVals extends Transform with TypingTransformers with ast.TreeDSL {
   // inherits abstract value `global` and class `Phase` from Transform
 
   import global._                  // the global environment
   import definitions._             // standard classes and methods
-  import typer.{typed, atOwner}    // methods to type trees
+  import typer.typed               // methods to type trees
   import CODE._
 
   val phaseName: String = "lazyvals"
@@ -38,6 +38,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
 
           case ClassDef(_, _, _, _) | DefDef(_, _, _, _, _, _) | ModuleDef(_, _, _) =>
 
+          // Avoid adding bitmaps when they are fully overshadowed by those that are added inside loops
           case LabelDef(name, _, _) if nme.isLoopHeaderLabel(name) =>
 
           case _ =>
@@ -54,9 +55,28 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
     private val lazyVals = perRunCaches.newMap[Symbol, Int]() withDefaultValue 0
 
     import symtab.Flags._
+    private def flattenThickets(stats: List[Tree]): List[Tree] = stats.flatMap(_ match {
+      case b @ Block(List(d1@DefDef(_, n1, _, _, _, _)), d2@DefDef(_, n2, _, _, _, _)) if b.tpe == null && n1.endsWith(nme.LAZY_SLOW_SUFFIX) =>
+        List(d1, d2)
+      case stat =>
+        List(stat)
+    })
 
     /** Perform the following transformations:
      *  - for a lazy accessor inside a method, make it check the initialization bitmap
+     *  - implement double checked locking of member modules for non-trait owners (trait just have the abstract accessor)
+     *     ```
+     *     // typer
+     *     class C { object x }
+     *     // refchecks
+     *     class C { var x$module; def x() = { x$module = new x; x$module }
+     *     // lazyvals
+     *     class C {
+     *       var x$module                                                                               // module var
+     *       def x() = { if (x$module == null) x$lzycompute() else x$module                             // fast path
+     *       def x$lzycompute() = { synchronized { if (x$module == null) x$module = new x }; x$module } // slow path
+     *     }
+     *     ```
      *  - for all methods, add enough int vars to allow one flag per lazy local value
      *  - blocks in template bodies behave almost like methods. A single bitmaps section is
      *      added in the first block, for all lazy values defined in such blocks.
@@ -72,20 +92,14 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
         case Block(_, _) =>
           val block1 = super.transform(tree)
           val Block(stats, expr) = block1
-          val stats1 = stats.flatMap(_ match {
-            case Block(List(d1@DefDef(_, n1, _, _, _, _)), d2@DefDef(_, n2, _, _, _, _)) if (nme.newLazyValSlowComputeName(n2) == n1) =>
-              List(d1, d2)
-            case stat =>
-              List(stat)
-          })
-          treeCopy.Block(block1, stats1, expr)
+          treeCopy.Block(block1, flattenThickets(stats), expr)
 
         case DefDef(_, _, _, _, _, rhs) => atOwner(tree.symbol) {
           val (res, slowPathDef) = if (!sym.owner.isClass && sym.isLazy) {
             val enclosingClassOrDummyOrMethod = {
               val enclMethod = sym.enclMethod
 
-              if (enclMethod != NoSymbol ) {
+              if (enclMethod != NoSymbol) {
                 val enclClass = sym.enclClass
                 if (enclClass != NoSymbol && enclMethod == enclClass.enclMethod)
                   enclClass
@@ -100,30 +114,39 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
             val (rhs1, sDef) = mkLazyDef(enclosingClassOrDummyOrMethod, transform(rhs), idx, sym)
             sym.resetFlag((if (lazyUnit(sym)) 0 else LAZY) | ACCESSOR)
             (rhs1, sDef)
-          } else
+          } else if (sym.hasAllFlags(MODULE | METHOD) && !sym.owner.isTrait) {
+            rhs match {
+              case b @ Block((assign @ Assign(moduleRef, _)) :: Nil, expr) =>
+                def cond = Apply(Select(moduleRef, Object_eq), List(Literal(Constant(null))))
+                val (fastPath, slowPath) = mkFastPathBody(sym.owner.enclClass, moduleRef.symbol, cond, transform(assign) :: Nil, Nil, transform(expr))
+                (localTyper.typedPos(tree.pos)(fastPath), localTyper.typedPos(tree.pos)(slowPath))
+              case rhs =>
+                global.reporter.error(tree.pos, "Unexpected tree on the RHS of a module accessor: " + rhs)
+                (rhs, EmptyTree)
+            }
+          } else {
             (transform(rhs), EmptyTree)
+          }
 
           val ddef1 = deriveDefDef(tree)(_ => if (LocalLazyValFinder.find(res)) typed(addBitmapDefs(sym, res)) else res)
-          if (slowPathDef != EmptyTree) Block(slowPathDef, ddef1) else ddef1
+          if (slowPathDef != EmptyTree) {
+            // The contents of this block are flattened into the enclosing statement sequence, see flattenThickets
+            // This is a poor man's version of dotty's Thicket: https://github.com/lampepfl/dotty/blob/d5280358d1/src/dotty/tools/dotc/ast/Trees.scala#L707
+            Block(slowPathDef, ddef1)
+          } else ddef1
         }
 
         case Template(_, _, body) => atOwner(currentOwner) {
-          val body1 = super.transformTrees(body)
+          // TODO: shady business... can this logic be encapsulated in LocalLazyValFinder?
           var added = false
-          val stats =
-            for (stat <- body1) yield stat match {
-              case Block(_, _) | Apply(_, _) | If(_, _, _) | Try(_, _, _) if !added =>
-                // Avoid adding bitmaps when they are fully overshadowed by those
-                // that are added inside loops
-                if (LocalLazyValFinder.find(stat)) {
-                  added = true
-                  typed(addBitmapDefs(sym, stat))
-                } else stat
-              case ValDef(_, _, _, _) =>
-                typed(deriveValDef(stat)(addBitmapDefs(stat.symbol, _)))
-              case _ =>
-                stat
+          val stats = super.transformTrees(body) mapConserve {
+              case stat: ValDef => typed(deriveValDef(stat)(addBitmapDefs(stat.symbol, _)))
+              case stat: TermTree if !added && (LocalLazyValFinder find stat) =>
+                added = true
+                typed(addBitmapDefs(sym, stat))
+              case stat => stat
             }
+
           val innerClassBitmaps = if (!added && currentOwner.isClass && bitmaps.contains(currentOwner)) {
               // add bitmap to inner class if necessary
                 val toAdd0 = bitmaps(currentOwner).map(s => typed(ValDef(s, ZERO)))
@@ -135,7 +158,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
                 })
                 toAdd0
             } else List()
-          deriveTemplate(tree)(_ => innerClassBitmaps ++ stats)
+          deriveTemplate(tree)(_ => innerClassBitmaps ++ flattenThickets(stats))
         }
 
         case ValDef(_, _, _, _) if !sym.owner.isModule && !sym.owner.isClass =>
@@ -206,7 +229,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
     }
 
 
-    def mkFastPathBody(clazz: Symbol, lzyVal: Symbol, cond: Tree, syncBody: List[Tree],
+    def mkFastPathBody(clazz: Symbol, lzyVal: Symbol, cond: => Tree, syncBody: List[Tree],
                        stats: List[Tree], retVal: Tree): (Tree, Tree) = {
       val slowPathDef: Tree = mkSlowPathDef(clazz, lzyVal, cond, syncBody, stats, retVal)
       (If(cond, Apply(Ident(slowPathDef.symbol), Nil), retVal), slowPathDef)
@@ -261,7 +284,7 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD
           (mkBlock(rhs),         UNIT)
       }
 
-      val cond = (bitmapRef GEN_& (mask, bitmapKind)) GEN_== (ZERO, bitmapKind)
+      def cond = (bitmapRef GEN_& (mask, bitmapKind)) GEN_== (ZERO, bitmapKind)
       val lazyDefs = mkFastPathBody(methOrClass.enclClass, lazyVal, cond, List(block), Nil, res)
       (atPos(tree.pos)(localTyper.typed {lazyDefs._1 }), atPos(tree.pos)(localTyper.typed {lazyDefs._2 }))
     }
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index 00a994fe87..d13e11e9ec 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -8,7 +8,7 @@ package transform
 
 import symtab._
 import Flags._
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 
 abstract class Mixin extends InfoTransform with ast.TreeDSL {
   import global._
@@ -784,12 +784,12 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
         defSym
       }
 
-      def mkFastPathLazyBody(clazz: Symbol, lzyVal: Symbol, cond: Tree, syncBody: List[Tree],
+      def mkFastPathLazyBody(clazz: Symbol, lzyVal: Symbol, cond: => Tree, syncBody: List[Tree],
                              stats: List[Tree], retVal: Tree): Tree = {
         mkFastPathBody(clazz, lzyVal, cond, syncBody, stats, retVal, gen.mkAttributedThis(clazz), List())
       }
 
-      def mkFastPathBody(clazz: Symbol, lzyVal: Symbol, cond: Tree, syncBody: List[Tree],
+      def mkFastPathBody(clazz: Symbol, lzyVal: Symbol, cond: => Tree, syncBody: List[Tree],
                         stats: List[Tree], retVal: Tree, attrThis: Tree, args: List[Tree]): Tree = {
         val slowPathSym: Symbol = mkSlowPathDef(clazz, lzyVal, cond, syncBody, stats, retVal, attrThis, args)
         If(cond, fn (This(clazz), slowPathSym, args.map(arg => Ident(arg.symbol)): _*), retVal)
@@ -861,16 +861,6 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
         typedPos(init.head.pos)(mkFastPathLazyBody(clazz, lzyVal, cond, syncBody, nulls, retVal))
       }
 
-      def mkInnerClassAccessorDoubleChecked(attrThis: Tree, rhs: Tree, moduleSym: Symbol, args: List[Tree]): Tree =
-        rhs match {
-          case Block(List(assign), returnTree) =>
-            val Assign(moduleVarRef, _) = assign
-            val cond                    = Apply(Select(moduleVarRef, Object_eq), List(NULL))
-            mkFastPathBody(clazz, moduleSym, cond, List(assign), List(NULL), returnTree, attrThis, args)
-          case _ =>
-            abort(s"Invalid getter $rhs for module in $clazz")
-        }
-
       def mkCheckedAccessor(clazz: Symbol, retVal: Tree, offset: Int, pos: Position, fieldSym: Symbol): Tree = {
         val sym = fieldSym.getterIn(fieldSym.owner)
         val bitmapSym = bitmapFor(clazz, offset, sym)
@@ -926,18 +916,6 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
               deriveDefDef(stat)(rhs => Block(List(rhs, localTyper.typed(mkSetFlag(clazz, fieldOffset(getter), getter, bitmapKind(getter)))), UNIT))
             else stat
           }
-          else if (sym.isModule && (!clazz.isTrait || clazz.isImplClass) && !sym.isBridge) {
-            deriveDefDef(stat)(rhs =>
-              typedPos(stat.pos)(
-                mkInnerClassAccessorDoubleChecked(
-                  // Martin to Hubert: I think this can be replaced by selfRef(tree.pos)
-                  // @PP: It does not seem so, it crashes for me trying to bootstrap.
-                  if (clazz.isImplClass) gen.mkAttributedIdent(stat.vparamss.head.head.symbol) else gen.mkAttributedThis(clazz),
-                  rhs, sym, stat.vparamss.head
-                )
-              )
-            )
-          }
           else stat
         }
         stats map {
@@ -1082,18 +1060,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
             })
           }
           else if (sym.isModule && !(sym hasFlag LIFTED | BRIDGE)) {
-            // add modules
-            val vsym = sym.owner.newModuleVarSymbol(sym)
-            addDef(position(sym), ValDef(vsym))
-
-            // !!! TODO - unravel the enormous duplication between this code and
-            // eliminateModuleDefs in RefChecks.
-            val rhs          = gen.newModule(sym, vsym.tpe)
-            val assignAndRet = gen.mkAssignAndReturn(vsym, rhs)
-            val attrThis     = gen.mkAttributedThis(clazz)
-            val rhs1         = mkInnerClassAccessorDoubleChecked(attrThis, assignAndRet, sym, List())
-
-            addDefDef(sym, rhs1)
+            // Moved to Refchecks
           }
           else if (!sym.isMethod) {
             // add fields
diff --git a/src/compiler/scala/tools/nsc/transform/Statics.scala b/src/compiler/scala/tools/nsc/transform/Statics.scala
index 4673be6de7..9ab00f1a83 100644
--- a/src/compiler/scala/tools/nsc/transform/Statics.scala
+++ b/src/compiler/scala/tools/nsc/transform/Statics.scala
@@ -1,49 +1,32 @@
 package scala.tools.nsc
 package transform
 
-import collection.mutable.Buffer
-
 abstract class Statics extends Transform with ast.TreeDSL {
   import global._
 
   class StaticsTransformer extends Transformer {
-
-    /** finds the static ctor DefDef tree within the template if it exists. */
-    def findStaticCtor(template: Template): Option[Tree] =
-      template.body find {
-        case defdef @ DefDef(_, nme.CONSTRUCTOR, _, _, _, _) => defdef.symbol.hasStaticFlag
-        case _ => false
-      }
-
-    /** changes the template for the class so that it contains a static constructor with symbol fields inits,
-      * augments an existing static ctor if one already existed.
+    /** generate a static constructor with symbol fields inits, or an augmented existing static ctor
       */
-    def addStaticInits(template: Template, newStaticInits: Buffer[Tree], localTyper: analyzer.Typer): Template = {
-      if (newStaticInits.isEmpty)
-        template
-      else {
-        val newCtor = findStaticCtor(template) match {
-          // in case there already were static ctors - augment existing ones
-          // currently, however, static ctors aren't being generated anywhere else
-          case Some(ctor @ DefDef(_,_,_,_,_,_)) =>
-            // modify existing static ctor
-            deriveDefDef(ctor) {
-              case block @ Block(stats, expr) =>
-                // need to add inits to existing block
-                treeCopy.Block(block, newStaticInits.toList ::: stats, expr)
-              case term: TermTree =>
-                // need to create a new block with inits and the old term
-                treeCopy.Block(term, newStaticInits.toList, term)
-            }
-          case _ =>
-            // create new static ctor
-            val staticCtorSym  = currentClass.newStaticConstructor(template.pos)
-            val rhs            = Block(newStaticInits.toList, Literal(Constant(())))
+    def staticConstructor(body: List[Tree], localTyper: analyzer.Typer, pos: Position)(newStaticInits: List[Tree]): Tree =
+      body.collectFirst {
+        // If there already was a static ctor - augment existing one
+        // currently, however, static ctors aren't being generated anywhere else (!!!)
+        case ctor@DefDef(_, nme.CONSTRUCTOR, _, _, _, _) if ctor.symbol.hasStaticFlag =>
+          // modify existing static ctor
+          deriveDefDef(ctor) {
+            case block@Block(stats, expr) =>
+              // need to add inits to existing block
+              treeCopy.Block(block, newStaticInits ::: stats, expr)
+            case term: TermTree           =>
+              // need to create a new block with inits and the old term
+              treeCopy.Block(term, newStaticInits, term)
+          }
+      } getOrElse {
+        // create new static ctor
+        val staticCtorSym = currentClass.newStaticConstructor(pos)
+        val rhs = Block(newStaticInits, Literal(Constant(())))
 
-            localTyper.typedPos(template.pos)(DefDef(staticCtorSym, rhs))
-        }
-        deriveTemplate(template)(newCtor :: _)
+        localTyper.typedPos(pos)(DefDef(staticCtorSym, rhs))
       }
-    }
   }
 }
diff --git a/src/compiler/scala/tools/nsc/transform/TypeAdaptingTransformer.scala b/src/compiler/scala/tools/nsc/transform/TypeAdaptingTransformer.scala
index 3b23306386..1ed728247b 100644
--- a/src/compiler/scala/tools/nsc/transform/TypeAdaptingTransformer.scala
+++ b/src/compiler/scala/tools/nsc/transform/TypeAdaptingTransformer.scala
@@ -2,7 +2,6 @@ package scala.tools.nsc
 package transform
 
 import scala.tools.nsc.ast.TreeDSL
-import scala.tools.nsc.Global
 
 /**
  * A trait usable by transforms that need to adapt trees of one type to another type
diff --git a/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala b/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala
index dc3313e2e4..d5adfe12e9 100644
--- a/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala
+++ b/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala
@@ -26,7 +26,7 @@ trait TypingTransformers {
 
     def atOwner[A](tree: Tree, owner: Symbol)(trans: => A): A = {
       val savedLocalTyper = localTyper
-      localTyper = localTyper.atOwner(tree, if (owner.isModule) owner.moduleClass else owner)
+      localTyper = localTyper.atOwner(tree, if (owner.isModuleNotMethod) owner.moduleClass else owner)
       val result = super.atOwner(owner)(trans)
       localTyper = savedLocalTyper
       result
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 9d61dbbcae..f7a1f462b7 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -7,9 +7,10 @@ package scala
 package tools.nsc
 package transform
 
-import symtab.Flags._
-import scala.collection.{ mutable, immutable }
 import scala.language.postfixOps
+
+import symtab.Flags._
+import scala.collection.mutable
 import scala.reflect.internal.util.ListOfNil
 
 /*<export> */
@@ -696,7 +697,7 @@ abstract class UnCurry extends InfoTransform
               // declared type and assign this to a synthetic val. Later, we'll patch
               // the method body to refer to this, rather than the parameter.
               val tempVal: ValDef = {
-                // SI-9442: using the "uncurry-erased" type (the one after the uncurry phase) can lead to incorrect 
+                // SI-9442: using the "uncurry-erased" type (the one after the uncurry phase) can lead to incorrect
                 // tree transformations. For example, compiling:
                 // ```
                 //   def foo(c: Ctx)(l: c.Tree): Unit = {
@@ -725,7 +726,7 @@ abstract class UnCurry extends InfoTransform
                 //    to redo this desugaring manually here
                 // 2. the type needs to be normalized, since `gen.mkCast` checks this (no HK here, just aliases have
                 //    to be expanded before handing the type to `gen.mkAttributedCast`, which calls `gen.mkCast`)
-                val info0 = 
+                val info0 =
                   enteringUncurry(p.symbol.info) match {
                     case DesugaredParameterType(desugaredTpe) =>
                       desugaredTpe
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala b/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala
index 62d9c497ba..1a4df9973e 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala
@@ -8,9 +8,9 @@ package scala
 package tools.nsc.transform.patmat
 
 import scala.language.postfixOps
+
 import scala.collection.mutable
 import scala.reflect.internal.util.{NoPosition, Position, Statistics, HashSet}
-import scala.tools.nsc.Global
 
 trait Logic extends Debugging  {
   import PatternMatchingStats._
@@ -646,7 +646,7 @@ trait ScalaLogic extends Interface with Logic with TreeAndTypeAnalysis {
     }
 
 
-    import global.{ConstantType, Constant, EmptyScope, SingletonType, Literal, Ident, refinedType, singleType, TypeBounds, NoSymbol}
+    import global.{ConstantType, SingletonType, Literal, Ident, singleType, TypeBounds, NoSymbol}
     import global.definitions._
 
 
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala
index f259283e48..affbcf9ec8 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala
@@ -6,9 +6,8 @@
 
 package scala.tools.nsc.transform.patmat
 
-import scala.annotation.tailrec
-import scala.collection.immutable.{IndexedSeq, Iterable}
 import scala.language.postfixOps
+
 import scala.collection.mutable
 import scala.reflect.internal.util.Statistics
 
@@ -707,9 +706,8 @@ trait MatchAnalysis extends MatchApproximation {
 
         val (equal, notEqual) = varAssignment.getOrElse(variable, Nil -> Nil)
 
-        def addVarAssignment(equalTo: List[Const], notEqualTo: List[Const]) = {
-          Map(variable ->(equal ++ equalTo, notEqual ++ notEqualTo))
-        }
+        def addVarAssignment(equalTo: List[Const], notEqualTo: List[Const]) =
+          Map(variable ->((equal ++ equalTo, notEqual ++ notEqualTo)))
 
         // this assignment is needed in case that
         // there exists already an assign
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchCodeGen.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchCodeGen.scala
index 1642613b9b..03d0a28fb1 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/MatchCodeGen.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchCodeGen.scala
@@ -6,9 +6,9 @@
 
 package scala.tools.nsc.transform.patmat
 
-import scala.tools.nsc.symtab.Flags.SYNTHETIC
 import scala.language.postfixOps
-import scala.reflect.internal.util.Statistics
+
+import scala.tools.nsc.symtab.Flags.SYNTHETIC
 import scala.reflect.internal.util.Position
 
 /** Factory methods used by TreeMakers to make the actual trees.
@@ -55,7 +55,15 @@ trait MatchCodeGen extends Interface {
       def flatMap(prev: Tree, b: Symbol, next: Tree): Tree
       def flatMapCond(cond: Tree, res: Tree, nextBinder: Symbol, next: Tree): Tree
       def flatMapGuard(cond: Tree, next: Tree): Tree
-      def ifThenElseZero(c: Tree, thenp: Tree): Tree = IF (c) THEN thenp ELSE zero
+      def ifThenElseZero(c: Tree, thenp: Tree): Tree = {
+        val z = zero
+        thenp match {
+          case If(c1, thenp1, elsep1) if z equalsStructure elsep1 =>
+            If(c AND c1, thenp1, elsep1) // cleaner, leaner trees
+          case _ =>
+            If(c, thenp, zero)
+        }
+      }
       protected def zero: Tree
     }
 
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala
index cca8d2dbb8..6fdaa79c10 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala
@@ -6,10 +6,10 @@
 
 package scala.tools.nsc.transform.patmat
 
-import scala.tools.nsc.symtab.Flags.MUTABLE
 import scala.language.postfixOps
+
+import scala.tools.nsc.symtab.Flags.MUTABLE
 import scala.collection.mutable
-import scala.reflect.internal.util.Statistics
 import scala.reflect.internal.util.Position
 
 /** Optimize and analyze matches based on their TreeMaker-representation.
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala
index 451b72d498..96a20ea631 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala
@@ -7,7 +7,7 @@
 package scala.tools.nsc.transform.patmat
 
 import scala.language.postfixOps
-import scala.collection.mutable
+
 import scala.reflect.internal.util.Statistics
 
 /** Translate typed Trees that represent pattern matches into the patternmatching IR, defined by TreeMakers.
@@ -18,8 +18,7 @@ trait MatchTranslation {
   import PatternMatchingStats._
   import global._
   import definitions._
-  import global.analyzer.{ErrorUtils, formalTypes}
-  import treeInfo.{ WildcardStarArg, Unapplied, isStar, unbind }
+  import treeInfo.{ Unapplied, unbind }
   import CODE._
 
   // Always map repeated params to sequences
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala
index e0fcc05de2..18a63a6e53 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala
@@ -6,10 +6,10 @@
 
 package scala.tools.nsc.transform.patmat
 
-import scala.tools.nsc.symtab.Flags.{SYNTHETIC, ARTIFACT}
 import scala.language.postfixOps
+
+import scala.tools.nsc.symtab.Flags.{SYNTHETIC, ARTIFACT}
 import scala.collection.mutable
-import scala.reflect.internal.util.Statistics
 import scala.reflect.internal.util.Position
 
 /** Translate our IR (TreeMakers) into actual Scala Trees using the factory methods in MatchCodeGen.
diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala
index 8beb1837ad..27d674762f 100644
--- a/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala
+++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala
@@ -7,8 +7,6 @@
 package scala.tools.nsc.transform.patmat
 
 import scala.language.postfixOps
-import scala.collection.mutable
-import scala.reflect.internal.util.Statistics
 
 trait MatchWarnings {
   self: PatternMatching =>
@@ -83,4 +81,4 @@ trait MatchWarnings {
       }
     }
   }
-}
\ No newline at end of file
+}
diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
index b7c72f5373..ccdff5c9a1 100644
--- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala
@@ -7,7 +7,6 @@ package scala.tools.nsc
 package typechecker
 
 import scala.reflect.internal.util.StringOps.{ countElementsAsString, countAsString }
-import symtab.Flags.IS_ERROR
 import scala.compat.Platform.EOL
 import scala.reflect.runtime.ReflectionUtils
 import scala.reflect.macros.runtime.AbortMacroException
@@ -1190,7 +1189,7 @@ trait ContextErrors {
 
       def IllegalDependentMethTpeError(sym: Symbol)(context: Context) = {
         val errorAddendum =
-          ": parameter appears in the type of another parameter in the same section or an earlier one"
+          ": parameter may only be referenced in a subsequent parameter section"
         issueSymbolTypeError(sym,  "illegal dependent method type" + errorAddendum)(context)
       }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
index 69ae6ec0c8..0c10242950 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Duplicators.scala
@@ -7,7 +7,7 @@ package scala.tools.nsc
 package typechecker
 
 import scala.tools.nsc.symtab.Flags
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 
 /** Duplicate trees and re-type check them, taking care to replace
  *  and create fresh symbols for new local definitions.
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 383baad2ad..a34e97b6cb 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -13,7 +13,7 @@ package tools.nsc
 package typechecker
 
 import scala.annotation.tailrec
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import mutable.{ LinkedHashMap, ListBuffer }
 import scala.util.matching.Regex
 import symtab.Flags._
@@ -588,10 +588,10 @@ trait Implicits {
       if (Statistics.canEnable) Statistics.incCounter(matchingImplicits)
 
       // workaround for deficient context provided by ModelFactoryImplicitSupport#makeImplicitConstraints
-      val isScalaDoc = context.tree == EmptyTree
+      val isScaladoc = context.tree == EmptyTree
 
       val itree0 = atPos(pos.focus) {
-        if (isLocalToCallsite && !isScalaDoc) {
+        if (isLocalToCallsite && !isScaladoc) {
           // SI-4270 SI-5376 Always use an unattributed Ident for implicits in the local scope,
           // rather than an attributed Select, to detect shadowing.
           Ident(info.name)
@@ -628,7 +628,7 @@ trait Implicits {
               // for instance, if we have `class C[T]` and `implicit def conv[T: Numeric](c: C[T]) = ???`
               // then Scaladoc will give us something of type `C[T]`, and it would like to know
               // that `conv` is potentially available under such and such conditions
-              case tree if isImplicitMethodType(tree.tpe) && !isScalaDoc =>
+              case tree if isImplicitMethodType(tree.tpe) && !isScaladoc =>
                 applyImplicitArgs(tree)
               case tree => tree
             }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 3ed128cbc5..bcf9e018e2 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -5,14 +5,11 @@ import java.lang.Math.min
 import symtab.Flags._
 import scala.reflect.internal.util.ScalaClassLoader
 import scala.reflect.runtime.ReflectionUtils
-import scala.collection.mutable.ListBuffer
-import scala.reflect.ClassTag
 import scala.reflect.internal.util.Statistics
 import scala.reflect.macros.util._
 import scala.util.control.ControlThrowable
 import scala.reflect.internal.util.ListOfNil
 import scala.reflect.macros.runtime.{AbortMacroException, MacroRuntimes}
-import scala.reflect.runtime.{universe => ru}
 import scala.reflect.macros.compiler.DefaultMacroCompiler
 import scala.tools.reflect.FastTrack
 import scala.runtime.ScalaRunTime
diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
index f3632b144d..abc3e91ed2 100644
--- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
@@ -5,12 +5,11 @@
 package scala.tools.nsc
 package typechecker
 
+import scala.language.higherKinds
+
 import symtab.Flags._
-import scala.reflect.internal.util.StringOps.{ ojoin }
-import scala.reflect.ClassTag
+import scala.reflect.internal.util.StringOps.ojoin
 import scala.reflect.internal.util.ListOfNil
-import scala.reflect.runtime.{ universe => ru }
-import scala.language.higherKinds
 
 /** Logic related to method synthesis which involves cooperation between
  *  Namer and Typer.
@@ -22,17 +21,6 @@ trait MethodSynthesis {
   import definitions._
   import CODE._
 
-  /** The annotations amongst those found on the original symbol which
-   *  should be propagated to this kind of accessor.
-   */
-  def deriveAnnotations(initial: List[AnnotationInfo], category: Symbol, keepClean: Boolean): List[AnnotationInfo] = {
-    def annotationFilter(ann: AnnotationInfo) = ann.metaAnnotations match {
-      case Nil if ann.defaultTargets.isEmpty => keepClean                             // no meta-annotations or default targets
-      case Nil                               => ann.defaultTargets contains category  // default targets exist for ann
-      case metas                             => metas exists (_ matches category)     // meta-annotations attached to ann
-    }
-    initial filter annotationFilter
-  }
 
   class ClassMethodSynthesis(val clazz: Symbol, localTyper: Typer) {
     def mkThis = This(clazz) setPos clazz.pos.focus
@@ -160,13 +148,15 @@ trait MethodSynthesis {
       enterBeans(tree)
     }
 
+    import AnnotationInfo.{mkFilter => annotationFilter}
+
     /** This is called for those ValDefs which addDerivedTrees ignores, but
      *  which might have a warnable annotation situation.
      */
     private def warnForDroppedAnnotations(tree: Tree) {
       val annotations   = tree.symbol.initialize.annotations
       val targetClass   = defaultAnnotationTarget(tree)
-      val retained      = deriveAnnotations(annotations, targetClass, keepClean = true)
+      val retained      = annotations filter annotationFilter(targetClass, defaultRetention = true)
 
       annotations filterNot (retained contains _) foreach (ann => issueAnnotationWarning(tree, ann, targetClass))
     }
@@ -208,8 +198,8 @@ trait MethodSynthesis {
         context.unit.synthetics get meth match {
           case Some(mdef) =>
             context.unit.synthetics -= meth
-            meth setAnnotations deriveAnnotations(annotations, MethodTargetClass, keepClean = false)
-            cd.symbol setAnnotations deriveAnnotations(annotations, ClassTargetClass, keepClean = true)
+            meth setAnnotations (annotations filter annotationFilter(MethodTargetClass, defaultRetention = false))
+            cd.symbol setAnnotations (annotations filter annotationFilter(ClassTargetClass, defaultRetention = true))
             List(cd, mdef)
           case _ =>
             // Shouldn't happen, but let's give ourselves a reasonable error when it does
@@ -293,10 +283,6 @@ trait MethodSynthesis {
       def tree: ValDef
       final def enclClass = basisSym.enclClass
 
-      /** Which meta-annotation is associated with this kind of entity.
-       *  Presently one of: field, getter, setter, beanGetter, beanSetter, param.
-       */
-      def category: Symbol
 
       /* Explicit isSetter required for bean setters (beanSetterSym.isSetter is false) */
       final def completer(sym: Symbol) = namerOf(sym).accessorTypeCompleter(tree, isSetter)
@@ -307,7 +293,6 @@ trait MethodSynthesis {
 
       def isSetter   = false
       def isDeferred = mods.isDeferred
-      def keepClean  = false  // whether annotations whose definitions are not meta-annotated should be kept.
       def validate() { }
       def createAndEnterSymbol(): MethodSymbol = {
         val sym = owner.newMethod(name, tree.pos.focus, derivedMods.flags)
@@ -323,7 +308,29 @@ trait MethodSynthesis {
       }
       final def derive(initial: List[AnnotationInfo]): Tree = {
         validate()
-        derivedSym setAnnotations deriveAnnotations(initial, category, keepClean)
+
+        // see scala.annotation.meta's package class for more info
+        // Annotations on ValDefs can be targeted towards the following: field, getter, setter, beanGetter, beanSetter, param.
+        // The defaults are:
+        //   - (`val`-, `var`- or plain) constructor parameter annotations end up on the parameter, not on any other entity.
+        //   - val/var member annotations solely end up on the underlying field.
+        //
+        // TODO: these defaults can be surprising for annotations not meant for accessors/fields -- should we revisit?
+        // (In order to have `@foo val X` result in the X getter being annotated with `@foo`, foo needs to be meta-annotated with @getter)
+        val annotFilter: AnnotationInfo => Boolean = this match {
+          case _: Param                       => annotationFilter(ParamTargetClass,      defaultRetention = true)
+          // By default annotations go to the field, except if the field is generated for a class parameter (PARAMACCESSOR).
+          case _: Field                       => annotationFilter(FieldTargetClass,      defaultRetention = !mods.isParamAccessor)
+          case _: BaseGetter                  => annotationFilter(GetterTargetClass,     defaultRetention = false)
+          case _: Setter                      => annotationFilter(SetterTargetClass,     defaultRetention = false)
+          case _: BeanSetter                  => annotationFilter(BeanSetterTargetClass, defaultRetention = false)
+          case _: AnyBeanGetter               => annotationFilter(BeanGetterTargetClass, defaultRetention = false)
+        }
+
+        // The annotations amongst those found on the original symbol which
+        // should be propagated to this kind of accessor.
+        derivedSym setAnnotations (initial filter annotFilter)
+
         logDerived(derivedTree)
       }
     }
@@ -370,7 +377,6 @@ trait MethodSynthesis {
 
     sealed abstract class BaseGetter(tree: ValDef) extends DerivedGetter {
       def name       = tree.name
-      def category   = GetterTargetClass
       def flagsMask  = GetterFlags
       def flagsExtra = ACCESSOR.toLong | ( if (tree.mods.isMutable) 0 else STABLE )
 
@@ -395,12 +401,13 @@ trait MethodSynthesis {
         // starts compiling (instead of failing like it's supposed to) because the typer
         // expects to be able to identify escaping locals in typedDefDef, and fails to
         // spot that brand of them. In other words it's an artifact of the implementation.
-        val tpt = derivedSym.tpe_*.finalResultType.widen match {
+        val getterTp = derivedSym.tpe_*.finalResultType
+        val tpt = getterTp.widen match {
           // Range position errors ensue if we don't duplicate this in some
           // circumstances (at least: concrete vals with existential types.)
-          case ExistentialType(_, _)  => TypeTree() setOriginal (tree.tpt.duplicate setPos tree.tpt.pos.focus)
-          case _ if isDeferred        => TypeTree() setOriginal tree.tpt // keep type tree of original abstract field
-          case tp                     => TypeTree(tp)
+          case _: ExistentialType => TypeTree() setOriginal (tree.tpt.duplicate setPos tree.tpt.pos.focus)
+          case _ if isDeferred    => TypeTree() setOriginal tree.tpt // keep type tree of original abstract field
+          case _                  => TypeTree(getterTp)
         }
         tpt setPos tree.tpt.pos.focus
       }
@@ -449,7 +456,6 @@ trait MethodSynthesis {
     }
     case class Setter(tree: ValDef) extends DerivedSetter {
       def name       = tree.setterName
-      def category   = SetterTargetClass
       def flagsMask  = SetterFlags
       def flagsExtra = ACCESSOR
 
@@ -469,18 +475,14 @@ trait MethodSynthesis {
       // NOTE: do not look at `vd.symbol` when called from `enterGetterSetter` (luckily, that call-site implies `!mods.isLazy`),
       // as the symbol info is in the process of being created then.
       // TODO: harmonize tree & symbol creation
-      // TODO: the `def field` call-site does not tollerate including `|| vd.symbol.owner.isTrait` --> tests break
-      def noFieldFor(vd: ValDef) = vd.mods.isDeferred || (vd.mods.isLazy && isUnitType(vd.symbol.info)) // || vd.symbol.owner.isTrait))
+      // TODO: the `def field` call-site breaks when you add `|| vd.symbol.owner.isTrait` (detected in test suite)
+      def noFieldFor(vd: ValDef) = vd.mods.isDeferred || (vd.mods.isLazy && isUnitType(vd.symbol.info))
     }
 
     case class Field(tree: ValDef) extends DerivedFromValDef {
       def name       = tree.localName
-      def category   = FieldTargetClass
       def flagsMask  = FieldFlags
       def flagsExtra = PrivateLocal
-      // By default annotations go to the field, except if the field is
-      // generated for a class parameter (PARAMACCESSOR).
-      override def keepClean = !mods.isParamAccessor
 
       // handle lazy val first for now (we emit a Field even though we probably shouldn't...)
       override def derivedTree =
@@ -491,10 +493,8 @@ trait MethodSynthesis {
     }
     case class Param(tree: ValDef) extends DerivedFromValDef {
       def name       = tree.name
-      def category   = ParamTargetClass
       def flagsMask  = -1L
       def flagsExtra = 0L
-      override def keepClean = true
       override def derivedTree = EmptyTree
     }
     def validateParam(tree: ValDef) {
@@ -508,7 +508,6 @@ trait MethodSynthesis {
       override def derivedSym = enclClass.info decl name
     }
     sealed trait AnyBeanGetter extends BeanAccessor with DerivedGetter {
-      def category = BeanGetterTargetClass
       override def validate() {
         if (derivedSym == NoSymbol) {
           // the namer decides whether to generate these symbols or not. at that point, we don't
@@ -531,9 +530,7 @@ trait MethodSynthesis {
     }
     case class BooleanBeanGetter(tree: ValDef) extends BeanAccessor("is") with AnyBeanGetter { }
     case class BeanGetter(tree: ValDef) extends BeanAccessor("get") with AnyBeanGetter { }
-    case class BeanSetter(tree: ValDef) extends BeanAccessor("set") with DerivedSetter {
-      def category = BeanSetterTargetClass
-    }
+    case class BeanSetter(tree: ValDef) extends BeanAccessor("set") with DerivedSetter
 
     // No Symbols available.
     private def beanAccessorsFromNames(tree: ValDef) = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index ba095c808e..8943ec810d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -7,7 +7,6 @@ package scala.tools.nsc
 package typechecker
 
 import scala.collection.mutable
-import scala.annotation.tailrec
 import symtab.Flags._
 import scala.language.postfixOps
 import scala.reflect.internal.util.ListOfNil
@@ -654,8 +653,10 @@ trait Namers extends MethodSynthesis {
       if (isScala && deriveAccessors(tree)) enterGetterSetter(tree)
       else assignAndEnterFinishedSymbol(tree)
 
-      if (isEnumConstant(tree))
+      if (isEnumConstant(tree)) {
         tree.symbol setInfo ConstantType(Constant(tree.symbol))
+        tree.symbol.owner.linkedClassOfClass addChild tree.symbol
+      }
     }
 
     def enterLazyVal(tree: ValDef, lazyAccessor: Symbol): TermSymbol = {
@@ -1593,11 +1594,7 @@ trait Namers extends MethodSynthesis {
       import SymValidateErrors._
       def fail(kind: SymValidateErrors.Value) = SymbolValidationError(sym, kind)
 
-      def checkWithDeferred(flag: Int) {
-        if (sym hasFlag flag)
-          AbstractMemberWithModiferError(sym, flag)
-      }
-      def checkNoConflict(flag1: Int, flag2: Int) {
+      def checkNoConflict(flag1: Int, flag2: Int) = {
         if (sym hasAllFlags flag1.toLong | flag2)
           IllegalModifierCombination(sym, flag1, flag2)
       }
@@ -1636,6 +1633,10 @@ trait Namers extends MethodSynthesis {
         checkNoConflict(ABSTRACT, FINAL)
 
       if (sym.isDeferred) {
+        def checkWithDeferred(flag: Int) = {
+          if (sym hasFlag flag)
+            AbstractMemberWithModiferError(sym, flag)
+        }
         // Is this symbol type always allowed the deferred flag?
         def symbolAllowsDeferred = (
              sym.isValueParameter
@@ -1651,14 +1652,16 @@ trait Namers extends MethodSynthesis {
         )
         if (sym hasAnnotation NativeAttr)
           sym resetFlag DEFERRED
-        else if (!symbolAllowsDeferred && ownerRequiresConcrete)
-          fail(AbstractVar)
+        else {
+          if (!symbolAllowsDeferred && ownerRequiresConcrete) fail(AbstractVar)
 
-        checkWithDeferred(PRIVATE)
-        checkWithDeferred(FINAL)
+          checkWithDeferred(PRIVATE)
+          checkWithDeferred(FINAL)
+        }
       }
 
-      checkNoConflict(FINAL, SEALED)
+      if (!sym.isJavaEnum)
+        checkNoConflict(FINAL, SEALED)
       checkNoConflict(PRIVATE, PROTECTED)
       // checkNoConflict(PRIVATE, OVERRIDE) // this one leads to bad error messages like #4174, so catch in refchecks
       // checkNoConflict(PRIVATE, FINAL)    // can't do this because FINAL also means compile-time constant
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 7252cae0b5..3860cc252d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -6,15 +6,17 @@
 package scala.tools.nsc
 package typechecker
 
-import symtab.Flags._
-import scala.collection.{ mutable, immutable }
-import transform.InfoTransform
-import scala.collection.mutable.ListBuffer
 import scala.language.postfixOps
+
+import scala.collection.mutable
+import scala.collection.mutable.ListBuffer
 import scala.tools.nsc.settings.ScalaVersion
-import scala.tools.nsc.settings.AnyScalaVersion
 import scala.tools.nsc.settings.NoScalaVersion
 
+import symtab.Flags._
+import transform.InfoTransform
+
+
 /** <p>
  *    Post-attribution checking and transformation.
  *  </p>
@@ -48,7 +50,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
 
   import global._
   import definitions._
-  import typer.{typed, typedOperator, atOwner}
+  import typer.typed
 
   /** the following two members override abstract members in Transform */
   val phaseName: String = "refchecks"
@@ -1188,14 +1190,6 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
       // set NoType so it will be ignored.
       val cdef          = ClassDef(module.moduleClass, impl) setType NoType
 
-      def newInnerObject() = {
-        val moduleVar = site newModuleVarSymbol module
-        val rhs       = gen.newModule(module, moduleVar.tpe)
-        val body      = if (site.isTrait) rhs else gen.mkAssignAndReturn(moduleVar, rhs)
-        val accessor  = DefDef(module, body.changeOwner(moduleVar -> module))
-
-        ValDef(moduleVar) :: accessor :: Nil
-      }
       def matchingInnerObject() = {
         val newFlags = (module.flags | STABLE) & ~MODULE
         val newInfo  = NullaryMethodType(module.moduleClass.tpe)
@@ -1208,10 +1202,36 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
           // trait T { def f: Object }; object O extends T { object f }. Need to generate method f in O.
           if (module.isOverridingSymbol) matchingInnerObject() else Nil
         else
-          newInnerObject()
+          newInnerObject(site, module)
       )
       transformTrees(newTrees map localTyper.typedPos(moduleDef.pos))
     }
+    def newInnerObject(site: Symbol, module: Symbol): List[Tree] = {
+      if (site.isTrait)
+        DefDef(module, EmptyTree) :: Nil
+      else {
+        val moduleVar = site newModuleVarSymbol module
+        // used for the mixin case: need a new symbol owned by the subclass for the accessor, rather than repurposing the module symbol
+        def mkAccessorSymbol =
+          site.newMethod(module.name.toTermName, site.pos, STABLE | MODULE | MIXEDIN)
+            .setInfo(moduleVar.tpe)
+            .andAlso(self => if (module.isPrivate) self.expandName(module.owner))
+
+        val accessor = if (module.owner == site) module else mkAccessorSymbol
+        val accessorDef = DefDef(accessor, gen.mkAssignAndReturn(moduleVar, gen.newModule(module, moduleVar.tpe)).changeOwner(moduleVar -> accessor))
+
+        ValDef(moduleVar) :: accessorDef :: Nil
+      }
+    }
+
+    def mixinModuleDefs(clazz: Symbol): List[Tree] = {
+      val res = for {
+        mixinClass <- clazz.mixinClasses.iterator
+        module     <- mixinClass.info.decls.iterator.filter(_.isModule)
+        newMember  <- newInnerObject(clazz, module)
+      } yield transform(localTyper.typedPos(clazz.pos)(newMember))
+      res.toList
+    }
 
     def transformStat(tree: Tree, index: Int): List[Tree] = tree match {
       case t if treeInfo.isSelfConstrCall(t) =>
@@ -1643,11 +1663,12 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
             // SI-7870 default getters for constructors live in the companion module
             checkOverloadedRestrictions(currentOwner, currentOwner.companionModule)
             val bridges = addVarargBridges(currentOwner)
+            val moduleDesugared = if (currentOwner.isTrait) Nil else mixinModuleDefs(currentOwner)
             checkAllOverrides(currentOwner)
             checkAnyValSubclass(currentOwner)
             if (currentOwner.isDerivedValueClass)
               currentOwner.primaryConstructor makeNotPrivate NoSymbol // SI-6601, must be done *after* pickler!
-            if (bridges.nonEmpty) deriveTemplate(tree)(_ ::: bridges) else tree
+            if (bridges.nonEmpty || moduleDesugared.nonEmpty) deriveTemplate(tree)(_ ::: bridges ::: moduleDesugared) else tree
 
           case dc@TypeTreeWithDeferredRefCheck() => abort("adapt should have turned dc: TypeTreeWithDeferredRefCheck into tpt: TypeTree, with tpt.original == dc")
           case tpt@TypeTree() =>
diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
index e0d96df062..a1bec13999 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
@@ -287,7 +287,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
                 val result = (localTyper.typedPos(tree.pos) {
                   Select(Super(qual, tpnme.EMPTY) setPos qual.pos, sym.alias)
                 }).asInstanceOf[Select]
-                debuglog("alias replacement: " + tree + " ==> " + result); //debug
+                debuglog(s"alias replacement: $sym --> ${sym.alias} / $tree ==> $result"); //debug
                 localTyper.typed(gen.maybeMkAsInstanceOf(transformSuperSelect(result), sym.tpe, sym.alias.tpe, beforeRefChecks = true))
               } else {
                 /*
@@ -387,7 +387,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
       val savedValid = validCurrentOwner
       if (owner.isClass) validCurrentOwner = true
       val savedLocalTyper = localTyper
-      localTyper = localTyper.atOwner(tree, if (owner.isModule) owner.moduleClass else owner)
+      localTyper = localTyper.atOwner(tree, if (owner.isModuleNotMethod) owner.moduleClass else owner)
       typers = typers updated (owner, localTyper)
       val result = super.atOwner(tree, owner)(trans)
       localTyper = savedLocalTyper
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index 4ccc183334..243a706745 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -6,11 +6,13 @@
 package scala.tools.nsc
 package typechecker
 
-import scala.collection.{ mutable, immutable }
-import symtab.Flags._
-import scala.collection.mutable.ListBuffer
 import scala.language.postfixOps
 
+import scala.collection.mutable
+import scala.collection.mutable.ListBuffer
+
+import symtab.Flags._
+
 /** Synthetic method implementations for case classes and case objects.
  *
  *  Added to all case classes/objects:
diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
index e8db8309f1..f6ee0c47a5 100644
--- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
@@ -7,8 +7,6 @@ package scala.tools.nsc
 package typechecker
 
 import scala.collection.mutable
-import mutable.ListBuffer
-import util.returning
 import scala.reflect.internal.util.shortClassOfInstance
 import scala.reflect.internal.util.StringOps._
 
@@ -94,7 +92,7 @@ abstract class TreeCheckers extends Analyzer {
     def latest        = maps.head._2
     val defSyms       = symbolTreeMap[DefTree]()
     val newSyms       = mutable.HashSet[Symbol]()
-    val movedMsgs     = new ListBuffer[String]
+    val movedMsgs     = mutable.ListBuffer[String]()
     def sortedNewSyms = newSyms.toList.distinct sortBy (_.name.toString)
 
     def record(tree: Tree) {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 510c83eb88..84af9233e1 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -14,7 +14,7 @@ package tools.nsc
 package typechecker
 
 import scala.collection.{mutable, immutable}
-import scala.reflect.internal.util.{ BatchSourceFile, Statistics, shortClassOfInstance, ListOfNil }
+import scala.reflect.internal.util.{ Statistics, ListOfNil }
 import mutable.ListBuffer
 import symtab.Flags._
 import Mode._
@@ -110,7 +110,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
 
   abstract class Typer(context0: Context) extends TyperDiagnostics with Adaptation with Tag with PatternTyper with TyperContextErrors {
     import context0.unit
-    import typeDebug.{ ptTree, ptBlock, ptLine, inGreen, inRed }
+    import typeDebug.ptTree
     import TyperErrorGen._
     val runDefinitions = currentRun.runDefinitions
     import runDefinitions._
@@ -862,7 +862,14 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           case Block(_, tree1) => tree1.symbol
           case _               => tree.symbol
         }
-        if (!meth.isConstructor && (isFunctionType(pt) || samOf(pt).exists)) { // (4.2)
+        def shouldEtaExpandToSam: Boolean = {
+          // SI-9536 don't adapt parameterless method types to a to SAM's, fall through to empty application
+          // instead for backwards compatiblity with 2.11. See comments of that ticket and SI-7187
+          // for analogous trouble with non-SAM eta expansion. Suggestions there are: a) deprecate eta expansion to Function0,
+          // or b) switch the order of eta-expansion and empty application in this adaptation.
+          !mt.params.isEmpty && samOf(pt).exists
+        }
+        if (!meth.isConstructor && (isFunctionType(pt) || shouldEtaExpandToSam)) { // (4.2)
           debuglog(s"eta-expanding $tree: ${tree.tpe} to $pt")
           checkParamsConvertible(tree, tree.tpe)
           val tree0 = etaExpand(context.unit, tree, this)
diff --git a/src/compiler/scala/tools/nsc/typechecker/TypersTracking.scala b/src/compiler/scala/tools/nsc/typechecker/TypersTracking.scala
index 37fbb73b85..f2911fb98b 100644
--- a/src/compiler/scala/tools/nsc/typechecker/TypersTracking.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/TypersTracking.scala
@@ -6,9 +6,6 @@
 package scala.tools.nsc
 package typechecker
 
-import scala.collection.mutable
-import scala.reflect.internal.util.{ BatchSourceFile, Statistics }
-import mutable.ListBuffer
 import Mode._
 
 trait TypersTracking {
diff --git a/src/compiler/scala/tools/reflect/FastTrack.scala b/src/compiler/scala/tools/reflect/FastTrack.scala
index 8fed53c89f..dc26c93066 100644
--- a/src/compiler/scala/tools/reflect/FastTrack.scala
+++ b/src/compiler/scala/tools/reflect/FastTrack.scala
@@ -4,7 +4,6 @@ package reflect
 import scala.reflect.reify.Taggers
 import scala.tools.nsc.typechecker.{ Analyzer, Macros }
 import scala.reflect.runtime.Macros.currentMirror
-import scala.reflect.api.Universe
 import scala.reflect.quasiquotes.{ Quasiquotes => QuasiquoteImpls }
 
 /** Optimizes system macro expansions by hardwiring them directly to their implementations
diff --git a/src/compiler/scala/tools/reflect/FormatInterpolator.scala b/src/compiler/scala/tools/reflect/FormatInterpolator.scala
index b445f1e2bb..cbdb01a10a 100644
--- a/src/compiler/scala/tools/reflect/FormatInterpolator.scala
+++ b/src/compiler/scala/tools/reflect/FormatInterpolator.scala
@@ -6,7 +6,7 @@ import scala.reflect.internal.util.Position
 import scala.PartialFunction.cond
 import scala.util.matching.Regex.Match
 
-import java.util.{ Formatter, Formattable, IllegalFormatException }
+import java.util.Formattable
 
 abstract class FormatInterpolator {
   val c: Context
@@ -262,7 +262,7 @@ abstract class FormatInterpolator {
     def goodFlags = {
       val badFlags = flags map (_ filterNot (okFlags contains _))
       for (bf <- badFlags; f <- bf) badFlag(f, s"Illegal flag '$f'")
-      badFlags.getOrElse("").isEmpty 
+      badFlags.getOrElse("").isEmpty
     }
     def goodIndex = {
       if (index.nonEmpty && hasFlag('<'))
@@ -281,7 +281,7 @@ abstract class FormatInterpolator {
       ) orElse Some(variants(0))
   }
   object Conversion {
-    import SpecifierGroups.{ Spec, CC, Width }
+    import SpecifierGroups.{ Spec, CC }
     def apply(m: Match, p: Position, n: Int): Option[Conversion] = {
       def badCC(msg: String) = {
         val dk = new ErrorXn(m, p)
diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
index 47c88f2c00..ae6a9e22b6 100644
--- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
+++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
@@ -3,13 +3,12 @@ package tools
 package reflect
 
 import scala.tools.cmd.CommandLineParser
-import scala.tools.nsc.Global
 import scala.tools.nsc.reporters._
 import scala.tools.nsc.CompilerCommand
 import scala.tools.nsc.io.{AbstractFile, VirtualDirectory}
 import scala.reflect.internal.util.AbstractFileClassLoader
 import scala.reflect.internal.Flags._
-import scala.reflect.internal.util.{BatchSourceFile, NoSourceFile, NoFile}
+import scala.reflect.internal.util.NoSourceFile
 import java.lang.{Class => jClass}
 import scala.compat.Platform.EOL
 import scala.reflect.NameTransformer
diff --git a/src/compiler/scala/tools/util/PathResolver.scala b/src/compiler/scala/tools/util/PathResolver.scala
index 09c6c9d744..42b939f18b 100644
--- a/src/compiler/scala/tools/util/PathResolver.scala
+++ b/src/compiler/scala/tools/util/PathResolver.scala
@@ -7,15 +7,16 @@ package scala
 package tools
 package util
 
+import scala.language.postfixOps
+
 import java.net.URL
 import scala.tools.reflect.WrappedProperties.AccessControl
 import scala.tools.nsc.Settings
 import scala.tools.nsc.util.{ ClassFileLookup, ClassPath, JavaClassPath }
 import scala.reflect.io.{ File, Directory, Path, AbstractFile }
 import scala.reflect.runtime.ReflectionUtils
-import ClassPath.{ JavaContext, DefaultJavaContext, join, split }
+import ClassPath.{ JavaContext, DefaultJavaContext, split }
 import PartialFunction.condOpt
-import scala.language.postfixOps
 import scala.tools.nsc.classpath.{ AggregateFlatClassPath, ClassPathFactory, FlatClassPath, FlatClassPathFactory }
 import scala.tools.nsc.settings.ClassPathRepresentationType
 
diff --git a/src/eclipse/README.md b/src/eclipse/README.md
index a0152faa86..3df7fbed7d 100644
--- a/src/eclipse/README.md
+++ b/src/eclipse/README.md
@@ -1,10 +1,15 @@
 Eclipse project files
 =====================
 
-The following points describe how to get Scala to run in Eclipse. Please also take a look at the [excellent tutorial on scala-ide.org](http://scala-ide.org/docs/tutorials/scalac-trunk/index.html).
+For important details on building, debugging and file encodings, please see [the excellent tutorial on scala-ide.org](http://scala-ide.org/docs/tutorials/scalac-trunk/index.html).
 
-0. Import all projects into a [very recent version of Scala IDE for Eclipse](http://scala-ide.org/download/nightly.html) by choosing `File/Import Existing Projects`
-and navigate to `scala/src/eclipse`. Check all projects and click ok.
+The following points describe how to build Scala using Eclipse.
+
+0. Download the [Scala IDE bundle](http://scala-ide.org/download/sdk.html). It comes preconfigured for optimal performance.
+
+0. Run `ant init` to download some necessary jars.
+
+0. Import the project (in `src/eclipse`) via `File` → `Import Existing Projects` and navigate to `scala/src/eclipse`. Check all projects and click ok.
 
 0. You need to define a `path variable` inside Eclipse. Define `SCALA_BASEDIR` in
 `Preferences/General/Workspace/Linked Resources`. The value should be the absolute
diff --git a/src/intellij/README b/src/intellij/README
deleted file mode 100644
index 4ecab5561f..0000000000
--- a/src/intellij/README
+++ /dev/null
@@ -1,12 +0,0 @@
-Use the latest IntelliJ IDEA release and install the Scala plugin from within the IDE.
-
-Compilation withing IDEA is performed in "-Dlocker.skip=1" mode: the sources are built
-directly using the STARR compiler.
-
-The following steps are required to use IntelliJ IDEA on Scala trunk
- - Run "ant init". This will download some JARs from to ./build/deps, which are
-   included in IntelliJ's classpath.
- - Run src/intellij/setup.sh
- - Open ./src/intellij/scala.ipr in IntelliJ
- - File, Project Settings, Project, SDK. Create an SDK entry named "1.6" containing the
-   Java 1.6 SDK
diff --git a/src/intellij/README.md b/src/intellij/README.md
new file mode 100644
index 0000000000..8717003441
--- /dev/null
+++ b/src/intellij/README.md
@@ -0,0 +1,20 @@
+# Building Scala using IntelliJ IDEA
+
+## Requirements
+
+Use the latest IntelliJ release and install the Scala plugin from within the IDE.
+
+## Initial setup
+
+To create the IntelliJ project definition,
+
+ - Run `ant init`. This will download some JARs to `./build/deps`, which are included in IntelliJ's classpath.
+ - Run `./src/intellij/setup.sh`.
+ - Open `./src/intellij/scala.ipr` in IntelliJ.
+ - In `File` → `Project Structure` → `Project` → `Project SDK`, create an SDK entry named "1.8" containing the Java 1.8 SDK.
+
+## Usage
+
+Compiling, running, and debugging should all work.  You can work on the compiler, the standard library, and other components as well.
+
+Note that compilation within IntelliJ is performed in `-Dlocker.skip=1` mode. Code is compiled not by bootstrapping the current compiler sources, but simply by using the "STARR" (stable reference) compiler, as specified by `starr.version` in `versions.properties`.
diff --git a/src/intellij/scala.ipr.SAMPLE b/src/intellij/scala.ipr.SAMPLE
index 3e6e074717..c4c6a2e44f 100644
--- a/src/intellij/scala.ipr.SAMPLE
+++ b/src/intellij/scala.ipr.SAMPLE
@@ -50,7 +50,7 @@
       <module fileurl="file://$PROJECT_DIR$/test-junit.iml" filepath="$PROJECT_DIR$/test-junit.iml" />
     </modules>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_6" default="true" assert-keyword="true" jdk-15="true" project-jdk-name="1.6" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" assert-keyword="true" jdk-15="true" project-jdk-name="1.8" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/../../out" />
   </component>
   <component name="ScalaCompilerConfiguration">
diff --git a/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala b/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala
index 586f011429..cb12cebc49 100644
--- a/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala
+++ b/src/interactive/scala/tools/nsc/interactive/CompilerControl.scala
@@ -10,7 +10,7 @@ import scala.tools.nsc.io.AbstractFile
 import scala.tools.nsc.util.FailedInterrupt
 import scala.tools.nsc.util.EmptyAction
 import scala.tools.nsc.util.WorkScheduler
-import scala.reflect.internal.util.{SourceFile, Position}
+import scala.reflect.internal.util.SourceFile
 import scala.tools.nsc.util.InterruptReq
 
 /** Interface of interactive compiler to a client such as an IDE
@@ -189,7 +189,7 @@ trait CompilerControl { self: Global =>
    * continues with current pass.
    * Waits until source is fully type checked and returns body in response.
    * @param source     The source file that needs to be fully typed.
-   * @param keepLoaded Whether to keep that file in the PC if it was not loaded before. If 
+   * @param keepLoaded Whether to keep that file in the PC if it was not loaded before. If
                        the file is already loaded, this flag is ignored.
    * @param response   The response, which is set to the fully attributed tree of `source`.
    *                   If the unit corresponding to `source` has been removed in the meantime
diff --git a/src/interactive/scala/tools/nsc/interactive/Global.scala b/src/interactive/scala/tools/nsc/interactive/Global.scala
index 5298a6ae57..64535a749f 100644
--- a/src/interactive/scala/tools/nsc/interactive/Global.scala
+++ b/src/interactive/scala/tools/nsc/interactive/Global.scala
@@ -5,12 +5,12 @@
 package scala.tools.nsc
 package interactive
 
-import java.io.{ PrintWriter, StringWriter, FileReader, FileWriter }
+import java.io.{ FileReader, FileWriter }
 import scala.collection.mutable
-import mutable.{LinkedHashMap, SynchronizedMap, HashSet, SynchronizedSet}
+import mutable.{LinkedHashMap, HashSet, SynchronizedSet}
 import scala.util.control.ControlThrowable
 import scala.tools.nsc.io.AbstractFile
-import scala.reflect.internal.util.{ SourceFile, BatchSourceFile, Position, NoPosition }
+import scala.reflect.internal.util.SourceFile
 import scala.tools.nsc.reporters._
 import scala.tools.nsc.symtab._
 import scala.tools.nsc.typechecker.Analyzer
@@ -82,7 +82,7 @@ trait InteractiveAnalyzer extends Analyzer {
         val existingDerivedSym = owningInfo.decl(sym.name.toTermName).filter(sym => sym.isSynthetic && sym.isMethod)
         existingDerivedSym.alternatives foreach (owningInfo.decls.unlink)
         val defTree = tree match {
-          case dd: DocDef => dd.definition // See SI-9011, Scala IDE's presentation compiler incorporates ScalaDocGlobal with InterativeGlobal, so we have to unwrap DocDefs.
+          case dd: DocDef => dd.definition // See SI-9011, Scala IDE's presentation compiler incorporates ScaladocGlobal with InteractiveGlobal, so we have to unwrap DocDefs.
           case _ => tree
         }
         enterImplicitWrapper(defTree.asInstanceOf[ClassDef])
diff --git a/src/interactive/scala/tools/nsc/interactive/Pickler.scala b/src/interactive/scala/tools/nsc/interactive/Pickler.scala
index ddc0c8a068..c0446b0402 100644
--- a/src/interactive/scala/tools/nsc/interactive/Pickler.scala
+++ b/src/interactive/scala/tools/nsc/interactive/Pickler.scala
@@ -1,9 +1,9 @@
 package scala.tools.nsc.interactive
 
+import scala.language.implicitConversions
+
 import Lexer._
 import java.io.Writer
-import scala.language.implicitConversions
-import scala.reflect.ClassTag
 
 /** An abstract class for writing and reading Scala objects to and
  *  from a legible representation. The representation follows the following grammar:
diff --git a/src/interactive/scala/tools/nsc/interactive/REPL.scala b/src/interactive/scala/tools/nsc/interactive/REPL.scala
index ffa61b0524..e9cec31975 100644
--- a/src/interactive/scala/tools/nsc/interactive/REPL.scala
+++ b/src/interactive/scala/tools/nsc/interactive/REPL.scala
@@ -9,7 +9,6 @@ package interactive
 import scala.reflect.internal.util._
 import scala.tools.nsc.reporters._
 import scala.tools.nsc.io._
-import java.io.FileWriter
 
 /** Interface of interactive compiler to a client such as an IDE
  */
diff --git a/src/interactive/scala/tools/nsc/interactive/RichCompilationUnits.scala b/src/interactive/scala/tools/nsc/interactive/RichCompilationUnits.scala
index b83c2cd095..b82888b2aa 100644
--- a/src/interactive/scala/tools/nsc/interactive/RichCompilationUnits.scala
+++ b/src/interactive/scala/tools/nsc/interactive/RichCompilationUnits.scala
@@ -5,7 +5,7 @@
 package scala.tools.nsc
 package interactive
 
-import scala.reflect.internal.util.{SourceFile, Position, NoPosition}
+import scala.reflect.internal.util.SourceFile
 import scala.collection.mutable.ArrayBuffer
 
 trait RichCompilationUnits { self: Global =>
diff --git a/src/library/scala/Enumeration.scala b/src/library/scala/Enumeration.scala
index c4aa511cd7..9d9a3f849b 100644
--- a/src/library/scala/Enumeration.scala
+++ b/src/library/scala/Enumeration.scala
@@ -9,7 +9,7 @@
 package scala
 
 import scala.collection.{ mutable, immutable, generic, SortedSetLike, AbstractSet }
-import java.lang.reflect.{ Modifier, Method => JMethod, Field => JField }
+import java.lang.reflect.{ Method => JMethod, Field => JField }
 import scala.reflect.NameTransformer._
 import scala.util.matching.Regex
 
@@ -154,14 +154,14 @@ abstract class Enumeration (initial: Int) extends Serializable {
   protected final def Value(i: Int, name: String): Value = new Val(i, name)
 
   private def populateNameMap() {
-    val fields = getClass.getDeclaredFields
-    def isValDef(m: JMethod) = fields exists (fd => fd.getName == m.getName && fd.getType == m.getReturnType)
+    val fields: Array[JField] = getClass.getDeclaredFields
+    def isValDef(m: JMethod): Boolean = fields exists (fd => fd.getName == m.getName && fd.getType == m.getReturnType)
 
     // The list of possible Value methods: 0-args which return a conforming type
-    val methods = getClass.getMethods filter (m => m.getParameterTypes.isEmpty &&
-                                                   classOf[Value].isAssignableFrom(m.getReturnType) &&
-                                                   m.getDeclaringClass != classOf[Enumeration] &&
-                                                   isValDef(m))
+    val methods: Array[JMethod] = getClass.getMethods filter (m => m.getParameterTypes.isEmpty &&
+                                                                   classOf[Value].isAssignableFrom(m.getReturnType) &&
+                                                                   m.getDeclaringClass != classOf[Enumeration] &&
+                                                                   isValDef(m))
     methods foreach { m =>
       val name = m.getName
       // invoke method to obtain actual `Value` instance
diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala
index 98dd35d306..c1a413d516 100644
--- a/src/library/scala/PartialFunction.scala
+++ b/src/library/scala/PartialFunction.scala
@@ -20,7 +20,7 @@ package scala
  *  {{{
  *  val f: PartialFunction[Int, Any] = { case _ => 1/0 }
  *  }}}
- * 
+ *
  *  It is the responsibility of the caller to call `isDefinedAt` before
  *  calling `apply`, because if `isDefinedAt` is false, it is not guaranteed
  *  `apply` will throw an exception to indicate an error condition. If an
@@ -161,7 +161,8 @@ trait PartialFunction[-A, +B] extends (A => B) { self =>
 object PartialFunction {
   /** Composite function produced by `PartialFunction#orElse` method
    */
-  private class OrElse[-A, +B] (f1: PartialFunction[A, B], f2: PartialFunction[A, B]) extends scala.runtime.AbstractPartialFunction[A, B] {
+  private class OrElse[-A, +B] (f1: PartialFunction[A, B], f2: PartialFunction[A, B])
+    extends scala.runtime.AbstractPartialFunction[A, B] with Serializable {
     def isDefinedAt(x: A) = f1.isDefinedAt(x) || f2.isDefinedAt(x)
 
     override def apply(x: A): B = f1.applyOrElse(x, f2)
@@ -180,7 +181,7 @@ object PartialFunction {
 
   /** Composite function produced by `PartialFunction#andThen` method
    */
-  private class AndThen[-A, B, +C] (pf: PartialFunction[A, B], k: B => C) extends PartialFunction[A, C] {
+  private class AndThen[-A, B, +C] (pf: PartialFunction[A, B], k: B => C) extends PartialFunction[A, C] with Serializable {
     def isDefinedAt(x: A) = pf.isDefinedAt(x)
 
     def apply(x: A): C = k(pf(x))
@@ -217,7 +218,7 @@ object PartialFunction {
   private def fallbackOccurred[B](x: B) = (fallback_pf eq x.asInstanceOf[AnyRef])
 
   private class Lifted[-A, +B] (val pf: PartialFunction[A, B])
-      extends scala.runtime.AbstractFunction1[A, Option[B]] {
+      extends scala.runtime.AbstractFunction1[A, Option[B]] with Serializable {
 
     def apply(x: A): Option[B] = {
       val z = pf.applyOrElse(x, checkFallback[B])
@@ -225,7 +226,7 @@ object PartialFunction {
     }
   }
 
-  private class Unlifted[A, B] (f: A => Option[B]) extends scala.runtime.AbstractPartialFunction[A, B] {
+  private class Unlifted[A, B] (f: A => Option[B]) extends scala.runtime.AbstractPartialFunction[A, B] with Serializable {
     def isDefinedAt(x: A): Boolean = f(x).isDefined
 
     override def applyOrElse[A1 <: A, B1 >: B](x: A1, default: A1 => B1): B1 = {
@@ -248,7 +249,7 @@ object PartialFunction {
 
   private[this] val constFalse: Any => Boolean = { _ => false}
 
-  private[this] val empty_pf: PartialFunction[Any, Nothing] = new PartialFunction[Any, Nothing] {
+  private[this] val empty_pf: PartialFunction[Any, Nothing] = new PartialFunction[Any, Nothing] with Serializable {
     def isDefinedAt(x: Any) = false
     def apply(x: Any) = throw new MatchError(x)
     override def orElse[A1, B1](that: PartialFunction[A1, B1]) = that
diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala
index a6f0fa9e78..50a53732f1 100644
--- a/src/library/scala/Predef.scala
+++ b/src/library/scala/Predef.scala
@@ -8,13 +8,14 @@
 
 package scala
 
+import scala.language.implicitConversions
+
 import scala.collection.{ mutable, immutable, generic }
 import immutable.StringOps
 import mutable.ArrayOps
 import generic.CanBuildFrom
 import scala.annotation.{ elidable, implicitNotFound }
 import scala.annotation.elidable.ASSERTION
-import scala.language.{implicitConversions, existentials}
 import scala.io.StdIn
 
 /** The `Predef` object provides definitions that are accessible in all Scala
diff --git a/src/library/scala/annotation/elidable.scala b/src/library/scala/annotation/elidable.scala
index f9c5e8a744..dd0d9b511c 100644
--- a/src/library/scala/annotation/elidable.scala
+++ b/src/library/scala/annotation/elidable.scala
@@ -8,8 +8,6 @@
 
 package scala.annotation
 
-import java.util.logging.Level
-
 /** An annotation for methods whose bodies may be excluded
  *  from compiler-generated bytecode.
  *
@@ -62,7 +60,7 @@ import java.util.logging.Level
  *  @author   Paul Phillips
  *  @since    2.8
  */
-final class elidable(final val level: Int) extends scala.annotation.StaticAnnotation {}
+final class elidable(final val level: Int) extends scala.annotation.StaticAnnotation
 
 /** This useless appearing code was necessary to allow people to use
  *  named constants for the elidable annotation.  This is what it takes
diff --git a/src/library/scala/annotation/implicitAmbiguous.scala b/src/library/scala/annotation/implicitAmbiguous.scala
index f190865623..44e8d23085 100644
--- a/src/library/scala/annotation/implicitAmbiguous.scala
+++ b/src/library/scala/annotation/implicitAmbiguous.scala
@@ -1,7 +1,5 @@
 package scala.annotation
 
-import scala.annotation.meta._
-
 /**
   * To customize the error message that's emitted when an implicit search finds
   * multiple ambiguous values, annotate at least one of the implicit values
@@ -31,4 +29,4 @@ import scala.annotation.meta._
   * @author Brian McKenna
   * @since 2.12.0
   */
-final class implicitAmbiguous(msg: String) extends scala.annotation.StaticAnnotation {}
+final class implicitAmbiguous(msg: String) extends scala.annotation.StaticAnnotation
diff --git a/src/library/scala/collection/BitSetLike.scala b/src/library/scala/collection/BitSetLike.scala
index 8a8af79151..29369447d1 100644
--- a/src/library/scala/collection/BitSetLike.scala
+++ b/src/library/scala/collection/BitSetLike.scala
@@ -115,7 +115,7 @@ trait BitSetLike[+This <: BitSetLike[This] with SortedSet[Int]] extends SortedSe
       else Iterator.empty.next()
   }
 
-  override def foreach[B](f: Int => B) {
+  override def foreach[U](f: Int => U) {
     /* NOTE: while loops are significantly faster as of 2.11 and
        one major use case of bitsets is performance. Also, there
        is nothing to do when all bits are clear, so use that as
diff --git a/src/library/scala/collection/GenMapLike.scala b/src/library/scala/collection/GenMapLike.scala
index bce9740522..2b39fa2289 100644
--- a/src/library/scala/collection/GenMapLike.scala
+++ b/src/library/scala/collection/GenMapLike.scala
@@ -124,8 +124,7 @@ trait GenMapLike[A, +B, +Repr] extends GenIterableLike[(A, B), Repr] with Equals
           }
         }
       } catch {
-        case ex: ClassCastException =>
-          println("class cast "); false
+        case ex: ClassCastException => false
       }}
     case _ =>
       false
diff --git a/src/library/scala/collection/GenTraversableLike.scala b/src/library/scala/collection/GenTraversableLike.scala
index 8b9d3e7a17..d730996be2 100644
--- a/src/library/scala/collection/GenTraversableLike.scala
+++ b/src/library/scala/collection/GenTraversableLike.scala
@@ -158,18 +158,6 @@ trait GenTraversableLike[+A, +Repr] extends Any with GenTraversableOnce[A] with
   @migration("The behavior of `scanRight` has changed. The previous behavior can be reproduced with scanRight.reverse.", "2.9.0")
   def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
 
-  /** Applies a function `f` to all elements of this $coll.
-   *
-   *  @param  f   the function that is applied for its side-effect to every element.
-   *              The result of function `f` is discarded.
-   *
-   *  @tparam  U  the type parameter describing the result of function `f`.
-   *              This result will always be ignored. Typically `U` is `Unit`,
-   *              but this is not necessary.
-   *
-   *  @usecase def foreach(f: A => Unit): Unit
-   *    @inheritdoc
-   */
   def foreach[U](f: A => U): Unit
 
   /** Builds a new collection by applying a function to all elements of this $coll.
@@ -269,16 +257,16 @@ trait GenTraversableLike[+A, +Repr] extends Any with GenTraversableOnce[A] with
    *    {{{
    *      scala> val a = List(1)
    *      a: List[Int] = List(1)
-   *      
+   *
    *      scala> val b = List(2)
    *      b: List[Int] = List(2)
-   *      
+   *
    *      scala> val c = a ++ b
    *      c: List[Int] = List(1, 2)
-   *      
+   *
    *      scala> val d = List('a')
    *      d: List[Char] = List(a)
-   *      
+   *
    *      scala> val e = c ++ d
    *      e: List[AnyVal] = List(1, 2, a)
    *    }}}
diff --git a/src/library/scala/collection/GenTraversableOnce.scala b/src/library/scala/collection/GenTraversableOnce.scala
index a45ec965f5..244ff26397 100644
--- a/src/library/scala/collection/GenTraversableOnce.scala
+++ b/src/library/scala/collection/GenTraversableOnce.scala
@@ -49,6 +49,22 @@ import scala.language.higherKinds
  */
 trait GenTraversableOnce[+A] extends Any {
 
+  /** Applies a function `f` to all elements of this $coll.
+    *
+    *  @param  f   the function that is applied for its side-effect to every element.
+    *              The result of function `f` is discarded.
+    *
+    *  @tparam  U  the type parameter describing the result of function `f`.
+    *              This result will always be ignored. Typically `U` is `Unit`,
+    *              but this is not necessary.
+    *
+    *  @usecase def foreach(f: A => Unit): Unit
+    *    @inheritdoc
+    *
+    *    Note: this method underlies the implementation of most other bulk operations.
+    *    It's important to implement this method in an efficient way.
+    *
+    */
   def foreach[U](f: A => U): Unit
 
   def hasDefiniteSize: Boolean
@@ -110,13 +126,14 @@ trait GenTraversableOnce[+A] extends Any {
    *  binary operator.
    *
    *  $undefinedorder
+   *  $willNotTerminateInf
    *
    *  @tparam A1     a type parameter for the binary operator, a supertype of `A`.
    *  @param z       a neutral element for the fold operation; may be added to the result
    *                 an arbitrary number of times, and must not change the result (e.g., `Nil` for list concatenation,
-   *                 0 for addition, or 1 for multiplication.)
-   *  @param op      a binary operator that must be associative
-   *  @return        the result of applying fold operator `op` between all the elements and `z`
+   *                 0 for addition, or 1 for multiplication).
+   *  @param op      a binary operator that must be associative.
+   *  @return        the result of applying the fold operator `op` between all the elements and `z`, or `z` if this $coll is empty.
    */
   def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1
 
@@ -205,6 +222,7 @@ trait GenTraversableOnce[+A] extends Any {
    *             op(...op(z, x_1), x_2, ..., x_n)
    *           }}}
    *           where `x,,1,,, ..., x,,n,,` are the elements of this $coll.
+   *           Returns `z` if this $coll is empty.
    */
   def foldLeft[B](z: B)(op: (B, A) => B): B
 
@@ -222,30 +240,32 @@ trait GenTraversableOnce[+A] extends Any {
    *             op(x_1, op(x_2, ... op(x_n, z)...))
    *           }}}
    *           where `x,,1,,, ..., x,,n,,` are the elements of this $coll.
+   *           Returns `z` if this $coll is empty.
    */
   def foldRight[B](z: B)(op: (A, B) => B): B
 
   /** Aggregates the results of applying an operator to subsequent elements.
    *
-   *  This is a more general form of `fold` and `reduce`. It has similar
-   *  semantics, but does not require the result to be a supertype of the
-   *  element type. It traverses the elements in different partitions
-   *  sequentially, using `seqop` to update the result, and then applies
-   *  `combop` to results from different partitions. The implementation of
-   *  this operation may operate on an arbitrary number of collection
-   *  partitions, so `combop` may be invoked an arbitrary number of times.
-   *
-   *  For example, one might want to process some elements and then produce
-   *  a `Set`. In this case, `seqop` would process an element and append it
-   *  to the list, while `combop` would concatenate two lists from different
-   *  partitions together. The initial value `z` would be an empty set.
+   *  This is a more general form of `fold` and `reduce`. It is similar to
+   *  `foldLeft` in that it doesn't require the result to be a supertype of the
+   *  element type. In addition, it allows parallel collections to be processed
+   *  in chunks, and then combines the intermediate results.
+   *
+   *  `aggregate` splits the $coll into partitions and processes each
+   *  partition by sequentially applying `seqop`, starting with `z` (like
+   *  `foldLeft`). Those intermediate results are then combined by using
+   *  `combop` (like `fold`). The implementation of this operation may operate
+   *  on an arbitrary number of collection partitions (even 1), so `combop` may
+   *  be invoked an arbitrary number of times (even 0).
+   *
+   *  As an example, consider summing up the integer values of a list of chars.
+   *  The initial value for the sum is 0. First, `seqop` transforms each input
+   *  character to an Int and adds it to the sum (of the partition). Then,
+   *  `combop` just needs to sum up the intermediate results of the partitions:
    *  {{{
-   *    pc.aggregate(Set[Int]())(_ += process(_), _ ++ _)
+   *    List('a', 'b', 'c').aggregate(0)({ (sum, ch) => sum + ch.toInt }, { (p1, p2) => p1 + p2 })
    *  }}}
    *
-   *  Another example is calculating geometric mean from a collection of doubles
-   *  (one would typically require big doubles for this).
-   *
    *  @tparam B        the type of accumulated results
    *  @param z         the initial value for the accumulated result of the partition - this
    *                   will typically be the neutral element for the `seqop` operator (e.g.
@@ -423,13 +443,13 @@ trait GenTraversableOnce[+A] extends Any {
    */
   def find(@deprecatedName('pred) p: A => Boolean): Option[A]
 
-  /** Copies values of this $coll to an array.
+  /** Copies the elements of this $coll to an array.
    *  Fills the given array `xs` with values of this $coll.
    *  Copying will stop once either the end of the current $coll is reached,
-   *  or the end of the array is reached.
+   *  or the end of the target array is reached.
    *
    *  @param  xs     the array to fill.
-   *  @tparam B      the type of the elements of the array.
+   *  @tparam B      the type of the elements of the target array.
    *
    *  @usecase def copyToArray(xs: Array[A]): Unit
    *    @inheritdoc
@@ -438,14 +458,14 @@ trait GenTraversableOnce[+A] extends Any {
    */
   def copyToArray[B >: A](xs: Array[B]): Unit
 
-  /** Copies values of this $coll to an array.
+  /** Copies the elements of this $coll to an array.
    *  Fills the given array `xs` with values of this $coll, beginning at index `start`.
    *  Copying will stop once either the end of the current $coll is reached,
-   *  or the end of the array is reached.
+   *  or the end of the target array is reached.
    *
    *  @param  xs     the array to fill.
    *  @param  start  the starting index.
-   *  @tparam B      the type of the elements of the array.
+   *  @tparam B      the type of the elements of the target array.
    *
    *  @usecase def copyToArray(xs: Array[A], start: Int): Unit
    *    @inheritdoc
@@ -454,6 +474,22 @@ trait GenTraversableOnce[+A] extends Any {
    */
   def copyToArray[B >: A](xs: Array[B], start: Int): Unit
 
+  /** Copies the elements of this $coll to an array.
+   *  Fills the given array `xs` with at most `len` elements of
+   *  this $coll, starting at position `start`.
+   *  Copying will stop once either the end of the current $coll is reached,
+   *  or the end of the target array is reached, or `len` elements have been copied.
+   *
+   *  @param  xs     the array to fill.
+   *  @param  start  the starting index.
+   *  @param  len    the maximal number of elements to copy.
+   *  @tparam B      the type of the elements of the target array.
+   *
+   *  @usecase def copyToArray(xs: Array[A], start: Int, len: Int): Unit
+   *    @inheritdoc
+   *
+   *    $willNotTerminateInf
+   */
   def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit
 
   /** Displays all elements of this $coll in a string using start, end, and
diff --git a/src/library/scala/collection/IndexedSeqLike.scala b/src/library/scala/collection/IndexedSeqLike.scala
index 18c9175ee1..f4bf58ffe3 100644
--- a/src/library/scala/collection/IndexedSeqLike.scala
+++ b/src/library/scala/collection/IndexedSeqLike.scala
@@ -9,9 +9,6 @@
 package scala
 package collection
 
-import mutable.ArrayBuffer
-import scala.annotation.tailrec
-
 /** A template trait for indexed sequences of type `IndexedSeq[A]`.
  *
  *  $indexedSeqInfo
diff --git a/src/library/scala/collection/IndexedSeqOptimized.scala b/src/library/scala/collection/IndexedSeqOptimized.scala
index a7e06b4d1a..3765b2fff0 100644
--- a/src/library/scala/collection/IndexedSeqOptimized.scala
+++ b/src/library/scala/collection/IndexedSeqOptimized.scala
@@ -10,7 +10,6 @@ package scala
 package collection
 
 import generic._
-import mutable.ArrayBuffer
 import scala.annotation.tailrec
 
 /** A template trait for indexed sequences of type `IndexedSeq[A]` which optimizes
diff --git a/src/library/scala/collection/IterableLike.scala b/src/library/scala/collection/IterableLike.scala
index ecf64624e8..b89720da78 100644
--- a/src/library/scala/collection/IterableLike.scala
+++ b/src/library/scala/collection/IterableLike.scala
@@ -10,8 +10,7 @@ package scala
 package collection
 
 import generic._
-import immutable.{ List, Stream }
-import scala.annotation.unchecked.uncheckedVariance
+import immutable.Stream
 
 /** A template trait for iterable collections of type `Iterable[A]`.
  *  $iterableInfo
@@ -83,8 +82,8 @@ self =>
     iterator.foldRight(z)(op)
   override /*TraversableLike*/ def reduceRight[B >: A](op: (A, B) => B): B =
     iterator.reduceRight(op)
-    
-  
+
+
   /** Returns this $coll as an iterable collection.
    *
    *  A new collection will not be built; lazy collections will stay lazy.
@@ -94,7 +93,7 @@ self =>
    */
   override /*TraversableLike*/ def toIterable: Iterable[A] =
     thisCollection
-  
+
   /** Returns an Iterator over the elements in this $coll.  Produces the same
    *  result as `iterator`.
    *  $willNotTerminateInf
@@ -102,7 +101,7 @@ self =>
    */
   @deprecatedOverriding("toIterator should stay consistent with iterator for all Iterables: override iterator instead.", "2.11.0")
   override def toIterator: Iterator[A] = iterator
-  
+
   override /*TraversableLike*/ def head: A =
     iterator.next()
 
diff --git a/src/library/scala/collection/IterableProxyLike.scala b/src/library/scala/collection/IterableProxyLike.scala
index 90e630ee28..334b511fb9 100644
--- a/src/library/scala/collection/IterableProxyLike.scala
+++ b/src/library/scala/collection/IterableProxyLike.scala
@@ -12,7 +12,6 @@ package scala
 package collection
 
 import generic._
-import mutable.Buffer
 
 // Methods could be printed by  cat IterableLike.scala | egrep '^  (override )?def'
 
diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala
index ff10fb44d7..17bb83e52e 100644
--- a/src/library/scala/collection/Iterator.scala
+++ b/src/library/scala/collection/Iterator.scala
@@ -12,8 +12,6 @@ package collection
 import mutable.ArrayBuffer
 import scala.annotation.migration
 import immutable.Stream
-import scala.collection.generic.CanBuildFrom
-import scala.annotation.unchecked.{ uncheckedVariance => uV }
 
 /** The `Iterator` object provides various functions for creating specialized iterators.
  *
@@ -521,13 +519,13 @@ trait Iterator[+A] extends TraversableOnce[A] {
   def collect[B](pf: PartialFunction[A, B]): Iterator[B] = new AbstractIterator[B] {
     // Manually buffer to avoid extra layer of wrapping with buffered
     private[this] var hd: A = _
-    
+
     // Little state machine to keep track of where we are
     // Seek = 0; Found = 1; Empty = -1
     // Not in vals because scalac won't make them static (@inline def only works with -optimize)
     // BE REALLY CAREFUL TO KEEP COMMENTS AND NUMBERS IN SYNC!
     private[this] var status = 0/*Seek*/
-    
+
     def hasNext = {
       while (status == 0/*Seek*/) {
         if (self.hasNext) {
@@ -700,9 +698,9 @@ trait Iterator[+A] extends TraversableOnce[A] {
         }
       }
     }
-    
+
     val leading = new Leading
-    
+
     val trailing = new AbstractIterator[A] {
       private[this] var myLeading = leading
       /* Status flags meanings:
@@ -738,7 +736,7 @@ trait Iterator[+A] extends TraversableOnce[A] {
         }
         else Iterator.empty.next()
       }
-            
+
       override def toString = "unknown-if-empty iterator"
     }
 
@@ -772,7 +770,7 @@ trait Iterator[+A] extends TraversableOnce[A] {
         status = 1
         false
       }
-    def next() = 
+    def next() =
       if (hasNext) {
         if (status == 1) self.next()
         else {
@@ -890,7 +888,7 @@ trait Iterator[+A] extends TraversableOnce[A] {
    *  @usecase def foreach(f: A => Unit): Unit
    *    @inheritdoc
    */
-  def foreach[U](f: A =>  U) { while (hasNext) f(next()) }
+  def foreach[U](f: A => U) { while (hasNext) f(next()) }
 
   /** Tests whether a predicate holds for all values produced by this iterator.
    *  $mayNotTerminateInf
@@ -1325,7 +1323,7 @@ trait Iterator[+A] extends TraversableOnce[A] {
    */
   def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit = {
     var i = start
-    val end = start + math.min(len, xs.length - start)   
+    val end = start + math.min(len, xs.length - start)
     while (i < end && hasNext) {
       xs(i) = next()
       i += 1
diff --git a/src/library/scala/collection/LinearSeqOptimized.scala b/src/library/scala/collection/LinearSeqOptimized.scala
index 571d58a3f3..a3860f10a4 100644
--- a/src/library/scala/collection/LinearSeqOptimized.scala
+++ b/src/library/scala/collection/LinearSeqOptimized.scala
@@ -9,8 +9,6 @@
 package scala
 package collection
 
-import mutable.ListBuffer
-import immutable.List
 import scala.annotation.tailrec
 
 /** A template trait for linear sequences of type `LinearSeq[A]` which optimizes
@@ -67,7 +65,7 @@ trait LinearSeqOptimized[+A, +Repr <: LinearSeqOptimized[A, Repr]] extends Linea
   }
 
   override /*IterableLike*/
-  def foreach[B](f: A => B) {
+  def foreach[U](f: A => U) {
     var these = this
     while (!these.isEmpty) {
       f(these.head)
diff --git a/src/library/scala/collection/MapLike.scala b/src/library/scala/collection/MapLike.scala
index b474abc12a..4ac87b29a9 100644
--- a/src/library/scala/collection/MapLike.scala
+++ b/src/library/scala/collection/MapLike.scala
@@ -11,7 +11,7 @@ package collection
 
 import generic._
 import mutable.{ Builder, MapBuilder }
-import scala.annotation.{migration, bridge}
+import scala.annotation.migration
 import parallel.ParMap
 
 /** A template trait for maps, which associate keys with values.
@@ -171,7 +171,7 @@ self =>
     def + (elem: A): Set[A] = (Set[A]() ++ this + elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
     def - (elem: A): Set[A] = (Set[A]() ++ this - elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
     override def size = self.size
-    override def foreach[C](f: A => C) = self.keysIterator foreach f
+    override def foreach[U](f: A => U) = self.keysIterator foreach f
   }
 
   /** Creates an iterator for all keys.
@@ -203,7 +203,7 @@ self =>
   protected class DefaultValuesIterable extends AbstractIterable[B] with Iterable[B] with Serializable {
     def iterator = valuesIterator
     override def size = self.size
-    override def foreach[C](f: B => C) = self.valuesIterator foreach f
+    override def foreach[U](f: B => U) = self.valuesIterator foreach f
   }
 
   /** Creates an iterator for all values in this map.
@@ -228,7 +228,7 @@ self =>
     throw new NoSuchElementException("key not found: " + key)
 
   protected class FilteredKeys(p: A => Boolean) extends AbstractMap[A, B] with DefaultMap[A, B] {
-    override def foreach[C](f: ((A, B)) => C): Unit = for (kv <- self) if (p(kv._1)) f(kv)
+    override def foreach[U](f: ((A, B)) => U): Unit = for (kv <- self) if (p(kv._1)) f(kv)
     def iterator = self.iterator.filter(kv => p(kv._1))
     override def contains(key: A) = p(key) && self.contains(key)
     def get(key: A) = if (!p(key)) None else self.get(key)
@@ -246,7 +246,7 @@ self =>
   def filterKeys(p: A => Boolean): Map[A, B] = new FilteredKeys(p)
 
   protected class MappedValues[C](f: B => C) extends AbstractMap[A, C] with DefaultMap[A, C] {
-    override def foreach[D](g: ((A, C)) => D): Unit = for ((k, v) <- self) g((k, f(v)))
+    override def foreach[U](g: ((A, C)) => U): Unit = for ((k, v) <- self) g((k, f(v)))
     def iterator = for ((k, v) <- self.iterator) yield (k, f(v))
     override def size = self.size
     override def contains(key: A) = self.contains(key)
@@ -331,8 +331,8 @@ self =>
       foreach(vb += _)
       vb.result
     }
-  }  
-  
+  }
+
   override def toBuffer[C >: (A, B)]: mutable.Buffer[C] = {
     val result = new mutable.ArrayBuffer[C](size)
     // Faster to let the map iterate itself than to defer through copyToBuffer
diff --git a/src/library/scala/collection/SeqLike.scala b/src/library/scala/collection/SeqLike.scala
index b775480532..a26765027c 100644
--- a/src/library/scala/collection/SeqLike.scala
+++ b/src/library/scala/collection/SeqLike.scala
@@ -9,11 +9,10 @@
 package scala
 package collection
 
-import mutable.{ ListBuffer, ArraySeq }
 import immutable.{ List, Range }
 import generic._
 import parallel.ParSeq
-import scala.math.{ min, max, Ordering }
+import scala.math.Ordering
 
 /** A template trait for sequences of type `Seq[A]`
  *  $seqInfo
@@ -146,7 +145,7 @@ trait SeqLike[+A, +Repr] extends Any with IterableLike[A, Repr] with GenSeqLike[
    *  more than one way to generate the same subsequence, only one will be returned.
    *
    *  For example, `"xyyy"` has three different ways to generate `"xy"` depending on
-   *  whether the first, second, or third `"y"` is selected.  However, since all are 
+   *  whether the first, second, or third `"y"` is selected.  However, since all are
    *  identical, only one will be chosen.  Which of the three will be taken is an
    *  implementation detail that is not defined.
    *
diff --git a/src/library/scala/collection/SetLike.scala b/src/library/scala/collection/SetLike.scala
index d03c808c2c..9143c40870 100644
--- a/src/library/scala/collection/SetLike.scala
+++ b/src/library/scala/collection/SetLike.scala
@@ -11,7 +11,7 @@ package collection
 
 import generic._
 import mutable.{ Builder, SetBuilder }
-import scala.annotation.{migration, bridge}
+import scala.annotation.migration
 import parallel.ParSet
 
 /** A template trait for sets.
@@ -86,7 +86,7 @@ self =>
       vb.result
     }
   }
-  
+
   override def toBuffer[A1 >: A]: mutable.Buffer[A1] = {
     val result = new mutable.ArrayBuffer[A1](size)
     // Faster to let the map iterate itself than to defer through copyToBuffer
diff --git a/src/library/scala/collection/Traversable.scala b/src/library/scala/collection/Traversable.scala
index a35750a35f..8145eaa204 100644
--- a/src/library/scala/collection/Traversable.scala
+++ b/src/library/scala/collection/Traversable.scala
@@ -38,7 +38,7 @@ trait Traversable[+A] extends TraversableLike[A, Traversable[A]]
   override def remove(p: A => Boolean): Traversable[A]
   override def partition(p: A => Boolean): (Traversable[A], Traversable[A])
   override def groupBy[K](f: A => K): Map[K, Traversable[A]]
-  override def foreach[U](f: A =>  U): Unit
+  override def foreach[U](f: A => U): Unit
   override def forall(p: A => Boolean): Boolean
   override def exists(p: A => Boolean): Boolean
   override def count(p: A => Boolean): Int
diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala
index a0b1430d17..fa9a3a7482 100644
--- a/src/library/scala/collection/TraversableLike.scala
+++ b/src/library/scala/collection/TraversableLike.scala
@@ -11,7 +11,7 @@ package collection
 
 import generic._
 import mutable.{ Builder }
-import scala.annotation.{tailrec, migration, bridge}
+import scala.annotation.migration
 import scala.annotation.unchecked.{ uncheckedVariance => uV }
 import parallel.ParIterable
 import scala.language.higherKinds
@@ -340,14 +340,6 @@ trait TraversableLike[+A, +Repr] extends Any
     b.result
   }
 
-  /** Tests whether a predicate holds for all elements of this $coll.
-   *
-   *  $mayNotTerminateInf
-   *
-   *  @param   p     the predicate used to test elements.
-   *  @return        `true`  if this $coll is empty, otherwise `true` if the given predicate `p`
-    *                holds for all elements of this $coll, otherwise `false`.
-   */
   def forall(p: A => Boolean): Boolean = {
     var result = true
     breakable {
@@ -374,15 +366,6 @@ trait TraversableLike[+A, +Repr] extends Any
     result
   }
 
-  /** Finds the first element of the $coll satisfying a predicate, if any.
-   *
-   *  $mayNotTerminateInf
-   *  $orderDependent
-   *
-   *  @param p    the predicate used to test elements.
-   *  @return     an option value containing the first element in the $coll
-   *              that satisfies `p`, or `None` if none exists.
-   */
   def find(p: A => Boolean): Option[A] = {
     var result: Option[A] = None
     breakable {
@@ -594,23 +577,6 @@ trait TraversableLike[+A, +Repr] extends Any
    */
   def inits: Iterator[Repr] = iterateUntilEmpty(_.init)
 
-  /** Copies elements of this $coll to an array.
-   *  Fills the given array `xs` with at most `len` elements of
-   *  this $coll, starting at position `start`.
-   *  Copying will stop once either the end of the current $coll is reached,
-   *  or the end of the array is reached, or `len` elements have been copied.
-   *
-   *  @param  xs     the array to fill.
-   *  @param  start  the starting index.
-   *  @param  len    the maximal number of elements to copy.
-   *  @tparam B      the type of the elements of the array.
-   *
-   *
-   *  @usecase def copyToArray(xs: Array[A], start: Int, len: Int): Unit
-   *    @inheritdoc
-   *
-   *    $willNotTerminateInf
-   */
   def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) {
     var i = start
     val end = (start + len) min xs.length
@@ -625,7 +591,7 @@ trait TraversableLike[+A, +Repr] extends Any
 
   @deprecatedOverriding("Enforce contract of toTraversable that if it is Traversable it returns itself.", "2.11.0")
   def toTraversable: Traversable[A] = thisCollection
-  
+
   def toIterator: Iterator[A] = toStream.iterator
   def toStream: Stream[A] = toBuffer.toStream
   // Override to provide size hint.
diff --git a/src/library/scala/collection/TraversableOnce.scala b/src/library/scala/collection/TraversableOnce.scala
index c5b0d0f085..41362e8dd7 100644
--- a/src/library/scala/collection/TraversableOnce.scala
+++ b/src/library/scala/collection/TraversableOnce.scala
@@ -9,7 +9,7 @@
 package scala
 package collection
 
-import mutable.{ Buffer, Builder, ListBuffer, ArrayBuffer }
+import mutable.{ Buffer, Builder, ArrayBuffer }
 import generic.CanBuildFrom
 import scala.annotation.unchecked.{ uncheckedVariance => uV }
 import scala.language.{implicitConversions, higherKinds}
@@ -61,7 +61,8 @@ import scala.reflect.ClassTag
 trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
   self =>
 
-  /** Self-documenting abstract methods. */
+  /* Self-documenting abstract methods. */
+
   def foreach[U](f: A => U): Unit
   def isEmpty: Boolean
   def hasDefiniteSize: Boolean
@@ -334,10 +335,10 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
    * {{{
    *      scala> val a = List(1,2,3,4)
    *      a: List[Int] = List(1, 2, 3, 4)
-   *      
+   *
    *      scala> val b = new StringBuilder()
-   *      b: StringBuilder = 
-   *      
+   *      b: StringBuilder =
+   *
    *      scala> a.addString(b , "List(" , ", " , ")")
    *      res5: StringBuilder = List(1, 2, 3, 4)
    * }}}
@@ -376,7 +377,7 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
    * {{{
    *      scala> val a = List(1,2,3,4)
    *      a: List[Int] = List(1, 2, 3, 4)
-   *      
+   *
    *      scala> val b = new StringBuilder()
    *      b: StringBuilder =
    *
@@ -399,7 +400,7 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] {
    * {{{
    *      scala> val a = List(1,2,3,4)
    *      a: List[Int] = List(1, 2, 3, 4)
-   *      
+   *
    *      scala> val b = new StringBuilder()
    *      b: StringBuilder =
    *
diff --git a/src/library/scala/collection/TraversableProxyLike.scala b/src/library/scala/collection/TraversableProxyLike.scala
index 4399dbc289..fa470ea238 100644
--- a/src/library/scala/collection/TraversableProxyLike.scala
+++ b/src/library/scala/collection/TraversableProxyLike.scala
@@ -28,7 +28,7 @@ import scala.reflect.ClassTag
 trait TraversableProxyLike[+A, +Repr <: TraversableLike[A, Repr] with Traversable[A]] extends TraversableLike[A, Repr] with Proxy {
   def self: Repr
 
-  override def foreach[B](f: A => B): Unit = self.foreach(f)
+  override def foreach[U](f: A => U): Unit = self.foreach(f)
   override def isEmpty: Boolean = self.isEmpty
   override def nonEmpty: Boolean = self.nonEmpty
   override def size: Int = self.size
diff --git a/src/library/scala/collection/concurrent/TrieMap.scala b/src/library/scala/collection/concurrent/TrieMap.scala
index 426f9bf864..d113cbfcdf 100644
--- a/src/library/scala/collection/concurrent/TrieMap.scala
+++ b/src/library/scala/collection/concurrent/TrieMap.scala
@@ -11,13 +11,11 @@ package collection
 package concurrent
 
 import java.util.concurrent.atomic._
-import scala.collection.immutable.{ ListMap => ImmutableListMap }
 import scala.collection.parallel.mutable.ParTrieMap
 import scala.util.hashing.Hashing
 import scala.util.control.ControlThrowable
 import generic._
 import scala.annotation.tailrec
-import scala.annotation.switch
 
 private[collection] final class INode[K, V](bn: MainNode[K, V], g: Gen) extends INodeBase[K, V](g) {
   import INodeBase._
diff --git a/src/library/scala/collection/convert/WrapAsScala.scala b/src/library/scala/collection/convert/WrapAsScala.scala
index 7332b71af1..ee161dcc87 100644
--- a/src/library/scala/collection/convert/WrapAsScala.scala
+++ b/src/library/scala/collection/convert/WrapAsScala.scala
@@ -139,13 +139,13 @@ trait WrapAsScala {
    * If the Java `Map` was previously obtained from an implicit or
    * explicit call of `mapAsScalaMap(scala.collection.mutable.Map)` then
    * the original Scala Map will be returned.
-   * 
+   *
    * If the wrapped map is synchronized (e.g. from `java.util.Collections.synchronizedMap`),
-   * it is your responsibility to wrap all 
+   * it is your responsibility to wrap all
    * non-atomic operations with `underlying.synchronized`.
    * This includes `get`, as `java.util.Map`'s API does not allow for an
    * atomic `get` when `null` values may be present.
-   * 
+   *
    * @param m The Map to be converted.
    * @return A Scala mutable Map view of the argument.
    */
@@ -170,20 +170,20 @@ trait WrapAsScala {
    */
   implicit def mapAsScalaConcurrentMap[A, B](m: juc.ConcurrentMap[A, B]): concurrent.Map[A, B] = m match {
     case null                             => null
-    case cmw: ConcurrentMapWrapper[A, B]  => cmw.underlying
+    case cmw: ConcurrentMapWrapper[_, _]  => cmw.underlying
     case _                                => new JConcurrentMapWrapper(m)
   }
 
   /**
    * Implicitly converts a Java `Dictionary` to a Scala mutable
-   * `Map[String, String]`.
+   * `Map`.
    *
-   * The returned Scala `Map[String, String]` is backed by the provided Java
+   * The returned Scala `Map` is backed by the provided Java
    * `Dictionary` and any side-effects of using it via the Scala interface
    * will be visible via the Java interface and vice versa.
    *
    * @param p The Dictionary to be converted.
-   * @return  A Scala mutable Map[String, String] view of the argument.
+   * @return  A Scala mutable Map view of the argument.
    */
   implicit def dictionaryAsScalaMap[A, B](p: ju.Dictionary[A, B]): mutable.Map[A, B] = p match {
     case null                       => null
diff --git a/src/library/scala/collection/generic/GenericParTemplate.scala b/src/library/scala/collection/generic/GenericParTemplate.scala
index b9b7043270..44a778a953 100644
--- a/src/library/scala/collection/generic/GenericParTemplate.scala
+++ b/src/library/scala/collection/generic/GenericParTemplate.scala
@@ -13,7 +13,6 @@ package generic
 import scala.collection.parallel.Combiner
 import scala.collection.parallel.ParIterable
 import scala.collection.parallel.ParMap
-import scala.collection.parallel.TaskSupport
 
 import scala.annotation.unchecked.uncheckedVariance
 import scala.language.higherKinds
diff --git a/src/library/scala/collection/generic/MapFactory.scala b/src/library/scala/collection/generic/MapFactory.scala
index b9f3d4b010..255d695303 100644
--- a/src/library/scala/collection/generic/MapFactory.scala
+++ b/src/library/scala/collection/generic/MapFactory.scala
@@ -10,8 +10,6 @@ package scala
 package collection
 package generic
 
-
-import mutable.{Builder, MapBuilder}
 import scala.language.higherKinds
 
 /** A template for companion objects of `Map` and subclasses thereof.
diff --git a/src/library/scala/collection/generic/ParFactory.scala b/src/library/scala/collection/generic/ParFactory.scala
index 4486cea419..901e9fc239 100644
--- a/src/library/scala/collection/generic/ParFactory.scala
+++ b/src/library/scala/collection/generic/ParFactory.scala
@@ -11,7 +11,6 @@ package collection
 package generic
 
 import scala.collection.parallel.ParIterable
-import scala.collection.parallel.Combiner
 import scala.language.higherKinds
 
 /** A template class for companion objects of `ParIterable` and subclasses
diff --git a/src/library/scala/collection/generic/ParSetFactory.scala b/src/library/scala/collection/generic/ParSetFactory.scala
index 4320635ae6..1341ddcb38 100644
--- a/src/library/scala/collection/generic/ParSetFactory.scala
+++ b/src/library/scala/collection/generic/ParSetFactory.scala
@@ -10,7 +10,6 @@ package scala
 package collection
 package generic
 
-import scala.collection.mutable.Builder
 import scala.collection.parallel.Combiner
 import scala.collection.parallel.ParSet
 import scala.collection.parallel.ParSetLike
diff --git a/src/library/scala/collection/generic/SetFactory.scala b/src/library/scala/collection/generic/SetFactory.scala
index fcd8d00c18..5e50844cc9 100644
--- a/src/library/scala/collection/generic/SetFactory.scala
+++ b/src/library/scala/collection/generic/SetFactory.scala
@@ -12,7 +12,6 @@ package scala
 package collection
 package generic
 
-import mutable.Builder
 import scala.language.higherKinds
 
 abstract class SetFactory[CC[X] <: Set[X] with SetLike[X, CC[X]]]
diff --git a/src/library/scala/collection/generic/TraversableForwarder.scala b/src/library/scala/collection/generic/TraversableForwarder.scala
index 1d7974f7a4..359ea402b6 100644
--- a/src/library/scala/collection/generic/TraversableForwarder.scala
+++ b/src/library/scala/collection/generic/TraversableForwarder.scala
@@ -32,7 +32,7 @@ trait TraversableForwarder[+A] extends Traversable[A] {
   /** The traversable object to which calls are forwarded. */
   protected def underlying: Traversable[A]
 
-  override def foreach[B](f: A => B): Unit = underlying foreach f
+  override def foreach[U](f: A => U): Unit = underlying foreach f
   override def isEmpty: Boolean = underlying.isEmpty
   override def nonEmpty: Boolean = underlying.nonEmpty
   override def size: Int = underlying.size
diff --git a/src/library/scala/collection/generic/package.scala b/src/library/scala/collection/generic/package.scala
index 1beb4a8599..015c3455db 100644
--- a/src/library/scala/collection/generic/package.scala
+++ b/src/library/scala/collection/generic/package.scala
@@ -1,6 +1,5 @@
 package scala
 package collection
-import generic.CanBuildFrom
 
 import scala.language.higherKinds
 
diff --git a/src/library/scala/collection/immutable/BitSet.scala b/src/library/scala/collection/immutable/BitSet.scala
index 70543aa3a6..846bc22182 100644
--- a/src/library/scala/collection/immutable/BitSet.scala
+++ b/src/library/scala/collection/immutable/BitSet.scala
@@ -14,7 +14,7 @@ package immutable
 
 import generic._
 import BitSetLike.{LogWL, updateArray}
-import mutable.{ Builder, SetBuilder }
+import mutable.Builder
 
 /** A class for immutable bitsets.
  *  $bitsetinfo
diff --git a/src/library/scala/collection/immutable/HashMap.scala b/src/library/scala/collection/immutable/HashMap.scala
index 3b3e65ea61..92d915fe8b 100644
--- a/src/library/scala/collection/immutable/HashMap.scala
+++ b/src/library/scala/collection/immutable/HashMap.scala
@@ -48,7 +48,7 @@ class HashMap[A, +B] extends AbstractMap[A, B]
 
   def iterator: Iterator[(A,B)] = Iterator.empty
 
-  override def foreach[U](f: ((A, B)) =>  U): Unit = { }
+  override def foreach[U](f: ((A, B)) => U): Unit = ()
 
   def get(key: A): Option[B] =
     get0(key, computeHash(key), 0)
@@ -422,7 +422,7 @@ object HashMap extends ImmutableMapFactory[HashMap] with BitOperations.Int {
       final override def getElem(cc: AnyRef): (A, B) = cc.asInstanceOf[HashMap1[A, B]].ensurePair
     }
 
-    override def foreach[U](f: ((A, B)) =>  U): Unit = {
+    override def foreach[U](f: ((A, B)) => U): Unit = {
       var i = 0
       while (i < elems.length) {
         elems(i).foreach(f)
diff --git a/src/library/scala/collection/immutable/HashSet.scala b/src/library/scala/collection/immutable/HashSet.scala
index 603d97c3ad..07758bf5a2 100644
--- a/src/library/scala/collection/immutable/HashSet.scala
+++ b/src/library/scala/collection/immutable/HashSet.scala
@@ -53,7 +53,7 @@ class HashSet[A] extends AbstractSet[A]
 
   def iterator: Iterator[A] = Iterator.empty
 
-  override def foreach[U](f: A =>  U): Unit = { }
+  override def foreach[U](f: A => U): Unit = ()
 
   def contains(e: A): Boolean = get0(e, computeHash(e), 0)
 
@@ -215,7 +215,7 @@ object HashSet extends ImmutableSetFactory[HashSet] {
 
   private object EmptyHashSet extends HashSet[Any] { }
   private[collection] def emptyInstance: HashSet[Any] = EmptyHashSet
-  
+
   // utility method to create a HashTrieSet from two leaf HashSets (HashSet1 or HashSetCollision1) with non-colliding hash code)
   private def makeHashTrieSet[A](hash0:Int, elem0:HashSet[A], hash1:Int, elem1:HashSet[A], level:Int) : HashTrieSet[A] = {
     val index0 = (hash0 >>> level) & 0x1f
@@ -966,7 +966,7 @@ object HashSet extends ImmutableSetFactory[HashSet] {
       final override def getElem(cc: AnyRef): A = cc.asInstanceOf[HashSet1[A]].key
     }
 
-    override def foreach[U](f: A =>  U): Unit = {
+    override def foreach[U](f: A => U): Unit = {
       var i = 0
       while (i < elems.length) {
         elems(i).foreach(f)
diff --git a/src/library/scala/collection/immutable/IntMap.scala b/src/library/scala/collection/immutable/IntMap.scala
index cb6196e130..c6bf6a77e8 100644
--- a/src/library/scala/collection/immutable/IntMap.scala
+++ b/src/library/scala/collection/immutable/IntMap.scala
@@ -184,7 +184,7 @@ sealed abstract class IntMap[+T] extends AbstractMap[Int, T]
   /**
    * Loops over the key, value pairs of the map in unsigned order of the keys.
    */
-  override final def foreach[U](f: ((Int, T)) =>  U): Unit = this match {
+  override final def foreach[U](f: ((Int, T)) => U): Unit = this match {
     case IntMap.Bin(_, _, left, right) => { left.foreach(f); right.foreach(f) }
     case IntMap.Tip(key, value) => f((key, value))
     case IntMap.Nil =>
diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala
index 66150c1a13..c09328cae6 100644
--- a/src/library/scala/collection/immutable/List.scala
+++ b/src/library/scala/collection/immutable/List.scala
@@ -25,6 +25,19 @@ import java.io.{ObjectOutputStream, ObjectInputStream}
  *  This class is optimal for last-in-first-out (LIFO), stack-like access patterns. If you need another access
  *  pattern, for example, random access or FIFO, consider using a collection more suited to this than `List`.
  *
+ *  ==Performance==
+ *  '''Time:''' `List` has `O(1)` prepend and head/tail access. Most other operations are `O(n)` on the number of elements in the list.
+ *  This includes the index-based lookup of elements, `length`, `append` and `reverse`.
+ *
+ *  '''Space:''' `List` implements '''structural sharing''' of the tail list. This means that many operations are either
+ *  zero- or constant-memory cost.
+ *  {{{
+ *  val mainList = List(3, 2, 1)
+ *  val with4 =    4 :: mainList  // re-uses mainList, costs one :: instance
+ *  val with42 =   42 :: mainList // also re-uses mainList, cost one :: instance
+ *  val shorter =  mainList.tail  // costs nothing as it uses the same 2::1::Nil instances as mainList
+ *  }}}
+ *
  *  @example {{{
  *  // Make a list via the companion object factory
  *  val days = List("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday")
@@ -41,19 +54,6 @@ import java.io.{ObjectOutputStream, ObjectInputStream}
  *  }
  *  }}}
  *
- *  ==Performance==
- *  '''Time:''' `List` has `O(1)` prepend and head/tail access. Most other operations are `O(n)` on the number of elements in the list.
- *  This includes the index-based lookup of elements, `length`, `append` and `reverse`.
- *
- *  '''Space:''' `List` implements '''structural sharing''' of the tail list. This means that many operations are either
- *  zero- or constant-memory cost.
- *  {{{
- *  val mainList = List(3, 2, 1)
- *  val with4 =    4 :: mainList  // re-uses mainList, costs one :: instance
- *  val with42 =   42 :: mainList // also re-uses mainList, cost one :: instance
- *  val shorter =  mainList.tail  // costs nothing as it uses the same 2::1::Nil instances as mainList
- *  }}}
- *
  *  @note The functional list is characterized by persistence and structural sharing, thus offering considerable
  *        performance and space consumption benefits in some scenarios if used correctly.
  *        However, note that objects having multiple references into the same functional list (that is,
@@ -89,8 +89,6 @@ sealed abstract class List[+A] extends AbstractSeq[A]
                                   with scala.Serializable {
   override def companion: GenericCompanion[List] = List
 
-  import scala.collection.{Iterable, Traversable, Seq, IndexedSeq}
-
   def isEmpty: Boolean
   def head: A
   def tail: List[A]
@@ -265,7 +263,7 @@ sealed abstract class List[+A] extends AbstractSeq[A]
     }
     (b.toList, these)
   }
-  
+
   final override def map[B, That](f: A => B)(implicit bf: CanBuildFrom[List[A], B, That]): That = {
     if (bf eq List.ReusableCBF) {
       if (this eq Nil) Nil.asInstanceOf[That] else {
@@ -283,7 +281,7 @@ sealed abstract class List[+A] extends AbstractSeq[A]
     }
     else super.map(f)
   }
-  
+
   final override def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[List[A], B, That]): That = {
     if (bf eq List.ReusableCBF) {
       if (this eq Nil) Nil.asInstanceOf[That] else {
@@ -312,7 +310,7 @@ sealed abstract class List[+A] extends AbstractSeq[A]
     }
     else super.collect(pf)
   }
-  
+
   final override def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[List[A], B, That]): That = {
     if (bf eq List.ReusableCBF) {
       if (this eq Nil) Nil.asInstanceOf[That] else {
@@ -452,7 +450,7 @@ object List extends SeqFactory[List] {
   override def empty[A]: List[A] = Nil
 
   override def apply[A](xs: A*): List[A] = xs.toList
-  
+
   private[collection] val partialNotApplied = new Function1[Any, Any] { def apply(x: Any): Any = this }
 
   @SerialVersionUID(1L)
diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala
index c59f4f7436..f30c0cbf8e 100644
--- a/src/library/scala/collection/immutable/ListMap.scala
+++ b/src/library/scala/collection/immutable/ListMap.scala
@@ -13,7 +13,7 @@ package collection
 package immutable
 
 import generic._
-import scala.annotation.{tailrec, bridge}
+import scala.annotation.tailrec
 
 /** $factoryInfo
  *  @since 1
@@ -30,7 +30,7 @@ object ListMap extends ImmutableMapFactory[ListMap] {
   def empty[A, B]: ListMap[A, B] = EmptyListMap.asInstanceOf[ListMap[A, B]]
 
   @SerialVersionUID(-8256686706655863282L)
-  private object EmptyListMap extends ListMap[Any, Nothing] { 
+  private object EmptyListMap extends ListMap[Any, Nothing] {
     override def apply(key: Any) = throw new NoSuchElementException("key not found: " + key)
     override def contains(key: Any) = false
   }
@@ -179,16 +179,16 @@ extends AbstractMap[A, B]
     @tailrec private def get0(cur: ListMap[A, B1], k: A): Option[B1] =
       if (k == cur.key) Some(cur.value)
       else if (cur.next.nonEmpty) get0(cur.next, k) else None
-      
-      
+
+
     override def contains(key: A): Boolean = contains0(this, key)
-    
+
     @tailrec private def contains0(cur: ListMap[A, B1], k: A): Boolean =
       if (k == cur.key) true
       else if (cur.next.nonEmpty) contains0(cur.next, k)
       else false
 
-      
+
     /** This method allows one to create a new map with an additional mapping
      *  from `key` to `value`. If the map contains already a mapping for `key`,
      *  it will be overridden by this function.
@@ -198,7 +198,7 @@ extends AbstractMap[A, B]
       new m.Node[B2](k, v)
     }
 
-    
+
     /** Creates a new mapping without the given `key`.
      *  If the map does not contain a mapping for the given key, the
      *  method returns the same map.
diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala
index adc975479a..a65e25ed6e 100644
--- a/src/library/scala/collection/immutable/ListSet.scala
+++ b/src/library/scala/collection/immutable/ListSet.scala
@@ -11,8 +11,8 @@ package collection
 package immutable
 
 import generic._
-import scala.annotation.{tailrec, bridge}
-import mutable.{ ListBuffer, Builder }
+import scala.annotation.tailrec
+import mutable.Builder
 
 /** $factoryInfo
  *  @define Coll immutable.ListSet
@@ -179,6 +179,6 @@ class ListSet[A] extends AbstractSet[A]
 
     override def tail: ListSet[A] = self
   }
-  
+
   override def toSet[B >: A]: Set[B] = this.asInstanceOf[ListSet[B]]
 }
diff --git a/src/library/scala/collection/immutable/LongMap.scala b/src/library/scala/collection/immutable/LongMap.scala
index 868c0c0f47..173d912fe5 100644
--- a/src/library/scala/collection/immutable/LongMap.scala
+++ b/src/library/scala/collection/immutable/LongMap.scala
@@ -176,7 +176,7 @@ extends AbstractMap[Long, T]
   /**
    * Loops over the key, value pairs of the map in unsigned order of the keys.
    */
-  override final def foreach[U](f: ((Long, T)) =>  U): Unit = this match {
+  override final def foreach[U](f: ((Long, T)) => U): Unit = this match {
     case LongMap.Bin(_, _, left, right) => { left.foreach(f); right.foreach(f) }
     case LongMap.Tip(key, value) => f((key, value))
     case LongMap.Nil =>
diff --git a/src/library/scala/collection/immutable/Map.scala b/src/library/scala/collection/immutable/Map.scala
index 63ddcb18cf..6f135cd35f 100644
--- a/src/library/scala/collection/immutable/Map.scala
+++ b/src/library/scala/collection/immutable/Map.scala
@@ -116,7 +116,7 @@ object Map extends ImmutableMapFactory[Map] {
     def + [B1 >: B](kv: (A, B1)): Map[A, B1] = updated(kv._1, kv._2)
     def - (key: A): Map[A, B] =
       if (key == key1) Map.empty else this
-    override def foreach[U](f: ((A, B)) =>  U): Unit = {
+    override def foreach[U](f: ((A, B)) => U): Unit = {
       f((key1, value1))
     }
   }
@@ -142,7 +142,7 @@ object Map extends ImmutableMapFactory[Map] {
       if (key == key1) new Map1(key2, value2)
       else if (key == key2) new Map1(key1, value1)
       else this
-    override def foreach[U](f: ((A, B)) =>  U): Unit = {
+    override def foreach[U](f: ((A, B)) => U): Unit = {
       f((key1, value1)); f((key2, value2))
     }
   }
@@ -172,7 +172,7 @@ object Map extends ImmutableMapFactory[Map] {
       else if (key == key2) new Map2(key1, value1, key3, value3)
       else if (key == key3) new Map2(key1, value1, key2, value2)
       else this
-    override def foreach[U](f: ((A, B)) =>  U): Unit = {
+    override def foreach[U](f: ((A, B)) => U): Unit = {
       f((key1, value1)); f((key2, value2)); f((key3, value3))
     }
   }
@@ -206,7 +206,7 @@ object Map extends ImmutableMapFactory[Map] {
       else if (key == key3) new Map3(key1, value1, key2, value2, key4, value4)
       else if (key == key4) new Map3(key1, value1, key2, value2, key3, value3)
       else this
-    override def foreach[U](f: ((A, B)) =>  U): Unit = {
+    override def foreach[U](f: ((A, B)) => U): Unit = {
       f((key1, value1)); f((key2, value2)); f((key3, value3)); f((key4, value4))
     }
   }
diff --git a/src/library/scala/collection/immutable/NumericRange.scala b/src/library/scala/collection/immutable/NumericRange.scala
index 11603a118b..c8d7519254 100644
--- a/src/library/scala/collection/immutable/NumericRange.scala
+++ b/src/library/scala/collection/immutable/NumericRange.scala
@@ -10,8 +10,6 @@ package scala
 package collection
 package immutable
 
-import mutable.{ Builder, ListBuffer }
-
 // TODO: Now the specialization exists there is no clear reason to have
 // separate classes for Range/NumericRange.  Investigate and consolidate.
 
@@ -193,7 +191,7 @@ extends AbstractSeq[T] with IndexedSeq[T] with Serializable {
         // Either numRangeElements or (head + last) must be even, so divide the even one before multiplying
         val a = head.toLong
         val b = last.toLong
-        val ans = 
+        val ans =
           if ((numRangeElements & 1) == 0) (numRangeElements / 2) * (a + b)
           else numRangeElements * {
             // Sum is even, but we might overflow it, so divide in pieces and add back remainder
diff --git a/src/library/scala/collection/immutable/PagedSeq.scala b/src/library/scala/collection/immutable/PagedSeq.scala
index c8d0b00327..fab5ad47eb 100644
--- a/src/library/scala/collection/immutable/PagedSeq.scala
+++ b/src/library/scala/collection/immutable/PagedSeq.scala
@@ -13,7 +13,6 @@ package collection
 package immutable
 
 import java.io.{File, FileReader, Reader}
-import scala.util.matching.Regex
 import scala.reflect.ClassTag
 
 /** The `PagedSeq` object defines a lazy implementations of
@@ -23,6 +22,7 @@ import scala.reflect.ClassTag
  * `fromIterator` and `fromIterable` provide generalised instances of `PagedSeq`
  *  @since 2.7
  */
+@deprecated("This object will be moved to the scala-parser-combinators module", "2.11.8")
 object PagedSeq {
   final val UndeterminedEnd = Int.MaxValue
 
@@ -126,7 +126,7 @@ import PagedSeq._
  *  @define mayNotTerminateInf
  *  @define willNotTerminateInf
  */
-@deprecatedInheritance("The implementation details of paged sequences make inheriting from them unwise.", "2.11.0")
+@deprecated("This class will be moved to the scala-parser-combinators module", "2.11.8")
 class PagedSeq[T: ClassTag] protected(
   more: (Array[T], Int, Int) => Int,
   first1: Page[T],
diff --git a/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala
index 53af3ce158..70b51f8251 100644
--- a/src/library/scala/collection/immutable/Queue.scala
+++ b/src/library/scala/collection/immutable/Queue.scala
@@ -12,7 +12,6 @@ package immutable
 
 import generic._
 import mutable.{ Builder, ListBuffer }
-import scala.annotation.tailrec
 
 /** `Queue` objects implement data structures that allow to
  *  insert and retrieve elements in a first-in-first-out (FIFO) manner.
diff --git a/src/library/scala/collection/immutable/SortedMap.scala b/src/library/scala/collection/immutable/SortedMap.scala
index 682788e18e..0f3bd2e195 100644
--- a/src/library/scala/collection/immutable/SortedMap.scala
+++ b/src/library/scala/collection/immutable/SortedMap.scala
@@ -14,7 +14,6 @@ package immutable
 
 import generic._
 import mutable.Builder
-import scala.annotation.unchecked.uncheckedVariance
 
 /** A map whose keys are sorted.
  *
diff --git a/src/library/scala/collection/immutable/SortedSet.scala b/src/library/scala/collection/immutable/SortedSet.scala
index 4a8859a7ab..107f77f287 100644
--- a/src/library/scala/collection/immutable/SortedSet.scala
+++ b/src/library/scala/collection/immutable/SortedSet.scala
@@ -13,7 +13,6 @@ package collection
 package immutable
 
 import generic._
-import mutable.Builder
 
 /** A subtrait of `collection.SortedSet` which represents sorted sets
  *  which cannot be mutated.
diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala
index 5989517532..d92b159f3b 100644
--- a/src/library/scala/collection/immutable/Stream.scala
+++ b/src/library/scala/collection/immutable/Stream.scala
@@ -11,7 +11,7 @@ package collection
 package immutable
 
 import generic._
-import mutable.{Builder, StringBuilder, LazyBuilder, ListBuffer}
+import mutable.{Builder, StringBuilder, LazyBuilder}
 import scala.annotation.tailrec
 import Stream.cons
 import scala.language.implicitConversions
@@ -176,9 +176,9 @@ import scala.language.implicitConversions
  *    loop(1, 1)
  *  }
  *  }}}
- * 
+ *
  *  Note that `mkString` forces evaluation of a `Stream`, but `addString` does
- *  not.  In both cases, a `Stream` that is or ends in a cycle 
+ *  not.  In both cases, a `Stream` that is or ends in a cycle
  *  (e.g. `lazy val s: Stream[Int] = 0 #:: s`) will convert additional trips
  *  through the cycle to `...`.  Additionally, `addString` will display an
  *  un-memoized tail as `?`.
@@ -203,11 +203,9 @@ abstract class Stream[+A] extends AbstractSeq[A]
                              with LinearSeq[A]
                              with GenericTraversableTemplate[A, Stream]
                              with LinearSeqOptimized[A, Stream[A]]
-                             with Serializable {
-self =>
-  override def companion: GenericCompanion[Stream] = Stream
+                             with Serializable { self =>
 
-  import scala.collection.{Traversable, Iterable, Seq, IndexedSeq}
+  override def companion: GenericCompanion[Stream] = Stream
 
   /** Indicates whether or not the `Stream` is empty.
    *
@@ -528,7 +526,7 @@ self =>
    *  unless the `f` throws an exception.
    */
   @tailrec
-  override final def foreach[B](f: A => B) {
+  override final def foreach[U](f: A => U) {
     if (!this.isEmpty) {
       f(head)
       tail.foreach(f)
@@ -1091,14 +1089,12 @@ object Stream extends SeqFactory[Stream] {
   /** Creates a new builder for a stream */
   def newBuilder[A]: Builder[A, Stream[A]] = new StreamBuilder[A]
 
-  import scala.collection.{Iterable, Seq, IndexedSeq}
-
   /** A builder for streams
    *  @note This builder is lazy only in the sense that it does not go downs the spine
    *        of traversables that are added as a whole. If more laziness can be achieved,
    *        this builder should be bypassed.
    */
-  class StreamBuilder[A] extends scala.collection.mutable.LazyBuilder[A, Stream[A]] {
+  class StreamBuilder[A] extends LazyBuilder[A, Stream[A]] {
     def result: Stream[A] = parts.toStream flatMap (_.toStream)
   }
 
diff --git a/src/library/scala/collection/immutable/StringLike.scala b/src/library/scala/collection/immutable/StringLike.scala
index 7b3da1e2ea..d92db68912 100644
--- a/src/library/scala/collection/immutable/StringLike.scala
+++ b/src/library/scala/collection/immutable/StringLike.scala
@@ -10,7 +10,7 @@ package scala
 package collection
 package immutable
 
-import mutable.{ ArrayBuilder, Builder }
+import mutable.Builder
 import scala.util.matching.Regex
 import scala.math.ScalaNumber
 import scala.reflect.ClassTag
@@ -208,32 +208,32 @@ self =>
     else "\\" + ch
 
   /** Split this string around the separator character
-   * 
+   *
    * If this string is the empty string, returns an array of strings
    * that contains a single empty string.
-   * 
+   *
    * If this string is not the empty string, returns an array containing
    * the substrings terminated by the start of the string, the end of the
    * string or the separator character, excluding empty trailing substrings
-   * 
-   * If the separator character is a surrogate character, only split on 
+   *
+   * If the separator character is a surrogate character, only split on
    * matching surrogate characters if they are not part of a surrogate pair
-   * 
+   *
    * The behaviour follows, and is implemented in terms of <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#split%28java.lang.String%29">String.split(re: String)</a>
-   * 
-   * 
+   *
+   *
    * @example {{{
    * "a.b".split('.') //returns Array("a", "b")
-   * 
+   *
    * //splitting the empty string always returns the array with a single
    * //empty string
-   * "".split('.') //returns Array("") 
-   * 
+   * "".split('.') //returns Array("")
+   *
    * //only trailing empty substrings are removed
    * "a.".split('.') //returns Array("a")
    * ".a.".split('.') //returns Array("", "a")
    * "..a..".split('.') //returns Array("", "", "a")
-   * 
+   *
    * //all parts are empty and trailing
    * ".".split('.') //returns Array()
    * "..".split('.') //returns Array()
@@ -247,16 +247,16 @@ self =>
    * //well-formed surrogate pairs are not split
    * val highlow = highstring + lowstring
    * highlow.split(high) //returns Array(highlow)
-   * 
+   *
    * //bare surrogate characters are split
    * val bare = "_" + highstring + "_"
    * bare.split(high) //returns Array("_", "_")
-   * 
+   *
    *  }}}
-   * 
+   *
    * @param separator the character used as a delimiter
    */
-  def split(separator: Char): Array[String] = 
+  def split(separator: Char): Array[String] =
     toString.split(escape(separator))
 
 
diff --git a/src/library/scala/collection/immutable/TreeMap.scala b/src/library/scala/collection/immutable/TreeMap.scala
index 662075cd93..b845b76026 100644
--- a/src/library/scala/collection/immutable/TreeMap.scala
+++ b/src/library/scala/collection/immutable/TreeMap.scala
@@ -200,5 +200,5 @@ class TreeMap[A, +B] private (tree: RB.Tree[A, B])(implicit val ordering: Orderi
   override def contains(key: A): Boolean = RB.contains(tree, key)
   override def isDefinedAt(key: A): Boolean = RB.contains(tree, key)
 
-  override def foreach[U](f : ((A,B)) =>  U) = RB.foreach(tree, f)
+  override def foreach[U](f : ((A,B)) => U) = RB.foreach(tree, f)
 }
diff --git a/src/library/scala/collection/immutable/TreeSet.scala b/src/library/scala/collection/immutable/TreeSet.scala
index 7378211db0..2800030d67 100644
--- a/src/library/scala/collection/immutable/TreeSet.scala
+++ b/src/library/scala/collection/immutable/TreeSet.scala
@@ -151,7 +151,7 @@ class TreeSet[A] private (tree: RB.Tree[A, Unit])(implicit val ordering: Orderin
   def iterator: Iterator[A] = RB.keysIterator(tree)
   override def keysIteratorFrom(start: A): Iterator[A] = RB.keysIterator(tree, Some(start))
 
-  override def foreach[U](f: A =>  U) = RB.foreachKey(tree, f)
+  override def foreach[U](f: A => U) = RB.foreachKey(tree, f)
 
   override def rangeImpl(from: Option[A], until: Option[A]): TreeSet[A] = newSet(RB.rangeImpl(tree, from, until))
   override def range(from: A, until: A): TreeSet[A] = newSet(RB.range(tree, from, until))
diff --git a/src/library/scala/collection/immutable/Vector.scala b/src/library/scala/collection/immutable/Vector.scala
index 8bb581d44c..cd2d3f843b 100644
--- a/src/library/scala/collection/immutable/Vector.scala
+++ b/src/library/scala/collection/immutable/Vector.scala
@@ -951,8 +951,6 @@ private[immutable] trait VectorPointer[T] {
     // STUFF BELOW USED BY APPEND / UPDATE
 
     private[immutable] final def copyOf(a: Array[AnyRef]) = {
-      //println("copy")
-      if (a eq null) println ("NULL")
       val b = new Array[AnyRef](a.length)
       Platform.arraycopy(a, 0, b, 0, a.length)
       b
diff --git a/src/library/scala/collection/mutable/AnyRefMap.scala b/src/library/scala/collection/mutable/AnyRefMap.scala
index 46991ac101..af7600ad3d 100644
--- a/src/library/scala/collection/mutable/AnyRefMap.scala
+++ b/src/library/scala/collection/mutable/AnyRefMap.scala
@@ -5,23 +5,23 @@ package mutable
 import generic.CanBuildFrom
 
 /** This class implements mutable maps with `AnyRef` keys based on a hash table with open addressing.
- * 
- *  Basic map operations on single entries, including `contains` and `get`, 
+ *
+ *  Basic map operations on single entries, including `contains` and `get`,
  *  are typically significantly faster with `AnyRefMap` than [[HashMap]].
  *  Note that numbers and characters are not handled specially in AnyRefMap;
  *  only plain `equals` and `hashCode` are used in comparisons.
- * 
+ *
  *  Methods that traverse or regenerate the map, including `foreach` and `map`,
  *  are not in general faster than with `HashMap`.  The methods `foreachKey`,
  *  `foreachValue`, `mapValuesNow`, and `transformValues` are, however, faster
  *  than alternative ways to achieve the same functionality.
- * 
+ *
  *  Maps with open addressing may become less efficient at lookup after
  *  repeated addition/removal of elements.  Although `AnyRefMap` makes a
  *  decent attempt to remain efficient regardless,  calling `repack`
  *  on a map that will no longer have elements removed but will be
  *  used heavily may save both time and storage space.
- * 
+ *
  *  This map is not intended to contain more than 2^29^ entries (approximately
  *  500 million).  The maximum capacity is 2^30^, but performance will degrade
  *  rapidly as 2^30^ is approached.
@@ -36,50 +36,50 @@ extends AbstractMap[K, V]
 {
   import AnyRefMap._
   def this() = this(AnyRefMap.exceptionDefault, 16, true)
-  
+
   /** Creates a new `AnyRefMap` that returns default values according to a supplied key-value mapping. */
   def this(defaultEntry: K => V) = this(defaultEntry, 16, true)
 
   /** Creates a new `AnyRefMap` with an initial buffer of specified size.
-   * 
+   *
    *  An `AnyRefMap` can typically contain half as many elements as its buffer size
    *  before it requires resizing.
    */
   def this(initialBufferSize: Int) = this(AnyRefMap.exceptionDefault, initialBufferSize, true)
-  
+
   /** Creates a new `AnyRefMap` with specified default values and initial buffer size. */
   def this(defaultEntry: K => V, initialBufferSize: Int) = this(defaultEntry, initialBufferSize, true)
-  
+
   private[this] var mask = 0
   private[this] var _size = 0
   private[this] var _vacant = 0
   private[this] var _hashes: Array[Int] = null
   private[this] var _keys: Array[AnyRef] = null
   private[this] var _values: Array[AnyRef] = null
-    
+
   if (initBlank) defaultInitialize(initialBufferSize)
-  
+
   private[this] def defaultInitialize(n: Int) {
-    mask = 
+    mask =
       if (n<0) 0x7
       else (((1 << (32 - java.lang.Integer.numberOfLeadingZeros(n-1))) - 1) & 0x3FFFFFFF) | 0x7
     _hashes = new Array[Int](mask+1)
     _keys = new Array[AnyRef](mask+1)
     _values = new Array[AnyRef](mask+1)
   }
-  
+
   private[collection] def initializeTo(
     m: Int, sz: Int, vc: Int, hz: Array[Int], kz: Array[AnyRef], vz: Array[AnyRef]
   ) {
     mask = m; _size = sz; _vacant = vc; _hashes = hz; _keys = kz; _values = vz
   }
-  
+
   override def size: Int = _size
   override def empty: AnyRefMap[K,V] = new AnyRefMap(defaultEntry)
-  
-  private def imbalanced: Boolean = 
+
+  private def imbalanced: Boolean =
     (_size + _vacant) > 0.5*mask || _vacant > _size
-  
+
   private def hashOf(key: K): Int = {
     if (key eq null) 0x41081989
     else {
@@ -90,7 +90,7 @@ extends AbstractMap[K, V]
       if (j==0) 0x41081989 else j & 0x7FFFFFFF
     }
   }
-  
+
   private def seekEntry(h: Int, k: AnyRef): Int = {
     var e = h & mask
     var x = 0
@@ -102,7 +102,7 @@ extends AbstractMap[K, V]
     }
     e | MissingBit
   }
-  
+
   private def seekEntryOrOpen(h: Int, k: AnyRef): Int = {
     var e = h & mask
     var x = 0
@@ -116,19 +116,19 @@ extends AbstractMap[K, V]
     }
     if (o >= 0) o | MissVacant else e | MissingBit
   }
-  
+
   override def contains(key: K): Boolean = seekEntry(hashOf(key), key) >= 0
-  
+
   override def get(key: K): Option[V] = {
     val i = seekEntry(hashOf(key), key)
     if (i < 0) None else Some(_values(i).asInstanceOf[V])
   }
-  
+
   override def getOrElse[V1 >: V](key: K, default: => V1): V1 = {
     val i = seekEntry(hashOf(key), key)
     if (i < 0) default else _values(i).asInstanceOf[V]
   }
-  
+
   override def getOrElseUpdate(key: K, defaultValue: => V): V = {
     val h = hashOf(key)
     var i = seekEntryOrOpen(h, key)
@@ -156,10 +156,10 @@ extends AbstractMap[K, V]
     }
     else _values(i).asInstanceOf[V]
   }
-  
+
   /** Retrieves the value associated with a key, or the default for that type if none exists
    *  (null for AnyRef, 0 for floats and integers).
-   * 
+   *
    *  Note: this is the fastest way to retrieve a value that may or
    *  may not exist, if the default null/zero is acceptable.  For key/value
    *  pairs that do exist, `apply` (i.e. `map(key)`) is equally fast.
@@ -168,22 +168,22 @@ extends AbstractMap[K, V]
     val i = seekEntry(hashOf(key), key)
     (if (i < 0) null else _values(i)).asInstanceOf[V]
   }
-  
-  /** Retrieves the value associated with a key. 
+
+  /** Retrieves the value associated with a key.
    *  If the key does not exist in the map, the `defaultEntry` for that key
-   *  will be returned instead; an exception will be thrown if no 
+   *  will be returned instead; an exception will be thrown if no
    *  `defaultEntry` was supplied.
    */
   override def apply(key: K): V = {
     val i = seekEntry(hashOf(key), key)
     if (i < 0) defaultEntry(key) else _values(i).asInstanceOf[V]
   }
-  
+
   /** Defers to defaultEntry to find a default value for the key.  Throws an
    *  exception if no other default behavior was specified.
    */
   override def default(key: K) = defaultEntry(key)
-  
+
   private def repack(newMask: Int) {
     val oh = _hashes
     val ok = _keys
@@ -207,9 +207,9 @@ extends AbstractMap[K, V]
       i += 1
     }
   }
-  
+
   /** Repacks the contents of this `AnyRefMap` for maximum efficiency of lookup.
-   * 
+   *
    *  For maps that undergo a complex creation process with both addition and
    *  removal of keys, and then are used heavily with no further removal of
    *  elements, calling `repack` after the end of the creation can result in
@@ -222,7 +222,7 @@ extends AbstractMap[K, V]
     while (m > 8 && 8*_size < m) m = m >>> 1
     repack(m)
   }
-  
+
   override def put(key: K, value: V): Option[V] = {
     val h = hashOf(key)
     val k = key
@@ -245,9 +245,9 @@ extends AbstractMap[K, V]
       ans
     }
   }
-  
+
   /** Updates the map to include a new key-value pair.
-   * 
+   *
    *  This is the fastest way to add an entry to an `AnyRefMap`.
    */
   override def update(key: K, value: V): Unit = {
@@ -269,12 +269,12 @@ extends AbstractMap[K, V]
       _values(i) = value.asInstanceOf[AnyRef]
     }
   }
-  
+
   /** Adds a new key/value pair to this map and returns the map. */
   def +=(key: K, value: V): this.type = { update(key, value); this }
 
   def +=(kv: (K, V)): this.type = { update(kv._1, kv._2); this }
-  
+
   def -=(key: K): this.type = {
     val i = seekEntry(hashOf(key), key)
     if (i >= 0) {
@@ -286,14 +286,14 @@ extends AbstractMap[K, V]
     }
     this
   }
-  
+
   def iterator: Iterator[(K, V)] = new Iterator[(K, V)] {
     private[this] val hz = _hashes
     private[this] val kz = _keys
     private[this] val vz = _values
-    
+
     private[this] var index = 0
-    
+
     def hasNext: Boolean = index<hz.length && {
       var h = hz(index)
       while (h+h == 0) {
@@ -303,7 +303,7 @@ extends AbstractMap[K, V]
       }
       true
     }
-    
+
     def next: (K, V) = {
       if (hasNext) {
         val ans = (kz(index).asInstanceOf[K], vz(index).asInstanceOf[V])
@@ -313,8 +313,8 @@ extends AbstractMap[K, V]
       else throw new NoSuchElementException("next")
     }
   }
-  
-  override def foreach[A](f: ((K,V)) => A) {
+
+  override def foreach[U](f: ((K,V)) => U) {
     var i = 0
     var e = _size
     while (e > 0) {
@@ -327,7 +327,7 @@ extends AbstractMap[K, V]
       else return
     }
   }
-    
+
   override def clone(): AnyRefMap[K, V] = {
     val hz = java.util.Arrays.copyOf(_hashes, _hashes.length)
     val kz = java.util.Arrays.copyOf(_keys, _keys.length)
@@ -336,25 +336,25 @@ extends AbstractMap[K, V]
     arm.initializeTo(mask, _size, _vacant, hz, kz,  vz)
     arm
   }
-  
+
   override def +[V1 >: V](kv: (K, V1)): AnyRefMap[K, V1] = {
     val arm = clone().asInstanceOf[AnyRefMap[K, V1]]
     arm += kv
     arm
   }
-  
+
   override def ++[V1 >: V](xs: GenTraversableOnce[(K, V1)]): AnyRefMap[K, V1] = {
     val arm = clone().asInstanceOf[AnyRefMap[K, V1]]
     xs.foreach(kv => arm += kv)
     arm
   }
-  
+
   override def updated[V1 >: V](key: K, value: V1): AnyRefMap[K, V1] = {
     val arm = clone().asInstanceOf[AnyRefMap[K, V1]]
     arm += (key, value)
     arm
   }
-  
+
   private[this] def foreachElement[A,B](elems: Array[AnyRef], f: A => B) {
     var i,j = 0
     while (i < _hashes.length & j < _size) {
@@ -366,13 +366,13 @@ extends AbstractMap[K, V]
       i += 1
     }
   }
-  
+
   /** Applies a function to all keys of this map. */
   def foreachKey[A](f: K => A) { foreachElement[K,A](_keys, f) }
 
   /** Applies a function to all values of this map. */
   def foreachValue[A](f: V => A) { foreachElement[V,A](_values, f) }
-  
+
   /** Creates a new `AnyRefMap` with different values.
    *  Unlike `mapValues`, this method generates a new
    *  collection immediately.
@@ -394,8 +394,8 @@ extends AbstractMap[K, V]
     arm.initializeTo(mask, _size, _vacant, hz, kz, vz)
     arm
   }
-  
-  /** Applies a transformation function to all values stored in this map. 
+
+  /** Applies a transformation function to all values stored in this map.
    *  Note: the default, if any,  is not transformed.
    */
   def transformValues(f: V => V): this.type = {
@@ -418,15 +418,15 @@ object AnyRefMap {
   private final val MissingBit = 0x80000000
   private final val VacantBit  = 0x40000000
   private final val MissVacant = 0xC0000000
-  
+
   private val exceptionDefault = (k: Any) => throw new NoSuchElementException(if (k == null) "(null)" else k.toString)
-  
+
   implicit def canBuildFrom[K <: AnyRef, V, J <: AnyRef, U]: CanBuildFrom[AnyRefMap[K,V], (J, U), AnyRefMap[J,U]] =
     new CanBuildFrom[AnyRefMap[K,V], (J, U), AnyRefMap[J,U]] {
       def apply(from: AnyRefMap[K,V]): AnyRefMapBuilder[J, U] = apply()
       def apply(): AnyRefMapBuilder[J, U] = new AnyRefMapBuilder[J, U]
     }
-  
+
   final class AnyRefMapBuilder[K <: AnyRef, V] extends Builder[(K, V), AnyRefMap[K, V]] {
     private[collection] var elems: AnyRefMap[K, V] = new AnyRefMap[K, V]
     def +=(entry: (K, V)): this.type = {
@@ -445,14 +445,14 @@ object AnyRefMap {
     if (arm.size < (sz>>3)) arm.repack()
     arm
   }
-  
+
   /** Creates a new empty `AnyRefMap`. */
   def empty[K <: AnyRef, V]: AnyRefMap[K, V] = new AnyRefMap[K, V]
-  
+
   /** Creates a new empty `AnyRefMap` with the supplied default */
   def withDefault[K <: AnyRef, V](default: K => V): AnyRefMap[K, V] = new AnyRefMap[K, V](default)
-  
-  /** Creates a new `AnyRefMap` from arrays of keys and values. 
+
+  /** Creates a new `AnyRefMap` from arrays of keys and values.
    *  Equivalent to but more efficient than `AnyRefMap((keys zip values): _*)`.
    */
   def fromZip[K <: AnyRef, V](keys: Array[K], values: Array[V]): AnyRefMap[K, V] = {
@@ -463,8 +463,8 @@ object AnyRefMap {
     if (arm.size < (sz>>3)) arm.repack()
     arm
   }
-  
-  /** Creates a new `AnyRefMap` from keys and values. 
+
+  /** Creates a new `AnyRefMap` from keys and values.
    *  Equivalent to but more efficient than `AnyRefMap((keys zip values): _*)`.
    */
   def fromZip[K <: AnyRef, V](keys: Iterable[K], values: Iterable[V]): AnyRefMap[K, V] = {
diff --git a/src/library/scala/collection/mutable/ArrayBuilder.scala b/src/library/scala/collection/mutable/ArrayBuilder.scala
index 6e53824cbe..ac78ab823b 100644
--- a/src/library/scala/collection/mutable/ArrayBuilder.scala
+++ b/src/library/scala/collection/mutable/ArrayBuilder.scala
@@ -11,7 +11,6 @@ package collection
 package mutable
 
 import scala.reflect.ClassTag
-import scala.runtime.ScalaRunTime
 
 /** A builder class for arrays.
  *
diff --git a/src/library/scala/collection/mutable/ArrayOps.scala b/src/library/scala/collection/mutable/ArrayOps.scala
index 2bc41b5802..5144db7de3 100644
--- a/src/library/scala/collection/mutable/ArrayOps.scala
+++ b/src/library/scala/collection/mutable/ArrayOps.scala
@@ -10,7 +10,6 @@ package scala
 package collection
 package mutable
 
-import scala.compat.Platform.arraycopy
 import scala.reflect.ClassTag
 import scala.runtime.ScalaRunTime._
 import parallel.mutable.ParArray
@@ -106,9 +105,9 @@ trait ArrayOps[T] extends Any with ArrayLike[T, Array[T]] with CustomParalleliza
       bb.result()
     }
   }
-  
+
   /** Converts an array of pairs into an array of first elements and an array of second elements.
-   *  
+   *
    *  @tparam T1    the type of the first half of the element pairs
    *  @tparam T2    the type of the second half of the element pairs
    *  @param asPair an implicit conversion which asserts that the element type
@@ -134,9 +133,9 @@ trait ArrayOps[T] extends Any with ArrayLike[T, Array[T]] with CustomParalleliza
     }
     (a1, a2)
   }
-  
+
   /** Converts an array of triples into three arrays, one containing the elements from each position of the triple.
-   *  
+   *
    *  @tparam T1      the type of the first of three elements in the triple
    *  @tparam T2      the type of the second of three elements in the triple
    *  @tparam T3      the type of the third of three elements in the triple
@@ -168,7 +167,7 @@ trait ArrayOps[T] extends Any with ArrayLike[T, Array[T]] with CustomParalleliza
     }
     (a1, a2, a3)
   }
-  
+
 
   def seq = thisCollection
 
diff --git a/src/library/scala/collection/mutable/ArraySeq.scala b/src/library/scala/collection/mutable/ArraySeq.scala
index 5a50f4fb27..1e82096baf 100644
--- a/src/library/scala/collection/mutable/ArraySeq.scala
+++ b/src/library/scala/collection/mutable/ArraySeq.scala
@@ -68,7 +68,7 @@ extends AbstractSeq[A]
     array(idx) = elem.asInstanceOf[AnyRef]
   }
 
-  override def foreach[U](f: A =>  U) {
+  override def foreach[U](f: A => U) {
     var i = 0
     while (i < length) {
       f(array(i).asInstanceOf[A])
diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala
index fec2da8839..951a90b084 100644
--- a/src/library/scala/collection/mutable/ArrayStack.scala
+++ b/src/library/scala/collection/mutable/ArrayStack.scala
@@ -64,9 +64,10 @@ object ArrayStack extends SeqFactory[ArrayStack] {
 class ArrayStack[T] private(private var table : Array[AnyRef],
                             private var index : Int)
 extends AbstractSeq[T]
-   with Seq[T]
-   with SeqLike[T, ArrayStack[T]]
+   with IndexedSeq[T]
+   with IndexedSeqLike[T, ArrayStack[T]]
    with GenericTraversableTemplate[T, ArrayStack]
+   with IndexedSeqOptimized[T, ArrayStack[T]]
    with Cloneable[ArrayStack[T]]
    with Builder[T, ArrayStack[T]]
    with Serializable
@@ -224,7 +225,7 @@ extends AbstractSeq[T]
   /** Creates and iterator over the stack in LIFO order.
    *  @return an iterator over the elements of the stack.
    */
-  def iterator: Iterator[T] = new AbstractIterator[T] {
+  override def iterator: Iterator[T] = new AbstractIterator[T] {
     var currentIndex = index
     def hasNext = currentIndex > 0
     def next() = {
@@ -233,7 +234,7 @@ extends AbstractSeq[T]
     }
   }
 
-  override def foreach[U](f: T =>  U) {
+  override def foreach[U](f: T => U) {
     var currentIndex = index
     while (currentIndex > 0) {
       currentIndex -= 1
diff --git a/src/library/scala/collection/mutable/BitSet.scala b/src/library/scala/collection/mutable/BitSet.scala
index e92d48cfeb..feef694e01 100644
--- a/src/library/scala/collection/mutable/BitSet.scala
+++ b/src/library/scala/collection/mutable/BitSet.scala
@@ -13,7 +13,7 @@ package collection
 package mutable
 
 import generic._
-import BitSetLike.{LogWL, MaxSize, updateArray}
+import BitSetLike.{LogWL, MaxSize}
 
 /** A class for mutable bitsets.
  *
@@ -56,7 +56,7 @@ class BitSet(protected final var elems: Array[Long]) extends AbstractSet[Int]
 
   @deprecatedOverriding("Internal implementation does not admit sensible overriding of this method.", "2.11.0")
   protected def nwords = elems.length
-  
+
   @deprecatedOverriding("Internal implementation does not admit sensible overriding of this method.", "2.11.0")
   protected def word(idx: Int): Long =
     if (idx < nwords) elems(idx) else 0L
@@ -100,7 +100,7 @@ class BitSet(protected final var elems: Array[Long]) extends AbstractSet[Int]
 
   @deprecatedOverriding("Override add to prevent += and add from exhibiting different behavior.", "2.11.0")
   def += (elem: Int): this.type = { add(elem); this }
-  
+
   @deprecatedOverriding("Override add to prevent += and add from exhibiting different behavior.", "2.11.0")
   def -= (elem: Int): this.type = { remove(elem); this }
 
diff --git a/src/library/scala/collection/mutable/BufferLike.scala b/src/library/scala/collection/mutable/BufferLike.scala
index bd9c61ae6a..98c9771a05 100644
--- a/src/library/scala/collection/mutable/BufferLike.scala
+++ b/src/library/scala/collection/mutable/BufferLike.scala
@@ -14,7 +14,7 @@ package mutable
 
 import generic._
 import script._
-import scala.annotation.{migration, bridge}
+import scala.annotation.migration
 
 /** A template trait for buffers of type `Buffer[A]`.
  *
diff --git a/src/library/scala/collection/mutable/HashMap.scala b/src/library/scala/collection/mutable/HashMap.scala
index 6fca75ffea..eab4202353 100644
--- a/src/library/scala/collection/mutable/HashMap.scala
+++ b/src/library/scala/collection/mutable/HashMap.scala
@@ -96,16 +96,16 @@ extends AbstractMap[A, B]
 
   def iterator = entriesIterator map (e => ((e.key, e.value)))
 
-  override def foreach[C](f: ((A, B)) => C): Unit = foreachEntry(e => f((e.key, e.value)))
+  override def foreach[U](f: ((A, B)) => U): Unit = foreachEntry(e => f((e.key, e.value)))
 
   /* Override to avoid tuple allocation in foreach */
   override def keySet: scala.collection.Set[A] = new DefaultKeySet {
-    override def foreach[C](f: A => C) = foreachEntry(e => f(e.key))
+    override def foreach[U](f: A => U) = foreachEntry(e => f(e.key))
   }
 
   /* Override to avoid tuple allocation in foreach */
   override def values: scala.collection.Iterable[B] = new DefaultValuesIterable {
-    override def foreach[C](f: B => C) = foreachEntry(e => f(e.value))
+    override def foreach[U](f: B => U) = foreachEntry(e => f(e.value))
   }
 
   /* Override to avoid tuple allocation */
diff --git a/src/library/scala/collection/mutable/HashSet.scala b/src/library/scala/collection/mutable/HashSet.scala
index 886fee5a59..3a16e4efa5 100644
--- a/src/library/scala/collection/mutable/HashSet.scala
+++ b/src/library/scala/collection/mutable/HashSet.scala
@@ -70,7 +70,7 @@ extends AbstractSet[A]
 
   override def iterator: Iterator[A] = super[FlatHashTable].iterator
 
-  override def foreach[U](f: A =>  U) {
+  override def foreach[U](f: A => U) {
     var i = 0
     val len = table.length
     while (i < len) {
diff --git a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
index 730b22227d..d7eec70b15 100644
--- a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
+++ b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
@@ -32,7 +32,7 @@ extends AbstractSet[A]
 
   def contains(elem: A): Boolean = set.contains(elem)
 
-  override def foreach[U](f: A =>  U): Unit = set.foreach(f)
+  override def foreach[U](f: A => U): Unit = set.foreach(f)
 
   override def exists(p: A => Boolean): Boolean = set.exists(p)
 
diff --git a/src/library/scala/collection/mutable/LinkedListLike.scala b/src/library/scala/collection/mutable/LinkedListLike.scala
index a9d385bc5b..d0748b8a9f 100644
--- a/src/library/scala/collection/mutable/LinkedListLike.scala
+++ b/src/library/scala/collection/mutable/LinkedListLike.scala
@@ -172,7 +172,7 @@ trait LinkedListLike[A, This <: Seq[A] with LinkedListLike[A, This]] extends Seq
     }
   }
 
-  override def foreach[B](f: A => B) {
+  override def foreach[U](f: A => U) {
     var these = this
     while (these.nonEmpty) {
       f(these.elem)
diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala
index eece557fe8..0a483ceb86 100644
--- a/src/library/scala/collection/mutable/ListBuffer.scala
+++ b/src/library/scala/collection/mutable/ListBuffer.scala
@@ -13,7 +13,6 @@ package mutable
 import generic._
 import immutable.{List, Nil, ::}
 import java.io.{ObjectOutputStream, ObjectInputStream}
-import scala.annotation.migration
 
 /** A `Buffer` implementation backed by a list. It provides constant time
  *  prepend and append. Most other operations are linear.
diff --git a/src/library/scala/collection/mutable/LongMap.scala b/src/library/scala/collection/mutable/LongMap.scala
index 1eb12d817c..f39a6ba634 100644
--- a/src/library/scala/collection/mutable/LongMap.scala
+++ b/src/library/scala/collection/mutable/LongMap.scala
@@ -5,20 +5,20 @@ package mutable
 import generic.CanBuildFrom
 
 /** This class implements mutable maps with `Long` keys based on a hash table with open addressing.
- * 
- *  Basic map operations on single entries, including `contains` and `get`, 
+ *
+ *  Basic map operations on single entries, including `contains` and `get`,
  *  are typically substantially faster with `LongMap` than [[HashMap]].  Methods
  *  that act on the whole map,  including `foreach` and `map` are not in
  *  general expected to be faster than with a generic map, save for those
  *  that take particular advantage of the internal structure of the map:
  *  `foreachKey`, `foreachValue`, `mapValuesNow`, and `transformValues`.
- * 
+ *
  *  Maps with open addressing may become less efficient at lookup after
  *  repeated addition/removal of elements.  Although `LongMap` makes a
  *  decent attempt to remain efficient regardless,  calling `repack`
  *  on a map that will no longer have elements removed but will be
  *  used heavily may save both time and storage space.
- * 
+ *
  *  This map is not intended to contain more than 2^29 entries (approximately
  *  500 million).  The maximum capacity is 2^30, but performance will degrade
  *  rapidly as 2^30 is approached.
@@ -33,20 +33,20 @@ extends AbstractMap[Long, V]
   import LongMap._
 
   def this() = this(LongMap.exceptionDefault, 16, true)
-  
+
   /** Creates a new `LongMap` that returns default values according to a supplied key-value mapping. */
   def this(defaultEntry: Long => V) = this(defaultEntry, 16, true)
-  
+
   /** Creates a new `LongMap` with an initial buffer of specified size.
-   * 
+   *
    *  A LongMap can typically contain half as many elements as its buffer size
    *  before it requires resizing.
    */
   def this(initialBufferSize: Int) = this(LongMap.exceptionDefault, initialBufferSize, true)
-  
+
   /** Creates a new `LongMap` with specified default values and initial buffer size. */
   def this(defaultEntry: Long => V,  initialBufferSize: Int) = this(defaultEntry,  initialBufferSize,  true)
-  
+
   private[this] var mask = 0
   private[this] var extraKeys: Int = 0
   private[this] var zeroValue: AnyRef = null
@@ -55,43 +55,43 @@ extends AbstractMap[Long, V]
   private[this] var _vacant = 0
   private[this] var _keys: Array[Long] = null
   private[this] var _values: Array[AnyRef] = null
-    
+
   if (initBlank) defaultInitialize(initialBufferSize)
-  
+
   private[this] def defaultInitialize(n: Int) = {
-    mask = 
+    mask =
       if (n<0) 0x7
       else (((1 << (32 - java.lang.Integer.numberOfLeadingZeros(n-1))) - 1) & 0x3FFFFFFF) | 0x7
     _keys = new Array[Long](mask+1)
     _values = new Array[AnyRef](mask+1)
   }
-  
+
   private[collection] def initializeTo(
     m: Int, ek: Int, zv: AnyRef, mv: AnyRef, sz: Int, vc: Int, kz: Array[Long], vz: Array[AnyRef]
   ) {
     mask = m; extraKeys = ek; zeroValue = zv; minValue = mv; _size = sz; _vacant = vc; _keys = kz; _values = vz
   }
-  
+
   override def size: Int = _size + (extraKeys+1)/2
   override def empty: LongMap[V] = new LongMap()
-  
-  private def imbalanced: Boolean = 
+
+  private def imbalanced: Boolean =
     (_size + _vacant) > 0.5*mask || _vacant > _size
-  
+
   private def toIndex(k: Long): Int = {
     // Part of the MurmurHash3 32 bit finalizer
     val h = ((k ^ (k >>> 32)) & 0xFFFFFFFFL).toInt
     val x = (h ^ (h >>> 16)) * 0x85EBCA6B
     (x ^ (x >>> 13)) & mask
   }
-  
+
   private def seekEmpty(k: Long): Int = {
     var e = toIndex(k)
     var x = 0
     while (_keys(e) != 0) { x += 1; e = (e + 2*(x+1)*x - 3) & mask }
     e
   }
-  
+
   private def seekEntry(k: Long): Int = {
     var e = toIndex(k)
     var x = 0
@@ -99,7 +99,7 @@ extends AbstractMap[Long, V]
     while ({ q = _keys(e); if (q==k) return e; q != 0}) { x += 1; e = (e + 2*(x+1)*x - 3) & mask }
     e | MissingBit
   }
-  
+
   private def seekEntryOrOpen(k: Long): Int = {
     var e = toIndex(k)
     var x = 0
@@ -116,12 +116,12 @@ extends AbstractMap[Long, V]
     }
     o
   }
-  
+
   override def contains(key: Long): Boolean = {
     if (key == -key) (((key>>>63).toInt+1) & extraKeys) != 0
     else seekEntry(key) >= 0
   }
-  
+
   override def get(key: Long): Option[V] = {
     if (key == -key) {
       if ((((key>>>63).toInt+1) & extraKeys) == 0) None
@@ -133,7 +133,7 @@ extends AbstractMap[Long, V]
       if (i < 0) None else Some(_values(i).asInstanceOf[V])
     }
   }
-  
+
   override def getOrElse[V1 >: V](key: Long, default: => V1): V1 = {
     if (key == -key) {
       if ((((key>>>63).toInt+1) & extraKeys) == 0) default
@@ -145,7 +145,7 @@ extends AbstractMap[Long, V]
       if (i < 0) default else _values(i).asInstanceOf[V1]
     }
   }
-  
+
   override def getOrElseUpdate(key: Long, defaultValue: => V): V = {
     if (key == -key) {
       val kbits = (key>>>63).toInt + 1
@@ -185,10 +185,10 @@ extends AbstractMap[Long, V]
       else _values(i).asInstanceOf[V]
     }
   }
-  
+
   /** Retrieves the value associated with a key, or the default for that type if none exists
    *  (null for AnyRef, 0 for floats and integers).
-   * 
+   *
    *  Note: this is the fastest way to retrieve a value that may or
    *  may not exist, if the default null/zero is acceptable.  For key/value
    *  pairs that do exist,  `apply` (i.e. `map(key)`) is equally fast.
@@ -204,8 +204,8 @@ extends AbstractMap[Long, V]
       if (i < 0) null.asInstanceOf[V] else _values(i).asInstanceOf[V]
     }
   }
-  
-  /** Retrieves the value associated with a key. 
+
+  /** Retrieves the value associated with a key.
    *  If the key does not exist in the map, the `defaultEntry` for that key
    *  will be returned instead.
    */
@@ -220,12 +220,12 @@ extends AbstractMap[Long, V]
       if (i < 0) defaultEntry(key) else _values(i).asInstanceOf[V]
     }
   }
-  
+
   /** The user-supplied default value for the key.  Throws an exception
    *  if no other default behavior was specified.
    */
   override def default(key: Long) = defaultEntry(key)
-  
+
   private def repack(newMask: Int) {
     val ok = _keys
     val ov = _values
@@ -244,9 +244,9 @@ extends AbstractMap[Long, V]
       i += 1
     }
   }
-  
+
   /** Repacks the contents of this `LongMap` for maximum efficiency of lookup.
-   * 
+   *
    *  For maps that undergo a complex creation process with both addition and
    *  removal of keys, and then are used heavily with no further removal of
    *  elements, calling `repack` after the end of the creation can result in
@@ -259,7 +259,7 @@ extends AbstractMap[Long, V]
     while (m > 8 && 8*_size < m) m = m >>> 1
     repack(m)
   }
-  
+
   override def put(key: Long, value: V): Option[V] = {
     if (key == -key) {
       if (key == 0) {
@@ -294,9 +294,9 @@ extends AbstractMap[Long, V]
       }
     }
   }
-  
+
   /** Updates the map to include a new key-value pair.
-   * 
+   *
    *  This is the fastest way to add an entry to a `LongMap`.
    */
   override def update(key: Long, value: V): Unit = {
@@ -326,12 +326,12 @@ extends AbstractMap[Long, V]
       }
     }
   }
-  
+
   /** Adds a new key/value pair to this map and returns the map. */
   def +=(key: Long, value: V): this.type = { update(key, value); this }
-  
+
   def +=(kv: (Long, V)): this.type = { update(kv._1, kv._2); this }
-  
+
   def -=(key: Long): this.type = {
     if (key == -key) {
       if (key == 0L) {
@@ -354,22 +354,22 @@ extends AbstractMap[Long, V]
     }
     this
   }
-  
+
   def iterator: Iterator[(Long, V)] = new Iterator[(Long, V)] {
     private[this] val kz = _keys
     private[this] val vz = _values
-    
-    private[this] var nextPair: (Long, V) = 
+
+    private[this] var nextPair: (Long, V) =
       if (extraKeys==0) null
       else if ((extraKeys&1)==1) (0L, zeroValue.asInstanceOf[V])
       else (Long.MinValue, minValue.asInstanceOf[V])
 
-    private[this] var anotherPair: (Long, V) = 
+    private[this] var anotherPair: (Long, V) =
       if (extraKeys==3) (Long.MinValue, minValue.asInstanceOf[V])
       else null
-        
+
     private[this] var index = 0
-    
+
     def hasNext: Boolean = nextPair != null || (index < kz.length && {
       var q = kz(index)
       while (q == -q) {
@@ -392,8 +392,8 @@ extends AbstractMap[Long, V]
       ans
     }
   }
-  
-  override def foreach[A](f: ((Long,V)) => A) {
+
+  override def foreach[U](f: ((Long,V)) => U) {
     if ((extraKeys & 1) == 1) f((0L, zeroValue.asInstanceOf[V]))
     if ((extraKeys & 2) == 2) f((Long.MinValue, minValue.asInstanceOf[V]))
     var i,j = 0
@@ -406,7 +406,7 @@ extends AbstractMap[Long, V]
       i += 1
     }
   }
-  
+
   override def clone(): LongMap[V] = {
     val kz = java.util.Arrays.copyOf(_keys, _keys.length)
     val vz = java.util.Arrays.copyOf(_values,  _values.length)
@@ -414,19 +414,19 @@ extends AbstractMap[Long, V]
     lm.initializeTo(mask, extraKeys, zeroValue, minValue, _size, _vacant, kz,  vz)
     lm
   }
-  
+
   override def +[V1 >: V](kv: (Long, V1)): LongMap[V1] = {
     val lm = clone().asInstanceOf[LongMap[V1]]
     lm += kv
     lm
   }
-  
+
   override def ++[V1 >: V](xs: GenTraversableOnce[(Long, V1)]): LongMap[V1] = {
     val lm = clone().asInstanceOf[LongMap[V1]]
     xs.foreach(kv => lm += kv)
     lm
   }
-  
+
   override def updated[V1 >: V](key: Long, value: V1): LongMap[V1] = {
     val lm = clone().asInstanceOf[LongMap[V1]]
     lm += (key, value)
@@ -462,7 +462,7 @@ extends AbstractMap[Long, V]
       i += 1
     }
   }
-  
+
   /** Creates a new `LongMap` with different values.
    *  Unlike `mapValues`, this method generates a new
    *  collection immediately.
@@ -485,8 +485,8 @@ extends AbstractMap[Long, V]
     lm.initializeTo(mask, extraKeys, zv, mv, _size, _vacant, kz, vz)
     lm
   }
-  
-  /** Applies a transformation function to all values stored in this map. 
+
+  /** Applies a transformation function to all values stored in this map.
    *  Note: the default, if any,  is not transformed.
    */
   def transformValues(f: V => V): this.type = {
@@ -510,15 +510,15 @@ object LongMap {
   private final val MissingBit = 0x80000000
   private final val VacantBit  = 0x40000000
   private final val MissVacant = 0xC0000000
-  
+
   private val exceptionDefault: Long => Nothing = (k: Long) => throw new NoSuchElementException(k.toString)
-  
-  implicit def canBuildFrom[V, U]: CanBuildFrom[LongMap[V], (Long, U), LongMap[U]] = 
+
+  implicit def canBuildFrom[V, U]: CanBuildFrom[LongMap[V], (Long, U), LongMap[U]] =
     new CanBuildFrom[LongMap[V], (Long, U), LongMap[U]] {
       def apply(from: LongMap[V]): LongMapBuilder[U] = apply()
       def apply(): LongMapBuilder[U] = new LongMapBuilder[U]
     }
-  
+
   final class LongMapBuilder[V] extends Builder[(Long, V), LongMap[V]] {
     private[collection] var elems: LongMap[V] = new LongMap[V]
     def +=(entry: (Long, V)): this.type = {
@@ -537,14 +537,14 @@ object LongMap {
     if (lm.size < (sz>>3)) lm.repack()
     lm
   }
-  
+
   /** Creates a new empty `LongMap`. */
   def empty[V]: LongMap[V] = new LongMap[V]
-  
+
   /** Creates a new empty `LongMap` with the supplied default */
   def withDefault[V](default: Long => V): LongMap[V] = new LongMap[V](default)
-  
-  /** Creates a new `LongMap` from arrays of keys and values. 
+
+  /** Creates a new `LongMap` from arrays of keys and values.
    *  Equivalent to but more efficient than `LongMap((keys zip values): _*)`.
    */
   def fromZip[V](keys: Array[Long], values: Array[V]): LongMap[V] = {
@@ -555,8 +555,8 @@ object LongMap {
     if (lm.size < (sz>>3)) lm.repack()
     lm
   }
-  
-  /** Creates a new `LongMap` from keys and values. 
+
+  /** Creates a new `LongMap` from keys and values.
    *  Equivalent to but more efficient than `LongMap((keys zip values): _*)`.
    */
   def fromZip[V](keys: collection.Iterable[Long], values: collection.Iterable[V]): LongMap[V] = {
diff --git a/src/library/scala/collection/mutable/MutableList.scala b/src/library/scala/collection/mutable/MutableList.scala
index 646023f469..a333eedb1a 100644
--- a/src/library/scala/collection/mutable/MutableList.scala
+++ b/src/library/scala/collection/mutable/MutableList.scala
@@ -11,7 +11,7 @@ package collection
 package mutable
 
 import generic._
-import immutable.{List, Nil}
+import immutable.List
 
 /**
  *  This class is used internally to represent mutable lists. It is the
diff --git a/src/library/scala/collection/mutable/SetLike.scala b/src/library/scala/collection/mutable/SetLike.scala
index 40a5c93064..a19130e742 100644
--- a/src/library/scala/collection/mutable/SetLike.scala
+++ b/src/library/scala/collection/mutable/SetLike.scala
@@ -140,7 +140,9 @@ trait SetLike[A, +This <: SetLike[A, This] with Set[A]]
   /** Removes all elements from the set. After this operation is completed,
    *  the set will be empty.
    */
-  def clear() { foreach(-=) }
+  def clear(): Unit =
+    for (elem <- this.toList)
+      this -= elem
 
   override def clone(): This = empty ++= repr.seq
 
diff --git a/src/library/scala/collection/mutable/SynchronizedSet.scala b/src/library/scala/collection/mutable/SynchronizedSet.scala
index 60e2e79d3f..dd842f26ce 100644
--- a/src/library/scala/collection/mutable/SynchronizedSet.scala
+++ b/src/library/scala/collection/mutable/SynchronizedSet.scala
@@ -78,7 +78,7 @@ trait SynchronizedSet[A] extends Set[A] {
     super.subsetOf(that)
   }
 
-  override def foreach[U](f: A =>  U) = synchronized {
+  override def foreach[U](f: A => U) = synchronized {
     super.foreach(f)
   }
 
diff --git a/src/library/scala/collection/mutable/SynchronizedStack.scala b/src/library/scala/collection/mutable/SynchronizedStack.scala
index bbb6f5a9bb..c77a6fad62 100644
--- a/src/library/scala/collection/mutable/SynchronizedStack.scala
+++ b/src/library/scala/collection/mutable/SynchronizedStack.scala
@@ -27,7 +27,6 @@ package mutable
  */
 @deprecated("Synchronization via selective overriding of methods is inherently unreliable.  Consider java.util.concurrent.LinkedBlockingDequeue instead.", "2.11.0")
 class SynchronizedStack[A] extends Stack[A] {
-  import scala.collection.Traversable
 
   /** Checks if the stack is empty.
    *
diff --git a/src/library/scala/collection/package.scala b/src/library/scala/collection/package.scala
index 13fe7a79c4..856f901b77 100644
--- a/src/library/scala/collection/package.scala
+++ b/src/library/scala/collection/package.scala
@@ -13,8 +13,11 @@ package scala
  *
  * == Guide ==
  *
- * A detailed guide for the collections library is available
+ * A detailed guide for using the collections library is available
  * at [[http://docs.scala-lang.org/overviews/collections/introduction.html]].
+ * Developers looking to extend the collections library can find a description
+ * of its architecture at
+ * [[http://docs.scala-lang.org/overviews/core/architecture-of-scala-collections.html]].
  *
  * == Using Collections ==
  *
@@ -31,24 +34,25 @@ package scala
  * array: Array[Int] = Array(1, 2, 3, 4, 5, 6)
  *
  * scala> array map { _.toString }
- * res0: Array[java.lang.String] = Array(1, 2, 3, 4, 5, 6)
+ * res0: Array[String] = Array(1, 2, 3, 4, 5, 6)
  *
  * scala> val list = List(1,2,3,4,5,6)
  * list: List[Int] = List(1, 2, 3, 4, 5, 6)
  *
  * scala> list map { _.toString }
- * res1: List[java.lang.String] = List(1, 2, 3, 4, 5, 6)
+ * res1: List[String] = List(1, 2, 3, 4, 5, 6)
  *
  * }}}
  *
  * == Creating Collections ==
  *
- * The most common way to create a collection is to use the companion objects as factories.
- * Of these, the three most common
- * are [[scala.collection.Seq]], [[scala.collection.immutable.Set]], and [[scala.collection.immutable.Map]].  Their
- * companion objects are all available
- * as type aliases the either the [[scala]] package or in `scala.Predef`, and can be used
- * like so:
+ * The most common way to create a collection is to use its companion object as
+ * a factory. The three most commonly used collections are
+ * [[scala.collection.Seq]], [[scala.collection.immutable.Set]], and
+ * [[scala.collection.immutable.Map]].
+ * They can be used directly as shown below since their companion objects are
+ * all available as type aliases in either the [[scala]] package or in
+ * `scala.Predef`. New collections are created like this:
  * {{{
  * scala> val seq = Seq(1,2,3,4,1)
  * seq: Seq[Int] = List(1, 2, 3, 4, 1)
@@ -56,12 +60,12 @@ package scala
  * scala> val set = Set(1,2,3,4,1)
  * set: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)
  *
- * scala> val map = Map(1 -> "one",2 -> "two", 3 -> "three",2 -> "too")
- * map: scala.collection.immutable.Map[Int,java.lang.String] = Map((1,one), (2,too), (3,three))
+ * scala> val map = Map(1 -> "one", 2 -> "two", 3 -> "three", 2 -> "too")
+ * map: scala.collection.immutable.Map[Int,String] = Map(1 -> one, 2 -> too, 3 -> three)
  * }}}
  *
- * It is also typical to use the [[scala.collection.immutable]] collections over those
- * in [[scala.collection.mutable]]; The types aliased in
+ * It is also typical to prefer the [[scala.collection.immutable]] collections
+ * over those in [[scala.collection.mutable]]; the types aliased in
  * the `scala.Predef` object are the immutable versions.
  *
  * Also note that the collections library was carefully designed to include several implementations of
@@ -74,9 +78,13 @@ package scala
  *
  * === Converting between Java Collections ===
  *
- * The `JavaConversions` object provides implicit defs that will allow mostly seamless integration
- * between Java Collections-based APIs and the Scala collections library.
+ * The [[scala.collection.JavaConversions]] object provides implicit defs that
+ * will allow mostly seamless integration between APIs using Java Collections
+ * and the Scala collections library.
  *
+ * Alternatively the [[scala.collection.JavaConverters]] object provides a collection
+ * of decorators that allow converting between Scala and Java collections using `asScala`
+ * and `asJava` methods.
  */
 package object collection {
   import scala.collection.generic.CanBuildFrom
diff --git a/src/library/scala/collection/parallel/ParIterableLike.scala b/src/library/scala/collection/parallel/ParIterableLike.scala
index a5a82764d6..2ed7bc075e 100644
--- a/src/library/scala/collection/parallel/ParIterableLike.scala
+++ b/src/library/scala/collection/parallel/ParIterableLike.scala
@@ -9,6 +9,8 @@
 package scala
 package collection.parallel
 
+import scala.language.{ higherKinds, implicitConversions }
+
 import scala.collection.mutable.Builder
 import scala.collection.mutable.ArrayBuffer
 import scala.collection.IterableLike
@@ -21,13 +23,9 @@ import scala.collection.GenIterable
 import scala.collection.GenTraversableOnce
 import scala.collection.GenTraversable
 import immutable.HashMapCombiner
-import scala.reflect.{ClassTag, classTag}
-
-import java.util.concurrent.atomic.AtomicBoolean
+import scala.reflect.ClassTag
 
 import scala.annotation.unchecked.uncheckedVariance
-import scala.annotation.unchecked.uncheckedStable
-import scala.language.{ higherKinds, implicitConversions }
 
 import scala.collection.parallel.ParallelCollectionImplicits._
 
@@ -1284,7 +1282,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
   extends Transformer[Combiner[(U, S), That], Zip[U, S, That]] {
     @volatile var result: Result = null
     def leaf(prev: Option[Result]) = result = pit.zip2combiner[U, S, That](othpit, pbf())
-    protected[this] def newSubtask(p: IterableSplitter[T]) = unsupported
+    protected[this] def newSubtask(p: IterableSplitter[T]) = throw new UnsupportedOperationException
     override def split = {
       val pits = pit.splitWithSignalling
       val sizes = pits.map(_.remaining)
@@ -1300,7 +1298,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
   extends Transformer[Combiner[(U, S), That], ZipAll[U, S, That]] {
     @volatile var result: Result = null
     def leaf(prev: Option[Result]) = result = pit.zipAll2combiner[U, S, That](othpit, thiselem, thatelem, pbf())
-    protected[this] def newSubtask(p: IterableSplitter[T]) = unsupported
+    protected[this] def newSubtask(p: IterableSplitter[T]) = throw new UnsupportedOperationException
     override def split = if (pit.remaining <= len) {
       val pits = pit.splitWithSignalling
       val sizes = pits.map(_.remaining)
@@ -1322,7 +1320,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
   extends Accessor[Unit, CopyToArray[U, This]] {
     @volatile var result: Unit = ()
     def leaf(prev: Option[Unit]) = pit.copyToArray(array, from, len)
-    protected[this] def newSubtask(p: IterableSplitter[T]) = unsupported
+    protected[this] def newSubtask(p: IterableSplitter[T]) = throw new UnsupportedOperationException
     override def split = {
       val pits = pit.splitWithSignalling
       for ((p, untilp) <- pits zip pits.scanLeft(0)(_ + _.remaining); if untilp < len) yield {
@@ -1379,7 +1377,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
       val half = howmany / 2
       ScanNode(mergeTrees(trees, from, half), mergeTrees(trees, from + half, howmany - half))
     } else trees(from)
-    protected[this] def newSubtask(pit: IterableSplitter[T]) = unsupported
+    protected[this] def newSubtask(pit: IterableSplitter[T]) = throw new UnsupportedOperationException
     override def split = {
       val pits = pit.splitWithSignalling
       for ((p, untilp) <- pits zip pits.scanLeft(from)(_ + _.remaining)) yield {
@@ -1416,7 +1414,7 @@ self: ParIterableLike[T, Repr, Sequential] =>
         new FromScanTree(left, z, op, cbf),
         new FromScanTree(right, z, op, cbf)
       )
-      case _ => unsupportedop("Cannot be split further")
+      case _ => throw new UnsupportedOperationException("Cannot be split further")
     }
     def shouldSplitFurther = tree match {
       case ScanNode(_, _) => true
@@ -1499,5 +1497,4 @@ self: ParIterableLike[T, Repr, Sequential] =>
       append(s)
     }
   })
-
 }
diff --git a/src/library/scala/collection/parallel/ParMap.scala b/src/library/scala/collection/parallel/ParMap.scala
index 9f92e6c1e8..70afe5174b 100644
--- a/src/library/scala/collection/parallel/ParMap.scala
+++ b/src/library/scala/collection/parallel/ParMap.scala
@@ -11,7 +11,6 @@ package collection.parallel
 
 import scala.collection.Map
 import scala.collection.GenMap
-import scala.collection.mutable.Builder
 import scala.collection.generic.ParMapFactory
 import scala.collection.generic.GenericParMapTemplate
 import scala.collection.generic.GenericParMapCompanion
diff --git a/src/library/scala/collection/parallel/ParMapLike.scala b/src/library/scala/collection/parallel/ParMapLike.scala
index ee1334ba55..a3ac388587 100644
--- a/src/library/scala/collection/parallel/ParMapLike.scala
+++ b/src/library/scala/collection/parallel/ParMapLike.scala
@@ -12,10 +12,8 @@ package collection.parallel
 import scala.collection.MapLike
 import scala.collection.GenMapLike
 import scala.collection.Map
-import scala.collection.mutable.Builder
+
 import scala.annotation.unchecked.uncheckedVariance
-import scala.collection.generic.IdleSignalling
-import scala.collection.generic.Signalling
 
 /** A template trait for mutable parallel maps. This trait is to be mixed in
  *  with concrete parallel maps to override the representation type.
@@ -99,14 +97,14 @@ self =>
     def - (elem: K): ParSet[K] =
       (ParSet[K]() ++ this - elem).asInstanceOf[ParSet[K]] // !!! concrete overrides abstract problem
     override def size = self.size
-    override def foreach[S](f: K => S) = for ((k, v) <- self) f(k)
+    override def foreach[U](f: K => U) = for ((k, v) <- self) f(k)
     override def seq = self.seq.keySet
   }
 
   protected class DefaultValuesIterable extends ParIterable[V] {
     def splitter = valuesIterator(self.splitter)
     override def size = self.size
-    override def foreach[S](f: V => S) = for ((k, v) <- self) f(v)
+    override def foreach[U](f: V => U) = for ((k, v) <- self) f(v)
     def seq = self.seq.values
   }
 
@@ -118,7 +116,7 @@ self =>
 
   def filterKeys(p: K => Boolean): ParMap[K, V] = new ParMap[K, V] {
     lazy val filtered = self.filter(kv => p(kv._1))
-    override def foreach[S](f: ((K, V)) => S): Unit = for (kv <- self) if (p(kv._1)) f(kv)
+    override def foreach[U](f: ((K, V)) => U): Unit = for (kv <- self) if (p(kv._1)) f(kv)
     def splitter = filtered.splitter
     override def contains(key: K) = self.contains(key) && p(key)
     def get(key: K) = if (!p(key)) None else self.get(key)
@@ -129,7 +127,7 @@ self =>
   }
 
   def mapValues[S](f: V => S): ParMap[K, S] = new ParMap[K, S] {
-    override def foreach[Q](g: ((K, S)) => Q): Unit = for ((k, v) <- self) g((k, f(v)))
+    override def foreach[U](g: ((K, S)) => U): Unit = for ((k, v) <- self) g((k, f(v)))
     def splitter = self.splitter.map(kv => (kv._1, f(kv._2)))
     override def size = self.size
     override def contains(key: K) = self.contains(key)
diff --git a/src/library/scala/collection/parallel/ParSeqLike.scala b/src/library/scala/collection/parallel/ParSeqLike.scala
index 0b6fec364e..60fa1858e7 100644
--- a/src/library/scala/collection/parallel/ParSeqLike.scala
+++ b/src/library/scala/collection/parallel/ParSeqLike.scala
@@ -9,11 +9,10 @@
 package scala
 package collection.parallel
 
-import scala.collection.{ Parallel, SeqLike, GenSeqLike, GenSeq, GenIterable, Iterator }
+import scala.collection.{ SeqLike, GenSeq, GenIterable, Iterator }
 import scala.collection.generic.DefaultSignalling
 import scala.collection.generic.AtomicIndexFlag
 import scala.collection.generic.CanBuildFrom
-import scala.collection.generic.CanCombineFrom
 import scala.collection.generic.VolatileAbort
 
 import scala.collection.parallel.ParallelCollectionImplicits._
@@ -365,7 +364,7 @@ self =>
         pit.setIndexFlagIfLesser(from)
       }
     }
-    protected[this] def newSubtask(p: SuperParIterator) = unsupported
+    protected[this] def newSubtask(p: SuperParIterator) = throw new UnsupportedOperationException
     override def split = {
       val pits = pit.splitWithSignalling
       for ((p, untilp) <- pits zip pits.scanLeft(from)(_ + _.remaining)) yield new IndexWhere(pred, untilp, p)
@@ -386,7 +385,7 @@ self =>
         pit.setIndexFlagIfGreater(pos)
       }
     }
-    protected[this] def newSubtask(p: SuperParIterator) = unsupported
+    protected[this] def newSubtask(p: SuperParIterator) = throw new UnsupportedOperationException
     override def split = {
       val pits = pit.splitWithSignalling
       for ((p, untilp) <- pits zip pits.scanLeft(pos)(_ + _.remaining)) yield new LastIndexWhere(pred, untilp, p)
@@ -420,7 +419,7 @@ self =>
       result = pit.sameElements(otherpit)
       if (!result) pit.abort()
     }
-    protected[this] def newSubtask(p: SuperParIterator) = unsupported
+    protected[this] def newSubtask(p: SuperParIterator) = throw new UnsupportedOperationException
     override def split = {
       val fp = pit.remaining / 2
       val sp = pit.remaining - fp
@@ -434,7 +433,7 @@ self =>
   extends Transformer[Combiner[U, That], Updated[U, That]] {
     @volatile var result: Combiner[U, That] = null
     def leaf(prev: Option[Combiner[U, That]]) = result = pit.updated2combiner(pos, elem, pbf())
-    protected[this] def newSubtask(p: SuperParIterator) = unsupported
+    protected[this] def newSubtask(p: SuperParIterator) = throw new UnsupportedOperationException
     override def split = {
       val pits = pit.splitWithSignalling
       for ((p, untilp) <- pits zip pits.scanLeft(0)(_ + _.remaining)) yield new Updated(pos - untilp, elem, pbf, p)
@@ -447,7 +446,7 @@ self =>
   extends Transformer[Combiner[(U, S), That], Zip[U, S, That]] {
     @volatile var result: Result = null
     def leaf(prev: Option[Result]) = result = pit.zip2combiner[U, S, That](otherpit, cf())
-    protected[this] def newSubtask(p: SuperParIterator) = unsupported
+    protected[this] def newSubtask(p: SuperParIterator) = throw new UnsupportedOperationException
     override def split = {
       val fp = len / 2
       val sp = len - len / 2
@@ -468,7 +467,7 @@ self =>
       result = pit.corresponds(corr)(otherpit)
       if (!result) pit.abort()
     }
-    protected[this] def newSubtask(p: SuperParIterator) = unsupported
+    protected[this] def newSubtask(p: SuperParIterator) = throw new UnsupportedOperationException
     override def split = {
       val fp = pit.remaining / 2
       val sp = pit.remaining - fp
diff --git a/src/library/scala/collection/parallel/RemainsIterator.scala b/src/library/scala/collection/parallel/RemainsIterator.scala
index 7bb278b038..63d63d9ef3 100644
--- a/src/library/scala/collection/parallel/RemainsIterator.scala
+++ b/src/library/scala/collection/parallel/RemainsIterator.scala
@@ -9,13 +9,10 @@
 package scala
 package collection.parallel
 
-import scala.collection.Parallel
 import scala.collection.generic.Signalling
 import scala.collection.generic.DelegatedSignalling
 import scala.collection.generic.IdleSignalling
-import scala.collection.generic.CanCombineFrom
 import scala.collection.mutable.Builder
-import scala.collection.Iterator.empty
 import scala.collection.GenTraversableOnce
 import scala.collection.parallel.immutable.repetition
 
diff --git a/src/library/scala/collection/parallel/immutable/ParMap.scala b/src/library/scala/collection/parallel/immutable/ParMap.scala
index 2956c2a883..65bb2e12c5 100644
--- a/src/library/scala/collection/parallel/immutable/ParMap.scala
+++ b/src/library/scala/collection/parallel/immutable/ParMap.scala
@@ -16,7 +16,6 @@ import scala.collection.generic.GenericParMapCompanion
 import scala.collection.generic.CanCombineFrom
 import scala.collection.parallel.ParMapLike
 import scala.collection.parallel.Combiner
-import scala.collection.GenMapLike
 
 /** A template trait for immutable parallel maps.
  *
diff --git a/src/library/scala/collection/parallel/immutable/ParRange.scala b/src/library/scala/collection/parallel/immutable/ParRange.scala
index ec90de3a7d..8fd5382ce9 100644
--- a/src/library/scala/collection/parallel/immutable/ParRange.scala
+++ b/src/library/scala/collection/parallel/immutable/ParRange.scala
@@ -12,7 +12,6 @@ package collection.parallel.immutable
 import scala.collection.immutable.Range
 import scala.collection.parallel.Combiner
 import scala.collection.parallel.SeqSplitter
-import scala.collection.generic.CanCombineFrom
 import scala.collection.Iterator
 
 /** Parallel ranges.
diff --git a/src/library/scala/collection/parallel/mutable/ParArray.scala b/src/library/scala/collection/parallel/mutable/ParArray.scala
index d0d022db4b..8a2cf2716a 100644
--- a/src/library/scala/collection/parallel/mutable/ParArray.scala
+++ b/src/library/scala/collection/parallel/mutable/ParArray.scala
@@ -18,7 +18,6 @@ import scala.collection.generic.GenericParCompanion
 import scala.collection.generic.CanCombineFrom
 import scala.collection.generic.CanBuildFrom
 import scala.collection.generic.ParFactory
-import scala.collection.generic.Sizing
 import scala.collection.parallel.Combiner
 import scala.collection.parallel.SeqSplitter
 import scala.collection.parallel.ParSeqLike
diff --git a/src/library/scala/collection/parallel/mutable/ResizableParArrayCombiner.scala b/src/library/scala/collection/parallel/mutable/ResizableParArrayCombiner.scala
index 79322c85b1..6883457fef 100644
--- a/src/library/scala/collection/parallel/mutable/ResizableParArrayCombiner.scala
+++ b/src/library/scala/collection/parallel/mutable/ResizableParArrayCombiner.scala
@@ -9,18 +9,10 @@
 package scala
 package collection.parallel.mutable
 
-
-
-import scala.collection.generic.Sizing
 import scala.collection.mutable.ArraySeq
 import scala.collection.mutable.ArrayBuffer
-import scala.collection.parallel.TaskSupport
-import scala.collection.parallel.unsupportedop
-import scala.collection.parallel.Combiner
 import scala.collection.parallel.Task
 
-
-
 /** An array combiner that uses a chain of arraybuffers to store elements. */
 trait ResizableParArrayCombiner[T] extends LazyCombiner[T, ParArray[T], ExposedArrayBuffer[T]] {
 
diff --git a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
index d1379cde11..5e4572da60 100644
--- a/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
+++ b/src/library/scala/collection/parallel/mutable/UnrolledParArrayCombiner.scala
@@ -9,13 +9,9 @@
 package scala
 package collection.parallel.mutable
 
-import scala.collection.generic.Sizing
 import scala.collection.mutable.ArraySeq
-import scala.collection.mutable.ArrayBuffer
 import scala.collection.mutable.UnrolledBuffer
 import scala.collection.mutable.UnrolledBuffer.Unrolled
-import scala.collection.parallel.TaskSupport
-import scala.collection.parallel.unsupportedop
 import scala.collection.parallel.Combiner
 import scala.collection.parallel.Task
 import scala.reflect.ClassTag
@@ -62,7 +58,7 @@ extends Combiner[T, ParArray[T]] {
     case that: UnrolledParArrayCombiner[t] =>
       buff concat that.buff
       this
-    case _ => unsupportedop("Cannot combine with combiner of different type.")
+    case _ => throw new UnsupportedOperationException("Cannot combine with combiner of different type.")
   }
 
   def size = buff.size
diff --git a/src/library/scala/collection/parallel/package.scala b/src/library/scala/collection/parallel/package.scala
index d77dcb0658..ba64ca505b 100644
--- a/src/library/scala/collection/parallel/package.scala
+++ b/src/library/scala/collection/parallel/package.scala
@@ -35,15 +35,7 @@ package object parallel {
     else sz
   }
 
-  private[parallel] def unsupported = throw new UnsupportedOperationException
-
-  private[parallel] def unsupportedop(msg: String) = throw new UnsupportedOperationException(msg)
-
-  private[parallel] def outofbounds(idx: Int) = throw new IndexOutOfBoundsException(idx.toString)
-
-  private[parallel] def getTaskSupport: TaskSupport = new ExecutionContextTaskSupport
-
-  val defaultTaskSupport: TaskSupport = getTaskSupport
+  val defaultTaskSupport: TaskSupport = new ExecutionContextTaskSupport
 
   def setTaskSupport[Coll](c: Coll, t: TaskSupport): Coll = {
     c match {
@@ -98,7 +90,7 @@ package parallel {
       }
     }
   }
-  
+
   trait FactoryOps[From, Elem, To] {
     trait Otherwise[R] {
       def otherwise(notbody: => R): R
diff --git a/src/library/scala/concurrent/ExecutionContext.scala b/src/library/scala/concurrent/ExecutionContext.scala
index df2d68c9c6..e022b94ea8 100644
--- a/src/library/scala/concurrent/ExecutionContext.scala
+++ b/src/library/scala/concurrent/ExecutionContext.scala
@@ -11,7 +11,6 @@ package scala.concurrent
 
 import java.util.concurrent.{ ExecutorService, Executor }
 import scala.annotation.implicitNotFound
-import scala.util.Try
 
 /**
  * An `ExecutionContext` can execute program logic asynchronously,
@@ -75,7 +74,7 @@ trait ExecutionContext {
   /** Prepares for the execution of a task. Returns the prepared
      *  execution context. The recommended implementation of
      *  `prepare` is to return `this`.
-     * 
+     *
      *  This method should no longer be overridden or called. It was
      *  originally expected that `prepare` would be called by
      *  all libraries that consume ExecutionContexts, in order to
diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala
index c8ababbcab..f49536d351 100644
--- a/src/library/scala/concurrent/Future.scala
+++ b/src/library/scala/concurrent/Future.scala
@@ -10,15 +10,12 @@ package scala.concurrent
 
 import scala.language.higherKinds
 
-import java.util.concurrent.{ CountDownLatch, TimeUnit, Callable }
-import java.util.concurrent.TimeUnit.{ NANOSECONDS => NANOS, MILLISECONDS ⇒ MILLIS }
+import java.util.concurrent.{CountDownLatch, TimeUnit}
 import java.util.concurrent.atomic.AtomicInteger
 
 import scala.util.control.NonFatal
 import scala.util.{Try, Success, Failure}
 import scala.concurrent.duration._
-import scala.annotation.tailrec
-import scala.collection.mutable.Builder
 import scala.collection.generic.CanBuildFrom
 import scala.reflect.ClassTag
 
@@ -215,7 +212,7 @@ trait Future[+T] extends Awaitable[T] {
    *  @param  f  function that transforms a failure of the receiver into a failure of the returned future
    *  @return    a `Future` that will be completed with the transformed value
    */
-  def transform[S](s: T => S, f: Throwable => Throwable)(implicit executor: ExecutionContext): Future[S] = 
+  def transform[S](s: T => S, f: Throwable => Throwable)(implicit executor: ExecutionContext): Future[S] =
     transform {
       case Success(r) => Try(s(r))
       case Failure(t) => Try(throw f(t)) // will throw fatal errors!
@@ -348,7 +345,7 @@ trait Future[+T] extends Awaitable[T] {
    *  @param pf    the `PartialFunction` to apply if this `Future` fails
    *  @return      a `Future` with the successful value of this `Future` or the result of the `PartialFunction`
    */
-  def recover[U >: T](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Future[U] = 
+  def recover[U >: T](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Future[U] =
     transform { _ recover pf }
 
   /** Creates a new future that will handle any matching throwable that this
@@ -429,7 +426,7 @@ trait Future[+T] extends Awaitable[T] {
    *  @return       a `Future` with the successful result of this or that `Future` or the failure of this `Future` if both fail
    */
   def fallbackTo[U >: T](that: Future[U]): Future[U] =
-    if (this eq that) this 
+    if (this eq that) this
     else {
       implicit val ec = internalExecutor
       recoverWith { case _ => that } recoverWith { case _ => this }
@@ -532,7 +529,7 @@ object Future {
       ready(atMost)
       throw new TimeoutException(s"Future timed out after [$atMost]")
     }
-    
+
     override def onSuccess[U](pf: PartialFunction[Nothing, U])(implicit executor: ExecutionContext): Unit = ()
     override def onFailure[U](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Unit = ()
     override def onComplete[U](f: Try[Nothing] => U)(implicit executor: ExecutionContext): Unit = ()
@@ -597,7 +594,7 @@ object Future {
   *  @return          the `Future` holding the result of the computation
   */
   def apply[T](body: =>T)(implicit @deprecatedName('execctx) executor: ExecutionContext): Future[T] =
-    unit.map(_ => body)    
+    unit.map(_ => body)
 
   /** Simple version of `Future.traverse`. Asynchronously and non-blockingly transforms a `TraversableOnce[Future[A]]`
    *  into a `Future[TraversableOnce[A]]`. Useful for reducing many `Future`s into a single `Future`.
diff --git a/src/library/scala/concurrent/FutureTaskRunner.scala b/src/library/scala/concurrent/FutureTaskRunner.scala
deleted file mode 100644
index 089e67cedd..0000000000
--- a/src/library/scala/concurrent/FutureTaskRunner.scala
+++ /dev/null
@@ -1,39 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2009-2013, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-package scala.concurrent
-
-import scala.language.{implicitConversions, higherKinds}
-
-/** The `FutureTaskRunner` trait is a base trait of task runners
- *  that provide some sort of future abstraction.
- *
- *  @author Philipp Haller
- */
-@deprecated("Use `ExecutionContext` instead.", "2.10.0")
-private[scala] trait FutureTaskRunner extends TaskRunner {
-
-  /** The type of the futures that the underlying task runner supports.
-   */
-  type Future[T]
-
-  /** An implicit conversion from futures to zero-parameter functions.
-   */
-  implicit def futureAsFunction[S](x: Future[S]): () => S
-
-  /** Submits a task to run which returns its result in a future.
-   */
-  def submit[S](task: Task[S]): Future[S]
-
-   /* Possibly blocks the current thread, for example, waiting for
-    * a lock or condition.
-    */
-  @deprecated("Use `blocking` instead.", "2.10.0")
-  def managedBlock(blocker: ManagedBlocker): Unit
-
-}
diff --git a/src/library/scala/concurrent/ManagedBlocker.scala b/src/library/scala/concurrent/ManagedBlocker.scala
deleted file mode 100644
index b5a6e21893..0000000000
--- a/src/library/scala/concurrent/ManagedBlocker.scala
+++ /dev/null
@@ -1,34 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-package scala.concurrent
-
-/** The `ManagedBlocker` trait...
- *
- *  @author Philipp Haller
- */
-@deprecated("Use `blocking` instead.", "2.10.0")
-private[scala] trait ManagedBlocker {
-
-  /**
-   * Possibly blocks the current thread, for example waiting for
-   * a lock or condition.
-   *
-   * @return true if no additional blocking is necessary (i.e.,
-   *         if `isReleasable` would return `true`).
-   * @throws InterruptedException if interrupted while waiting
-   *         (the method is not required to do so, but is allowed to).
-   */
-  def block(): Boolean
-
-  /**
-   * Returns `true` if blocking is unnecessary.
-   */
-  def isReleasable: Boolean
-
-}
diff --git a/src/library/scala/concurrent/SyncVar.scala b/src/library/scala/concurrent/SyncVar.scala
index 1ee27b0f36..127e6b58d2 100644
--- a/src/library/scala/concurrent/SyncVar.scala
+++ b/src/library/scala/concurrent/SyncVar.scala
@@ -19,17 +19,17 @@ import java.util.concurrent.TimeUnit
  */
 class SyncVar[A] {
   private var isDefined: Boolean = false
-  private var value: Option[A] = None
+  private var value: A = _
 
   /**
-   * Waits for this SyncVar to become defined and returns
-   * the result, without modifying the stored value.
+   * Wait for this SyncVar to become defined and then get
+   * the stored value without modifying it.
    *
    * @return value that is held in this container
    */
   def get: A = synchronized {
     while (!isDefined) wait()
-    value.get
+    value
   }
 
   /** Waits `timeout` millis. If `timeout <= 0` just returns 0.
@@ -44,11 +44,10 @@ class SyncVar[A] {
     if (elapsed < 0) 0 else TimeUnit.NANOSECONDS.toMillis(elapsed)
   }
 
-  /** Waits for this SyncVar to become defined at least for
-   *  `timeout` milliseconds (possibly more), and gets its
-   *  value.
+  /** Wait at least `timeout` milliseconds (possibly more) for this `SyncVar`
+   *  to become defined and then get its value.
    *
-   *  @param timeout     the amount of milliseconds to wait, 0 means forever
+   *  @param timeout     time in milliseconds to wait
    *  @return            `None` if variable is undefined after `timeout`, `Some(value)` otherwise
    */
   def get(timeout: Long): Option[A] = synchronized {
@@ -61,12 +60,12 @@ class SyncVar[A] {
       val elapsed = waitMeasuringElapsed(rest)
       rest -= elapsed
     }
-    value
+    if (isDefined) Some(value) else None
   }
 
   /**
-   * Waits for this SyncVar to become defined and returns
-   * the result, unsetting the stored value before returning.
+   * Wait for this SyncVar to become defined and then get
+   * the stored value, unsetting it as a side effect.
    *
    * @return value that was held in this container
    */
@@ -75,12 +74,11 @@ class SyncVar[A] {
     finally unsetVal()
   }
 
-  /** Waits for this SyncVar to become defined at least for
-   *  `timeout` milliseconds (possibly more), and takes its
-   *  value by first reading and then removing the value from
-   *  the SyncVar.
+  /** Wait at least `timeout` milliseconds (possibly more) for this `SyncVar`
+   *  to become defined and then get the stored value, unsetting it
+   *  as a side effect.
    *
-   *  @param timeout     the amount of milliseconds to wait, 0 means forever
+   *  @param timeout     the amount of milliseconds to wait
    *  @return            the value or a throws an exception if the timeout occurs
    *  @throws NoSuchElementException on timeout
    */
@@ -97,14 +95,14 @@ class SyncVar[A] {
   // NOTE: Used by SBT 0.13.0-M2 and below
   def set(x: A): Unit = setVal(x)
 
-  /** Places a value in the SyncVar. If the SyncVar already has a stored value,
-   * it waits until another thread takes it */
+  /** Place a value in the SyncVar. If the SyncVar already has a stored value,
+   * wait until another thread takes it. */
   def put(x: A): Unit = synchronized {
     while (isDefined) wait()
     setVal(x)
   }
 
-  /** Checks whether a value is stored in the synchronized variable */
+  /** Check whether a value is stored in the synchronized variable. */
   def isSet: Boolean = synchronized {
     isDefined
   }
@@ -117,7 +115,7 @@ class SyncVar[A] {
   // NOTE: Used by SBT 0.13.0-M2 and below
   def unset(): Unit = synchronized {
     isDefined = false
-    value = None
+    value = null.asInstanceOf[A]
     notifyAll()
   }
 
@@ -126,7 +124,7 @@ class SyncVar[A] {
   // implementation of `set` was moved to `setVal` to achieve this
   private def setVal(x: A): Unit = synchronized {
     isDefined = true
-    value = Some(x)
+    value = x
     notifyAll()
   }
 
@@ -135,8 +133,7 @@ class SyncVar[A] {
   // implementation of `unset` was moved to `unsetVal` to achieve this
   private def unsetVal(): Unit = synchronized {
     isDefined = false
-    value = None
+    value = null.asInstanceOf[A]
     notifyAll()
   }
-
 }
diff --git a/src/library/scala/concurrent/TaskRunner.scala b/src/library/scala/concurrent/TaskRunner.scala
deleted file mode 100644
index 1ea23b35e8..0000000000
--- a/src/library/scala/concurrent/TaskRunner.scala
+++ /dev/null
@@ -1,27 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-package scala.concurrent
-
-import scala.language.{higherKinds, implicitConversions}
-
-/** The `TaskRunner` trait...
- *
- *  @author Philipp Haller
- */
-@deprecated("Use `ExecutionContext` instead.", "2.10.0")
-private[scala] trait TaskRunner {
-
-  type Task[T]
-
-  implicit def functionAsTask[S](fun: () => S): Task[S]
-
-  def execute[S](task: Task[S]): Unit
-
-  def shutdown(): Unit
-}
diff --git a/src/library/scala/concurrent/ThreadPoolRunner.scala b/src/library/scala/concurrent/ThreadPoolRunner.scala
deleted file mode 100644
index 7784681f71..0000000000
--- a/src/library/scala/concurrent/ThreadPoolRunner.scala
+++ /dev/null
@@ -1,51 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-package scala.concurrent
-
-import java.util.concurrent.{ExecutorService, Callable, TimeUnit}
-import scala.language.implicitConversions
-
-/** The `ThreadPoolRunner` trait uses a `java.util.concurrent.ExecutorService`
- *  to run submitted tasks.
- *
- *  @author Philipp Haller
- */
-@deprecated("Use `ExecutionContext` instead.", "2.10.0")
-private[scala] trait ThreadPoolRunner extends FutureTaskRunner {
-
-  type Task[T] = Callable[T] with Runnable
-  type Future[T] = java.util.concurrent.Future[T]
-
-  private class RunCallable[S](fun: () => S) extends Runnable with Callable[S] {
-    def run() = fun()
-    def call() = fun()
-  }
-
-  implicit def functionAsTask[S](fun: () => S): Task[S] =
-    new RunCallable(fun)
-
-  implicit def futureAsFunction[S](x: Future[S]): () => S =
-    () => x.get()
-
-  protected def executor: ExecutorService
-
-  def submit[S](task: Task[S]): Future[S] = {
-    executor.submit[S](task)
-  }
-
-  def execute[S](task: Task[S]) {
-    executor execute task
-  }
-
-  @deprecated("Use `blocking` instead.", "2.10.0")
-  def managedBlock(blocker: ManagedBlocker) {
-    blocker.block()
-  }
-
-}
diff --git a/src/library/scala/concurrent/impl/ExecutionContextImpl.scala b/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
index c98746a98d..7bf5cc5729 100644
--- a/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
+++ b/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
@@ -8,13 +8,10 @@
 
 package scala.concurrent.impl
 
-
-
-import java.util.concurrent.{ ForkJoinPool, ForkJoinWorkerThread, ForkJoinTask, LinkedBlockingQueue, Callable, Executor, ExecutorService, Executors, ThreadFactory, TimeUnit, ThreadPoolExecutor }
+import java.util.concurrent.{ ForkJoinPool, ForkJoinWorkerThread, ForkJoinTask, Callable, Executor, ExecutorService, ThreadFactory, TimeUnit }
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.Collection
-import scala.concurrent.{ BlockContext, ExecutionContext, Awaitable, CanAwait, ExecutionContextExecutor, ExecutionContextExecutorService }
-import scala.util.control.NonFatal
+import scala.concurrent.{ BlockContext, ExecutionContext, CanAwait, ExecutionContextExecutor, ExecutionContextExecutorService }
 import scala.annotation.tailrec
 
 
@@ -57,7 +54,7 @@ private[concurrent] object ExecutionContextImpl {
     }
 
     // As per ThreadFactory contract newThread should return `null` if cannot create new thread.
-    def newThread(runnable: Runnable): Thread = 
+    def newThread(runnable: Runnable): Thread =
       if (reserveThread())
         wire(new Thread(new Runnable {
           // We have to decrement the current thread count when the thread exits
@@ -80,7 +77,7 @@ private[concurrent] object ExecutionContextImpl {
                   } finally {
                     isdone = true
                   }
-                
+
                 true
               }
               override def isReleasable = isdone
@@ -123,33 +120,17 @@ private[concurrent] object ExecutionContextImpl {
                                                                       prefix = "scala-execution-context-global",
                                                                       uncaught = uncaughtExceptionHandler)
 
-    try {
-      new ForkJoinPool(desiredParallelism, threadFactory, uncaughtExceptionHandler, true) {
-        override def execute(runnable: Runnable): Unit = {
-            val fjt: ForkJoinTask[_] = runnable match {
-              case t: ForkJoinTask[_] => t
-              case r                  => new ExecutionContextImpl.AdaptedForkJoinTask(r)
-            }
-            Thread.currentThread match {
-              case fjw: ForkJoinWorkerThread if fjw.getPool eq this => fjt.fork()
-              case _                                                => super.execute(fjt)
-            }
+    new ForkJoinPool(desiredParallelism, threadFactory, uncaughtExceptionHandler, true) {
+      override def execute(runnable: Runnable): Unit = {
+        val fjt: ForkJoinTask[_] = runnable match {
+          case t: ForkJoinTask[_] => t
+          case r                  => new ExecutionContextImpl.AdaptedForkJoinTask(r)
+        }
+        Thread.currentThread match {
+          case fjw: ForkJoinWorkerThread if fjw.getPool eq this => fjt.fork()
+          case _                                                => super.execute(fjt)
         }
       }
-    } catch {
-      case NonFatal(t) =>
-        System.err.println("Failed to create ForkJoinPool for the default ExecutionContext, falling back to ThreadPoolExecutor")
-        t.printStackTrace(System.err)
-        val exec = new ThreadPoolExecutor(
-          desiredParallelism,
-          desiredParallelism,
-          5L,
-          TimeUnit.MINUTES,
-          new LinkedBlockingQueue[Runnable],
-          threadFactory
-        )
-        exec.allowCoreThreadTimeOut(true)
-        exec
     }
   }
 
diff --git a/src/library/scala/concurrent/impl/Promise.scala b/src/library/scala/concurrent/impl/Promise.scala
index 3538ac6b94..178cd6d912 100644
--- a/src/library/scala/concurrent/impl/Promise.scala
+++ b/src/library/scala/concurrent/impl/Promise.scala
@@ -8,13 +8,13 @@
 
 package scala.concurrent.impl
 
-import scala.concurrent.{ ExecutionContext, CanAwait, OnCompleteRunnable, TimeoutException, ExecutionException, blocking }
+import scala.concurrent.{ ExecutionContext, CanAwait, OnCompleteRunnable, TimeoutException, ExecutionException }
 import scala.concurrent.Future.InternalCallbackExecutor
-import scala.concurrent.duration.{ Duration, Deadline, FiniteDuration, NANOSECONDS }
+import scala.concurrent.duration.{ Duration, FiniteDuration }
 import scala.annotation.tailrec
 import scala.util.control.NonFatal
 import scala.util.{ Try, Success, Failure }
-import java.io.ObjectInputStream
+
 import java.util.concurrent.locks.AbstractQueuedSynchronizer
 import java.util.concurrent.atomic.AtomicReference
 
@@ -393,7 +393,7 @@ private[concurrent] object Promise {
       override def collect[S](pf: PartialFunction[T, S])(implicit executor: ExecutionContext): Future[S] = thisAs[S]
       override def zip[U](that: Future[U]): Future[(T, U)] = thisAs[(T,U)]
       override def zipWith[U, R](that: Future[U])(f: (T, U) => R)(implicit executor: ExecutionContext): Future[R] = thisAs[R]
-      override def fallbackTo[U >: T](that: Future[U]): Future[U] = 
+      override def fallbackTo[U >: T](that: Future[U]): Future[U] =
         if (this eq that) this else that.recoverWith({ case _ => this })(InternalCallbackExecutor)
       override def mapTo[S](implicit tag: ClassTag[S]): Future[S] = thisAs[S]
     }
diff --git a/src/library/scala/deprecatedInheritance.scala b/src/library/scala/deprecatedInheritance.scala
index 7d20219d4d..7614a96f95 100644
--- a/src/library/scala/deprecatedInheritance.scala
+++ b/src/library/scala/deprecatedInheritance.scala
@@ -19,5 +19,4 @@ package scala
  *  @since  2.10
  *  @see    [[scala.deprecatedOverriding]]
  */
-private[scala] // for now, this needs to be generalized to communicate other modifier deltas
 class deprecatedInheritance(message: String = "", since: String = "") extends scala.annotation.StaticAnnotation
diff --git a/src/library/scala/deprecatedOverriding.scala b/src/library/scala/deprecatedOverriding.scala
index 04bce343a0..26a9d9ee7d 100644
--- a/src/library/scala/deprecatedOverriding.scala
+++ b/src/library/scala/deprecatedOverriding.scala
@@ -17,5 +17,4 @@ package scala
  *  @since  2.10
  *  @see    [[scala.deprecatedInheritance]]
  */
-private[scala] // for the same reasons as deprecatedInheritance
 class deprecatedOverriding(message: String = "", since: String = "") extends scala.annotation.StaticAnnotation
diff --git a/src/library/scala/io/BufferedSource.scala b/src/library/scala/io/BufferedSource.scala
index 52fa525b24..33b5a1468e 100644
--- a/src/library/scala/io/BufferedSource.scala
+++ b/src/library/scala/io/BufferedSource.scala
@@ -8,11 +8,9 @@
 
 package scala.io
 
-import java.util.Arrays
 import java.io.{ InputStream, BufferedReader, InputStreamReader, PushbackReader }
 import Source.DefaultBufSize
 import scala.collection.{ Iterator, AbstractIterator }
-import scala.collection.mutable.ArrayBuffer
 
 /** This object provides convenience methods to create an iterable
  *  representation of a source file.
diff --git a/src/library/scala/math/BigDecimal.scala b/src/library/scala/math/BigDecimal.scala
index bb337e7a1d..371fd59a93 100644
--- a/src/library/scala/math/BigDecimal.scala
+++ b/src/library/scala/math/BigDecimal.scala
@@ -10,13 +10,12 @@
 package scala
 package math
 
-import java.{ lang => jl }
-import java.math.{ MathContext, BigDecimal => BigDec }
-import scala.collection.immutable.NumericRange
 import scala.language.implicitConversions
 
+import java.math.{ MathContext, BigDecimal => BigDec }
+import scala.collection.immutable.NumericRange
 
-/** 
+/**
  *  @author  Stephane Micheloud
  *  @author  Rex Kerr
  *  @version 1.1
@@ -44,17 +43,17 @@ object BigDecimal {
     val HALF_UP     = Value(RM.HALF_UP.ordinal)
     val HALF_DOWN   = Value(RM.HALF_DOWN.ordinal)
     val HALF_EVEN   = Value(RM.HALF_EVEN.ordinal)
-    val UNNECESSARY = Value(RM.UNNECESSARY.ordinal) 
+    val UNNECESSARY = Value(RM.UNNECESSARY.ordinal)
   }
-  
+
   /** Constructs a `BigDecimal` using the decimal text representation of `Double` value `d`, rounding if necessary. */
   def decimal(d: Double, mc: MathContext): BigDecimal =
     new BigDecimal(new BigDec(java.lang.Double.toString(d), mc), mc)
 
   /** Constructs a `BigDecimal` using the decimal text representation of `Double` value `d`. */
   def decimal(d: Double): BigDecimal = decimal(d, defaultMathContext)
-  
-  /** Constructs a `BigDecimal` using the decimal text representation of `Float` value `f`, rounding if necessary. 
+
+  /** Constructs a `BigDecimal` using the decimal text representation of `Float` value `f`, rounding if necessary.
    *  Note that `BigDecimal.decimal(0.1f) != 0.1f` since equality agrees with the `Double` representation, and
    *  `0.1 != 0.1f`.
    */
@@ -66,18 +65,18 @@ object BigDecimal {
    *  `0.1 != 0.1f`.
    */
   def decimal(f: Float): BigDecimal = decimal(f, defaultMathContext)
-  
+
   // This exists solely to avoid conversion from Int/Long to Float, screwing everything up.
   /** Constructs a `BigDecimal` from a `Long`, rounding if necessary.  This is identical to `BigDecimal(l, mc)`. */
   def decimal(l: Long, mc: MathContext): BigDecimal = apply(l, mc)
-  
+
   // This exists solely to avoid conversion from Int/Long to Float, screwing everything up.
   /** Constructs a `BigDecimal` from a `Long`.  This is identical to `BigDecimal(l)`. */
   def decimal(l: Long): BigDecimal = apply(l)
-  
+
   /** Constructs a `BigDecimal` using a `java.math.BigDecimal`, rounding if necessary. */
   def decimal(bd: BigDec, mc: MathContext): BigDecimal = new BigDecimal(bd.round(mc), mc)
-  
+
   /** Constructs a `BigDecimal` by expanding the binary fraction
    *  contained by `Double` value `d` into a decimal representation,
    *  rounding if necessary.  When a `Float` is converted to a
@@ -85,50 +84,50 @@ object BigDecimal {
    *  also works for converted `Float`s.
    */
   def binary(d: Double, mc: MathContext): BigDecimal = new BigDecimal(new BigDec(d, mc), mc)
-  
+
   /** Constructs a `BigDecimal` by expanding the binary fraction
    *  contained by `Double` value `d` into a decimal representation.
    *  Note: this also works correctly on converted `Float`s.
    */
   def binary(d: Double): BigDecimal = binary(d, defaultMathContext)
-  
+
   /** Constructs a `BigDecimal` from a `java.math.BigDecimal`.  The
    *  precision is the default for `BigDecimal` or enough to represent
    *  the `java.math.BigDecimal` exactly, whichever is greater.
    */
   def exact(repr: BigDec): BigDecimal = {
-    val mc = 
+    val mc =
       if (repr.precision <= defaultMathContext.getPrecision) defaultMathContext
       else new MathContext(repr.precision, java.math.RoundingMode.HALF_EVEN)
     new BigDecimal(repr, mc)
   }
-  
+
   /** Constructs a `BigDecimal` by fully expanding the binary fraction
    *  contained by `Double` value `d`, adjusting the precision as
    *  necessary.  Note: this works correctly on converted `Float`s also.
    */
   def exact(d: Double): BigDecimal = exact(new BigDec(d))
-  
+
   /** Constructs a `BigDecimal` that exactly represents a `BigInt`.
    */
   def exact(bi: BigInt): BigDecimal = exact(new BigDec(bi.bigInteger))
-  
+
   /** Constructs a `BigDecimal` that exactly represents a `Long`.  Note that
    *  all creation methods for `BigDecimal` that do not take a `MathContext`
    *  represent a `Long`; this is equivalent to `apply`, `valueOf`, etc..
    */
   def exact(l: Long): BigDecimal = apply(l)
-  
+
   /** Constructs a `BigDecimal` that exactly represents the number
    *  specified in a `String`.
    */
   def exact(s: String): BigDecimal = exact(new BigDec(s))
-  
+
   /** Constructs a `BigDecimal` that exactly represents the number
    *  specified in base 10 in a character array.
    */
  def exact(cs: Array[Char]): BigDecimal = exact(new BigDec(cs))
-  
+
 
   /** Constructs a `BigDecimal` using the java BigDecimal static
    *  valueOf constructor.  Equivalent to `BigDecimal.decimal`.
@@ -137,7 +136,7 @@ object BigDecimal {
    *  @return the constructed `BigDecimal`
    */
   def valueOf(d: Double): BigDecimal = apply(BigDec valueOf d)
-  
+
   /** Constructs a `BigDecimal` using the java BigDecimal static
    *  valueOf constructor, specifying a `MathContext` that is
    *  used for computations but isn't used for rounding.  Use
@@ -151,7 +150,7 @@ object BigDecimal {
    */
   @deprecated("MathContext is not applied to Doubles in valueOf.  Use BigDecimal.decimal to use rounding, or java.math.BigDecimal.valueOf to avoid it.","2.11")
   def valueOf(d: Double, mc: MathContext): BigDecimal = apply(BigDec valueOf d, mc)
-  
+
   /** Constructs a `BigDecimal` using the java BigDecimal static
    *  valueOf constructor.
    *
@@ -159,14 +158,14 @@ object BigDecimal {
    *  @return the constructed `BigDecimal`
    */
   def valueOf(x: Long): BigDecimal = apply(x)
-  
+
   /** Constructs a `BigDecimal` using the java BigDecimal static
    *  valueOf constructor.  This is unlikely to do what you want;
    *  use `valueOf(f.toDouble)` or `decimal(f)` instead.
    */
   @deprecated("Float arguments to valueOf may not do what you wish.  Use decimal or valueOf(f.toDouble).","2.11")
   def valueOf(f: Float): BigDecimal = valueOf(f.toDouble)
-  
+
   /** Constructs a `BigDecimal` using the java BigDecimal static
    *  valueOf constructor.  This is unlikely to do what you want;
    *  use `valueOf(f.toDouble)` or `decimal(f)` instead.
@@ -174,7 +173,7 @@ object BigDecimal {
   @deprecated("Float arguments to valueOf may not do what you wish.  Use decimal or valueOf(f.toDouble).","2.11")
   def valueOf(f: Float, mc: MathContext): BigDecimal = valueOf(f.toDouble, mc)
 
-  
+
   /** Constructs a `BigDecimal` whose value is equal to that of the
    *  specified `Integer` value.
    *
@@ -247,7 +246,7 @@ object BigDecimal {
    *  @return  the constructed `BigDecimal`
    */
   def apply(d: Double): BigDecimal = decimal(d, defaultMathContext)
-  
+
   // note we don't use the static valueOf because it doesn't let us supply
   // a MathContext, but we should be duplicating its logic, modulo caching.
   /** Constructs a `BigDecimal` whose value is equal to that of the
@@ -281,7 +280,7 @@ object BigDecimal {
    *  into a `BigDecimal`.
    */
   def apply(x: String): BigDecimal = exact(x)
-  
+
   /** Translates the decimal String representation of a `BigDecimal`
    *  into a `BigDecimal`, rounding if necessary.
    */
@@ -295,12 +294,12 @@ object BigDecimal {
    *  @return  the constructed `BigDecimal`
    */
   def apply(x: BigInt): BigDecimal = exact(x)
-  
+
   /** Constructs a `BigDecimal` whose value is equal to that of the
    *  specified `BigInt` value, rounding if necessary.
    *
    *  @param x  the specified `BigInt` value
-   *  @param mc the precision and rounding mode for creation of this value and future operations on it   
+   *  @param mc the precision and rounding mode for creation of this value and future operations on it
    *  @return   the constructed `BigDecimal`
    */
   def apply(x: BigInt, mc: MathContext): BigDecimal =
@@ -315,13 +314,13 @@ object BigDecimal {
    */
   def apply(unscaledVal: BigInt, scale: Int): BigDecimal =
     exact(new BigDec(unscaledVal.bigInteger, scale))
-  
+
   /** Constructs a `BigDecimal` whose unscaled value is equal to that
    *  of the specified `BigInt` value.
    *
    *  @param unscaledVal the specified `BigInt` value
    *  @param scale       the scale
-   *  @param mc          the precision and rounding mode for creation of this value and future operations on it   
+   *  @param mc          the precision and rounding mode for creation of this value and future operations on it
    *  @return  the constructed `BigDecimal`
    */
   def apply(unscaledVal: BigInt, scale: Int, mc: MathContext): BigDecimal =
@@ -329,7 +328,7 @@ object BigDecimal {
 
   /** Constructs a `BigDecimal` from a `java.math.BigDecimal`. */
   def apply(bd: BigDec): BigDecimal = apply(bd, defaultMathContext)
-  
+
   @deprecated("This method appears to round a java.math.BigDecimal but actually doesn't.  Use new BigDecimal(bd, mc) instead for no rounding, or BigDecimal.decimal(bd, mc) for rounding.", "2.11")
   def apply(bd: BigDec, mc: MathContext): BigDecimal = new BigDecimal(bd, mc)
 
@@ -402,7 +401,7 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
   def this(bigDecimal: BigDec) = this(bigDecimal, BigDecimal.defaultMathContext)
   import BigDecimal.RoundingMode._
   import BigDecimal.{decimal, binary, exact}
-  
+
   if (bigDecimal eq null) throw new IllegalArgumentException("null value for BigDecimal")
   if (mc eq null) throw new IllegalArgumentException("null MathContext for BigDecimal")
 
@@ -423,7 +422,7 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
         scala.util.hashing.MurmurHash3.mixLast( temp.scaleByPowerOfTen(temp.scale).toBigInteger.hashCode, temp.scale )
       }
   }
-  
+
   /** Returns the hash code for this BigDecimal.
    *  Note that this does not merely use the underlying java object's
    *  `hashCode` because we compare `BigDecimal`s with `compareTo`
@@ -444,15 +443,15 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
    */
   override def equals (that: Any): Boolean = that match {
     case that: BigDecimal     => this equals that
-    case that: BigInt         => 
-      that.bitLength > (precision-scale-2)*BigDecimal.deci2binary && 
+    case that: BigInt         =>
+      that.bitLength > (precision-scale-2)*BigDecimal.deci2binary &&
       this.toBigIntExact.exists(that equals _)
-    case that: Double         => 
+    case that: Double         =>
       !that.isInfinity && {
         val d = toDouble
         !d.isInfinity && d == that && equals(decimal(d))
       }
-    case that: Float          => 
+    case that: Float          =>
       !that.isInfinity && {
         val f = toFloat
         !f.isInfinity && f == that && equals(decimal(f.toDouble))
@@ -482,43 +481,43 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
     val d = toDouble
     !d.isInfinity && bigDecimal.compareTo(new BigDec(d)) == 0
   }
-  
+
   /** Tests whether this `BigDecimal` holds the decimal representation of a `Double`. */
   def isDecimalDouble = {
     val d = toDouble
     !d.isInfinity && equals(decimal(d))
   }
-  
+
   /** Tests whether this `BigDecimal` holds the decimal representation of a `Float`. */
   def isDecimalFloat = {
     val f = toFloat
     !f.isInfinity && equals(decimal(f))
   }
-  
+
   /** Tests whether this `BigDecimal` holds, to within precision, the binary representation of a `Double`. */
   def isBinaryDouble = {
     val d = toDouble
     !d.isInfinity && equals(binary(d,mc))
   }
-  
+
   /** Tests whether this `BigDecimal` holds, to within precision, the binary representation of a `Float`. */
   def isBinaryFloat = {
     val f = toFloat
     !f.isInfinity && equals(binary(f,mc))
   }
-  
+
   /** Tests whether this `BigDecimal` holds the exact expansion of a `Double`'s binary fractional form into base 10. */
   def isExactDouble = {
     val d = toDouble
     !d.isInfinity && equals(exact(d))
   }
-  
+
   /** Tests whether this `BigDecimal` holds the exact expansion of a `Float`'s binary fractional form into base 10. */
   def isExactFloat = {
     val f = toFloat
     !f.isInfinity && equals(exact(f.toDouble))
   }
-  
+
 
   private def noArithmeticException(body: => Unit): Boolean = {
     try   { body ; true }
@@ -526,9 +525,9 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
   }
 
   def isWhole() = scale <= 0 || bigDecimal.stripTrailingZeros.scale <= 0
-  
+
   def underlying = bigDecimal
-  
+
 
   /** Compares this BigDecimal with the specified BigDecimal for equality.
    */
@@ -589,14 +588,14 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
     case x if x <= 0 => this
     case _           => that
   }
-  
+
   /** Returns the maximum of this and that, or this if the two are equal
    */
   def max (that: BigDecimal): BigDecimal = (this compare that) match {
     case x if x >= 0 => this
     case _           => that
   }
-  
+
   /** Remainder after dividing this by that.
    */
   def remainder (that: BigDecimal): BigDecimal = new BigDecimal(this.bigDecimal remainder that.bigDecimal, mc)
@@ -635,7 +634,7 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
     val r = this.bigDecimal round mc
     if (r eq bigDecimal) this else new BigDecimal(r, this.mc)
   }
-  
+
   /** Returns a `BigDecimal` rounded according to its own `MathContext` */
   def rounded: BigDecimal = {
     val r = bigDecimal round mc
@@ -657,7 +656,7 @@ extends ScalaNumber with ScalaNumericConversions with Serializable {
   /** Returns a `BigDecimal` whose scale is the specified value, and whose value is
    *  numerically equal to this BigDecimal's.
    */
-  def setScale(scale: Int): BigDecimal = 
+  def setScale(scale: Int): BigDecimal =
     if (this.scale == scale) this
     else new BigDecimal(this.bigDecimal setScale scale, mc)
 
diff --git a/src/library/scala/reflect/ScalaLongSignature.java b/src/library/scala/reflect/ScalaLongSignature.java
index 5b6d78f446..94cf504aa4 100644
--- a/src/library/scala/reflect/ScalaLongSignature.java
+++ b/src/library/scala/reflect/ScalaLongSignature.java
@@ -8,5 +8,5 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 public @interface ScalaLongSignature {
-    public String[] bytes();
+    String[] bytes();
 }
diff --git a/src/library/scala/reflect/ScalaSignature.java b/src/library/scala/reflect/ScalaSignature.java
index a8af554d2b..217ae8e8f7 100644
--- a/src/library/scala/reflect/ScalaSignature.java
+++ b/src/library/scala/reflect/ScalaSignature.java
@@ -8,5 +8,5 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
 public @interface ScalaSignature {
-    public String bytes();
+    String bytes();
 }
diff --git a/src/library/scala/runtime/AbstractPartialFunction.scala b/src/library/scala/runtime/AbstractPartialFunction.scala
index 986cd0390f..630966d0d4 100644
--- a/src/library/scala/runtime/AbstractPartialFunction.scala
+++ b/src/library/scala/runtime/AbstractPartialFunction.scala
@@ -9,8 +9,6 @@
 package scala
 package runtime
 
-import scala.annotation.unspecialized
-
 /** `AbstractPartialFunction` reformulates all operations of its supertrait `PartialFunction`
  *  in terms of `isDefinedAt` and `applyOrElse`.
  *
diff --git a/src/library/scala/runtime/ScalaNumberProxy.scala b/src/library/scala/runtime/ScalaNumberProxy.scala
index 5e4da24c0d..9b4899aef6 100644
--- a/src/library/scala/runtime/ScalaNumberProxy.scala
+++ b/src/library/scala/runtime/ScalaNumberProxy.scala
@@ -9,8 +9,8 @@
 package scala
 package runtime
 
-import scala.collection.{ mutable, immutable }
-import scala.math.{ ScalaNumericConversions, ScalaNumericAnyConversions }
+import scala.collection.immutable
+import scala.math.ScalaNumericAnyConversions
 import immutable.NumericRange
 import Proxy.Typed
 
diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala
index 026d5edd29..1195f95093 100644
--- a/src/library/scala/runtime/ScalaRunTime.scala
+++ b/src/library/scala/runtime/ScalaRunTime.scala
@@ -9,16 +9,14 @@
 package scala
 package runtime
 
-import scala.collection.{ Seq, IndexedSeq, TraversableView, AbstractIterator, GenIterable }
+import scala.collection.{ TraversableView, AbstractIterator, GenIterable }
 import scala.collection.mutable.WrappedArray
-import scala.collection.immutable.{ StringLike, NumericRange, List, Stream, Nil, :: }
+import scala.collection.immutable.{ StringLike, NumericRange }
 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 }
+import java.lang.reflect.{ Method => JMethod }
 
 /** The object ScalaRunTime provides support methods required by
  *  the scala runtime.  All these methods should be considered
diff --git a/src/library/scala/runtime/SeqCharSequence.scala b/src/library/scala/runtime/SeqCharSequence.scala
index 74e67bb9e7..293bf950db 100644
--- a/src/library/scala/runtime/SeqCharSequence.scala
+++ b/src/library/scala/runtime/SeqCharSequence.scala
@@ -9,8 +9,6 @@
 package scala
 package runtime
 
-import java.util.Arrays.copyOfRange
-
 @deprecated("Use Predef.SeqCharSequence", "2.11.0")
 final class SeqCharSequence(val xs: scala.collection.IndexedSeq[Char]) extends CharSequence {
   def length: Int                                     = xs.length
diff --git a/src/library/scala/sys/SystemProperties.scala b/src/library/scala/sys/SystemProperties.scala
index 3ee4f6c708..ebe94651f9 100644
--- a/src/library/scala/sys/SystemProperties.scala
+++ b/src/library/scala/sys/SystemProperties.scala
@@ -32,7 +32,7 @@ class SystemProperties
 extends mutable.AbstractMap[String, String]
    with mutable.Map[String, String] {
 
-  override def empty = new SystemProperties
+  override def empty = mutable.Map[String, String]()
   override def default(key: String): String = null
 
   def iterator: Iterator[(String, String)] = wrapAccess {
@@ -69,24 +69,24 @@ object SystemProperties {
   def exclusively[T](body: => T) = this synchronized body
 
   implicit def systemPropertiesToCompanion(p: SystemProperties): SystemProperties.type = this
-  private lazy val propertyHelp = mutable.Map[String, String]()
-  private def addHelp[P <: Prop[_]](p: P, helpText: String): P = {
-    propertyHelp(p.key) = helpText
-    p
+
+  private final val HeadlessKey            = "java.awt.headless"
+  private final val PreferIPv4StackKey     = "java.net.preferIPv4Stack"
+  private final val PreferIPv6AddressesKey = "java.net.preferIPv6Addresses"
+  private final val NoTraceSuppressionKey  = "scala.control.noTraceSuppression"
+
+  def help(key: String): String = key match {
+    case HeadlessKey            => "system should not utilize a display device"
+    case PreferIPv4StackKey     => "system should prefer IPv4 sockets"
+    case PreferIPv6AddressesKey => "system should prefer IPv6 addresses"
+    case NoTraceSuppressionKey  => "scala should not suppress any stack trace creation"
+    case _                      => ""
   }
-  private def bool(key: String, helpText: String): BooleanProp = addHelp[BooleanProp](
-    if (key startsWith "java.") BooleanProp.valueIsTrue(key) else BooleanProp.keyExists(key),
-    helpText
-  )
-  def help(key: String) = propertyHelp.getOrElse(key, "")
-
-  // Todo: bring some sanity to the intersection of system properties aka "mutable
-  // state shared by everyone and everything" and the reality that there is no other
-  // mechanism for accomplishing some things on the jvm.
-  lazy val headless            = bool("java.awt.headless", "system should not utilize a display device")
-  lazy val preferIPv4Stack     = bool("java.net.preferIPv4Stack", "system should prefer IPv4 sockets")
-  lazy val preferIPv6Addresses = bool("java.net.preferIPv6Addresses", "system should prefer IPv6 addresses")
-  lazy val noTraceSuppression  = bool("scala.control.noTraceSuppression", "scala should not suppress any stack trace creation")
+
+  lazy val headless: BooleanProp            = BooleanProp.keyExists(HeadlessKey)
+  lazy val preferIPv4Stack: BooleanProp     = BooleanProp.keyExists(PreferIPv4StackKey)
+  lazy val preferIPv6Addresses: BooleanProp = BooleanProp.keyExists(PreferIPv6AddressesKey)
+  lazy val noTraceSuppression: BooleanProp  = BooleanProp.valueIsTrue(NoTraceSuppressionKey)
   @deprecated("Use noTraceSuppression", "2.12.0")
   def noTraceSupression        = noTraceSuppression
 }
diff --git a/src/library/scala/sys/process/Process.scala b/src/library/scala/sys/process/Process.scala
index 06b9967908..0ec749e78a 100644
--- a/src/library/scala/sys/process/Process.scala
+++ b/src/library/scala/sys/process/Process.scala
@@ -26,11 +26,11 @@ import scala.language.implicitConversions
  *  make it possible for one to block until the process exits and get the exit value,
  *  or destroy the process altogether.
  *
- *  Presently, one cannot poll the `Process` to see if it has finished.
- *
  *  @see [[scala.sys.process.ProcessBuilder]]
  */
 trait Process {
+  /** Returns this process alive status */
+  def isAlive(): Boolean
   /** Blocks until this process exits and returns the exit code.*/
   def exitValue(): Int
   /** Destroys this process. */
diff --git a/src/library/scala/sys/process/ProcessImpl.scala b/src/library/scala/sys/process/ProcessImpl.scala
index d15f1a2b3d..559c0ee525 100644
--- a/src/library/scala/sys/process/ProcessImpl.scala
+++ b/src/library/scala/sys/process/ProcessImpl.scala
@@ -27,18 +27,18 @@ private[process] trait ProcessImpl {
     }
   }
   private[process] object Future {
-    def apply[T](f: => T): () => T = {
+    def apply[T](f: => T): (Thread, () => T) = {
       val result = new SyncVar[Either[Throwable, T]]
       def run(): Unit =
         try result set Right(f)
         catch { case e: Exception => result set Left(e) }
 
-      Spawn(run())
+      val t = Spawn(run())
 
-      () => result.get match {
+      (t, () => result.get match {
         case Right(value)    => value
         case Left(exception) => throw exception
-      }
+      })
     }
   }
 
@@ -84,16 +84,18 @@ private[process] trait ProcessImpl {
   }
 
   private[process] abstract class CompoundProcess extends BasicProcess {
+    def isAlive()   = processThread.isAlive()
     def destroy()   = destroyer()
-    def exitValue() = getExitValue() getOrElse scala.sys.error("No exit code: process destroyed.")
+    def exitValue() = getExitValue._2() getOrElse scala.sys.error("No exit code: process destroyed.")
     def start()     = getExitValue
 
-    protected lazy val (getExitValue, destroyer) = {
+    protected lazy val (processThread, getExitValue, destroyer) = {
       val code = new SyncVar[Option[Int]]()
       code set None
       val thread = Spawn(code set runAndExitValue())
 
       (
+        thread,
         Future { thread.join(); code.get },
         () => thread.interrupt()
       )
@@ -216,7 +218,8 @@ private[process] trait ProcessImpl {
   * The implementation of `exitValue` waits until these threads die before returning. */
   private[process] class DummyProcess(action: => Int) extends Process {
     private[this] val exitCode = Future(action)
-    override def exitValue() = exitCode()
+    override def isAlive() = exitCode._1.isAlive()
+    override def exitValue() = exitCode._2()
     override def destroy() { }
   }
   /** A thin wrapper around a java.lang.Process.  `outputThreads` are the Threads created to read from the
@@ -225,6 +228,7 @@ private[process] trait ProcessImpl {
   * The implementation of `exitValue` interrupts `inputThread` and then waits until all I/O threads die before
   * returning. */
   private[process] class SimpleProcess(p: JProcess, inputThread: Thread, outputThreads: List[Thread]) extends Process {
+    override def isAlive() = p.isAlive()
     override def exitValue() = {
       try p.waitFor()                   // wait for the process to terminate
       finally inputThread.interrupt()   // we interrupt the input thread to notify it that it can terminate
@@ -241,6 +245,7 @@ private[process] trait ProcessImpl {
     }
   }
   private[process] final class ThreadProcess(thread: Thread, success: SyncVar[Boolean]) extends Process {
+    override def isAlive() = thread.isAlive()
     override def exitValue() = {
       thread.join()
       if (success.get) 0 else 1
diff --git a/src/library/scala/util/Sorting.scala b/src/library/scala/util/Sorting.scala
index b4f965f69b..3bda7c0d39 100644
--- a/src/library/scala/util/Sorting.scala
+++ b/src/library/scala/util/Sorting.scala
@@ -45,7 +45,7 @@ object Sorting {
 
   /** Sort an array of Floats using `java.util.Arrays.sort`. */
   def quickSort(a: Array[Float]): Unit  = java.util.Arrays.sort(a)
-  
+
   private final val qsortThreshold = 16
 
   /** Sort array `a` with quicksort, using the Ordering on its elements.
@@ -57,9 +57,9 @@ object Sorting {
     def inner(a: Array[K], i0: Int, iN: Int, ord: Ordering[K]): Unit = {
       if (iN - i0 < qsortThreshold) insertionSort(a, i0, iN, ord)
       else {
-        var iK = (i0 + iN) >>> 1    // Unsigned div by 2
+        val iK = (i0 + iN) >>> 1    // Unsigned div by 2
         // Find index of median of first, central, and last elements
-        var pL = 
+        var pL =
           if (ord.compare(a(i0), a(iN - 1)) <= 0)
             if (ord.compare(a(i0), a(iK)) < 0)
               if (ord.compare(a(iN - 1), a(iK)) < 0) iN - 1 else iK
@@ -140,9 +140,9 @@ object Sorting {
     }
     inner(a, 0, a.length, implicitly[Ordering[K]])
   }
-  
+
   private final val mergeThreshold = 32
-  
+
   // Ordering[T] might be slow especially for boxed primitives, so use binary search variant of insertion sort
   // Caller must pass iN >= i0 or math will fail.  Also, i0 >= 0.
   private def insertionSort[@specialized T](a: Array[T], i0: Int, iN: Int, ord: Ordering[T]): Unit = {
@@ -176,7 +176,7 @@ object Sorting {
       m += 1
     }
   }
-  
+
   // Caller is required to pass iN >= i0, else math will fail.  Also, i0 >= 0.
   private def mergeSort[@specialized T: ClassTag](a: Array[T], i0: Int, iN: Int, ord: Ordering[T], scratch: Array[T] = null): Unit = {
     if (iN - i0 < mergeThreshold) insertionSort(a, i0, iN, ord)
@@ -188,7 +188,7 @@ object Sorting {
       mergeSorted(a, i0, iK, iN, ord, sc)
     }
   }
-  
+
   // Must have 0 <= i0 < iK < iN
   private def mergeSorted[@specialized T](a: Array[T], i0: Int, iK: Int, iN: Int, ord: Ordering[T], scratch: Array[T]): Unit = {
     // Check to make sure we're not already in order
@@ -212,7 +212,7 @@ object Sorting {
       // Don't need to finish a(i) because it's already in place, k = i
     }
   }
-  
+
   // Why would you even do this?
   private def booleanSort(a: Array[Boolean]): Unit = {
     var i = 0
@@ -235,7 +235,7 @@ object Sorting {
   // TODO: add upper bound: T <: AnyRef, propagate to callers below (not binary compatible)
   // Maybe also rename all these methods to `sort`.
   @inline private def sort[T](a: Array[T], ord: Ordering[T]): Unit = a match {
-    case _: Array[AnyRef]  => 
+    case _: Array[AnyRef]  =>
       // Note that runtime matches are covariant, so could actually be any Array[T] s.t. T is not primitive (even boxed value classes)
       if (a.length > 1 && (ord eq null)) throw new NullPointerException("Ordering")
       java.util.Arrays.sort(a, ord)
diff --git a/src/library/scala/util/Try.scala b/src/library/scala/util/Try.scala
index b1b9965614..84d170249d 100644
--- a/src/library/scala/util/Try.scala
+++ b/src/library/scala/util/Try.scala
@@ -9,7 +9,6 @@
 package scala
 package util
 
-import scala.collection.Seq
 import scala.util.control.NonFatal
 import scala.language.implicitConversions
 
@@ -218,12 +217,12 @@ final case class Failure[+T](exception: Throwable) extends Try[T] {
   override def isSuccess: Boolean = false
   override def get: T = throw exception
   override def getOrElse[U >: T](default: => U): U = default
-  override def orElse[U >: T](default: => Try[U]): Try[U] = 
+  override def orElse[U >: T](default: => Try[U]): Try[U] =
     try default catch { case NonFatal(e) => Failure(e) }
   override def flatMap[U](f: T => Try[U]): Try[U] = this.asInstanceOf[Try[U]]
   override def flatten[U](implicit ev: T <:< Try[U]): Try[U] = this.asInstanceOf[Try[U]]
   override def foreach[U](f: T => U): Unit = ()
-  override def transform[U](s: T => Try[U], f: Throwable => Try[U]): Try[U] = 
+  override def transform[U](s: T => Try[U], f: Throwable => Try[U]): Try[U] =
     try f(exception) catch { case NonFatal(e) => Failure(e) }
   override def map[U](f: T => U): Try[U] = this.asInstanceOf[Try[U]]
   override def collect[U](pf: PartialFunction[T, U]): Try[U] = this.asInstanceOf[Try[U]]
diff --git a/src/library/scala/util/control/Exception.scala b/src/library/scala/util/control/Exception.scala
index 24c297a2fc..702d3b5e5e 100644
--- a/src/library/scala/util/control/Exception.scala
+++ b/src/library/scala/util/control/Exception.scala
@@ -10,9 +10,7 @@ package scala
 package util
 package control
 
-import scala.collection.immutable.List
 import scala.reflect.{ ClassTag, classTag }
-import java.lang.reflect.InvocationTargetException
 import scala.language.implicitConversions
 
 
diff --git a/src/library/scala/util/control/TailCalls.scala b/src/library/scala/util/control/TailCalls.scala
index 953d5b407e..c7fefb1eba 100644
--- a/src/library/scala/util/control/TailCalls.scala
+++ b/src/library/scala/util/control/TailCalls.scala
@@ -55,7 +55,7 @@ object TailCalls {
         case Done(a) => Call(() => f(a))
         case c@Call(_) => Cont(c, f)
         // Take advantage of the monad associative law to optimize the size of the required stack
-        case c: Cont[a1, b1] => Cont(c.a, (x: a1) => c f x flatMap f)
+        case c: Cont[a1, b1] => Cont(c.a, (x: a1) => c.f(x) flatMap f)
       }
 
     /** Returns either the next step of the tailcalling computation,
diff --git a/src/manual/scala/tools/docutil/ManMaker.scala b/src/manual/scala/tools/docutil/ManMaker.scala
index 802b357f5f..4b8bfc6606 100644
--- a/src/manual/scala/tools/docutil/ManMaker.scala
+++ b/src/manual/scala/tools/docutil/ManMaker.scala
@@ -57,3 +57,13 @@ class ManMaker extends Task {
     })
   }
 }
+
+/** Command line runner for ManMaker which is called from the sbt build. */
+object ManMaker extends App {
+  val Array(commands, htmlout, manout) = args
+  val mm = new ManMaker
+  mm.setCommand(commands)
+  mm.setHtmlout(new File(htmlout))
+  mm.setManout(new File(manout))
+  mm.execute()
+}
diff --git a/src/partest-extras/scala/tools/partest/BytecodeTest.scala b/src/partest-extras/scala/tools/partest/BytecodeTest.scala
index 8459419fa5..290b7b434e 100644
--- a/src/partest-extras/scala/tools/partest/BytecodeTest.scala
+++ b/src/partest-extras/scala/tools/partest/BytecodeTest.scala
@@ -4,7 +4,7 @@ import scala.tools.nsc.util.JavaClassPath
 import scala.collection.JavaConverters._
 import scala.tools.asm.{ClassWriter, ClassReader}
 import scala.tools.asm.tree._
-import java.io.{FileOutputStream, FileInputStream, File => JFile, InputStream}
+import java.io.{File => JFile, InputStream}
 import AsmNode._
 
 /**
diff --git a/src/partest-extras/scala/tools/partest/JavapTest.scala b/src/partest-extras/scala/tools/partest/JavapTest.scala
index 3cb3dc6ca8..27017b1585 100644
--- a/src/partest-extras/scala/tools/partest/JavapTest.scala
+++ b/src/partest-extras/scala/tools/partest/JavapTest.scala
@@ -1,7 +1,6 @@
 
 package scala.tools.partest
 
-import scala.util.{Try,Success,Failure}
 import java.lang.System.{out => sysout}
 
 /** A trait for testing repl's javap command
diff --git a/src/partest-extras/scala/tools/partest/ReplTest.scala b/src/partest-extras/scala/tools/partest/ReplTest.scala
index 20dfe0eb16..608ac73b61 100644
--- a/src/partest-extras/scala/tools/partest/ReplTest.scala
+++ b/src/partest-extras/scala/tools/partest/ReplTest.scala
@@ -7,8 +7,6 @@ package scala.tools.partest
 
 import scala.tools.nsc.Settings
 import scala.tools.nsc.interpreter.{ ILoop, replProps }
-import java.lang.reflect.{ Method => JMethod, Field => JField }
-import scala.util.matching.Regex
 import scala.util.matching.Regex.Match
 
 /** A class for testing repl code.
diff --git a/src/partest-extras/scala/tools/partest/SigTest.scala b/src/partest-extras/scala/tools/partest/SigTest.scala
index fe233a4fb5..a516daa629 100644
--- a/src/partest-extras/scala/tools/partest/SigTest.scala
+++ b/src/partest-extras/scala/tools/partest/SigTest.scala
@@ -5,8 +5,6 @@
 
 package scala.tools.partest
 
-import scala.tools.nsc.Settings
-import scala.tools.nsc.interpreter.ILoop
 import java.lang.reflect.{ Method => JMethod, Field => JField }
 import scala.reflect.{ClassTag, classTag}
 
diff --git a/src/reflect/scala/reflect/api/Printers.scala b/src/reflect/scala/reflect/api/Printers.scala
index c0abc5120c..257dd6c43e 100644
--- a/src/reflect/scala/reflect/api/Printers.scala
+++ b/src/reflect/scala/reflect/api/Printers.scala
@@ -232,7 +232,7 @@ trait Printers { self: Universe =>
    *  @group Printers
    */
   def showRaw(any: Any, printTypes: BooleanFlag = None, printIds: BooleanFlag = None, printOwners: BooleanFlag = None, printKinds: BooleanFlag = None, printMirrors: BooleanFlag = None, printPositions: BooleanFlag = None): String =
-    render(any, newRawTreePrinter(_), printTypes, printIds, printOwners, printKinds, printMirrors, printPositions)
+    render(any, newRawTreePrinter, printTypes, printIds, printOwners, printKinds, printMirrors, printPositions)
 
   /** Hook to define what `showRaw(...)` means.
    * @group Printers
diff --git a/src/reflect/scala/reflect/api/TypeTags.scala b/src/reflect/scala/reflect/api/TypeTags.scala
index bc239ca870..cad318dbed 100644
--- a/src/reflect/scala/reflect/api/TypeTags.scala
+++ b/src/reflect/scala/reflect/api/TypeTags.scala
@@ -7,8 +7,6 @@ package scala
 package reflect
 package api
 
-import java.lang.{ Class => jClass }
-import scala.language.implicitConversions
 import java.io.ObjectStreamException
 
 /**
diff --git a/src/reflect/scala/reflect/internal/AnnotationInfos.scala b/src/reflect/scala/reflect/internal/AnnotationInfos.scala
index 207a66e360..fa19103d0c 100644
--- a/src/reflect/scala/reflect/internal/AnnotationInfos.scala
+++ b/src/reflect/scala/reflect/internal/AnnotationInfos.scala
@@ -7,7 +7,6 @@ package scala
 package reflect
 package internal
 
-import pickling.ByteCodecs
 import scala.annotation.tailrec
 import scala.collection.immutable.ListMap
 import scala.language.postfixOps
@@ -169,6 +168,22 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable =>
 
     def unapply(info: AnnotationInfo): Option[(Type, List[Tree], List[(Name, ClassfileAnnotArg)])] =
       Some((info.atp, info.args, info.assocs))
+
+    def mkFilter(category: Symbol, defaultRetention: Boolean)(ann: AnnotationInfo) =
+      (ann.metaAnnotations, ann.defaultTargets) match {
+        case (Nil, Nil)      => defaultRetention
+        case (Nil, defaults) => defaults contains category
+        case (metas, _)      => metas exists (_ matches category)
+      }
+
+    def mkFilter(categories: List[Symbol], defaultRetention: Boolean)(ann: AnnotationInfo) =
+      (ann.metaAnnotations, ann.defaultTargets) match {
+        case (Nil, Nil)      => defaultRetention
+        case (Nil, defaults) => categories exists defaults.contains
+        case (metas, _)      =>
+          val metaSyms = metas collect { case ann if !ann.symbol.isInstanceOf[StubSymbol] => ann.symbol }
+          categories exists (category => metaSyms exists (_ isNonBottomSubClass category))
+      }
   }
 
   class CompleteAnnotationInfo(
diff --git a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
index 54f64153c1..81281b5eb4 100644
--- a/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
+++ b/src/reflect/scala/reflect/internal/BaseTypeSeqs.scala
@@ -7,8 +7,7 @@ package reflect
 package internal
 
 // todo implement in terms of BitSet
-import scala.collection.{ mutable, immutable }
-import scala.math.max
+import scala.collection.mutable
 import util.Statistics
 
 /** A base type sequence (BaseTypeSeq) is an ordered sequence spanning all the base types
diff --git a/src/reflect/scala/reflect/internal/Chars.scala b/src/reflect/scala/reflect/internal/Chars.scala
index 74413fdaba..daee8a49ee 100644
--- a/src/reflect/scala/reflect/internal/Chars.scala
+++ b/src/reflect/scala/reflect/internal/Chars.scala
@@ -6,10 +6,11 @@ package scala
 package reflect
 package internal
 
-import scala.annotation.{ tailrec, switch }
-import java.lang.{ Character => JCharacter }
 import scala.language.postfixOps
 
+import scala.annotation.switch
+import java.lang.{ Character => JCharacter }
+
 /** Contains constants and classifier methods for characters */
 trait Chars {
   // Be very careful touching these.
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index f2da7614a3..ba6c363918 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -8,8 +8,9 @@ package reflect
 package internal
 
 import scala.language.postfixOps
-import scala.annotation.{ switch, meta }
-import scala.collection.{ mutable, immutable }
+
+import scala.annotation.meta
+import scala.collection.mutable
 import Flags._
 import scala.reflect.api.{Universe => ApiUniverse}
 
@@ -522,7 +523,6 @@ trait Definitions extends api.StandardDefinitions {
     lazy val ScalaSignatureAnnotation = requiredClass[scala.reflect.ScalaSignature]
     lazy val ScalaLongSignatureAnnotation = requiredClass[scala.reflect.ScalaLongSignature]
 
-    lazy val LambdaMetaFactory = getClassIfDefined("java.lang.invoke.LambdaMetafactory")
     lazy val MethodHandle = getClassIfDefined("java.lang.invoke.MethodHandle")
 
     // Option classes
@@ -1402,8 +1402,8 @@ trait Definitions extends api.StandardDefinitions {
       if (isInitialized) return
       ObjectClass.initialize
       ScalaPackageClass.initialize
-      val forced1 = symbolsNotPresentInBytecode
-      val forced2 = NoSymbol
+      symbolsNotPresentInBytecode
+      NoSymbol
       isInitialized = true
     } //init
 
diff --git a/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala b/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala
index 3e18f88f80..cc9f379cfe 100644
--- a/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala
+++ b/src/reflect/scala/reflect/internal/ExistentialsAndSkolems.scala
@@ -7,7 +7,6 @@ package scala
 package reflect
 package internal
 
-import scala.collection.{ mutable, immutable }
 
 /** The name of this trait defines the eventual intent better than
  *  it does the initial contents.
diff --git a/src/reflect/scala/reflect/internal/Flags.scala b/src/reflect/scala/reflect/internal/Flags.scala
index 754b96a9dd..b022ba2981 100644
--- a/src/reflect/scala/reflect/internal/Flags.scala
+++ b/src/reflect/scala/reflect/internal/Flags.scala
@@ -7,8 +7,6 @@ package scala
 package reflect
 package internal
 
-import scala.collection.{ mutable, immutable }
-
 // Flags at each index of a flags Long.  Those marked with /M are used in
 // Parsers/JavaParsers and therefore definitely appear on Modifiers; but the
 // absence of /M on the other flags does not imply they aren't.
diff --git a/src/reflect/scala/reflect/internal/Internals.scala b/src/reflect/scala/reflect/internal/Internals.scala
index ad4cec5b4d..cfacad24b4 100644
--- a/src/reflect/scala/reflect/internal/Internals.scala
+++ b/src/reflect/scala/reflect/internal/Internals.scala
@@ -4,12 +4,9 @@ package internal
 
 import scala.language.implicitConversions
 import scala.language.higherKinds
-import scala.collection.mutable.WeakHashMap
-import scala.ref.WeakReference
+
 import scala.reflect.api.Universe
 import scala.reflect.macros.Attachments
-import scala.reflect.internal.util.FreshNameCreator
-import scala.reflect.internal.util.ListOfNil
 
 trait Internals extends api.Internals {
   self: SymbolTable =>
@@ -60,19 +57,7 @@ trait Internals extends api.Internals {
     def typeDef(sym: Symbol): TypeDef = self.TypeDef(sym)
     def labelDef(sym: Symbol, params: List[Symbol], rhs: Tree): LabelDef = self.LabelDef(sym, params, rhs)
 
-    def changeOwner(tree: Tree, prev: Symbol, next: Symbol): tree.type = {
-      object changeOwnerAndModuleClassTraverser extends ChangeOwnerTraverser(prev, next) {
-        override def traverse(tree: Tree) {
-          tree match {
-            case _: DefTree => change(tree.symbol.moduleClass)
-            case _          => // do nothing
-          }
-          super.traverse(tree)
-        }
-      }
-      changeOwnerAndModuleClassTraverser.traverse(tree)
-      tree
-    }
+    def changeOwner(tree: Tree, prev: Symbol, next: Symbol): tree.type = { new ChangeOwnerTraverser(prev, next).traverse(tree); tree }
 
     lazy val gen = self.treeBuild
 
@@ -170,4 +155,4 @@ trait Internals extends api.Internals {
     def mkZero(tp: Type): Tree = self.gen.mkZero(tp)
     def mkCast(tree: Tree, pt: Type): Tree = self.gen.mkCast(tree, pt)
   }
-}
\ No newline at end of file
+}
diff --git a/src/reflect/scala/reflect/internal/JMethodOrConstructor.scala b/src/reflect/scala/reflect/internal/JMethodOrConstructor.scala
index fb1cdb34e1..b9cc167933 100644
--- a/src/reflect/scala/reflect/internal/JMethodOrConstructor.scala
+++ b/src/reflect/scala/reflect/internal/JMethodOrConstructor.scala
@@ -7,7 +7,7 @@ package reflect
 package internal
 
 import scala.language.implicitConversions
-import java.lang.{ Class => jClass }
+
 import java.lang.annotation.{ Annotation => jAnnotation }
 import java.lang.reflect.{
   Member => jMember, Constructor => jConstructor, Method => jMethod,
diff --git a/src/reflect/scala/reflect/internal/Kinds.scala b/src/reflect/scala/reflect/internal/Kinds.scala
index 902ba9fa80..a7e462d8de 100644
--- a/src/reflect/scala/reflect/internal/Kinds.scala
+++ b/src/reflect/scala/reflect/internal/Kinds.scala
@@ -7,7 +7,6 @@ package scala
 package reflect
 package internal
 
-import scala.collection.{ mutable, immutable }
 import scala.reflect.internal.util.StringOps.{ countAsString, countElementsAsString }
 
 trait Kinds {
diff --git a/src/reflect/scala/reflect/internal/Names.scala b/src/reflect/scala/reflect/internal/Names.scala
index 32d12d305e..97f51149ba 100644
--- a/src/reflect/scala/reflect/internal/Names.scala
+++ b/src/reflect/scala/reflect/internal/Names.scala
@@ -7,10 +7,10 @@ package scala
 package reflect
 package internal
 
-import scala.io.Codec
-import java.security.MessageDigest
 import scala.language.implicitConversions
 
+import scala.io.Codec
+
 trait Names extends api.Names {
   private final val HASH_SIZE  = 0x8000
   private final val HASH_MASK  = 0x7FFF
diff --git a/src/reflect/scala/reflect/internal/Phase.scala b/src/reflect/scala/reflect/internal/Phase.scala
index 1ecc202a07..a761f686e6 100644
--- a/src/reflect/scala/reflect/internal/Phase.scala
+++ b/src/reflect/scala/reflect/internal/Phase.scala
@@ -39,10 +39,14 @@ abstract class Phase(val prev: Phase) {
   def description: String = name
   // Will running with -Ycheck:name work?
   def checkable: Boolean = true
-  def specialized: Boolean = false
-  def erasedTypes: Boolean = false
-  def flatClasses: Boolean = false
-  def refChecked: Boolean = false
+
+  // NOTE: sbt injects its own phases which extend this class, and not GlobalPhase, so we must implement this logic here
+  private val _erasedTypes = ((prev ne null) && (prev ne NoPhase)) && (prev.name == "erasure" || prev.erasedTypes)
+  def erasedTypes: Boolean = _erasedTypes // overridden in back-end
+  final val flatClasses: Boolean   = ((prev ne null) && (prev ne NoPhase)) && (prev.name == "flatten"    || prev.flatClasses)
+  final val specialized: Boolean   = ((prev ne null) && (prev ne NoPhase)) && (prev.name == "specialize" || prev.specialized)
+  final val refChecked: Boolean    = ((prev ne null) && (prev ne NoPhase)) && (prev.name == "refchecks"  || prev.refChecked)
+
 
   /** This is used only in unsafeTypeParams, and at this writing is
    *  overridden to false in parser, namer, typer, and erasure. (And NoPhase.)
diff --git a/src/reflect/scala/reflect/internal/Printers.scala b/src/reflect/scala/reflect/internal/Printers.scala
index b44c4022f6..37b99c4345 100644
--- a/src/reflect/scala/reflect/internal/Printers.scala
+++ b/src/reflect/scala/reflect/internal/Printers.scala
@@ -9,7 +9,7 @@ package scala
 package reflect
 package internal
 
-import java.io.{ OutputStream, PrintWriter, StringWriter, Writer }
+import java.io.{ OutputStream, PrintWriter, Writer }
 import Flags._
 import scala.compat.Platform.EOL
 
@@ -73,10 +73,10 @@ trait Printers extends api.Printers { self: SymbolTable =>
     def indent() = indentMargin += indentStep
     def undent() = indentMargin -= indentStep
 
-    def printPosition(tree: Tree) = 
+    def printPosition(tree: Tree) =
       if (printPositions) comment(print(tree.pos.show))
-    
-    protected def printTypesInfo(tree: Tree) = 
+
+    protected def printTypesInfo(tree: Tree) =
       if (printTypes && tree.isTerm && tree.canHaveAttrs)
         comment{
           print("{", if (tree.tpe eq null) "<null>" else tree.tpe.toString, "}")
@@ -313,7 +313,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
 
     protected def printBlock(stats: List[Tree], expr: Tree) =
       printColumn(stats ::: List(expr), "{", ";", "}")
-    
+
     def printTree(tree: Tree) = {
       tree match {
         case EmptyTree =>
@@ -639,14 +639,14 @@ trait Printers extends api.Printers { self: SymbolTable =>
         case _ => true
       }
 
-    protected def syntheticToRemove(tree: Tree) = 
+    protected def syntheticToRemove(tree: Tree) =
       tree match {
         case _: ValDef | _: TypeDef => false // don't remove ValDef and TypeDef
         case md: MemberDef if md.mods.isSynthetic => true
         case _ => false
       }
 
-    override def printOpt(prefix: String, tree: Tree) = 
+    override def printOpt(prefix: String, tree: Tree) =
       if (!isEmptyTree(tree)) super.printOpt(prefix, tree)
 
     override def printColumn(ts: List[Tree], start: String, sep: String, end: String) = {
@@ -959,13 +959,13 @@ trait Printers extends api.Printers { self: SymbolTable =>
           printFunction(f)(printValueParams(vparams, inParentheses = printParentheses))
 
         case Typed(expr, tp) =>
-          def printTp = print("(", tp, ")")
+          def printTp() = print("(", tp, ")")
 
           tp match {
-            case EmptyTree | EmptyTypeTree() => printTp
+            case EmptyTree | EmptyTypeTree() => printTp()
             // case for untypechecked trees
-            case Annotated(annot, arg) if (expr ne null) && (arg ne null) && expr.equalsStructure(arg) => printTp // remove double arg - 5: 5: @unchecked
-            case tt: TypeTree if tt.original.isInstanceOf[Annotated] => printTp
+            case Annotated(annot, arg) if (expr ne null) && (arg ne null) && expr.equalsStructure(arg) => printTp() // remove double arg - 5: 5: @unchecked
+            case tt: TypeTree if tt.original.isInstanceOf[Annotated] => printTp()
             case Function(List(), EmptyTree) => print("(", expr, " _)") //func _
             // parentheses required when (a match {}) : Type
             case _ => print("((", expr, "): ", tp, ")")
@@ -1000,7 +1000,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
               }
             case _ => print(fun)
           }
-          printRow(args, "(", ", ", ")")  
+          printRow(args, "(", ", ", ")")
 
         case st @ Super(This(qual), mix) =>
           printSuper(st, printedName(qual), checkSymbol = false)
@@ -1016,7 +1016,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
           print(qual)
 
         case Select(qual, name) =>
-          def checkRootPackage(tr: Tree): Boolean = 
+          def checkRootPackage(tr: Tree): Boolean =
             (currentParent match { //check that Select is not for package def name
               case Some(_: PackageDef) => false
               case _ => true
@@ -1134,11 +1134,12 @@ trait Printers extends api.Printers { self: SymbolTable =>
   def newRawTreePrinter(writer: PrintWriter): RawTreePrinter = new RawTreePrinter(writer)
 
   // provides footnotes for types and mirrors
-  import scala.collection.mutable.{Map, WeakHashMap, SortedSet}
-  private val footnoteIndex = new FootnoteIndex
-  private class FootnoteIndex {
+  private class Footnotes {
+    import scala.collection.mutable.{Map, WeakHashMap, SortedSet}
+
     private val index = Map[Class[_], WeakHashMap[Any, Int]]()
     private def classIndex[T: ClassTag] = index.getOrElseUpdate(classTag[T].runtimeClass, WeakHashMap[Any, Int]())
+
     private val counters = Map[Class[_], Int]()
     private def nextCounter[T: ClassTag] = {
       val clazz = classTag[T].runtimeClass
@@ -1147,29 +1148,26 @@ trait Printers extends api.Printers { self: SymbolTable =>
       counters(clazz)
     }
 
-    def mkFootnotes() = new Footnotes
-    class Footnotes {
-      private val footnotes = Map[Class[_], SortedSet[Int]]()
-      private def classFootnotes[T: ClassTag] = footnotes.getOrElseUpdate(classTag[T].runtimeClass, SortedSet[Int]())
+    private val footnotes = Map[Class[_], SortedSet[Int]]()
+    private def classFootnotes[T: ClassTag] = footnotes.getOrElseUpdate(classTag[T].runtimeClass, SortedSet[Int]())
 
-      def put[T: ClassTag](any: T): Int = {
-        val index = classIndex[T].getOrElseUpdate(any, nextCounter[T])
-        classFootnotes[T] += index
-        index
-      }
+    def put[T: ClassTag](any: T): Int = {
+      val index = classIndex[T].getOrElseUpdate(any, nextCounter[T])
+      classFootnotes[T] += index
+      index
+    }
 
-      def get[T: ClassTag]: List[(Int, Any)] =
-        classFootnotes[T].toList map (fi => (fi, classIndex[T].find{ case (any, ii) => ii == fi }.get._1))
-
-      def print[T: ClassTag](printer: Printers.super.TreePrinter): Unit = {
-        val footnotes = get[T]
-        if (footnotes.nonEmpty) {
-          printer.print(EOL)
-          footnotes.zipWithIndex foreach {
-            case ((fi, any), ii) =>
-              printer.print("[", fi, "] ", any)
-              if (ii < footnotes.length - 1) printer.print(EOL)
-          }
+    def get[T: ClassTag]: List[(Int, Any)] =
+      classFootnotes[T].toList map (fi => (fi, classIndex[T].find{ case (any, ii) => ii == fi }.get._1))
+
+    def print[T: ClassTag](printer: Printers.super.TreePrinter): Unit = {
+      val footnotes = get[T]
+      if (footnotes.nonEmpty) {
+        printer.print(EOL)
+        footnotes.zipWithIndex foreach {
+          case ((fi, any), ii) =>
+            printer.print("[", fi, "] ", any)
+            if (ii < footnotes.length - 1) printer.print(EOL)
         }
       }
     }
@@ -1180,7 +1178,7 @@ trait Printers extends api.Printers { self: SymbolTable =>
     private var depth = 0
     private var printTypesInFootnotes = true
     private var printingFootnotes = false
-    private val footnotes = footnoteIndex.mkFootnotes()
+    private val footnotes = new Footnotes()
 
     def print(args: Any*): Unit = {
       // don't print type footnotes if the argument is a mere type
diff --git a/src/reflect/scala/reflect/internal/ReificationSupport.scala b/src/reflect/scala/reflect/internal/ReificationSupport.scala
index d393a841b7..c58cb71e97 100644
--- a/src/reflect/scala/reflect/internal/ReificationSupport.scala
+++ b/src/reflect/scala/reflect/internal/ReificationSupport.scala
@@ -726,7 +726,7 @@ trait ReificationSupport { self: SymbolTable =>
     protected object FilterCall {
       def unapply(tree: Tree): Option[(Tree,Tree)] = tree match {
         case Apply(Select(obj, nme.withFilter | nme.filter), arg :: Nil) =>
-          Some(obj, arg)
+          Some((obj, arg))
         case _ => None
       }
     }
@@ -760,10 +760,10 @@ trait ReificationSupport { self: SymbolTable =>
       def unapply(tree: Tree) = tree match {
         case SyntacticApplied(SyntacticTypeApplied(sel @ Select(lhs, meth), _), (f :: Nil) :: Nil)
           if name == meth && sel.hasAttachment[ForAttachment.type] =>
-          Some(lhs, f)
+          Some((lhs, f))
         case SyntacticApplied(SyntacticTypeApplied(sel @ Select(lhs, meth), _), (f :: Nil) :: _ :: Nil)
           if name == meth && sel.hasAttachment[ForAttachment.type] =>
-          Some(lhs, f)
+          Some((lhs, f))
         case _ => None
       }
     }
@@ -1132,7 +1132,7 @@ trait ReificationSupport { self: SymbolTable =>
       def apply(tpt: Tree, where: List[Tree]): ExistentialTypeTree =
         ExistentialTypeTree(tpt, where.map {
           case md: MemberDef => md
-          case tree => throw new IllegalArgumentException("$tree is not legal forSome definition")
+          case tree => throw new IllegalArgumentException(s"$tree is not legal forSome definition")
         })
       def unapply(tree: Tree): Option[(Tree, List[MemberDef])] = tree match {
         case MaybeTypeTreeOriginal(ExistentialTypeTree(tpt, where)) =>
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index f1016e1b76..d16d431f6e 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -7,11 +7,11 @@ package scala
 package reflect
 package internal
 
+import scala.language.implicitConversions
+
 import java.security.MessageDigest
-import java.util.UUID.randomUUID
 import Chars.isOperatorPart
 import scala.annotation.switch
-import scala.language.implicitConversions
 import scala.collection.immutable
 import scala.io.Codec
 
@@ -876,7 +876,7 @@ trait StdNames {
     val toCharacter: NameType = "toCharacter"
     val toInteger: NameType   = "toInteger"
 
-    def newLazyValSlowComputeName(lzyValName: Name) = lzyValName append LAZY_SLOW_SUFFIX
+    def newLazyValSlowComputeName(lzyValName: Name) = (lzyValName stripSuffix MODULE_VAR_SUFFIX append LAZY_SLOW_SUFFIX).toTermName
 
     // ASCII names for operators
     val ADD       = encode("+")
diff --git a/src/reflect/scala/reflect/internal/SymbolTable.scala b/src/reflect/scala/reflect/internal/SymbolTable.scala
index b0145f8a89..88a94ab530 100644
--- a/src/reflect/scala/reflect/internal/SymbolTable.scala
+++ b/src/reflect/scala/reflect/internal/SymbolTable.scala
@@ -8,7 +8,7 @@ package reflect
 package internal
 
 import scala.annotation.elidable
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import util._
 import java.util.concurrent.TimeUnit
 import scala.reflect.internal.{TreeGen => InternalTreeGen}
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index ce93841567..65740e87f1 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -7,7 +7,7 @@ package scala
 package reflect
 package internal
 
-import scala.collection.{ mutable, immutable }
+import scala.collection.immutable
 import scala.collection.mutable.ListBuffer
 import util.{ Statistics, shortClassOfInstance }
 import Flags._
@@ -323,7 +323,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def newModuleVarSymbol(accessor: Symbol): TermSymbol = {
       val newName  = nme.moduleVarName(accessor.name.toTermName)
       val newFlags = MODULEVAR | ( if (this.isClass) PrivateLocal | SYNTHETIC else 0 )
-      val newInfo  = accessor.tpe.finalResultType
+      val newInfo  = thisType.memberType(accessor).finalResultType
       val mval     = newVariable(newName, accessor.pos.focus, newFlags.toLong) addAnnotation VolatileAttr
 
       if (this.isClass)
@@ -3441,7 +3441,6 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
   extends ClassSymbol(owner0, pos0, tpnme.REFINE_CLASS_NAME) {
     override def name_=(name: Name) {
       abort("Cannot set name of RefinementClassSymbol to " + name)
-      super.name_=(name)
     }
     override def isRefinementClass       = true
     override def isAnonOrRefinementClass = true
diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala
index 7ad5fdf096..86b70643c9 100644
--- a/src/reflect/scala/reflect/internal/TreeInfo.scala
+++ b/src/reflect/scala/reflect/internal/TreeInfo.scala
@@ -18,7 +18,7 @@ abstract class TreeInfo {
   val global: SymbolTable
 
   import global._
-  import definitions.{ isTupleSymbol, isVarArgsList, isCastSymbol, ThrowableClass, TupleClass, uncheckedStableClass, isBlackboxMacroBundleType, isWhiteboxContextType }
+  import definitions.{ isVarArgsList, isCastSymbol, ThrowableClass, uncheckedStableClass, isBlackboxMacroBundleType, isWhiteboxContextType }
 
   /* Does not seem to be used. Not sure what it does anyway.
   def isOwnerDefinition(tree: Tree): Boolean = tree match {
diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala
index 49554d6d0f..b43ea640d9 100644
--- a/src/reflect/scala/reflect/internal/Trees.scala
+++ b/src/reflect/scala/reflect/internal/Trees.scala
@@ -8,7 +8,7 @@ package reflect
 package internal
 
 import Flags._
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import scala.reflect.macros.Attachments
 import util.Statistics
 
@@ -1468,8 +1468,10 @@ trait Trees extends api.Trees {
 
   class ChangeOwnerTraverser(val oldowner: Symbol, val newowner: Symbol) extends Traverser {
     final def change(sym: Symbol) = {
-      if (sym != NoSymbol && sym.owner == oldowner)
+      if (sym != NoSymbol && sym.owner == oldowner) {
         sym.owner = newowner
+        if (sym.isModule) sym.moduleClass.owner = newowner
+      }
     }
     override def traverse(tree: Tree) {
       tree match {
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 33592bbd86..2e6cd819b4 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -7,7 +7,7 @@ package scala
 package reflect
 package internal
 
-import scala.collection.{ mutable, immutable, generic }
+import scala.collection.{ mutable, immutable }
 import scala.ref.WeakReference
 import mutable.ListBuffer
 import Flags._
@@ -2496,6 +2496,8 @@ trait Types
     override def isJava = true
   }
 
+  // TODO: rename so it's more appropriate for the type that is for a method without argument lists
+  // ("nullary" erroneously implies it has an argument list with zero arguments, it actually has zero argument lists)
   case class NullaryMethodType(override val resultType: Type) extends Type with NullaryMethodTypeApi {
     override def isTrivial = resultType.isTrivial && (resultType eq resultType.withoutAnnotations)
     override def prefix: Type = resultType.prefix
@@ -3938,7 +3940,8 @@ trait Types
     def maybeCreateDummyClone(pre: Type, sym: Symbol): Type = pre match {
       case SingleType(pre1, sym1) =>
         if (sym1.isModule && sym1.isStatic) {
-          NoType
+          if (sym.owner == sym1 || sym.isJavaDefined || sym.owner.sourceModule.isStaticModule) NoType
+          else pre
         } else if (sym1.isModule && sym.owner == sym1.moduleClass) {
           val pre2 = maybeCreateDummyClone(pre1, sym1)
           if (pre2 eq NoType) pre2
diff --git a/src/reflect/scala/reflect/internal/Variances.scala b/src/reflect/scala/reflect/internal/Variances.scala
index ef22df3f2e..8d74065207 100644
--- a/src/reflect/scala/reflect/internal/Variances.scala
+++ b/src/reflect/scala/reflect/internal/Variances.scala
@@ -8,7 +8,7 @@ package reflect
 package internal
 
 import Variance._
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import scala.annotation.tailrec
 
 /** See comments at scala.reflect.internal.Variance.
@@ -122,15 +122,21 @@ trait Variances {
        *  same is true of the parameters (ValDefs) unless we are inside a
        *  refinement, in which case they are checked from here.
        */
-      def apply(tp: Type): Type = tp match {
-        case _ if isUncheckedVariance(tp)                    => tp
-        case _ if resultTypeOnly(tp)                         => this(tp.resultType)
-        case TypeRef(_, sym, _) if sym.isAliasType           => this(tp.normalize)
-        case TypeRef(_, sym, _) if !sym.variance.isInvariant => checkVarianceOfSymbol(sym) ; mapOver(tp)
-        case RefinedType(_, _)                               => withinRefinement(mapOver(tp))
-        case ClassInfoType(parents, _, _)                    => parents foreach this ; tp
-        case mt @ MethodType(_, result)                      => flipped(mt.paramTypes foreach this) ; this(result)
-        case _                                               => mapOver(tp)
+      def apply(tp: Type): Type = {
+        tp match {
+          case _ if isUncheckedVariance(tp)                    =>
+          case _ if resultTypeOnly(tp)                         => this(tp.resultType)
+          case TypeRef(_, sym, _) if sym.isAliasType           => this(tp.normalize)
+          case TypeRef(_, sym, _) if !sym.variance.isInvariant => checkVarianceOfSymbol(sym) ; mapOver(tp)
+          case RefinedType(_, _)                               => withinRefinement(mapOver(tp))
+          case ClassInfoType(parents, _, _)                    => parents foreach this
+          case mt @ MethodType(_, result)                      => flipped(mt.paramTypes foreach this) ; this(result)
+          case _                                               => mapOver(tp)
+        }
+        // We're using TypeMap here for type traversal only. To avoid wasteful symbol
+        // cloning during the recursion, it is important to return the input `tp`, rather
+        // than the result of the pattern match above, which normalizes types.
+        tp
       }
       def validateDefinition(base: Symbol) {
         val saved = this.base
diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
index 277e89d656..4bc804445c 100644
--- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
@@ -14,7 +14,7 @@ import java.lang.Double.longBitsToDouble
 
 import Flags._
 import PickleFormat._
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
 import scala.annotation.switch
 
diff --git a/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala b/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala
index 28a7fb37a6..af5128163b 100644
--- a/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala
+++ b/src/reflect/scala/reflect/internal/tpe/TypeMaps.scala
@@ -1001,10 +1001,20 @@ private[internal] trait TypeMaps {
   class ContainsCollector(sym: Symbol) extends TypeCollector(false) {
     def traverse(tp: Type) {
       if (!result) {
-        tp.normalize match {
-          case TypeRef(_, sym1, _) if (sym == sym1) => result = true
-          case SingleType(_, sym1) if (sym == sym1) => result = true
-          case _ => mapOver(tp)
+        tp match {
+          case _: ExistentialType =>
+            // ExistentialType#normalize internally calls contains, which leads to exponential performance
+            // for types like: `A[_ <: B[_ <: ... ]]`. Example: pos/existential-contains.scala.
+            //
+            // We can just map over the components and wait until we see the underlying type before we call
+            // normalize.
+            mapOver(tp)
+          case _ =>
+            tp.normalize match {
+              case TypeRef(_, sym1, _) if (sym == sym1) => result = true
+              case SingleType(_, sym1) if (sym == sym1) => result = true
+              case _ => mapOver(tp)
+            }
         }
       }
     }
diff --git a/src/reflect/scala/reflect/internal/transform/Erasure.scala b/src/reflect/scala/reflect/internal/transform/Erasure.scala
index 9853a0fa0c..32af6529ca 100644
--- a/src/reflect/scala/reflect/internal/transform/Erasure.scala
+++ b/src/reflect/scala/reflect/internal/transform/Erasure.scala
@@ -3,8 +3,6 @@ package reflect
 package internal
 package transform
 
-import Flags.{PARAMACCESSOR, METHOD}
-
 trait Erasure {
 
   val global: SymbolTable
@@ -123,7 +121,7 @@ trait Erasure {
       case tref @ TypeRef(pre, sym, args) =>
         if (sym == ArrayClass)
           if (unboundedGenericArrayLevel(tp) == 1) ObjectTpe
-          else if (args.head.typeSymbol.isBottomClass) arrayType(ObjectTpe)
+          else if (args.head.typeSymbol.isBottomClass)  arrayType(ObjectTpe)
           else typeRef(apply(pre), sym, args map applyInArray)
         else if (sym == AnyClass || sym == AnyValClass || sym == SingletonClass) ObjectTpe
         else if (sym == UnitClass) BoxedUnitTpe
diff --git a/src/reflect/scala/reflect/internal/util/AbstractFileClassLoader.scala b/src/reflect/scala/reflect/internal/util/AbstractFileClassLoader.scala
index 5cbdb92664..b5030460b8 100644
--- a/src/reflect/scala/reflect/internal/util/AbstractFileClassLoader.scala
+++ b/src/reflect/scala/reflect/internal/util/AbstractFileClassLoader.scala
@@ -5,8 +5,8 @@
 package scala
 package reflect.internal.util
 
-import scala.collection.{ mutable, immutable }
-import scala.reflect.io.{ AbstractFile, Streamable }
+import scala.collection.mutable
+import scala.reflect.io.AbstractFile
 import java.net.{ URL, URLConnection, URLStreamHandler }
 import java.security.cert.Certificate
 import java.security.{ ProtectionDomain, CodeSource }
diff --git a/src/reflect/scala/reflect/internal/util/FreshNameCreator.scala b/src/reflect/scala/reflect/internal/util/FreshNameCreator.scala
index 8442c1015f..c69dd23c40 100644
--- a/src/reflect/scala/reflect/internal/util/FreshNameCreator.scala
+++ b/src/reflect/scala/reflect/internal/util/FreshNameCreator.scala
@@ -8,7 +8,6 @@ package util
 
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicLong
-import scala.collection.mutable
 import scala.reflect.NameTransformer
 
 class FreshNameCreator(creatorPrefix: String = "") {
diff --git a/src/reflect/scala/reflect/internal/util/Origins.scala b/src/reflect/scala/reflect/internal/util/Origins.scala
index 2eb4fa29d5..4c425457a7 100644
--- a/src/reflect/scala/reflect/internal/util/Origins.scala
+++ b/src/reflect/scala/reflect/internal/util/Origins.scala
@@ -7,7 +7,7 @@ package scala
 package reflect
 package internal.util
 
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 
 /** A debugging class for logging from whence a method is being called.
  *  Say you wanted to discover who was calling phase_= in SymbolTable.
diff --git a/src/reflect/scala/reflect/internal/util/ScalaClassLoader.scala b/src/reflect/scala/reflect/internal/util/ScalaClassLoader.scala
index 296934e253..cc5be92489 100644
--- a/src/reflect/scala/reflect/internal/util/ScalaClassLoader.scala
+++ b/src/reflect/scala/reflect/internal/util/ScalaClassLoader.scala
@@ -6,16 +6,16 @@
 package scala
 package reflect.internal.util
 
+import scala.language.implicitConversions
+
 import java.lang.{ ClassLoader => JClassLoader }
-import java.lang.reflect.{ Constructor, Modifier, Method }
-import java.io.{ File => JFile }
+import java.lang.reflect.Modifier
 import java.net.{ URLClassLoader => JURLClassLoader }
 import java.net.URL
-import scala.reflect.internal.FatalError
+
 import scala.reflect.runtime.ReflectionUtils.{ show, unwrapHandler }
 import ScalaClassLoader._
 import scala.util.control.Exception.{ catching }
-import scala.language.implicitConversions
 import scala.reflect.{ ClassTag, classTag }
 
 trait HasClassPath {
diff --git a/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala b/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala
index e4a6503184..e48c35908f 100644
--- a/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala
+++ b/src/reflect/scala/reflect/internal/util/TraceSymbolActivity.scala
@@ -2,8 +2,7 @@ package scala
 package reflect.internal
 package util
 
-import scala.collection.{ mutable, immutable }
-import scala.language.postfixOps
+import scala.collection.mutable
 
 trait TraceSymbolActivity {
   val global: SymbolTable
diff --git a/src/reflect/scala/reflect/internal/util/WeakHashSet.scala b/src/reflect/scala/reflect/internal/util/WeakHashSet.scala
index 3a7a7626fb..f8dfa720d5 100644
--- a/src/reflect/scala/reflect/internal/util/WeakHashSet.scala
+++ b/src/reflect/scala/reflect/internal/util/WeakHashSet.scala
@@ -3,7 +3,6 @@ package reflect.internal.util
 
 import java.lang.ref.{WeakReference, ReferenceQueue}
 import scala.annotation.tailrec
-import scala.collection.generic.Clearable
 import scala.collection.mutable.{Set => MSet}
 
 /**
@@ -41,7 +40,7 @@ final class WeakHashSet[A <: AnyRef](val initialCapacity: Int, val loadFactor: D
    * power of two equal to or greater than the specified initial capacity
    */
   private def computeCapacity = {
-    if (initialCapacity < 0) throw new IllegalArgumentException("initial capacity cannot be less than 0");
+    if (initialCapacity < 0) throw new IllegalArgumentException("initial capacity cannot be less than 0")
     var candidate = 1
     while (candidate < initialCapacity) {
       candidate  *= 2
@@ -372,13 +371,13 @@ final class WeakHashSet[A <: AnyRef](val initialCapacity: Int, val loadFactor: D
      * Number of buckets that hold collisions. Useful for diagnosing performance issues.
      */
     def collisionBucketsCount: Int =
-      (table filter (entry => entry != null && entry.tail != null)).size
+      (table count (entry => entry != null && entry.tail != null))
 
     /**
      * Number of buckets that are occupied in this hash table.
      */
     def fullBucketsCount: Int =
-      (table filter (entry => entry != null)).size
+      (table count (entry => entry != null))
 
     /**
      *  Number of buckets in the table
@@ -403,4 +402,4 @@ object WeakHashSet {
   val defaultLoadFactor = .75
 
   def apply[A <: AnyRef](initialCapacity: Int = WeakHashSet.defaultInitialCapacity, loadFactor: Double = WeakHashSet.defaultLoadFactor) = new WeakHashSet[A](initialCapacity, defaultLoadFactor)
-}
\ No newline at end of file
+}
diff --git a/src/reflect/scala/reflect/internal/util/package.scala b/src/reflect/scala/reflect/internal/util/package.scala
index 3618c150ca..ec5938b902 100644
--- a/src/reflect/scala/reflect/internal/util/package.scala
+++ b/src/reflect/scala/reflect/internal/util/package.scala
@@ -5,7 +5,6 @@ package internal
 import scala.language.existentials // SI-6541
 
 package object util {
-  import StringOps.longestCommonPrefix
 
   // An allocation-avoiding reusable instance of the so-common List(Nil).
   val ListOfNil: List[List[Nothing]] = Nil :: Nil
diff --git a/src/reflect/scala/reflect/io/AbstractFile.scala b/src/reflect/scala/reflect/io/AbstractFile.scala
index bcefcc471f..ee0bc129f8 100644
--- a/src/reflect/scala/reflect/io/AbstractFile.scala
+++ b/src/reflect/scala/reflect/io/AbstractFile.scala
@@ -8,10 +8,9 @@ package scala
 package reflect
 package io
 
-import java.io.{ FileOutputStream, IOException, InputStream, OutputStream, BufferedOutputStream, ByteArrayOutputStream }
+import java.io.{ IOException, InputStream, OutputStream, BufferedOutputStream, ByteArrayOutputStream }
 import java.io.{ File => JFile }
 import java.net.URL
-import scala.collection.mutable.ArrayBuffer
 import scala.reflect.internal.util.Statistics
 
 /**
diff --git a/src/reflect/scala/reflect/io/File.scala b/src/reflect/scala/reflect/io/File.scala
index a9c6807e88..206861adb3 100644
--- a/src/reflect/scala/reflect/io/File.scala
+++ b/src/reflect/scala/reflect/io/File.scala
@@ -6,20 +6,16 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala
 package reflect
 package io
 
 import java.io.{
-  FileInputStream, FileOutputStream, BufferedReader, BufferedWriter, InputStreamReader, OutputStreamWriter,
-  BufferedInputStream, BufferedOutputStream, IOException, PrintStream, PrintWriter, Closeable => JCloseable,
-  File => JFile
+  FileInputStream, FileOutputStream, BufferedWriter, OutputStreamWriter,
+  BufferedOutputStream, IOException, PrintWriter, File => JFile
 }
 
-import java.nio.channels.{ Channel, FileChannel }
 import scala.io.Codec
-import scala.language.{reflectiveCalls, implicitConversions}
 /**
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
diff --git a/src/reflect/scala/reflect/io/Path.scala b/src/reflect/scala/reflect/io/Path.scala
index 15fce953f2..5f93506015 100644
--- a/src/reflect/scala/reflect/io/Path.scala
+++ b/src/reflect/scala/reflect/io/Path.scala
@@ -7,12 +7,11 @@ package scala
 package reflect
 package io
 
-import java.io.{
-  FileInputStream, FileOutputStream, BufferedReader, BufferedWriter, InputStreamReader, OutputStreamWriter,
-  BufferedInputStream, BufferedOutputStream, RandomAccessFile, File => JFile }
+import scala.language.implicitConversions
+
+import java.io.{ RandomAccessFile, File => JFile }
 import java.net.{ URI, URL }
 import scala.util.Random.alphanumeric
-import scala.language.implicitConversions
 import scala.reflect.internal.util.Statistics
 
 /** An abstraction for filesystem paths.  The differences between
diff --git a/src/reflect/scala/reflect/io/PlainFile.scala b/src/reflect/scala/reflect/io/PlainFile.scala
index 8f24d84488..eb0940e703 100644
--- a/src/reflect/scala/reflect/io/PlainFile.scala
+++ b/src/reflect/scala/reflect/io/PlainFile.scala
@@ -7,8 +7,6 @@ package scala
 package reflect
 package io
 
-import java.io.{ FileInputStream, FileOutputStream, IOException }
-
 /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
 class PlainDirectory(givenPath: Directory) extends PlainFile(givenPath) {
   override def isDirectory = true
diff --git a/src/reflect/scala/reflect/io/Streamable.scala b/src/reflect/scala/reflect/io/Streamable.scala
index 99a14d1fb0..bc4031ca9b 100644
--- a/src/reflect/scala/reflect/io/Streamable.scala
+++ b/src/reflect/scala/reflect/io/Streamable.scala
@@ -7,8 +7,8 @@ package scala
 package reflect
 package io
 
-import java.net.{ URI, URL }
-import java.io.{ BufferedInputStream, InputStream, PrintStream }
+import java.net.URL
+import java.io.{ BufferedInputStream, InputStream }
 import java.io.{ BufferedReader, InputStreamReader, Closeable => JCloseable }
 import scala.io.{ Codec, BufferedSource, Source }
 import scala.collection.mutable.ArrayBuffer
diff --git a/src/reflect/scala/reflect/io/ZipArchive.scala b/src/reflect/scala/reflect/io/ZipArchive.scala
index 0c63acb86c..42e22fda6f 100644
--- a/src/reflect/scala/reflect/io/ZipArchive.scala
+++ b/src/reflect/scala/reflect/io/ZipArchive.scala
@@ -12,7 +12,7 @@ import java.io.{ IOException, InputStream, ByteArrayInputStream, FilterInputStre
 import java.io.{ File => JFile }
 import java.util.zip.{ ZipEntry, ZipFile, ZipInputStream }
 import java.util.jar.Manifest
-import scala.collection.{ immutable, mutable }
+import scala.collection.mutable
 import scala.collection.convert.WrapAsScala.asScalaIterator
 import scala.annotation.tailrec
 
diff --git a/src/reflect/scala/reflect/macros/Attachments.scala b/src/reflect/scala/reflect/macros/Attachments.scala
index b5c340645a..0b5360c004 100644
--- a/src/reflect/scala/reflect/macros/Attachments.scala
+++ b/src/reflect/scala/reflect/macros/Attachments.scala
@@ -39,7 +39,7 @@ abstract class Attachments { self =>
 
   /** An underlying payload of the given class type `T`. */
   def get[T: ClassTag]: Option[T] =
-    (all filter matchesTag[T]).headOption.asInstanceOf[Option[T]]
+    (all find matchesTag[T]).asInstanceOf[Option[T]]
 
   /** Check underlying payload contains an instance of type `T`. */
   def contains[T: ClassTag]: Boolean =
diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
index 50442519f2..40f2a1ef90 100644
--- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala
+++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala
@@ -2,24 +2,24 @@ package scala
 package reflect
 package runtime
 
+import scala.language.existentials
+
 import scala.ref.WeakReference
 import scala.collection.mutable.WeakHashMap
 
 import java.lang.{Class => jClass, Package => jPackage}
 import java.lang.reflect.{
   Method => jMethod, Constructor => jConstructor, Field => jField,
-  Member => jMember, Type => jType, TypeVariable => jTypeVariable, Array => jArray,
-  AccessibleObject => jAccessibleObject,
+  Member => jMember, Type => jType, TypeVariable => jTypeVariable,
   GenericDeclaration, GenericArrayType, ParameterizedType, WildcardType, AnnotatedElement }
 import java.lang.annotation.{Annotation => jAnnotation}
 import java.io.IOException
-import scala.reflect.internal.{ MissingRequirementError, JavaAccFlags, JMethodOrConstructor }
+import scala.reflect.internal.{ MissingRequirementError, JavaAccFlags }
 import internal.pickling.ByteCodecs
 import internal.pickling.UnPickler
-import scala.collection.mutable.{ HashMap, ListBuffer, ArrayBuffer }
+import scala.collection.mutable.ListBuffer
 import internal.Flags._
 import ReflectionUtils._
-import scala.language.existentials
 import scala.runtime.{ScalaRunTime, BoxesRunTime}
 
 private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUniverse with TwoWayCaches { thisUniverse: SymbolTable =>
diff --git a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
index 46e4371cfa..d6b611a3f4 100644
--- a/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
+++ b/src/reflect/scala/reflect/runtime/JavaUniverseForce.scala
@@ -313,7 +313,6 @@ trait JavaUniverseForce { self: runtime.JavaUniverse  =>
     definitions.QuasiquoteClass_api_unapply
     definitions.ScalaSignatureAnnotation
     definitions.ScalaLongSignatureAnnotation
-    definitions.LambdaMetaFactory
     definitions.MethodHandle
     definitions.OptionClass
     definitions.OptionModule
diff --git a/src/reflect/scala/reflect/runtime/ReflectionUtils.scala b/src/reflect/scala/reflect/runtime/ReflectionUtils.scala
index a4bd698068..d92e37953f 100644
--- a/src/reflect/scala/reflect/runtime/ReflectionUtils.scala
+++ b/src/reflect/scala/reflect/runtime/ReflectionUtils.scala
@@ -10,7 +10,6 @@ import java.lang.{Class => jClass}
 import java.lang.reflect.{ Method, InvocationTargetException, UndeclaredThrowableException }
 import scala.reflect.internal.util.AbstractFileClassLoader
 import scala.reflect.io._
-import java.io.{File => JFile}
 
 /** A few java-reflection oriented utility functions useful during reflection bootstrapping.
  */
@@ -72,7 +71,7 @@ object ReflectionUtils {
     def singletonAccessor(clazz: Class[_]): Option[Method] =
       if (clazz == null) None
       else {
-        val declaredAccessor = clazz.getDeclaredMethods.filter(_.getName == accessorName).headOption
+        val declaredAccessor = clazz.getDeclaredMethods.find(_.getName == accessorName)
         declaredAccessor orElse singletonAccessor(clazz.getSuperclass)
       }
 
@@ -92,7 +91,7 @@ object ReflectionUtils {
   }
 
   class EnclosedIn[T](enclosure: jClass[_] => T) {
-    def unapply(jclazz: jClass[_]): Option[T] = if (enclosure(jclazz) != null) Some(enclosure(jclazz)) else None
+    def unapply(jclazz: jClass[_]): Option[T] = Option(enclosure(jclazz))
   }
 
   object EnclosedInMethod extends EnclosedIn(_.getEnclosingMethod)
diff --git a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala
index 9ce6331e33..43ab41f541 100644
--- a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala
+++ b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala
@@ -2,8 +2,6 @@ package scala
 package reflect
 package runtime
 
-import internal.Flags
-import java.lang.{Class => jClass, Package => jPackage}
 import scala.collection.mutable
 import scala.reflect.runtime.ReflectionUtils.scalacShouldntLoadClass
 import scala.reflect.internal.Flags._
diff --git a/src/reflect/scala/reflect/runtime/SynchronizedOps.scala b/src/reflect/scala/reflect/runtime/SynchronizedOps.scala
index 4a8585d616..f0d96e0fd6 100644
--- a/src/reflect/scala/reflect/runtime/SynchronizedOps.scala
+++ b/src/reflect/scala/reflect/runtime/SynchronizedOps.scala
@@ -15,7 +15,7 @@ private[reflect] trait SynchronizedOps extends internal.SymbolTable
 
   override protected def newBaseTypeSeq(parents: List[Type], elems: Array[Type]) =
     // only need to synchronize BaseTypeSeqs if they contain refined types
-    if (elems.filter(_.isInstanceOf[RefinedType]).nonEmpty) new BaseTypeSeq(parents, elems) with SynchronizedBaseTypeSeq
+    if (elems.exists(_.isInstanceOf[RefinedType])) new BaseTypeSeq(parents, elems) with SynchronizedBaseTypeSeq
     else new BaseTypeSeq(parents, elems)
 
   trait SynchronizedBaseTypeSeq extends BaseTypeSeq {
@@ -31,7 +31,7 @@ private[reflect] trait SynchronizedOps extends internal.SymbolTable
 
     override def lateMap(f: Type => Type): BaseTypeSeq =
       // only need to synchronize BaseTypeSeqs if they contain refined types
-      if (map(f).toList.filter(_.isInstanceOf[RefinedType]).nonEmpty) new MappedBaseTypeSeq(this, f) with SynchronizedBaseTypeSeq
+      if (map(f).toList.exists(_.isInstanceOf[RefinedType])) new MappedBaseTypeSeq(this, f) with SynchronizedBaseTypeSeq
       else new MappedBaseTypeSeq(this, f)
   }
 
diff --git a/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineReader.scala b/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineReader.scala
index dc33223f4b..1f2b0952e7 100644
--- a/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineReader.scala
+++ b/src/repl-jline/scala/tools/nsc/interpreter/jline/JLineReader.scala
@@ -11,7 +11,7 @@ import java.util.{Collection => JCollection, List => JList}
 
 import _root_.jline.{console => jconsole}
 import jline.console.ConsoleReader
-import jline.console.completer.{CompletionHandler, Completer, ArgumentCompleter}
+import jline.console.completer.{CompletionHandler, Completer}
 import jconsole.history.{History => JHistory}
 
 
diff --git a/src/repl/scala/tools/nsc/MainGenericRunner.scala b/src/repl/scala/tools/nsc/MainGenericRunner.scala
index 34057ed341..747b684293 100644
--- a/src/repl/scala/tools/nsc/MainGenericRunner.scala
+++ b/src/repl/scala/tools/nsc/MainGenericRunner.scala
@@ -6,8 +6,8 @@
 package scala
 package tools.nsc
 
-import io.{ File }
-import util.{ ClassPath, ScalaClassLoader }
+import io.File
+import util.ClassPath
 import GenericRunnerCommand._
 
 object JarRunner extends CommonRunner {
diff --git a/src/repl/scala/tools/nsc/interpreter/ExprTyper.scala b/src/repl/scala/tools/nsc/interpreter/ExprTyper.scala
index 8a6a405810..01e3a90950 100644
--- a/src/repl/scala/tools/nsc/interpreter/ExprTyper.scala
+++ b/src/repl/scala/tools/nsc/interpreter/ExprTyper.scala
@@ -6,8 +6,6 @@
 package scala.tools.nsc
 package interpreter
 
-import scala.tools.nsc.ast.parser.Tokens.EOF
-
 trait ExprTyper {
   val repl: IMain
 
diff --git a/src/repl/scala/tools/nsc/interpreter/ILoop.scala b/src/repl/scala/tools/nsc/interpreter/ILoop.scala
index 060bccb451..459450a94e 100644
--- a/src/repl/scala/tools/nsc/interpreter/ILoop.scala
+++ b/src/repl/scala/tools/nsc/interpreter/ILoop.scala
@@ -12,18 +12,17 @@ import Predef.{ println => _, _ }
 import interpreter.session._
 import StdReplTags._
 import scala.tools.asm.ClassReader
-import scala.util.Properties.{ jdkHome, javaVersion, versionString, javaVmName }
-import scala.tools.nsc.util.{ ClassPath, Exceptional, stringFromWriter, stringFromStream }
+import scala.util.Properties.jdkHome
+import scala.tools.nsc.util.{ ClassPath, stringFromStream }
 import scala.reflect.classTag
 import scala.reflect.internal.util.{ BatchSourceFile, ScalaClassLoader }
 import ScalaClassLoader._
-import scala.reflect.io.{ File, Directory }
+import scala.reflect.io.File
 import scala.tools.util._
 import io.AbstractFile
-import scala.collection.generic.Clearable
-import scala.concurrent.{ ExecutionContext, Await, Future, future }
+import scala.concurrent.{ ExecutionContext, Await, Future }
 import ExecutionContext.Implicits._
-import java.io.{ BufferedReader, FileReader, StringReader }
+import java.io.BufferedReader
 
 import scala.util.{ Try, Success, Failure }
 
@@ -543,7 +542,6 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
             case i  => val n = s.take(i).toInt ; (n, s.drop(i+1).toInt - n)
           }
         }
-      import scala.collection.JavaConverters._
       val index = (start - 1) max 0
       val text = history.asStrings(index, index + len) mkString "\n"
       edit(text)
@@ -870,7 +868,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
 
       if (settings.debug) {
         val readerDiags = (readerClasses, readers).zipped map {
-          case (cls, Failure(e)) => s"  - $cls --> " + e.getStackTrace.mkString(e.toString+"\n\t", "\n\t","\n")
+          case (cls, Failure(e)) => s"  - $cls --> \n\t" + scala.tools.nsc.util.stackTraceString(e) + "\n"
           case (cls, Success(_)) => s"  - $cls OK"
         }
         Console.println(s"All InteractiveReaders tried: ${readerDiags.mkString("\n","\n","\n")}")
@@ -906,7 +904,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter)
 
     // sets in to some kind of reader depending on environmental cues
     in = in0.fold(chooseReader(settings))(r => SimpleReader(r, out, interactive = true))
-    globalFuture = future {
+    globalFuture = Future {
       intp.initializeSynchronous()
       loopPostInit()
       !intp.reporter.hasErrors
diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala
index ef6ab4063a..893bde42ab 100644
--- a/src/repl/scala/tools/nsc/interpreter/IMain.scala
+++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala
@@ -15,19 +15,14 @@ import scala.concurrent.{ Future, ExecutionContext }
 import scala.reflect.runtime.{ universe => ru }
 import scala.reflect.{ ClassTag, classTag }
 import scala.reflect.internal.util.{ BatchSourceFile, SourceFile }
-import scala.tools.nsc.interactive
-import scala.tools.nsc.reporters.StoreReporter
-import scala.tools.nsc.util.ClassPath.DefaultJavaContext
 import scala.tools.util.PathResolverFactory
 import scala.tools.nsc.io.AbstractFile
 import scala.tools.nsc.typechecker.{ TypeStrings, StructuredTypeStrings }
 import scala.tools.nsc.util._
 import ScalaClassLoader.URLClassLoader
 import scala.tools.nsc.util.Exceptional.unwrap
-import scala.tools.nsc.backend.JavaPlatform
 import javax.script.{AbstractScriptEngine, Bindings, ScriptContext, ScriptEngine, ScriptEngineFactory, ScriptException, CompiledScript, Compilable}
 import java.net.URL
-import java.io.File
 
 /** An interpreter for Scala code.
  *
diff --git a/src/repl/scala/tools/nsc/interpreter/Imports.scala b/src/repl/scala/tools/nsc/interpreter/Imports.scala
index 5742c1d0d8..6a75432ac6 100644
--- a/src/repl/scala/tools/nsc/interpreter/Imports.scala
+++ b/src/repl/scala/tools/nsc/interpreter/Imports.scala
@@ -6,13 +6,13 @@
 package scala.tools.nsc
 package interpreter
 
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 
 trait Imports {
   self: IMain =>
 
   import global._
-  import definitions.{ ObjectClass, ScalaPackage, JavaLangPackage, PredefModule }
+  import definitions.{ ScalaPackage, JavaLangPackage, PredefModule }
   import memberHandlers._
 
   /** Synthetic import handlers for the language defined imports. */
diff --git a/src/repl/scala/tools/nsc/interpreter/JavapClass.scala b/src/repl/scala/tools/nsc/interpreter/JavapClass.scala
index 04f4512717..034437fe5c 100644
--- a/src/repl/scala/tools/nsc/interpreter/JavapClass.scala
+++ b/src/repl/scala/tools/nsc/interpreter/JavapClass.scala
@@ -6,23 +6,23 @@ package scala
 package tools.nsc
 package interpreter
 
+import scala.language.reflectiveCalls
+
 import java.lang.{ Iterable => JIterable }
-import scala.tools.nsc.util.ScalaClassLoader
+import scala.reflect.internal.util.ScalaClassLoader
 import java.io.{ ByteArrayInputStream, CharArrayWriter, FileNotFoundException, PrintWriter, StringWriter, Writer }
 import java.util.{ Locale }
 import java.util.concurrent.ConcurrentLinkedQueue
-import javax.tools.{ Diagnostic, DiagnosticCollector, DiagnosticListener,
+import javax.tools.{ Diagnostic, DiagnosticListener,
                      ForwardingJavaFileManager, JavaFileManager, JavaFileObject,
                      SimpleJavaFileObject, StandardLocation }
-import scala.reflect.io.{ AbstractFile, Directory, File, Path }
+import scala.reflect.io.File
 import scala.io.Source
 import scala.util.{ Try, Success, Failure }
 import scala.util.Properties.{ lineSeparator => EOL }
-import scala.util.matching.Regex
 import scala.collection.JavaConverters._
 import scala.collection.generic.Clearable
 import java.net.URL
-import scala.language.reflectiveCalls
 import Javap.{ JpResult, JpError, Showable, helper, toolArgs, DefaultOptions }
 
 /** Javap command implementation.
@@ -214,7 +214,6 @@ class JavapClass(
     ) orFailed null
 
     class JavaReporter extends DiagnosticListener[JavaFileObject] with Clearable {
-      import scala.collection.mutable.{ ArrayBuffer, SynchronizedBuffer }
       type D = Diagnostic[_ <: JavaFileObject]
       val diagnostics = new ConcurrentLinkedQueue[D]
       override def report(d: Diagnostic[_ <: JavaFileObject]) {
@@ -342,8 +341,6 @@ class JavapClass(
 }
 
 object JavapClass {
-  import scala.tools.asm.ClassReader
-  import scala.tools.asm.tree.{ ClassNode, MethodNode }
 
   def apply(
     loader: ScalaClassLoader = ScalaClassLoader.appLoader,
diff --git a/src/repl/scala/tools/nsc/interpreter/LoopCommands.scala b/src/repl/scala/tools/nsc/interpreter/LoopCommands.scala
index 9f555aee14..8c3b174513 100644
--- a/src/repl/scala/tools/nsc/interpreter/LoopCommands.scala
+++ b/src/repl/scala/tools/nsc/interpreter/LoopCommands.scala
@@ -8,10 +8,10 @@ package tools
 package nsc
 package interpreter
 
-import scala.collection.{ mutable, immutable }
-import mutable.ListBuffer
 import scala.language.implicitConversions
 
+import scala.collection.mutable.ListBuffer
+
 class ProcessResult(val line: String) {
   import scala.sys.process._
   private val buffer = new ListBuffer[String]
diff --git a/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala b/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala
index 4e45f6d615..d6c0dafaf2 100644
--- a/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala
+++ b/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala
@@ -6,9 +6,10 @@
 package scala.tools.nsc
 package interpreter
 
-import scala.collection.{ mutable, immutable }
 import scala.language.implicitConversions
 
+import scala.collection.mutable
+
 trait MemberHandlers {
   val intp: IMain
 
diff --git a/src/repl/scala/tools/nsc/interpreter/NamedParam.scala b/src/repl/scala/tools/nsc/interpreter/NamedParam.scala
index a0af72940a..d59b07a452 100644
--- a/src/repl/scala/tools/nsc/interpreter/NamedParam.scala
+++ b/src/repl/scala/tools/nsc/interpreter/NamedParam.scala
@@ -6,10 +6,11 @@
 package scala.tools.nsc
 package interpreter
 
-import NamedParam._
 import scala.language.implicitConversions
+
+import NamedParam._
 import scala.reflect.runtime.{universe => ru}
-import scala.reflect.{ClassTag, classTag}
+import scala.reflect.{ClassTag}
 import scala.tools.nsc.typechecker.{ TypeStrings }
 
 trait NamedParamCreator {
diff --git a/src/repl/scala/tools/nsc/interpreter/Phased.scala b/src/repl/scala/tools/nsc/interpreter/Phased.scala
index 1cdbd65949..d1d422ce3e 100644
--- a/src/repl/scala/tools/nsc/interpreter/Phased.scala
+++ b/src/repl/scala/tools/nsc/interpreter/Phased.scala
@@ -6,7 +6,6 @@
 package scala.tools.nsc
 package interpreter
 
-import scala.collection.immutable
 import scala.language.implicitConversions
 
 /** Mix this into an object and use it as a phasing
@@ -89,9 +88,8 @@ trait Phased {
 
     lazy val all = List(
       Parser, Namer, Packageobjects, Typer, Superaccessors, Pickler, Refchecks,
-      Selectiveanf, Liftcode, Selectivecps, Uncurry, Tailcalls, Specialize,
-      Explicitouter, Erasure, Lazyvals, Lambdalift, Constructors, Flatten, Mixin,
-      Cleanup, Delambdafy, Icode, Inliner, Closelim, Dce, Jvm, Terminal
+      Uncurry, Tailcalls, Specialize, Explicitouter, Erasure, Lazyvals, Lambdalift,
+      Constructors, Flatten, Mixin, Cleanup, Delambdafy, Jvm, Terminal
     )
     lazy val nameMap = all.map(x => x.name -> x).toMap withDefaultValue NoPhaseName
     multi = all
@@ -110,17 +108,17 @@ trait Phased {
   case object Namer extends PhaseName
   case object Packageobjects extends PhaseName
   case object Typer extends PhaseName
+  case object Patmat extends PhaseName
   case object Superaccessors extends PhaseName
+  case object Extmethods extends PhaseName
   case object Pickler extends PhaseName
   case object Refchecks extends PhaseName
-  case object Selectiveanf extends PhaseName
-  case object Liftcode extends PhaseName
-  case object Selectivecps extends PhaseName
   case object Uncurry extends PhaseName
   case object Tailcalls extends PhaseName
   case object Specialize extends PhaseName
   case object Explicitouter extends PhaseName
   case object Erasure extends PhaseName
+  case object PostErasure extends PhaseName
   case object Lazyvals extends PhaseName
   case object Lambdalift extends PhaseName
   case object Constructors extends PhaseName
@@ -128,10 +126,6 @@ trait Phased {
   case object Mixin extends PhaseName
   case object Cleanup extends PhaseName
   case object Delambdafy extends PhaseName
-  case object Icode extends PhaseName
-  case object Inliner extends PhaseName
-  case object Closelim extends PhaseName
-  case object Dce extends PhaseName
   case object Jvm extends PhaseName
   case object Terminal extends PhaseName
   case object NoPhaseName extends PhaseName {
diff --git a/src/repl/scala/tools/nsc/interpreter/Power.scala b/src/repl/scala/tools/nsc/interpreter/Power.scala
index a14a60d216..3c08a03c94 100644
--- a/src/repl/scala/tools/nsc/interpreter/Power.scala
+++ b/src/repl/scala/tools/nsc/interpreter/Power.scala
@@ -6,14 +6,13 @@
 package scala.tools.nsc
 package interpreter
 
-import scala.collection.{ mutable, immutable }
-import scala.util.matching.Regex
-import scala.io.Codec
-import java.net.{ URL, MalformedURLException }
-import io.{ Path }
 import scala.language.implicitConversions
+
+import scala.collection.mutable
+import scala.io.Codec
+import java.net.URL
 import scala.reflect.runtime.{universe => ru}
-import scala.reflect.{ClassTag, classTag}
+import scala.reflect.ClassTag
 
 /** Collecting some power mode examples.
 
@@ -43,7 +42,7 @@ Lost after 18/flatten {
 /** A class for methods to be injected into the intp in power mode.
  */
 class Power[ReplValsImpl <: ReplVals : ru.TypeTag: ClassTag](val intp: IMain, replVals: ReplValsImpl) {
-  import intp.{ beQuietDuring, typeOfExpression, interpret, parse }
+  import intp.{ beQuietDuring, parse }
   import intp.global._
   import definitions.{ compilerTypeFromTag, compilerSymbolFromTag}
 
diff --git a/src/repl/scala/tools/nsc/interpreter/PresentationCompilerCompleter.scala b/src/repl/scala/tools/nsc/interpreter/PresentationCompilerCompleter.scala
index 62e12f8703..a912ec9749 100644
--- a/src/repl/scala/tools/nsc/interpreter/PresentationCompilerCompleter.scala
+++ b/src/repl/scala/tools/nsc/interpreter/PresentationCompilerCompleter.scala
@@ -4,7 +4,6 @@
  */
 package scala.tools.nsc.interpreter
 
-import scala.reflect.internal.Flags
 import scala.reflect.internal.util.StringOps
 import scala.tools.nsc.interpreter.Completion.Candidates
 import scala.util.control.NonFatal
diff --git a/src/repl/scala/tools/nsc/interpreter/RichClass.scala b/src/repl/scala/tools/nsc/interpreter/RichClass.scala
index 36cdf65510..df900d1436 100644
--- a/src/repl/scala/tools/nsc/interpreter/RichClass.scala
+++ b/src/repl/scala/tools/nsc/interpreter/RichClass.scala
@@ -6,7 +6,7 @@
 package scala.tools.nsc
 package interpreter
 
-import scala.reflect.{ ClassTag, classTag }
+import scala.reflect.ClassTag
 
 class RichClass[T](val clazz: Class[T]) {
   def toTag: ClassTag[T] = ClassTag[T](clazz)
diff --git a/src/repl/scala/tools/nsc/interpreter/session/SimpleHistory.scala b/src/repl/scala/tools/nsc/interpreter/session/SimpleHistory.scala
index 504d0d30ee..92bf9d1df4 100644
--- a/src/repl/scala/tools/nsc/interpreter/session/SimpleHistory.scala
+++ b/src/repl/scala/tools/nsc/interpreter/session/SimpleHistory.scala
@@ -8,7 +8,6 @@ package interpreter
 package session
 
 import scala.collection.mutable.{ Buffer, ListBuffer }
-import scala.collection.JavaConverters._
 
 class SimpleHistory extends History {
   private var _index: Int = 0
diff --git a/src/scaladoc/scala/tools/ant/Scaladoc.scala b/src/scaladoc/scala/tools/ant/Scaladoc.scala
index 034416e844..b38aadd328 100644
--- a/src/scaladoc/scala/tools/ant/Scaladoc.scala
+++ b/src/scaladoc/scala/tools/ant/Scaladoc.scala
@@ -6,7 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.tools.ant
 
 import java.io.File
@@ -15,9 +14,8 @@ import org.apache.tools.ant.Project
 import org.apache.tools.ant.types.{Path, Reference}
 import org.apache.tools.ant.util.{FileUtils, GlobPatternMapper}
 
-import scala.tools.nsc.Global
 import scala.tools.nsc.doc.Settings
-import scala.tools.nsc.reporters.{Reporter, ConsoleReporter}
+import scala.tools.nsc.reporters.ConsoleReporter
 
 /** An Ant task to document Scala code.
  *
diff --git a/src/scaladoc/scala/tools/nsc/ScalaDoc.scala b/src/scaladoc/scala/tools/nsc/ScalaDoc.scala
index 32a6ba0ce3..bd00c27f7b 100644
--- a/src/scaladoc/scala/tools/nsc/ScalaDoc.scala
+++ b/src/scaladoc/scala/tools/nsc/ScalaDoc.scala
@@ -6,7 +6,6 @@
 
 package scala.tools.nsc
 
-import java.io.File.pathSeparator
 import scala.tools.nsc.doc.DocFactory
 import scala.tools.nsc.reporters.ConsoleReporter
 import scala.reflect.internal.util.FakePos
diff --git a/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala b/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala
index cbf8ff22ba..8ea8c4deff 100644
--- a/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala
@@ -125,9 +125,9 @@ abstract class ScaladocSyntaxAnalyzer[G <: Global](val global: G) extends Syntax
       } else if (in.ch == '*') {
         docBuffer = null
         in.next
-        val scalaDoc = ("/**", "*/")
+        val scaladoc = ("/**", "*/")
         if (in.ch == '*')
-          docBuffer = new StringBuilder(scalaDoc._1)
+          docBuffer = new StringBuilder(scaladoc._1)
         do {
           do {
             if (in.ch != '*' && in.ch != SU) {
diff --git a/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala b/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala
index 4b40d25c17..10bfe6f94b 100644
--- a/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala
@@ -6,11 +6,7 @@
 package scala.tools.nsc
 package doc
 
-import scala.tools.nsc.ast.parser.{ SyntaxAnalyzer, BracePatch }
 import reporters.Reporter
-import typechecker.Analyzer
-import scala.reflect.internal.util.{ BatchSourceFile, RangePosition }
-
 
 trait ScaladocGlobalTrait extends Global {
   outer =>
diff --git a/src/scaladoc/scala/tools/nsc/doc/Settings.scala b/src/scaladoc/scala/tools/nsc/doc/Settings.scala
index 067b2b2c29..a63ed1abe8 100644
--- a/src/scaladoc/scala/tools/nsc/doc/Settings.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/Settings.scala
@@ -25,7 +25,7 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_))
   )
 
   /** A setting that defines the overall title of the documentation, typically the name of the library being
-    * documented. ''Note:'' This setting is currently not used. */
+    * documented. */
   val doctitle = StringSetting (
     "-doc-title",
     "title",
@@ -34,7 +34,7 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_))
   )
 
   /** A setting that defines the overall version number of the documentation, typically the version of the library being
-    * documented. ''Note:'' This setting is currently not used. */
+    * documented. */
   val docversion = StringSetting (
     "-doc-version",
     "version",
@@ -45,7 +45,7 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_))
   val docfooter = StringSetting (
     "-doc-footer",
     "footer",
-    "A footer on every ScalaDoc page, by default the EPFL/Typesafe copyright notice. Can be overridden with a custom footer.",
+    "A footer on every Scaladoc page, by default the EPFL/Typesafe copyright notice. Can be overridden with a custom footer.",
     ""
   )
 
@@ -212,9 +212,10 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_))
   // For improved help output.
   def scaladocSpecific = Set[Settings#Setting](
     docformat, doctitle, docfooter, docversion, docUncompilable, docsourceurl, docgenerator, docRootContent, useStupidTypes,
+    docExternalDoc,
     docAuthor, docDiagrams, docDiagramsDebug, docDiagramsDotPath,
     docDiagramsDotTimeout, docDiagramsDotRestart,
-    docImplicits, docImplicitsDebug, docImplicitsShowAll, docImplicitsHide,
+    docImplicits, docImplicitsDebug, docImplicitsShowAll, docImplicitsHide, docImplicitsSoundShadowing,
     docDiagramsMaxNormalClasses, docDiagramsMaxImplicitClasses,
     docNoPrefixes, docNoLinkWarnings, docRawOutput, docSkipPackages,
     docExpandAllTypes, docGroups
@@ -275,24 +276,36 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_))
       ("scala.reflect.ClassManifest"            -> ((tparam: String) => tparam + " is accompanied by a ClassManifest, which is a runtime representation of its type that survives erasure")) +
       ("scala.reflect.OptManifest"              -> ((tparam: String) => tparam + " is accompanied by an OptManifest, which can be either a runtime representation of its type or the NoManifest, which means the runtime type is not available")) +
       ("scala.reflect.ClassTag"                 -> ((tparam: String) => tparam + " is accompanied by a ClassTag, which is a runtime representation of its type that survives erasure")) +
-      ("scala.reflect.api.TypeTags.WeakTypeTag" -> ((tparam: String) => tparam + " is accompanied by an WeakTypeTag, which is a runtime representation of its type that survives erasure")) +
+      ("scala.reflect.api.TypeTags.WeakTypeTag" -> ((tparam: String) => tparam + " is accompanied by a WeakTypeTag, which is a runtime representation of its type that survives erasure")) +
       ("scala.reflect.api.TypeTags.TypeTag"     -> ((tparam: String) => tparam + " is accompanied by a TypeTag, which is a runtime representation of its type that survives erasure"))
 
+    private val excludedClassnamePatterns = Set(
+      """^scala.Tuple.*""",
+      """^scala.Product.*""",
+      """^scala.Function.*""",
+      """^scala.runtime.AbstractFunction.*"""
+    ) map (_.r)
+
+    private val notExcludedClasses = Set(
+      "scala.Tuple1",
+      "scala.Tuple2",
+      "scala.Product",
+      "scala.Product1",
+      "scala.Product2",
+      "scala.Function",
+      "scala.Function1",
+      "scala.Function2",
+      "scala.runtime.AbstractFunction0",
+      "scala.runtime.AbstractFunction1",
+      "scala.runtime.AbstractFunction2"
+    )
+
     /**
      * Set of classes to exclude from index and diagrams
      * TODO: Should be configurable
      */
     def isExcluded(qname: String) = {
-      ( ( qname.startsWith("scala.Tuple") || qname.startsWith("scala.Product") ||
-         qname.startsWith("scala.Function") || qname.startsWith("scala.runtime.AbstractFunction")
-       ) && !(
-        qname == "scala.Tuple1" || qname == "scala.Tuple2" ||
-        qname == "scala.Product" || qname == "scala.Product1" || qname == "scala.Product2" ||
-        qname == "scala.Function" || qname == "scala.Function1" || qname == "scala.Function2" ||
-        qname == "scala.runtime.AbstractFunction0" || qname == "scala.runtime.AbstractFunction1" ||
-        qname == "scala.runtime.AbstractFunction2"
-      )
-     )
+      excludedClassnamePatterns.exists(_.findFirstMatchIn(qname).isDefined) && !notExcludedClasses(qname)
     }
 
     /** Common conversion targets that affect any class in Scala */
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala b/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala
index 8313d842e5..9086ee29c6 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/html/HtmlFactory.scala
@@ -25,10 +25,30 @@ class HtmlFactory(val universe: doc.Universe, index: doc.Index) {
   def siteRoot: JFile = new JFile(universe.settings.outdir.value)
 
   def libResources = List(
+    "class.svg",
+    "object.svg",
+    "trait.svg",
+    "package.svg",
+    "class_comp.svg",
+    "object_comp.svg",
+    "trait_comp.svg",
+    "permalink.svg",
+    "abstract_type.svg",
+    "lato-v11-latin-regular.eot",
+    "lato-v11-latin-regular.ttf",
+    "lato-v11-latin-regular.woff",
+    "open-sans-v13-latin-regular.eot",
+    "open-sans-v13-latin-regular.ttf",
+    "open-sans-v13-latin-regular.woff",
+    "source-code-pro-v6-latin-700.eot",
+    "source-code-pro-v6-latin-700.ttf",
+    "source-code-pro-v6-latin-700.woff",
+    "source-code-pro-v6-latin-regular.eot",
+    "source-code-pro-v6-latin-regular.ttf",
+    "source-code-pro-v6-latin-regular.woff",
+
     "index.js",
-    "jquery-ui.js",
     "jquery.js",
-    "jquery.layout.js",
     "scheduler.js",
     "diagrams.js",
     "template.js",
@@ -40,64 +60,14 @@ class HtmlFactory(val universe: doc.Universe, index: doc.Index) {
     "template.css",
     "diagrams.css",
 
-    "class.png",
-    "class_big.png",
     "class_diagram.png",
-    "object.png",
-    "object_big.png",
     "object_diagram.png",
-    "package.png",
-    "package_big.png",
-    "trait.png",
-    "trait_big.png",
     "trait_diagram.png",
-    "type.png",
-    "type_big.png",
     "type_diagram.png",
 
-    "class_to_object_big.png",
-    "object_to_class_big.png",
-    "trait_to_object_big.png",
-    "object_to_trait_big.png",
-    "type_to_object_big.png",
-    "object_to_type_big.png",
-
-    "arrow-down.png",
-    "arrow-right.png",
-    "filter_box_left.png",
-    "filter_box_left2.gif",
-    "filter_box_right.png",
-    "filterbg.gif",
-    "filterboxbarbg.gif",
-    "filterboxbg.gif",
-
-    "constructorsbg.gif",
-    "defbg-blue.gif",
-    "defbg-green.gif",
-    "filterboxbarbg.png",
-    "fullcommenttopbg.gif",
     "ownderbg2.gif",
     "ownerbg.gif",
-    "ownerbg2.gif",
-    "packagesbg.gif",
-    "signaturebg.gif",
-    "signaturebg2.gif",
-    "typebg.gif",
-    "conversionbg.gif",
-    "valuemembersbg.gif",
-
-    "navigation-li-a.png",
-    "navigation-li.png",
-    "remove.png",
-    "selected-right.png",
-    "selected.png",
-    "selected2-right.png",
-    "selected2.png",
-    "selected-right-implicits.png",
-    "selected-implicits.png",
-    "unselected.png",
-
-    "permalink.png"
+    "ownerbg2.gif"
   )
 
   /** Generates the Scaladoc site for a model into the site root.
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/HtmlPage.scala b/src/scaladoc/scala/tools/nsc/doc/html/HtmlPage.scala
index 6cdd99c9ee..16a2fc59d4 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/HtmlPage.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/html/HtmlPage.scala
@@ -15,7 +15,7 @@ import model._
 
 import scala.xml.NodeSeq
 import scala.xml.Elem
-import scala.xml.dtd.{DocType, PublicID}
+import scala.xml.dtd.DocType
 import scala.collection._
 import java.io.Writer
 
@@ -47,6 +47,8 @@ abstract class HtmlPage extends Page { thisPage =>
     val html =
       <html>
         <head>
+          <meta http-equiv="X-UA-Compatible" content="IE=edge"/>
+          <meta name="viewport" content="width=device-width, initial-scale=1"/>
           <title>{ title }</title>
           <meta name="description" content={ description }/>
           <meta name="keywords" content={ keywords }/>
@@ -242,13 +244,13 @@ abstract class HtmlPage extends Page { thisPage =>
   def permalink(template: Entity, isSelf: Boolean = true): Elem =
     <span class="permalink">
       <a href={ memberToUrl(template, isSelf) } title="Permalink" target="_top">
-        <img src={ relativeLinkTo(List("permalink.png", "lib")) } alt="Permalink" />
+        <img src={ relativeLinkTo(List("permalink.svg", "lib")) } alt="Permalink" />
       </a>
     </span>
-	
-  def docEntityKindToCompanionTitle(ety: DocTemplateEntity, baseString: String = "See companion") = 
+
+  def docEntityKindToCompanionTitle(ety: DocTemplateEntity, baseString: String = "See companion") =
     ety.companion match{
-	  case Some(companion) => 
+          case Some(companion) =>
 	    s"$baseString${
 		if(companion.isObject) " object"
 		else if(companion.isTrait) " trait"
@@ -269,7 +271,8 @@ abstract class HtmlPage extends Page { thisPage =>
           <div>
             Related Docs:
             <a href={relativeLinkTo(tpl.companion.get)} title={docEntityKindToCompanionTitle(tpl)}>{objClassTrait}</a>
-            | {templateToHtml(tpl.inTemplate, s"package ${tpl.inTemplate.name}")}
+            <span class="divider">|</span>
+            {templateToHtml(tpl.inTemplate, s"package ${tpl.inTemplate.name}")}
           </div>
         case None =>
           <div>Related Doc:
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/SyntaxHigh.scala b/src/scaladoc/scala/tools/nsc/doc/html/SyntaxHigh.scala
index 9ab3999447..640fda560e 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/SyntaxHigh.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/html/SyntaxHigh.scala
@@ -26,7 +26,7 @@ private[html] object SyntaxHigh {
     "new", "null", "object", "override", "package",
     "private", "protected", "return", "sealed", "super",
     "this", "throw", "trait", "true", "try", "type",
-    "val", "var", "while", "with", "yield")
+    "val", "var", "while", "with", "yield").sorted
 
   /** Annotations, sorted alphabetically */
   val annotations = Array(
@@ -38,18 +38,18 @@ private[html] object SyntaxHigh {
     "remote", "setter", "specialized", "strictfp", "switch",
     "tailrec", "throws", "transient",
     "unchecked", "uncheckedStable", "uncheckedVariance",
-    "varargs", "volatile")
+    "varargs", "volatile").sorted
 
   /** Standard library classes/objects, sorted alphabetically */
-  val standards = Array (
-    "WeakTypeTag", "Any", "AnyRef", "AnyVal", "App", "Array",
-    "Boolean", "Byte", "Char", "Class", "ClassTag", "ClassManifest",
+  val standards = Array(
+    "Any", "AnyRef", "AnyVal", "App", "Array",
+    "Boolean", "Byte", "Char", "Class", "ClassManifest", "ClassTag",
     "Console", "Double", "Enumeration", "Float", "Function", "Int",
     "List", "Long", "Manifest", "Map",
     "NoManifest", "None", "Nothing", "Null", "Object", "Option", "OptManifest",
     "Pair", "Predef",
     "Seq", "Set", "Short", "Some", "String", "Symbol",
-    "Triple", "TypeTag", "Unit")
+    "Triple", "TypeTag", "Unit", "WeakTypeTag").sorted
 
   def apply(data: String): NodeSeq = {
     val buf = data.toCharArray
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala
index 6bfe480e33..1aa1241847 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/html/page/Index.scala
@@ -26,20 +26,12 @@ class Index(universe: doc.Universe, val index: doc.Index) extends HtmlPage {
     <xml:group>
       <link href={ relativeLinkTo{List("index.css", "lib")} }  media="screen" type="text/css" rel="stylesheet"/>
       <script type="text/javascript" src={ relativeLinkTo{List("jquery.js", "lib")} }></script>
-      <script type="text/javascript" src={ relativeLinkTo{List("jquery-ui.js", "lib")} }></script>
-      <script type="text/javascript" src={ relativeLinkTo{List("jquery.layout.js", "lib")} }></script>
       <script type="text/javascript" src={ relativeLinkTo{List("index.js", "lib")} }></script>
       <script type="text/javascript" src={ relativeLinkTo{List("scheduler.js", "lib")} }></script>
     </xml:group>
 
   val body =
     <body>
-      <div id="library">
-        <img class='class icon' alt='class icon' src={ relativeLinkTo{List("class.png", "lib")} }/>
-        <img class='trait icon' alt='trait icon' src={ relativeLinkTo{List("trait.png", "lib")} }/>
-        <img class='object icon' alt='trait icon' src={ relativeLinkTo{List("object.png", "lib")} }/>
-        <img class='package icon' alt='trait icon' src={ relativeLinkTo{List("package.png", "lib")} }/>
-      </div>
       { browser }
       <div id="content" class="ui-layout-center">
         <iframe id="template" name="template" src={ relativeLinkTo{List("package.html")} }/>
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala
index 0353e58e67..e0cfbc9334 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala
@@ -13,11 +13,9 @@ package page
 import base._
 import base.comment._
 
-import model._
-import model.diagram._
-import scala.xml.{Elem, NodeSeq, Text, UnprefixedAttribute}
+import scala.collection.mutable
+import scala.xml.{NodeSeq, Text, UnprefixedAttribute}
 import scala.language.postfixOps
-import scala.collection.mutable. { Set, HashSet }
 
 import model._
 import model.diagram._
@@ -42,7 +40,6 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp
       <link href={ relativeLinkTo{List("template.css", "lib")} } media="screen" type="text/css" rel="stylesheet"/>
       <link href={ relativeLinkTo{List("diagrams.css", "lib")} } media="screen" type="text/css" rel="stylesheet" id="diagrams-css" />
       <script type="text/javascript" src={ relativeLinkTo{List("jquery.js", "lib")} } id="jquery-js"></script>
-      <script type="text/javascript" src={ relativeLinkTo{List("jquery-ui.js", "lib")} }></script>
       <script type="text/javascript" src={ relativeLinkTo{List("template.js", "lib")} }></script>
       <script type="text/javascript" src={ relativeLinkTo{List("tools.tooltip.js", "lib")} }></script>
       { if (universe.settings.docDiagrams.value) {
@@ -100,16 +97,18 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp
         <p id="owner">{ templatesToHtml(tpl.inTemplate.toRoot.reverse.tail, scala.xml.Text(".")) }</p>
     }
 
-    <body class={ if (tpl.isType) "type" else "value" }>
+    <body class={ tpl.kind + (if (tpl.isType) " type" else " value") }>
       <div id="definition">
         {
           val (src, alt) = docEntityKindToBigImage(tpl)
 
+          val identifier = alt.toString.substring(0,2).toLowerCase
+
           tpl.companion match {
             case Some(companion) if (companion.visibility.isPublic && companion.inSource != None) =>
-              <a href={relativeLinkTo(companion)} title={docEntityKindToCompanionTitle(tpl)}><img alt={alt} src={ relativeLinkTo(List(src, "lib")) }/></a>
+              <a href={relativeLinkTo(companion)} title={docEntityKindToCompanionTitle(tpl)}><div class={s"big-circle companion $identifier"}>{ identifier.substring(0,1) }</div></a>
             case _ =>
-              <img alt={alt} src={ relativeLinkTo(List(src, "lib")) }/>
+              <div class={ "big-circle " + alt.toString.toLowerCase }>{ identifier.substring(0,1) }</div>
         }}
         { owner }
         <h1>{ displayName }</h1>{
@@ -121,70 +120,73 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp
       { memberToCommentHtml(tpl, tpl.inTemplate, isSelf = true) }
 
       <div id="mbrsel">
-        <div id='textfilter'><span class='pre'/><span class='input'><input id='mbrsel-input' type='text' accesskey='/'/></span><span class='post'/></div>
-        { if (tpl.linearizationTemplates.isEmpty && tpl.conversions.isEmpty && (!universe.settings.docGroups.value || (tpl.members.map(_.group).distinct.length == 1)))
-            NodeSeq.Empty
-          else
-            <div id="order">
-              <span class="filtertype">Ordering</span>
+        <div class='toggle'></div>
+        <div id='textfilter'><span class='input'><input id='mbrsel-input' placeholder='Filter members' type='text' accesskey='/'/></span><span class='clear'>✖</span></div>
+          <div id='filterby'>
+          { if (tpl.linearizationTemplates.isEmpty && tpl.conversions.isEmpty && (!universe.settings.docGroups.value || (tpl.members.map(_.group).distinct.length == 1)))
+              NodeSeq.Empty
+            else
+              <div id="order">
+                <span class="filtertype">Ordering</span>
+                <ol>
+                  {
+                    if (!universe.settings.docGroups.value || (tpl.members.map(_.group).distinct.length == 1))
+                      NodeSeq.Empty
+                    else
+                      <li class="group out"><span>Grouped</span></li>
+                  }
+                  <li class="alpha in"><span>Alphabetic</span></li>
+                  {
+                    if (tpl.linearizationTemplates.isEmpty && tpl.conversions.isEmpty)
+                      NodeSeq.Empty
+                    else
+                      <li class="inherit out"><span>By inheritance</span></li>
+                  }
+                </ol>
+              </div>
+          }
+          { if (tpl.linearizationTemplates.isEmpty && tpl.conversions.isEmpty) NodeSeq.Empty else
+            {
+              if (!tpl.linearizationTemplates.isEmpty)
+                <div class="ancestors">
+                  <span class="filtertype">Inherited<br/>
+                  </span>
+                  <ol id="linearization">
+                    { (tpl :: tpl.linearizationTemplates).map(wte => <li class="in" name={ wte.qualifiedName }><span>{ wte.name }</span></li>) }
+                  </ol>
+                </div>
+              else NodeSeq.Empty
+            } ++ {
+              if (!tpl.conversions.isEmpty)
+                <div class="ancestors">
+                  <span class="filtertype">Implicitly<br/>
+                  </span>
+                  <ol id="implicits"> {
+                    tpl.conversions.map { conv =>
+                      val name = conv.conversionQualifiedName
+                      val hide = universe.settings.hiddenImplicits(name)
+                      <li class="in" name={ name } data-hidden={ hide.toString }><span>{ "by " + conv.conversionShortName }</span></li>
+                    }
+                  }
+                  </ol>
+                </div>
+              else NodeSeq.Empty
+            } ++
+            <div class="ancestors">
+              <span class="filtertype"></span>
               <ol>
-                {
-                  if (!universe.settings.docGroups.value || (tpl.members.map(_.group).distinct.length == 1))
-                    NodeSeq.Empty
-                  else
-                    <li class="group out"><span>Grouped</span></li>
-                }
-                <li class="alpha in"><span>Alphabetic</span></li>
-                {
-                  if (tpl.linearizationTemplates.isEmpty && tpl.conversions.isEmpty)
-                    NodeSeq.Empty
-                  else
-                    <li class="inherit out"><span>By inheritance</span></li>
-                }
+                <li class="hideall out"><span>Hide All</span></li>
+                <li class="showall in"><span>Show all</span></li>
               </ol>
             </div>
-        }
-        { if (tpl.linearizationTemplates.isEmpty && tpl.conversions.isEmpty) NodeSeq.Empty else
+          }
           {
-            if (!tpl.linearizationTemplates.isEmpty)
-              <div class="ancestors">
-                <span class="filtertype">Inherited<br/>
-                </span>
-                <ol id="linearization">
-                  { (tpl :: tpl.linearizationTemplates).map(wte => <li class="in" name={ wte.qualifiedName }><span>{ wte.name }</span></li>) }
-                </ol>
-              </div>
-            else NodeSeq.Empty
-          } ++ {
-            if (!tpl.conversions.isEmpty)
-              <div class="ancestors">
-                <span class="filtertype">Implicitly<br/>
-                </span>
-                <ol id="implicits"> {
-                  tpl.conversions.map { conv =>
-                    val name = conv.conversionQualifiedName
-                    val hide = universe.settings.hiddenImplicits(name)
-                    <li class="in" name={ name } data-hidden={ hide.toString }><span>{ "by " + conv.conversionShortName }</span></li>
-                  }
-                }
-                </ol>
-              </div>
-            else NodeSeq.Empty
-          } ++
-          <div class="ancestors">
-            <span class="filtertype"></span>
-            <ol>
-              <li class="hideall out"><span>Hide All</span></li>
-              <li class="showall in"><span>Show all</span></li>
-            </ol>
-          </div>
-        }
-        {
-          <div id="visbl">
-            <span class="filtertype">Visibility</span>
-            <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol>
-          </div>
-        }
+            <div id="visbl">
+              <span class="filtertype">Visibility</span>
+              <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol>
+            </div>
+          }
+        </div>
       </div>
 
       <div id="template">
@@ -284,8 +286,6 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp
         else
           <div id="footer"> { tpl.universe.settings.docfooter.value } </div>
       }
-
-
     </body>
   }
 
@@ -654,7 +654,7 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp
 
     val subclasses = mbr match {
       case dtpl: DocTemplateEntity if isSelf && !isReduced =>
-        val subs: Set[DocTemplateEntity] = HashSet.empty
+        val subs = mutable.HashSet.empty[DocTemplateEntity]
         def transitive(dtpl: DocTemplateEntity) {
           for (sub <- dtpl.directSubClasses if !(subs contains sub)) {
             subs add sub
@@ -666,7 +666,7 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp
           <div class="toggleContainer block">
             <span class="toggle">Known Subclasses</span>
             <div class="subClasses hiddenContent">{
-              templatesToHtml(subs.toList.sortBy(_.name), scala.xml.Text(", "))
+              templatesToHtml(subs.toList.sorted(Entity.EntityOrdering), scala.xml.Text(", "))
             }</div>
           </div>
         else NodeSeq.Empty
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DiagramGenerator.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DiagramGenerator.scala
index cf65de4151..829bba3f32 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DiagramGenerator.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DiagramGenerator.scala
@@ -23,5 +23,5 @@ trait DiagramGenerator {
    * @param p   The page the diagram will be embedded in (needed for link generation)
    * @return    The HTML to be embedded in the Scaladoc page
    */
-  def generate(d: Diagram, t: DocTemplateEntity, p: HtmlPage):NodeSeq
+  def generate(d: Diagram, t: DocTemplateEntity, p: HtmlPage): NodeSeq
 }
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala
index 4c0ba32856..2deb669ea9 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala
@@ -10,7 +10,7 @@ package html
 package page
 package diagram
 
-import scala.xml.{NodeSeq, XML, PrefixedAttribute, Elem, MetaData, Null, UnprefixedAttribute}
+import scala.xml.{NodeSeq, PrefixedAttribute, Elem, Null, UnprefixedAttribute}
 import scala.collection.immutable._
 import model._
 import model.diagram._
@@ -246,15 +246,12 @@ class DotDiagramGenerator(settings: doc.Settings, dotRunner: DotRunner) extends
 
     // HTML label
     var name = escape(node.name)
-    var img = ""
-    if(node.isTraitNode)
-      img = "trait_diagram.png"
-    else if(node.isClassNode)
-      img = "class_diagram.png"
-    else if(node.isObjectNode)
-      img = "object_diagram.png"
-    else if(node.isTypeNode)
-      img = "type_diagram.png"
+    var img =
+      if(node.isTraitNode) "trait_diagram.png"
+      else if(node.isClassNode) "class_diagram.png"
+      else if(node.isObjectNode) "object_diagram.png"
+      else if(node.isTypeNode) "type_diagram.png"
+      else ""
 
     if(!img.equals("")) {
       img = "<TD><IMG SCALE=\"TRUE\" SRC=\"" + settings.outdir.value + "/lib/" + img + "\" /></TD>"
@@ -439,22 +436,22 @@ class DotDiagramGenerator(settings: doc.Settings, dotRunner: DotRunner) extends
   )
 
   private val nodeAttributes = Map(
-    "shape" -> "rectangle",
-    "style" -> "filled",
+    "shape" -> "rect",
+    "style" -> "filled,rounded",
     "penwidth" -> "1",
     "margin" -> "0.08,0.01",
     "width" -> "0.0",
     "height" -> "0.0",
-    "fontname" -> "Arial",
-    "fontsize" -> "10.00"
+    "fontname" -> "Source Code Pro",
+    "fontsize" -> "8.00"
   )
 
   private val edgeAttributes = Map(
     "color" -> "#d4d4d4",
-    "arrowsize" -> "0.5",
+    "arrowsize" -> "0.7",
     "fontcolor" -> "#aaaaaa",
-    "fontsize" -> "10.00",
-    "fontname" -> "Arial"
+    "fontsize" -> "9.00",
+    "fontname" -> "Source Code Pro"
   )
 
   private val defaultStyle = Map(
@@ -477,26 +474,26 @@ class DotDiagramGenerator(settings: doc.Settings, dotRunner: DotRunner) extends
   )
 
   private val traitStyle = Map(
-    "color" -> "#37657D",
-    "fillcolor" -> "#498AAD",
+    "color" -> "#2E6D82",
+    "fillcolor" -> "#2E6D82",
     "fontcolor" -> "#ffffff"
   )
 
   private val classStyle = Map(
-    "color" -> "#115F3B",
-    "fillcolor" -> "#0A955B",
+    "color" -> "#418565",
+    "fillcolor" -> "#418565",
     "fontcolor" -> "#ffffff"
   )
 
   private val objectStyle = Map(
-    "color" -> "#102966",
-    "fillcolor" -> "#3556a7",
+    "color" -> "#103A51",
+    "fillcolor" -> "#103A51",
     "fontcolor" -> "#ffffff"
   )
 
   private val typeStyle = Map(
-    "color" -> "#115F3B",
-    "fillcolor" -> "#0A955B",
+    "color" -> "#2E6D82",
+    "fillcolor" -> "#2E6D82",
     "fontcolor" -> "#ffffff"
   )
 
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotRunner.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotRunner.scala
index 9381cf3a35..9287bfbc2b 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotRunner.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotRunner.scala
@@ -18,16 +18,16 @@ import model._
 /** This class takes care of running the graphviz dot utility */
 class DotRunner(settings: doc.Settings) {
 
-  private[this] var dotRestarts = 0
+  private[this] var dotAttempts = 0
   private[this] var dotProcess: DotProcess  = null
 
   def feedToDot(dotInput: String, template: DocTemplateEntity): String = {
 
     if (dotProcess == null) {
-      if (dotRestarts < settings.docDiagramsDotRestart.value) {
-        if (dotRestarts != 0)
+      if (dotAttempts < settings.docDiagramsDotRestart.value + 1) {
+        if (dotAttempts > 0)
           settings.printMsg("Graphviz will be restarted...\n")
-        dotRestarts += 1
+        dotAttempts += 1
         dotProcess = new DotProcess(settings)
       } else
         return null
@@ -41,7 +41,7 @@ class DotRunner(settings: doc.Settings) {
     if (result == null) {
       dotProcess.cleanup()
       dotProcess = null
-      if (dotRestarts == settings.docDiagramsDotRestart.value) {
+      if (dotAttempts == 1 + settings.docDiagramsDotRestart.value) {
         settings.printMsg("\n")
         settings.printMsg("**********************************************************************")
         settings.printMsg("Diagrams will be disabled for this run because the graphviz dot tool")
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/abstract_type.svg b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/abstract_type.svg
new file mode 100644
index 0000000000..8a820529df
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/abstract_type.svg
@@ -0,0 +1,54 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="72px" height="72px" viewBox="0 0 72 72" version="1.1">
+  <defs>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-1">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+    <circle id="path-2" cx="32" cy="32" r="32"/>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-4">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feOffset dx="0" dy="1" in="SourceAlpha" result="shadowOffsetInner1"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner1" result="shadowBlurInner1"/>
+      <feComposite in="shadowBlurInner1" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner1"/>
+      <feColorMatrix values="0 0 0 0 1   0 0 0 0 1   0 0 0 0 1  0 0 0 0.14 0" in="shadowInnerInner1" type="matrix" result="shadowMatrixInner1"/>
+      <feOffset dx="0" dy="-1" in="SourceAlpha" result="shadowOffsetInner2"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner2" result="shadowBlurInner2"/>
+      <feComposite in="shadowBlurInner2" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner2"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowInnerInner2" type="matrix" result="shadowMatrixInner2"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+        <feMergeNode in="shadowMatrixInner1"/>
+        <feMergeNode in="shadowMatrixInner2"/>
+      </feMerge>
+    </filter>
+    <path id="path-5" d="M32 61C49.673112 61 64 48.0162577 64 32 64 15.9837423 49.673112 3 32 3 14.326888 3 0 15.9837423 0 32 0 48.0162577 14.326888 61 32 61Z"/>
+  </defs>
+  <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+    <g id="Artboard-1" transform="translate(-298.000000, -91.000000)">
+      <g id="BG" transform="translate(302.000000, 91.000000)">
+        <g id="Icon">
+          <mask id="mask-3" fill="white">
+            <use xlink:href="#path-2"/>
+          </mask>
+          <use id="Mask" fill="#6C7A89" filter="url(#filter-1)" xlink:href="#path-2"/>
+          <mask id="mask-6" fill="white">
+            <use xlink:href="#path-5"/>
+          </mask>
+          <text id="a" mask="url(#mask-6)" font-family="Open Sans, Helvetica Neueu, Sans-serif" font-size="40" font-weight="normal" fill="#FFFFFF">
+            <tspan x="21" y="43">
+              a
+            </tspan>
+          </text>
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/arrow-down.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/arrow-down.png
deleted file mode 100644
index 7229603ae5..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/arrow-down.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/arrow-right.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/arrow-right.png
deleted file mode 100644
index b2f2935dc9..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/arrow-right.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class.png
deleted file mode 100644
index 97edbd49db..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class.svg b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class.svg
new file mode 100644
index 0000000000..128f74d1ce
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class.svg
@@ -0,0 +1,54 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="72px" height="72px" viewBox="0 0 72 72" version="1.1">
+  <defs>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-1">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+    <circle id="path-2" cx="32" cy="32" r="32"/>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-4">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feOffset dx="0" dy="1" in="SourceAlpha" result="shadowOffsetInner1"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner1" result="shadowBlurInner1"/>
+      <feComposite in="shadowBlurInner1" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner1"/>
+      <feColorMatrix values="0 0 0 0 1   0 0 0 0 1   0 0 0 0 1  0 0 0 0.14 0" in="shadowInnerInner1" type="matrix" result="shadowMatrixInner1"/>
+      <feOffset dx="0" dy="-1" in="SourceAlpha" result="shadowOffsetInner2"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner2" result="shadowBlurInner2"/>
+      <feComposite in="shadowBlurInner2" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner2"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowInnerInner2" type="matrix" result="shadowMatrixInner2"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+        <feMergeNode in="shadowMatrixInner1"/>
+        <feMergeNode in="shadowMatrixInner2"/>
+      </feMerge>
+    </filter>
+    <path id="path-5" d="M32 61C49.673112 61 64 48.0162577 64 32 64 15.9837423 49.673112 3 32 3 14.326888 3 0 15.9837423 0 32 0 48.0162577 14.326888 61 32 61Z"/>
+  </defs>
+  <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+    <g id="Artboard-1" transform="translate(-298.000000, -91.000000)">
+      <g id="BG" transform="translate(302.000000, 91.000000)">
+        <g id="Icon">
+          <mask id="mask-3" fill="white">
+            <use xlink:href="#path-2"/>
+          </mask>
+          <use id="Mask" fill="#44AD7D" filter="url(#filter-1)" xlink:href="#path-2"/>
+          <mask id="mask-6" fill="white">
+            <use xlink:href="#path-5"/>
+          </mask>
+          <text id="C" mask="url(#mask-6)" font-family="Open Sans, Helvetica Neueu, Sans-serif" font-size="40" font-weight="normal" fill="#FFFFFF">
+            <tspan x="17" y="47">
+              C
+            </tspan>
+          </text>
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class_big.png
deleted file mode 100644
index cb1f638a58..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class_comp.svg b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class_comp.svg
new file mode 100644
index 0000000000..b457207be1
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class_comp.svg
@@ -0,0 +1,57 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="72px" height="72px" viewBox="0 0 72 72" version="1.1">
+  <defs>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-1">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+    <circle id="path-2" cx="32" cy="32" r="32"/>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-4">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feOffset dx="0" dy="1" in="SourceAlpha" result="shadowOffsetInner1"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner1" result="shadowBlurInner1"/>
+      <feComposite in="shadowBlurInner1" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner1"/>
+      <feColorMatrix values="0 0 0 0 1   0 0 0 0 1   0 0 0 0 1  0 0 0 0.14 0" in="shadowInnerInner1" type="matrix" result="shadowMatrixInner1"/>
+      <feOffset dx="0" dy="-1" in="SourceAlpha" result="shadowOffsetInner2"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner2" result="shadowBlurInner2"/>
+      <feComposite in="shadowBlurInner2" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner2"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowInnerInner2" type="matrix" result="shadowMatrixInner2"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+        <feMergeNode in="shadowMatrixInner1"/>
+        <feMergeNode in="shadowMatrixInner2"/>
+      </feMerge>
+    </filter>
+    <path id="path-5" d="M32 61C49.673112 61 64 48.0162577 64 32 64 15.9837423 49.673112 3 32 3 14.326888 3 0 15.9837423 0 32 0 48.0162577 14.326888 61 32 61Z"/>
+  </defs>
+  <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+    <g id="Artboard-1" transform="translate(-298.000000, -91.000000)">
+      <g id="BG" transform="translate(302.000000, 91.000000)">
+        <g id="Icon">
+          <mask id="mask-3" fill="white">
+            <use xlink:href="#path-2"/>
+          </mask>
+          <use id="Mask" fill="#2C6C8D" filter="url(#filter-1)" xlink:href="#path-2"/>
+          <rect id="Rectangle-2" opacity="0.3" fill="#000000" mask="url(#mask-3)" x="-8" y="33" width="80" height="31"/>
+          <mask id="mask-6" fill="white">
+            <use xlink:href="#path-5"/>
+          </mask>
+          <use id="Mask" fill="#44AD7D" filter="url(#filter-4)" xlink:href="#path-5"/>
+          <text id="C" mask="url(#mask-6)" font-family="Open Sans, Helvetica Neueu, Sans-serif" font-size="40" font-weight="normal" fill="#FFFFFF">
+            <tspan x="17" y="47">
+              C
+            </tspan>
+          </text>
+          <rect id="Rectangle-2" opacity="0.190065299" fill="#000000" mask="url(#mask-6)" x="-8" y="2" width="80" height="31"/>
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class_to_object_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class_to_object_big.png
deleted file mode 100644
index 5dd6e38d2e..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/class_to_object_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/constructorsbg.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/constructorsbg.gif
deleted file mode 100644
index 2e3f5ea530..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/constructorsbg.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/conversionbg.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/conversionbg.gif
deleted file mode 100644
index 4be145d0af..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/conversionbg.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/defbg-blue.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/defbg-blue.gif
deleted file mode 100644
index 69038337a7..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/defbg-blue.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/defbg-green.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/defbg-green.gif
deleted file mode 100644
index 36c43be3a2..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/defbg-green.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/diagrams.css b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/diagrams.css
index 5fe33f72f5..22736a04dd 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/diagrams.css
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/diagrams.css
@@ -1,143 +1,113 @@
-.diagram-container
-{
-	display: none;
+.diagram-container {
+  display: none;
 }
 
-.diagram
-{
-	overflow: hidden;
-	padding-top:15px;
+.diagram {
+  overflow: hidden;
+  padding-top:15px;
 }
 
-.diagram svg
-{
-	display: block;
-	position: absolute;
-	visibility: hidden;
-	margin: auto;
+.diagram svg {
+  display: block;
+  position: absolute;
+  visibility: hidden;
+  margin: auto;
 }
 
-.diagram-help
-{
-	float:right;
-	display:none;
+.diagram-help {
+  float:right;
+  display:none;
 }
 
-.magnifying
-{
-	cursor: -webkit-zoom-in ! important;
-	cursor: -moz-zoom-in ! important;
-	cursor: pointer;
+.magnifying {
+  cursor: -webkit-zoom-in ! important;
+  cursor: -moz-zoom-in ! important;
+  cursor: pointer;
 }
 
-#close-link
-{
-	position: absolute;
-	z-index: 100;
-	font-family: Arial, sans-serif;
-	font-size: 10pt;
-	text-decoration: underline;
-	color: #315479;
+#close-link {
+  position: absolute;
+  z-index: 100;
+  font-family: Arial, sans-serif;
+  font-size: 10pt;
+  text-decoration: underline;
+  color: #315479;
 }
 
-#close:hover
-{
-	text-decoration: none;
+#close:hover {
+  text-decoration: none;
 }
 
-svg a
-{
-	cursor:pointer;
+svg a {
+  cursor:pointer;
 }
 
-svg text
-{
-	font-size: 10px;
+svg text {
+  font-size: 8.5px;
 }
 
 /* try to move the node text 1px in order to be vertically
-   centered (does not work in all browsers) */
-svg .node text
-{
-	transform: translate(0px,1px);
-	-ms-transform: translate(0px,1px);
-	-webkit-transform: translate(0px,1px);
-	-o-transform: translate(0px,1px);
-	-moz-transform: translate(0px,1px);
+ * centered (does not work in all browsers)
+ */
+svg .node text {
+  transform: translate(0px,1px);
+  -ms-transform: translate(0px,1px);
+  -webkit-transform: translate(0px,1px);
+  -o-transform: translate(0px,1px);
+  -moz-transform: translate(0px,1px);
 }
 
 /* hover effect for edges */
 
 svg .edge.over text,
 svg .edge.implicit-incoming.over polygon,
-svg .edge.implicit-outgoing.over polygon
-{
-	fill: #202020;
+svg .edge.implicit-outgoing.over polygon {
+  fill: #103A51;
 }
 
 svg .edge.over path,
-svg .edge.over polygon
-{
-	stroke: #202020;
+svg .edge.over polygon {
+  stroke: #103A51;
 }
 
-/* hover effect for nodes in class diagrams */
+/* for hover effect on nodes in diagrams, edit the following */
+svg.class-diagram .node {}
+svg.class-diagram .node.this {}
+svg.class-diagram .node.over {}
 
-svg.class-diagram .node
-{
-	opacity: 0.75;
-}
-
-svg.class-diagram .node.this
-{
-	opacity: 1.0;
-}
-
-svg.class-diagram .node.over
-{
-	opacity: 1.0;
-}
-
-svg .node.over polygon
-{
-	stroke: #202020;
+svg .node.over polygon {
+  stroke: #202020;
 }
 
 /* hover effect for nodes in package diagrams */
 
 svg.package-diagram .node.class.over polygon,
-svg.class-diagram .node.this.class.over polygon
-{
-	fill: #098552;
-	fill: #04663e;
+svg.class-diagram .node.this.class.over polygon {
+  fill: #098552;
+  fill: #04663e;
 }
 
 svg.package-diagram .node.trait.over polygon,
-svg.class-diagram .node.this.trait.over polygon
-{
-	fill: #3c7b9b;
-	fill: #235d7b;
+svg.class-diagram .node.this.trait.over polygon {
+  fill: #3c7b9b;
+  fill: #235d7b;
 }
 
 svg.package-diagram .node.type.over polygon,
-svg.class-diagram .node.this.type.over polygon
-{
-	fill: #098552;
-	fill: #04663e;
+svg.class-diagram .node.this.type.over polygon {
+  fill: #098552;
+  fill: #04663e;
 }
 
 
-svg.package-diagram .node.object.over polygon
-{
-	fill: #183377;
+svg.package-diagram .node.object.over polygon {
+  fill: #183377;
 }
 
-svg.package-diagram .node.outside.over polygon
-{
-	fill: #d4d4d4;
+svg.package-diagram .node.outside.over polygon {
+  fill: #d4d4d4;
 }
 
-svg.package-diagram .node.default.over polygon
-{
-	fill: #d4d4d4;
+svg.package-diagram .node.default.over polygon {
+  fill: #d4d4d4;
 }
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/diagrams.js b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/diagrams.js
index 680ead7a59..801680b687 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/diagrams.js
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/diagrams.js
@@ -1,6 +1,6 @@
 /**
  * JavaScript functions enhancing the SVG diagrams.
- * 
+ *
  * @author Damien Obrist
  */
 
@@ -31,7 +31,7 @@ $(document).ready(function()
 		// store unscaled clone of SVG element
 		$(this).data("svg", $(this).get(0).childNodes[0].cloneNode(true));
 	});
-	
+
 	// make diagram visible, hide container
 	$(".diagram").css("display", "none");
 	$(".diagram svg").css({
@@ -159,7 +159,7 @@ diagrams.initHighlighting = function()
 			toggleClass($(this));
 		});
 	});
-	
+
 	// implicit outgoing nodes
 
 	hover($("svg .node.implicit-outgoing"), function(evt){
@@ -185,7 +185,7 @@ diagrams.initHighlighting = function()
 diagrams.resize = function()
 {
 	// available width
-	var availableWidth = $("body").width() - 20;
+	var availableWidth = $("body").width() - 100;
 
 	$(".diagram-container").each(function() {
 		// unregister click event on whole div
@@ -258,7 +258,7 @@ diagrams.popup = function(diagram)
 		var svgIE = jQuery.browser.msie ? $("<div />").append(diagram.data("svg")).html() : "";
 		var html = '' +
 		'<?xml version="1.0" encoding="UTF-8"?>\n' +
-		'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">\n' + 
+		'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">\n' +
 		'<html>\n' +
 		'	<head>\n' +
 		'		<title>' + title + '</title>\n' +
@@ -321,4 +321,3 @@ diagrams.removeClass = function(svgElem, oldClass) {
 	classes = $.grep(classes.split(/\s+/), function(n, i) { return n != oldClass; }).join(' ');
 	svgElem.attr("class", classes);
 };
-
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_left.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_left.png
deleted file mode 100644
index 0e8c893315..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_left.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_left.psd b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_left.psd
deleted file mode 100644
index 4d740f3b17..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_left.psd
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_left2.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_left2.gif
deleted file mode 100644
index b9b49076a6..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_left2.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_right.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_right.png
deleted file mode 100644
index f127e35b48..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_right.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_right.psd b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_right.psd
deleted file mode 100644
index 63a1ae8349..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filter_box_right.psd
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterbg.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterbg.gif
deleted file mode 100644
index 542ba4aa5a..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterbg.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterboxbarbg.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterboxbarbg.gif
deleted file mode 100644
index b5075c16cd..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterboxbarbg.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterboxbarbg.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterboxbarbg.png
deleted file mode 100644
index d613cf5633..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterboxbarbg.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterboxbg.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterboxbg.gif
deleted file mode 100644
index ae2f85823b..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/filterboxbg.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/fullcommenttopbg.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/fullcommenttopbg.gif
deleted file mode 100644
index a0d93f4844..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/fullcommenttopbg.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.css b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.css
index 3e352a95b3..1260d860d0 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.css
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.css
@@ -1,10 +1,31 @@
+/* Fonts */
+@font-face {
+  font-family: 'Lato';
+  font-style: normal;
+  font-weight: 400;
+  src: url('lato-v11-latin-regular.eot');
+  src: local('Lato'), local('Lato'),
+  url('lato-v11-latin-regular.eot?#iefix') format('embedded-opentype'),
+  url('lato-v11-latin-regular.woff') format('woff'),
+  url('lato-v11-latin-regular.ttf') format('truetype');
+}
+
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  src: url('open-sans-v13-latin-regular.eot');
+  src: local('Open Sans'), local('OpenSans'),
+  url('open-sans-v13-latin-regular.eot?#iefix') format('embedded-opentype'),
+  url('open-sans-v13-latin-regular.woff') format('woff'),
+  url('open-sans-v13-latin-regular.ttf') format('truetype');
+}
+
 * {
   color: inherit;
-  font-size: 10pt;
   text-decoration: none;
-        font-family: Arial, sans-serif;
+  font-family: "Lato", Arial, sans-serif;
   border-width: 0px;
-  padding: 0px;
   margin: 0px;
 }
 
@@ -16,63 +37,106 @@ a:hover {
   text-decoration: underline;
 }
 
-h1 {
-  display: none;
+.selected {
+  background-color: #2E6D82;
 }
 
-.selected {
-  -moz-box-shadow: inset 0px 5px 10px rgba(58, 88, 97, .36);
-  -webkit-box-shadow: inset 0px 5px 10px rgba(58, 88, 97, .36);
-  border-top: solid 1px rgba(119, 138, 153, 0.8);
-  border-bottom: solid 1px rgba(151, 173, 191, 0.4);
-  background-color: #ced2d9;
-  margin: -1px 0px;
-}
-
-/*.letters {
-  font-family: monospace;
-  font-size: 2pt;
-  padding: 5px;
-  background-color: #DADADA;
-  text-shadow: #ffffff 0 1px 0;
-}*/
+html {
+  background-color: #364550;
+  box-sizing: border-box;
+}
+*, *:before, *:after {
+  box-sizing: inherit;
+}
+
+textarea, input { outline: none; }
 
 #library {
     display: none;
 }
 
 #browser {
+  width: 16.75em;
   top: 0px;
-  left: 0px;
+  left: 0;
   bottom: 0px;
-  width: 100%;
   display: block;
   position: fixed;
+  background-color: #364550;
+}
+
+#browser.full-screen {
+  left: -15em;
 }
 
 #filter {
   position: absolute;
   display: block;
-/*  padding: 5px;*/
   right: 0;
   left: 0;
   top: 0;
-  background-image:url('filterbg.gif');
-  background-repeat:repeat-x;
-  background-color: #ededee; /* light gray */
-  /*background-color: #DADADA;*/
-  border:1px solid #bbbbbb;
+  background-color: #364550; /* light gray */
   border-top:0;
   border-left:0;
   border-right:0;
+  z-index: 99;
+  min-height: 5.5em;
 }
 
-#textfilter {
-  position: relative;
+#filter.scrolled {
+  box-shadow: 0 0 8px rgba(0,0,0,0.5);
+}
+
+#filter > h1 {
+  font-size: 2em;
+  position: absolute;
+  left: 0.25em;
+  top: 0.5em;
+}
+
+#filter > h2 {
+  position: absolute;
+  left: 3.8em;
+  top: 3em;
+}
+
+#filter > img.scala-logo {
+  width: 3em;
+  height: auto;
+  position: absolute;
+  left: 5.8em;
+  top: 0.43em;
+}
+
+#filter > span.toggle-sidebar {
+  position: absolute;
+  top: 0.8em;
+  right: 0.2em;
+  color: #fff;
+  z-index: 99;
+  width: 1.5em;
+  height: 1.5em;
+}
+
+#filter > span.toggle-sidebar:hover {
+  cursor: pointer;
+}
+
+/* Pseudo element replacing UTF8-symbol "Trigram From Heaven" */
+#filter > span.toggle-sidebar:before {
+  position: absolute;
+  top: -0.45em;
+  left: 0.45em;
+  content: "";
   display: block;
-  height: 20px;
-  margin-top: 5px;
-  margin-bottom: 5px;
+  width: 0.7em;
+  -webkit-box-shadow: 0 0.8em 0 1px #fff, 0 1.1em 0 1px #fff, 0 1.4em 0 1px #fff;
+  box-shadow: 0 0.8em 0 1px #fff, 0 1.1em 0 1px #fff, 0 1.4em 0 1px #fff;
+}
+
+#filter > span.toggle-sidebar:hover:before {
+  -webkit-box-shadow: 0 0.8em 0 1px #c2c2c2, 0 1.1em 0 1px #c2c2c2, 0 1.4em 0 1px #c2c2c2;
+  box-shadow: 0 0.8em 0 1px #c2c2c2, 0 1.1em 0 1px #c2c2c2, 0 1.4em 0 1px #c2c2c2;
 }
 
 #textfilter > .pre {
@@ -82,177 +146,202 @@ h1 {
   left: 0;
   height: 23px;
   width: 21px;
-  background: url("filter_box_left.png");
+}
+
+#textfilter {
+  position: relative;
+  display: block;
+  height: 20px;
+  margin-top: 0.5em;
+  margin-bottom: 0.8em;
 }
 
 #textfilter > .input {
   display: block;
   position: absolute;
   top: 0;
-  right: 20px;
-  left: 20px;
-}
-
-#textfilter > .input > input {
-  height: 20px;
-  padding: 1px;
-  font-weight: bold;
-  color: #000000;
-  background: #ffffff url("filterboxbarbg.png") repeat-x bottom left;
+  left: 0;
+  padding: 0.2em 1.8em 0.2em 0.5em;
   width: 100%;
 }
 
-#textfilter > .post {
-  display: block;
+#textfilter > span.toggle {
+  cursor: pointer;
+  padding-left: 15px;
   position: absolute;
-  top: 0;
-  right: 0;
-  height: 23px;
-  width: 21px;
-  background: url("filter_box_right.png");
+  left: -0.55em;
+  top: 3em;
+  z-index: 99;
+  color: #fff;
+  font-size: 0.8em;
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -khtml-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
 }
 
-/*#textfilter {
-  position: relative;
-  display: block;
-    height: 20px;
-  margin-bottom: 5px;
+#textfilter > span.toggle:hover {
+  color: #c2c2c2;
 }
 
-#textfilter > .pre {
-    display: block;
-    position: absolute;
-    top: 0;
-    left: 0;
-    height: 20px;
-    width: 20px;
-    background: url("filter_box_left.png");
+#textfilter > span.toggle:hover {
+  cursor: pointer;
 }
 
-#textfilter > .input {
-  display: block;
-    position: absolute;
-    top: 0;
-    right: 20px;
-    left: 20px;
+#textfilter > .hide:hover {
+  cursor: pointer;
+  color: #a2a2a2;
 }
 
 #textfilter > .input > input {
-  height: 16px;
-  padding: 2px;
-  font-weight: bold;
-  color: darkblue;
-  background-color: white;
-    width: 100%;
+  font-family: "Open Sans";
+  font-size: 0.85em;
+  height: 2em;
+  padding: 0 0.5em;
+  color: #fff;
+  width: 100%;
+  border-radius: 0.2em;
+  background: rgba(255, 255, 255, 0.2);
 }
 
-#textfilter > .post {
-    display: block;
-    position: absolute;
-    top: 0;
-    right: 0;
-    height: 20px;
-    width: 20px;
-    background: url("filter_box_right.png");
-}*/
+#focusfilter > .focusremove:hover {
+  text-decoration: none;
+}
+
+#textfilter > .clear {
+  display: none;
+  position: absolute;
+  font-size: 0.9em;
+  top: 0.53em;
+  right: 1.8em;
+  height: 23px;
+  width: 21px;
+  color: rgba(255, 255, 255, 0.4);
+}
+
+#textfilter > .clear:hover {
+  cursor: pointer;
+  color: #fff;
+}
 
 #focusfilter {
+  font-size: 0.9em;
   position: relative;
   text-align: center;
   display: block;
-  padding: 5px;
-  background-color: #fffebd; /* light yellow*/
-  text-shadow: #ffffff 0 1px 0;
+  padding: 0.6em;
+  background-color: #f16665;
+  color: #fff;
+  margin-top: 0.65em;
 }
 
 #focusfilter .focuscoll {
   font-weight: bold;
-  text-shadow: #ffffff 0 1px 0;
 }
 
-#focusfilter img {
-  bottom: -2px;
-  position: relative;
+#focusfilter a.focusremove {
+  margin-left: 0.2em;
+  font-size: 0.9em;
 }
 
-#kindfilter {
-  position: relative;
+#kindfilter-container {
+  position: fixed;
   display: block;
-  padding: 5px;
-/*  background-color: #999;*/
-  text-align: center;
-}
-
-#kindfilter > a {
- color: black; 
-/* text-decoration: underline;*/
- text-shadow: #ffffff 0 1px 0;
-
+  z-index: 99;
+  bottom: 0.5em;
+  left: 0;
+  width: 16.75em;
 }
 
-#kindfilter > a:hover {
-  color: #4C4C4C; 
-  text-decoration: none;
-  text-shadow: #ffffff 0 1px 0;
+#kindfilter {
+  float: right;
+  text-align: center;
+  padding: 0.3em 1em;
+  border-radius: 0.8em;
+  background: #f16665;
+  border-bottom: 2px solid #d64546;
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -khtml-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+  color: #fff;
+  font-size: 0.8em;
+}
+
+#kindfilter:hover {
+  cursor: pointer;
+  background-color: rgb(226, 87, 88);
 }
 
 #letters {
   position: relative;
   text-align: center;
-  padding-bottom: 5px;
-  border:1px solid #bbbbbb;
-  border-top:0;
-  border-left:0;
-  border-right:0;
+  border: 0;
+  margin-top: 0em;
+  color: #fff;
 }
 
 #letters > a, #letters > span {
-/*  font-family: monospace;*/
-  color: #858484;
-  font-weight: bold;
-  font-size: 8pt;
-  text-shadow: #ffffff 0 1px 0;
+  color: #fff;
+  font-size: 0.67em;
   padding-right: 2px;
 }
 
+#letters > a:hover {
+  text-decoration: none;
+  color: #c2c2c2;
+}
+
 #letters > span {
   color: #bbb;
 }
-  
+
 #tpl {
-  display: block;
-  position: fixed;
+  font-size: 0.8em;
   overflow: auto;
   right: 0;
   left: 0;
   bottom: 0;
-  top: 5px;
+  top: 6.9em !important;
   position: absolute;
   display: block;
+  background-color: #364550;
+  padding-top: 0.3em;
+}
+
+#tpl.packfocused {
+  top: 9.5em !important;
 }
 
+#tpl .packfocus,
 #tpl .packhide {
   display: block;
   float: right;
   font-weight: normal;
-  color: white;
+  color: #f16665;
 }
 
-#tpl .packfocus {
-  display: block;
-  float: right;
-  font-weight: normal;
-  color: white;
+#tpl .packfocus:hover,
+#tpl .packhide:hover {
+  text-decoration: none;
+  color: #53cdec;
 }
 
-#tpl .packages > ol {
-  background-color: #dadfe6;
-  /*margin-bottom: 5px;*/
+#tpl .packages {
+  width: 100%;
+  padding-left: 0;
+  overflow-x: hidden;
 }
 
-/*#tpl .packages > ol > li {
-  margin-bottom: 1px;
-}*/
+#tpl .packages > ol {
+  color: #fff;
+  background-color: #364550;
+  padding-left: 0;
+}
 
 #tpl .packages > li > a {
   padding: 0px 5px;
@@ -260,18 +349,60 @@ h1 {
 
 #tpl .packages > li > a.tplshow {
   display: block;
-  color: white;
+  color: #f16665;
   font-weight: bold;
   display: block;
-  text-shadow: #000000 0 1px 0;
+}
+
+#tpl .packages > li > a.tplshow:hover {
+  color: #53cdec;
+  text-decoration: none;
+}
+
+#tpl .packages a.tplshow > .type-circle {
+  float: left;
+  border: 1px solid rgba(255, 255, 255, 0.4);
+  height: 0.8rem;
+  width: 0.8rem;
+  border-radius: 0.8rem;
+  color: #efefef;
+  margin-top: 0.16em;
+  margin-right: 0.1em;
+  position: relative;
+  font-size: 0.8em;
+  line-height: 0.9;
+  font-family: Arial, sans-serif;
+  text-align: center;
+  display: table-cell;
+  vertical-align: middle;
+}
+
+
+#tpl .packages a.tplshow > .type-circle > span {
+  font-size: 0.9em;
+}
+
+#tpl .packages a.tplshow > .type-circle.class {
+  background-color: #316555;
+}
+
+#tpl .packages a.tplshow > .type-circle.object {
+  background-color: #103A51;
+}
+
+#tpl .packages a.tplshow > .type-circle.trait {
+  background-color: #19AACF;
 }
 
 #tpl ol > li.pack {
   padding: 3px 5px;
-  background: url("packagesbg.gif");
-  background-repeat:repeat-x;
   min-height: 14px;
-  background-color: #6e808e;
+  background-color: #364550;
+}
+
+#tpl > ol > ol > li > a:hover {
+  text-decoration: none;
+  color: #53cdec;
 }
 
 #tpl ol > li {
@@ -280,7 +411,8 @@ h1 {
 
 #tpl .templates > li {
   padding-left: 5px;
-  min-height: 18px;
+  min-height: 1.4em;
+  width: 21em; /* tpl width == 20em */
 }
 
 #tpl ol > li .icon {
@@ -290,27 +422,34 @@ h1 {
 }
 
 #tpl .templates div.placeholder {
-  padding-right: 5px;
-  width: 13px;
+  padding-right: 14px;
+  width: 11px;
   display: inline-block;
 }
 
 #tpl .templates span.tplLink {
-  padding-left: 5px;
+  padding-left: 7px;
 }
 
 #content {
-  border-left-width: 1px;
-  border-left-color: black;
-  border-left-style: white;
   right: 0px;
-  left: 0px;
+  left: 16.75em;
   bottom: 0px;
   top: 0px;
   position: fixed;
-  margin-left: 300px;
   display: block;
+  overflow-y: auto;
   -webkit-overflow-scrolling: touch;
+  background-color: #fff;
+  z-index: 100;
+}
+
+#content.full-screen {
+  left: 1.7em;
+}
+
+#content.hide-filter {
+  left: 1.5em;
 }
 
 #content > iframe {
@@ -325,8 +464,6 @@ h1 {
 }
 
 .ui-layout-resizer {
-  background-image:url('filterbg.gif');
-  background-repeat:repeat-x;
   background-color: #ededee; /* light gray */
   border:1px solid #bbbbbb;
   border-top:0;
@@ -336,4 +473,4 @@ h1 {
 
 .ui-layout-toggler {
     background: #AAA;
-}
\ No newline at end of file
+}
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.js b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.js
index cf81f7fdf5..cad4072912 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.js
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.js
@@ -1,5 +1,5 @@
 // © 2009–2010 EPFL/LAMP
-// code by Gilles Dubochet with contributions by Johannes Rudolph, "spiros" and Marcin Kubala
+// code by Gilles Dubochet with contributions by Johannes Rudolph, "spiros", Marcin Kubala and Felix Mulder
 
 var topLevelTemplates = undefined;
 var topLevelPackages = undefined;
@@ -14,15 +14,17 @@ var title = $(document).attr('title');
 var lastFragment = "";
 
 $(document).ready(function() {
-    $('body').layout({
-        west__size: '20%',
-        center__maskContents: true
-    });
-    $('#browser').layout({
-        center__paneSelector: ".ui-west-center"
-        //,center__initClosed:true
-        ,north__paneSelector: ".ui-west-north"
-    });
+    /* check if browser is mobile, if so hide class nav */
+    if( /Android|webOS|Mobi|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) ) {
+        $("#browser").toggleClass("full-screen");
+        $("#content").toggleClass("full-screen");
+        $("#letters").toggle();
+        setTimeout(function() {
+            $(".packages").hide();
+            $("#kindfilter").hide();
+        }, 4000);
+    }
+
     $('iframe').bind("load", function(){
         try {
             var subtitle = $(this).contents().find('title').text();
@@ -49,9 +51,7 @@ $(document).ready(function() {
     scheduler.addLabel("filter", 4);
 
     prepareEntityList();
-
     configureTextFilter();
-    configureKindFilter();
     configureEntityList();
 
     setFrameSrcFromUrlFragment();
@@ -63,6 +63,19 @@ $(document).ready(function() {
         setFrameSrcFromUrlFragment();
       }
     });
+
+    // Wait until page has loaded until binding input fields, setting fold all
+    setTimeout(function() {
+      configureKindFilter();
+
+      $("#index-input").on("focus", function() {
+          $("#textfilter > .clear").show();
+      });
+
+      $("#index-input").on("blur", function() {
+          $("#textfilter > .clear").hide();
+      });
+    }, 1500);
 });
 
 // Set the iframe's src according to the fragment of the current url.
@@ -143,11 +156,11 @@ var Index = {};
         return [
             '<a class="tplshow" target="template" href="',
             href,
-            '"><img width="13" height="13" class="',
-            type,
-            ' icon" src="lib/',
+            '"><div class="type-circle ',
             type,
-            '.png" />'
+            '"><span>',
+            type.charAt(0).toLowerCase(),
+            '</span></div>'
         ].join('');
     }
 
@@ -266,26 +279,17 @@ function configureEntityList() {
     textFilter();
 }
 
-/* Updates the list of entities (i.e. the content of the #tpl element) from the raw form generated by Scaladoc to a
-   form suitable for display. In particular, it adds class and object etc. icons, and it configures links to open in
-   the right frame. Furthermore, it sets the two reference top-level entities lists (topLevelTemplates and
-   topLevelPackages) to serve as reference for resetting the list when needed.
-   Be advised: this function should only be called once, on page load. */
+/**
+ * Updates the list of entities (i.e. the content of the #tpl element) from the
+ * raw form generated by Scaladoc to a form suitable for display. It configures
+ * links to open in the right frame. Furthermore, it sets the two reference
+ * top-level entities lists (topLevelTemplates and topLevelPackages) to serve
+ * as reference for resetting the list when needed.
+ *
+ * Be advised: this function should only be called once, on page load.
+ */
 function prepareEntityList() {
-    var classIcon = $("#library > img.class");
-    var traitIcon = $("#library > img.trait");
-    var typeIcon = $("#library > img.type");
-    var objectIcon = $("#library > img.object");
-    var packageIcon = $("#library > img.package");
-
     $('#tpl li.pack > a.tplshow').attr("target", "template");
-    $('#tpl li.pack').each(function () {
-        $("span.class", this).each(function() { $(this).replaceWith(classIcon.clone()); });
-        $("span.trait", this).each(function() { $(this).replaceWith(traitIcon.clone()); });
-        $("span.type", this).each(function() { $(this).replaceWith(typeIcon.clone()); });
-        $("span.object", this).each(function() { $(this).replaceWith(objectIcon.clone()); });
-        $("span.package", this).each(function() { $(this).replaceWith(packageIcon.clone()); });
-    });
     $('#tpl li.pack')
         .prepend("<a class='packhide'>hide</a>")
         .prepend("<a class='packfocus'>focus</a>");
@@ -347,7 +351,7 @@ function keyboardScrolldownLeftPane() {
                 break;
             }
 
-            if ($new.is('li')) {
+            if ($new && $new.is('li')) {
                 $old.removeClass('selected');
                 $new.addClass('selected');
             } else if (e.keyCode == 38) {
@@ -361,7 +365,8 @@ function keyboardScrolldownLeftPane() {
 /* Configures the text filter  */
 function configureTextFilter() {
     scheduler.add("init", function() {
-        $("#textfilter").append("<span class='pre'/><span class='input'><input id='index-input' type='text' accesskey='/'/></span><span class='post'/>");
+        $("#filter").prepend("<span class='toggle-sidebar'></span>");
+        $("#textfilter").append("<span class='input'><input placeholder='Filter' id='index-input' type='text' accesskey='/'/></span><span class='clear'>✖</span>");
         var input = $("#textfilter input");
         resizeFilterBlock();
         input.bind('keyup', function(event) {
@@ -386,10 +391,24 @@ function configureTextFilter() {
         input.focus(function(event) { input.select(); });
     });
     scheduler.add("init", function() {
-        $("#textfilter > .post").click(function(){
+        $("#textfilter > .clear").click(function(){
             $("#textfilter input").attr("value", "");
             textFilter();
         });
+        $("#filter > span.toggle-sidebar").click(function() {
+            $("#browser").toggleClass("full-screen");
+            $("#content").toggleClass("full-screen");
+            $(".packages").toggle();
+            $("#letters").toggle();
+            $("#kindfilter").toggle();
+        });
+        $(".pack").scroll(function() {
+            var scroll = $(".pack").scrollTop();
+            if (scroll > 0)
+                $("#filter").addClass("scrolled");
+            else
+                $("#filter").removeClass("scrolled");
+        });
     });
 }
 
@@ -463,6 +482,7 @@ function textFilter() {
 
             $('#tpl a.packfocus').click(function () {
                 focusFilter($(this).parent().parent());
+                $("#tpl").addClass("packfocused");
             });
             configureHideFilter();
         };
@@ -497,12 +517,13 @@ function configureFocusFilter() {
     scheduler.add("init", function() {
         focusFilterState = null;
         if ($("#focusfilter").length == 0) {
-            $("#filter").append("<div id='focusfilter'>focused on <span class='focuscoll'></span> <a class='focusremove'><img class='icon' src='lib/remove.png'/></a></div>");
+            $("#filter").append("<div id='focusfilter'>focused on <span class='focuscoll'></span> <a class='focusremove'>✖</a></div>");
             $("#focusfilter > .focusremove").click(function(event) {
                 textFilter();
 
                 $("#focusfilter").hide();
                 $("#kindfilter").show();
+                $("#tpl").removeClass("packfocused");
                 resizeFilterBlock();
                 focusFilterState = null;
             });
@@ -540,8 +561,18 @@ function focusFilter(package) {
 function configureKindFilter() {
     scheduler.add("init", function() {
         kindFilterState = "all";
-        $("#filter").append("<div id='kindfilter'><a>display packages only</a></div>");
-        $("#kindfilter > a").click(function(event) { kindFilter("packs"); });
+        $("#filter").append("<div id='kindfilter-container'><div id='kindfilter'><span>Fold All</span></div></div>");
+
+        while(isNaN(scrollbarWidth())) {
+          // wait until the width is available
+        }
+
+        $("#kindfilter").css({"margin-right": (scrollbarWidth() + 7) + "px"});
+        $("#kindfilter").unbind("click");
+        $("#kindfilter").click(function(event) {
+            $("#kindfilter").toggleClass("open");
+            kindFilter("packs");
+        });
         resizeFilterBlock();
     });
 }
@@ -550,14 +581,22 @@ function kindFilter(kind) {
     if (kind == "packs") {
         kindFilterState = "packs";
         kindFilterSync();
-        $("#kindfilter > a").replaceWith("<a>display all entities</a>");
-        $("#kindfilter > a").click(function(event) { kindFilter("all"); });
+        $("#kindfilter > span").replaceWith("<span>Unfold All</span>");
+        $("#kindfilter").unbind("click");
+        $("#kindfilter").click(function(event) {
+            $("#kindfilter").toggleClass("open");
+            kindFilter("all");
+        });
     }
     else {
         kindFilterState = "all";
         kindFilterSync();
-        $("#kindfilter > a").replaceWith("<a>display packages only</a>");
-        $("#kindfilter > a").click(function(event) { kindFilter("packs"); });
+        $("#kindfilter > span").replaceWith("<span>Fold All</span>");
+        $("#kindfilter").unbind("click");
+        $("#kindfilter").click(function(event) {
+            $("#kindfilter").toggleClass("open");
+            kindFilter("packs");
+        });
     }
 }
 
@@ -575,3 +614,7 @@ function kindFilterSync() {
 function resizeFilterBlock() {
     $("#tpl").css("top", $("#filter").outerHeight(true));
 }
+
+function scrollbarWidth() {
+  return $("#tpl").width() - $("#tpl")[0].clientWidth;
+}
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/jquery-ui.js b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/jquery-ui.js
deleted file mode 100644
index faab0cf1a3..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/jquery-ui.js
+++ /dev/null
@@ -1,6 +0,0 @@
-/*! jQuery UI - v1.9.0 - 2012-10-05
-* http://jqueryui.com
-* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.position.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.effect.js, jquery.ui.effect-blind.js, jquery.ui.effect-bounce.js, jquery.ui.effect-clip.js, jquery.ui.effect-drop.js, jquery.ui.effect-explode.js, jquery.ui.effect-fade.js, jquery.ui.effect-fold.js, jquery.ui.effect-highlight.js, jquery.ui.effect-pulsate.js, jquery.ui.effect-scale.js, jquery.ui.effect-shake.js, jquery.ui.effect-slide.js, jquery.ui.effect-transfer.js, jquery.ui.menu.js, jquery.ui.progressbar.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.slider.js, jquery.ui.sortable.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js
-* Copyright (c) 2012 jQuery Foundation and other contributors Licensed MIT */
-
-(function(e,t){function i(t,n){var r,i,o,u=t.nodeName.toLowerCase();return"area"===u?(r=t.parentNode,i=r.name,!t.href||!i||r.nodeName.toLowerCase()!=="map"?!1:(o=e("img[usemap=#"+i+"]")[0],!!o&&s(o))):(/input|select|textarea|button|object/.test(u)?!t.disabled:"a"===u?t.href||n:n)&&s(t)}function s(t){return!e(t).parents().andSelf().filter(function(){return e.css(this,"visibility")==="hidden"||e.expr.filters.hidden(this)}).length}var n=0,r=/^ui-id-\d+$/;e.ui=e.ui||{};if(e.ui.version)return;e.extend(e.ui,{version:"1.9.0",keyCode:{BACKSPACE:8,COMMA:188,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,LEFT:37,NUMPAD_ADD:107,NUMPAD_DECIMAL:110,NUMPAD_DIVIDE:111,NUMPAD_ENTER:108,NUMPAD_MULTIPLY:106,NUMPAD_SUBTRACT:109,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SPACE:32,TAB:9,UP:38}}),e.fn.extend({_focus:e.fn.focus,focus:function(t,n){return typeof t=="number"?this.each(function(){var r=this;setTimeout(function(){e(r).focus(),n&&n.call(r)},t)}):this._focus.apply(this,arguments)},scrollParent:function(){var t;return e.browser.msie&&/(static|relative)/.test(this.css("position"))||/absolute/.test(this.css("position"))?t=this.parents().filter(function(){return/(relative|absolute|fixed)/.test(e.css(this,"position"))&&/(auto|scroll)/.test(e.css(this,"overflow")+e.css(this,"overflow-y")+e.css(this,"overflow-x"))}).eq(0):t=this.parents().filter(function(){return/(auto|scroll)/.test(e.css(this,"overflow")+e.css(this,"overflow-y")+e.css(this,"overflow-x"))}).eq(0),/fixed/.test(this.css("position"))||!t.length?e(document):t},zIndex:function(n){if(n!==t)return this.css("zIndex",n);if(this.length){var r=e(this[0]),i,s;while(r.length&&r[0]!==document){i=r.css("position");if(i==="absolute"||i==="relative"||i==="fixed"){s=parseInt(r.css("zIndex"),10);if(!isNaN(s)&&s!==0)return s}r=r.parent()}}return 0},uniqueId:function(){return this.each(function(){this.id||(this.id="ui-id-"+ ++n)})},removeUniqueId:function(){return this.each(function(){r.test(this.id)&&e(this).removeAttr("id")})}}),e("<a>").outerWidth(1).jquery||e.each(["Width","Height"],function(n,r){function u(t,n,r,s){return e.each(i,function(){n-=parseFloat(e.css(t,"padding"+this))||0,r&&(n-=parseFloat(e.css(t,"border"+this+"Width"))||0),s&&(n-=parseFloat(e.css(t,"margin"+this))||0)}),n}var i=r==="Width"?["Left","Right"]:["Top","Bottom"],s=r.toLowerCase(),o={innerWidth:e.fn.innerWidth,innerHeight:e.fn.innerHeight,outerWidth:e.fn.outerWidth,outerHeight:e.fn.outerHeight};e.fn["inner"+r]=function(n){return n===t?o["inner"+r].call(this):this.each(function(){e(this).css(s,u(this,n)+"px")})},e.fn["outer"+r]=function(t,n){return typeof t!="number"?o["outer"+r].call(this,t):this.each(function(){e(this).css(s,u(this,t,!0,n)+"px")})}}),e.extend(e.expr[":"],{data:e.expr.createPseudo?e.expr.createPseudo(function(t){return function(n){return!!e.data(n,t)}}):function(t,n,r){return!!e.data(t,r[3])},focusable:function(t){return i(t,!isNaN(e.attr(t,"tabindex")))},tabbable:function(t){var n=e.attr(t,"tabindex"),r=isNaN(n);return(r||n>=0)&&i(t,!r)}}),e(function(){var t=document.body,n=t.appendChild(n=document.createElement("div"));n.offsetHeight,e.extend(n.style,{minHeight:"100px",height:"auto",padding:0,borderWidth:0}),e.support.minHeight=n.offsetHeight===100,e.support.selectstart="onselectstart"in n,t.removeChild(n).style.display="none"}),e.fn.extend({disableSelection:function(){return this.bind((e.support.selectstart?"selectstart":"mousedown")+".ui-disableSelection",function(e){e.preventDefault()})},enableSelection:function(){return this.unbind(".ui-disableSelection")}}),e.extend(e.ui,{plugin:{add:function(t,n,r){var i,s=e.ui[t].prototype;for(i in r)s.plugins[i]=s.plugins[i]||[],s.plugins[i].push([n,r[i]])},call:function(e,t,n){var r,i=e.plugins[t];if(!i||!e.element[0].parentNode||e.element[0].parentNode.nodeType===11)return;for(r=0;r<i.length;r++)e.options[i[r][0]]&&i[r][1].apply(e.element,n)}},contains:e.contains,hasScroll:function(t,n){if(e(t).css("overflow")==="hidden")return!1;var r=n&&n==="left"?"scrollLeft":"scrollTop",i=!1;return t[r]>0?!0:(t[r]=1,i=t[r]>0,t[r]=0,i)},isOverAxis:function(e,t,n){return e>t&&e<t+n},isOver:function(t,n,r,i,s,o){return e.ui.isOverAxis(t,r,s)&&e.ui.isOverAxis(n,i,o)}})})(jQuery);(function(e,t){var n=0,r=Array.prototype.slice,i=e.cleanData;e.cleanData=function(t){for(var n=0,r;(r=t[n])!=null;n++)try{e(r).triggerHandler("remove")}catch(s){}i(t)},e.widget=function(t,n,r){var i,s,o,u,a=t.split(".")[0];t=t.split(".")[1],i=a+"-"+t,r||(r=n,n=e.Widget),e.expr[":"][i.toLowerCase()]=function(t){return!!e.data(t,i)},e[a]=e[a]||{},s=e[a][t],o=e[a][t]=function(e,t){if(!this._createWidget)return new o(e,t);arguments.length&&this._createWidget(e,t)},e.extend(o,s,{version:r.version,_proto:e.extend({},r),_childConstructors:[]}),u=new n,u.options=e.widget.extend({},u.options),e.each(r,function(t,i){e.isFunction(i)&&(r[t]=function(){var e=function(){return n.prototype[t].apply(this,arguments)},r=function(e){return n.prototype[t].apply(this,e)};return function(){var t=this._super,n=this._superApply,s;return this._super=e,this._superApply=r,s=i.apply(this,arguments),this._super=t,this._superApply=n,s}}())}),o.prototype=e.widget.extend(u,{widgetEventPrefix:t},r,{constructor:o,namespace:a,widgetName:t,widgetBaseClass:i,widgetFullName:i}),s?(e.each(s._childConstructors,function(t,n){var r=n.prototype;e.widget(r.namespace+"."+r.widgetName,o,n._proto)}),delete s._childConstructors):n._childConstructors.push(o),e.widget.bridge(t,o)},e.widget.extend=function(n){var i=r.call(arguments,1),s=0,o=i.length,u,a;for(;s<o;s++)for(u in i[s])a=i[s][u],i[s].hasOwnProperty(u)&&a!==t&&(n[u]=e.isPlainObject(a)?e.widget.extend({},n[u],a):a);return n},e.widget.bridge=function(n,i){var s=i.prototype.widgetFullName;e.fn[n]=function(o){var u=typeof o=="string",a=r.call(arguments,1),f=this;return o=!u&&a.length?e.widget.extend.apply(null,[o].concat(a)):o,u?this.each(function(){var r,i=e.data(this,s);if(!i)return e.error("cannot call methods on "+n+" prior to initialization; "+"attempted to call method '"+o+"'");if(!e.isFunction(i[o])||o.charAt(0)==="_")return e.error("no such method '"+o+"' for "+n+" widget instance");r=i[o].apply(i,a);if(r!==i&&r!==t)return f=r&&r.jquery?f.pushStack(r.get()):r,!1}):this.each(function(){var t=e.data(this,s);t?t.option(o||{})._init():new i(o,this)}),f}},e.Widget=function(e,t){},e.Widget._childConstructors=[],e.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",defaultElement:"<div>",options:{disabled:!1,create:null},_createWidget:function(t,r){r=e(r||this.defaultElement||this)[0],this.element=e(r),this.uuid=n++,this.eventNamespace="."+this.widgetName+this.uuid,this.options=e.widget.extend({},this.options,this._getCreateOptions(),t),this.bindings=e(),this.hoverable=e(),this.focusable=e(),r!==this&&(e.data(r,this.widgetName,this),e.data(r,this.widgetFullName,this),this._on({remove:"destroy"}),this.document=e(r.style?r.ownerDocument:r.document||r),this.window=e(this.document[0].defaultView||this.document[0].parentWindow)),this._create(),this._trigger("create",null,this._getCreateEventData()),this._init()},_getCreateOptions:e.noop,_getCreateEventData:e.noop,_create:e.noop,_init:e.noop,destroy:function(){this._destroy(),this.element.unbind(this.eventNamespace).removeData(this.widgetName).removeData(this.widgetFullName).removeData(e.camelCase(this.widgetFullName)),this.widget().unbind(this.eventNamespace).removeAttr("aria-disabled").removeClass(this.widgetFullName+"-disabled "+"ui-state-disabled"),this.bindings.unbind(this.eventNamespace),this.hoverable.removeClass("ui-state-hover"),this.focusable.removeClass("ui-state-focus")},_destroy:e.noop,widget:function(){return this.element},option:function(n,r){var i=n,s,o,u;if(arguments.length===0)return e.widget.extend({},this.options);if(typeof n=="string"){i={},s=n.split("."),n=s.shift();if(s.length){o=i[n]=e.widget.extend({},this.options[n]);for(u=0;u<s.length-1;u++)o[s[u]]=o[s[u]]||{},o=o[s[u]];n=s.pop();if(r===t)return o[n]===t?null:o[n];o[n]=r}else{if(r===t)return this.options[n]===t?null:this.options[n];i[n]=r}}return this._setOptions(i),this},_setOptions:function(e){var t;for(t in e)this._setOption(t,e[t]);return this},_setOption:function(e,t){return this.options[e]=t,e==="disabled"&&(this.widget().toggleClass(this.widgetFullName+"-disabled ui-state-disabled",!!t).attr("aria-disabled",t),this.hoverable.removeClass("ui-state-hover"),this.focusable.removeClass("ui-state-focus")),this},enable:function(){return this._setOption("disabled",!1)},disable:function(){return this._setOption("disabled",!0)},_on:function(t,n){n?(t=e(t),this.bindings=this.bindings.add(t)):(n=t,t=this.element);var r=this;e.each(n,function(n,i){function s(){if(r.options.disabled===!0||e(this).hasClass("ui-state-disabled"))return;return(typeof i=="string"?r[i]:i).apply(r,arguments)}typeof i!="string"&&(s.guid=i.guid=i.guid||s.guid||e.guid++);var o=n.match(/^(\w+)\s*(.*)$/),u=o[1]+r.eventNamespace,a=o[2];a?r.widget().delegate(a,u,s):t.bind(u,s)})},_off:function(e,t){t=(t||"").split(" ").join(this.eventNamespace+" ")+this.eventNamespace,e.unbind(t).undelegate(t)},_delay:function(e,t){function n(){return(typeof e=="string"?r[e]:e).apply(r,arguments)}var r=this;return setTimeout(n,t||0)},_hoverable:function(t){this.hoverable=this.hoverable.add(t),this._on(t,{mouseenter:function(t){e(t.currentTarget).addClass("ui-state-hover")},mouseleave:function(t){e(t.currentTarget).removeClass("ui-state-hover")}})},_focusable:function(t){this.focusable=this.focusable.add(t),this._on(t,{focusin:function(t){e(t.currentTarget).addClass("ui-state-focus")},focusout:function(t){e(t.currentTarget).removeClass("ui-state-focus")}})},_trigger:function(t,n,r){var i,s,o=this.options[t];r=r||{},n=e.Event(n),n.type=(t===this.widgetEventPrefix?t:this.widgetEventPrefix+t).toLowerCase(),n.target=this.element[0],s=n.originalEvent;if(s)for(i in s)i in n||(n[i]=s[i]);return this.element.trigger(n,r),!(e.isFunction(o)&&o.apply(this.element[0],[n].concat(r))===!1||n.isDefaultPrevented())}},e.each({show:"fadeIn",hide:"fadeOut"},function(t,n){e.Widget.prototype["_"+t]=function(r,i,s){typeof i=="string"&&(i={effect:i});var o,u=i?i===!0||typeof i=="number"?n:i.effect||n:t;i=i||{},typeof i=="number"&&(i={duration:i}),o=!e.isEmptyObject(i),i.complete=s,i.delay&&r.delay(i.delay),o&&e.effects&&(e.effects.effect[u]||e.uiBackCompat!==!1&&e.effects[u])?r[t](i):u!==t&&r[u]?r[u](i.duration,i.easing,s):r.queue(function(n){e(this)[t](),s&&s.call(r[0]),n()})}}),e.uiBackCompat!==!1&&(e.Widget.prototype._getCreateOptions=function(){return e.metadata&&e.metadata.get(this.element[0])[this.widgetName]})})(jQuery);(function(e,t){var n=!1;e(document).mouseup(function(e){n=!1}),e.widget("ui.mouse",{version:"1.9.0",options:{cancel:"input,textarea,button,select,option",distance:1,delay:0},_mouseInit:function(){var t=this;this.element.bind("mousedown."+this.widgetName,function(e){return t._mouseDown(e)}).bind("click."+this.widgetName,function(n){if(!0===e.data(n.target,t.widgetName+".preventClickEvent"))return e.removeData(n.target,t.widgetName+".preventClickEvent"),n.stopImmediatePropagation(),!1}),this.started=!1},_mouseDestroy:function(){this.element.unbind("."+this.widgetName),this._mouseMoveDelegate&&e(document).unbind("mousemove."+this.widgetName,this._mouseMoveDelegate).unbind("mouseup."+this.widgetName,this._mouseUpDelegate)},_mouseDown:function(t){if(n)return;this._mouseStarted&&this._mouseUp(t),this._mouseDownEvent=t;var r=this,i=t.which===1,s=typeof this.options.cancel=="string"&&t.target.nodeName?e(t.target).closest(this.options.cancel).length:!1;if(!i||s||!this._mouseCapture(t))return!0;this.mouseDelayMet=!this.options.delay,this.mouseDelayMet||(this._mouseDelayTimer=setTimeout(function(){r.mouseDelayMet=!0},this.options.delay));if(this._mouseDistanceMet(t)&&this._mouseDelayMet(t)){this._mouseStarted=this._mouseStart(t)!==!1;if(!this._mouseStarted)return t.preventDefault(),!0}return!0===e.data(t.target,this.widgetName+".preventClickEvent")&&e.removeData(t.target,this.widgetName+".preventClickEvent"),this._mouseMoveDelegate=function(e){return r._mouseMove(e)},this._mouseUpDelegate=function(e){return r._mouseUp(e)},e(document).bind("mousemove."+this.widgetName,this._mouseMoveDelegate).bind("mouseup."+this.widgetName,this._mouseUpDelegate),t.preventDefault(),n=!0,!0},_mouseMove:function(t){return!e.browser.msie||document.documentMode>=9||!!t.button?this._mouseStarted?(this._mouseDrag(t),t.preventDefault()):(this._mouseDistanceMet(t)&&this._mouseDelayMet(t)&&(this._mouseStarted=this._mouseStart(this._mouseDownEvent,t)!==!1,this._mouseStarted?this._mouseDrag(t):this._mouseUp(t)),!this._mouseStarted):this._mouseUp(t)},_mouseUp:function(t){return e(document).unbind("mousemove."+this.widgetName,this._mouseMoveDelegate).unbind("mouseup."+this.widgetName,this._mouseUpDelegate),this._mouseStarted&&(this._mouseStarted=!1,t.target===this._mouseDownEvent.target&&e.data(t.target,this.widgetName+".preventClickEvent",!0),this._mouseStop(t)),!1},_mouseDistanceMet:function(e){return Math.max(Math.abs(this._mouseDownEvent.pageX-e.pageX),Math.abs(this._mouseDownEvent.pageY-e.pageY))>=this.options.distance},_mouseDelayMet:function(e){return this.mouseDelayMet},_mouseStart:function(e){},_mouseDrag:function(e){},_mouseStop:function(e){},_mouseCapture:function(e){return!0}})})(jQuery);(function(e,t){function h(e,t,n){return[parseInt(e[0],10)*(l.test(e[0])?t/100:1),parseInt(e[1],10)*(l.test(e[1])?n/100:1)]}function p(t,n){return parseInt(e.css(t,n),10)||0}e.ui=e.ui||{};var n,r=Math.max,i=Math.abs,s=Math.round,o=/left|center|right/,u=/top|center|bottom/,a=/[\+\-]\d+%?/,f=/^\w+/,l=/%$/,c=e.fn.position;e.position={scrollbarWidth:function(){if(n!==t)return n;var r,i,s=e("<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>"),o=s.children()[0];return e("body").append(s),r=o.offsetWidth,s.css("overflow","scroll"),i=o.offsetWidth,r===i&&(i=s[0].clientWidth),s.remove(),n=r-i},getScrollInfo:function(t){var n=t.isWindow?"":t.element.css("overflow-x"),r=t.isWindow?"":t.element.css("overflow-y"),i=n==="scroll"||n==="auto"&&t.width<t.element[0].scrollWidth,s=r==="scroll"||r==="auto"&&t.height<t.element[0].scrollHeight;return{width:i?e.position.scrollbarWidth():0,height:s?e.position.scrollbarWidth():0}},getWithinInfo:function(t){var n=e(t||window),r=e.isWindow(n[0]);return{element:n,isWindow:r,offset:n.offset()||{left:0,top:0},scrollLeft:n.scrollLeft(),scrollTop:n.scrollTop(),width:r?n.width():n.outerWidth(),height:r?n.height():n.outerHeight()}}},e.fn.position=function(t){if(!t||!t.of)return c.apply(this,arguments);t=e.extend({},t);var n,l,d,v,m,g=e(t.of),y=e.position.getWithinInfo(t.within),b=e.position.getScrollInfo(y),w=g[0],E=(t.collision||"flip").split(" "),S={};return w.nodeType===9?(l=g.width(),d=g.height(),v={top:0,left:0}):e.isWindow(w)?(l=g.width(),d=g.height(),v={top:g.scrollTop(),left:g.scrollLeft()}):w.preventDefault?(t.at="left top",l=d=0,v={top:w.pageY,left:w.pageX}):(l=g.outerWidth(),d=g.outerHeight(),v=g.offset()),m=e.extend({},v),e.each(["my","at"],function(){var e=(t[this]||"").split(" "),n,r;e.length===1&&(e=o.test(e[0])?e.concat(["center"]):u.test(e[0])?["center"].concat(e):["center","center"]),e[0]=o.test(e[0])?e[0]:"center",e[1]=u.test(e[1])?e[1]:"center",n=a.exec(e[0]),r=a.exec(e[1]),S[this]=[n?n[0]:0,r?r[0]:0],t[this]=[f.exec(e[0])[0],f.exec(e[1])[0]]}),E.length===1&&(E[1]=E[0]),t.at[0]==="right"?m.left+=l:t.at[0]==="center"&&(m.left+=l/2),t.at[1]==="bottom"?m.top+=d:t.at[1]==="center"&&(m.top+=d/2),n=h(S.at,l,d),m.left+=n[0],m.top+=n[1],this.each(function(){var o,u,a=e(this),f=a.outerWidth(),c=a.outerHeight(),w=p(this,"marginLeft"),x=p(this,"marginTop"),T=f+w+p(this,"marginRight")+b.width,N=c+x+p(this,"marginBottom")+b.height,C=e.extend({},m),k=h(S.my,a.outerWidth(),a.outerHeight());t.my[0]==="right"?C.left-=f:t.my[0]==="center"&&(C.left-=f/2),t.my[1]==="bottom"?C.top-=c:t.my[1]==="center"&&(C.top-=c/2),C.left+=k[0],C.top+=k[1],e.support.offsetFractions||(C.left=s(C.left),C.top=s(C.top)),o={marginLeft:w,marginTop:x},e.each(["left","top"],function(r,i){e.ui.position[E[r]]&&e.ui.position[E[r]][i](C,{targetWidth:l,targetHeight:d,elemWidth:f,elemHeight:c,collisionPosition:o,collisionWidth:T,collisionHeight:N,offset:[n[0]+k[0],n[1]+k[1]],my:t.my,at:t.at,within:y,elem:a})}),e.fn.bgiframe&&a.bgiframe(),t.using&&(u=function(e){var n=v.left-C.left,s=n+l-f,o=v.top-C.top,u=o+d-c,h={target:{element:g,left:v.left,top:v.top,width:l,height:d},element:{element:a,left:C.left,top:C.top,width:f,height:c},horizontal:s<0?"left":n>0?"right":"center",vertical:u<0?"top":o>0?"bottom":"middle"};l<f&&i(n+s)<l&&(h.horizontal="center"),d<c&&i(o+u)<d&&(h.vertical="middle"),r(i(n),i(s))>r(i(o),i(u))?h.important="horizontal":h.important="vertical",t.using.call(this,e,h)}),a.offset(e.extend(C,{using:u}))})},e.ui.position={fit:{left:function(e,t){var n=t.within,i=n.isWindow?n.scrollLeft:n.offset.left,s=n.width,o=e.left-t.collisionPosition.marginLeft,u=i-o,a=o+t.collisionWidth-s-i,f;t.collisionWidth>s?u>0&&a<=0?(f=e.left+u+t.collisionWidth-s-i,e.left+=u-f):a>0&&u<=0?e.left=i:u>a?e.left=i+s-t.collisionWidth:e.left=i:u>0?e.left+=u:a>0?e.left-=a:e.left=r(e.left-o,e.left)},top:function(e,t){var n=t.within,i=n.isWindow?n.scrollTop:n.offset.top,s=t.within.height,o=e.top-t.collisionPosition.marginTop,u=i-o,a=o+t.collisionHeight-s-i,f;t.collisionHeight>s?u>0&&a<=0?(f=e.top+u+t.collisionHeight-s-i,e.top+=u-f):a>0&&u<=0?e.top=i:u>a?e.top=i+s-t.collisionHeight:e.top=i:u>0?e.top+=u:a>0?e.top-=a:e.top=r(e.top-o,e.top)}},flip:{left:function(e,t){var n=t.within,r=n.offset.left+n.scrollLeft,s=n.width,o=n.isWindow?n.scrollLeft:n.offset.left,u=e.left-t.collisionPosition.marginLeft,a=u-o,f=u+t.collisionWidth-s-o,l=t.my[0]==="left"?-t.elemWidth:t.my[0]==="right"?t.elemWidth:0,c=t.at[0]==="left"?t.targetWidth:t.at[0]==="right"?-t.targetWidth:0,h=-2*t.offset[0],p,d;if(a<0){p=e.left+l+c+h+t.collisionWidth-s-r;if(p<0||p<i(a))e.left+=l+c+h}else if(f>0){d=e.left-t.collisionPosition.marginLeft+l+c+h-o;if(d>0||i(d)<f)e.left+=l+c+h}},top:function(e,t){var n=t.within,r=n.offset.top+n.scrollTop,s=n.height,o=n.isWindow?n.scrollTop:n.offset.top,u=e.top-t.collisionPosition.marginTop,a=u-o,f=u+t.collisionHeight-s-o,l=t.my[1]==="top",c=l?-t.elemHeight:t.my[1]==="bottom"?t.elemHeight:0,h=t.at[1]==="top"?t.targetHeight:t.at[1]==="bottom"?-t.targetHeight:0,p=-2*t.offset[1],d,v;a<0?(v=e.top+c+h+p+t.collisionHeight-s-r,e.top+c+h+p>a&&(v<0||v<i(a))&&(e.top+=c+h+p)):f>0&&(d=e.top-t.collisionPosition.marginTop+c+h+p-o,e.top+c+h+p>f&&(d>0||i(d)<f)&&(e.top+=c+h+p))}},flipfit:{left:function(){e.ui.position.flip.left.apply(this,arguments),e.ui.position.fit.left.apply(this,arguments)},top:function(){e.ui.position.flip.top.apply(this,arguments),e.ui.position.fit.top.apply(this,arguments)}}},function(){var t,n,r,i,s,o=document.getElementsByTagName("body")[0],u=document.createElement("div");t=document.createElement(o?"div":"body"),r={visibility:"hidden",width:0,height:0,border:0,margin:0,background:"none"},o&&e.extend(r,{position:"absolute",left:"-1000px",top:"-1000px"});for(s in r)t.style[s]=r[s];t.appendChild(u),n=o||document.documentElement,n.insertBefore(t,n.firstChild),u.style.cssText="position: absolute; left: 10.7432222px;",i=e(u).offset().left,e.support.offsetFractions=i>10&&i<11,t.innerHTML="",n.removeChild(t)}(),e.uiBackCompat!==!1&&function(e){var n=e.fn.position;e.fn.position=function(r){if(!r||!r.offset)return n.call(this,r);var i=r.offset.split(" "),s=r.at.split(" ");return i.length===1&&(i[1]=i[0]),/^\d/.test(i[0])&&(i[0]="+"+i[0]),/^\d/.test(i[1])&&(i[1]="+"+i[1]),s.length===1&&(/left|center|right/.test(s[0])?s[1]="center":(s[1]=s[0],s[0]="center")),n.call(this,e.extend(r,{at:s[0]+i[0]+" "+s[1]+i[1],offset:t}))}}(jQuery)})(jQuery);(function(e,t){var n=0,r={},i={};r.height=r.paddingTop=r.paddingBottom=r.borderTopWidth=r.borderBottomWidth="hide",i.height=i.paddingTop=i.paddingBottom=i.borderTopWidth=i.borderBottomWidth="show",e.widget("ui.accordion",{version:"1.9.0",options:{active:0,animate:{},collapsible:!1,event:"click",header:"> li > :first-child,> :not(li):even",heightStyle:"auto",icons:{activeHeader:"ui-icon-triangle-1-s",header:"ui-icon-triangle-1-e"},activate:null,beforeActivate:null},_create:function(){var t=this.accordionId="ui-accordion-"+(this.element.attr("id")||++n),r=this.options;this.prevShow=this.prevHide=e(),this.element.addClass("ui-accordion ui-widget ui-helper-reset"),this.headers=this.element.find(r.header).addClass("ui-accordion-header ui-helper-reset ui-state-default ui-corner-all"),this._hoverable(this.headers),this._focusable(this.headers),this.headers.next().addClass("ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom").hide(),!r.collapsible&&r.active===!1&&(r.active=0),r.active<0&&(r.active+=this.headers.length),this.active=this._findActive(r.active).addClass("ui-accordion-header-active ui-state-active").toggleClass("ui-corner-all ui-corner-top"),this.active.next().addClass("ui-accordion-content-active").show(),this._createIcons(),this.originalHeight=this.element[0].style.height,this.refresh(),this.element.attr("role","tablist"),this.headers.attr("role","tab").each(function(n){var r=e(this),i=r.attr("id"),s=r.next(),o=s.attr("id");i||(i=t+"-header-"+n,r.attr("id",i)),o||(o=t+"-panel-"+n,s.attr("id",o)),r.attr("aria-controls",o),s.attr("aria-labelledby",i)}).next().attr("role","tabpanel"),this.headers.not(this.active).attr({"aria-selected":"false",tabIndex:-1}).next().attr({"aria-expanded":"false","aria-hidden":"true"}).hide(),this.active.length?this.active.attr({"aria-selected":"true",tabIndex:0}).next().attr({"aria-expanded":"true","aria-hidden":"false"}):this.headers.eq(0).attr("tabIndex",0),this._on(this.headers,{keydown:"_keydown"}),this._on(this.headers.next(),{keydown:"_panelKeyDown"}),this._setupEvents(r.event)},_getCreateEventData:function(){return{header:this.active,content:this.active.length?this.active.next():e()}},_createIcons:function(){var t=this.options.icons;t&&(e("<span>").addClass("ui-accordion-header-icon ui-icon "+t.header).prependTo(this.headers),this.active.children(".ui-accordion-header-icon").removeClass(t.header).addClass(t.activeHeader),this.headers.addClass("ui-accordion-icons"))},_destroyIcons:function(){this.headers.removeClass("ui-accordion-icons").children(".ui-accordion-header-icon").remove()},_destroy:function(){var e;this.element.removeClass("ui-accordion ui-widget ui-helper-reset").removeAttr("role"),this.headers.removeClass("ui-accordion-header ui-accordion-header-active ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-corner-top").removeAttr("role").removeAttr("aria-selected").removeAttr("aria-controls").removeAttr("tabIndex").each(function(){/^ui-accordion/.test(this.id)&&this.removeAttribute("id")}),this._destroyIcons(),e=this.headers.next().css("display","").removeAttr("role").removeAttr("aria-expanded").removeAttr("aria-hidden").removeAttr("aria-labelledby").removeClass("ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-state-disabled").each(function(){/^ui-accordion/.test(this.id)&&this.removeAttribute("id")}),this.options.heightStyle!=="content"&&(this.element.css("height",this.originalHeight),e.css("height",""))},_setOption:function(e,t){if(e==="active"){this._activate(t);return}e==="event"&&(this.options.event&&this._off(this.headers,this.options.event),this._setupEvents(t)),this._super(e,t),e==="collapsible"&&!t&&this.options.active===!1&&this._activate(0),e==="icons"&&(this._destroyIcons(),t&&this._createIcons()),e==="disabled"&&this.headers.add(this.headers.next()).toggleClass("ui-state-disabled",!!t)},_keydown:function(t){if(t.altKey||t.ctrlKey)return;var n=e.ui.keyCode,r=this.headers.length,i=this.headers.index(t.target),s=!1;switch(t.keyCode){case n.RIGHT:case n.DOWN:s=this.headers[(i+1)%r];break;case n.LEFT:case n.UP:s=this.headers[(i-1+r)%r];break;case n.SPACE:case n.ENTER:this._eventHandler(t);break;case n.HOME:s=this.headers[0];break;case n.END:s=this.headers[r-1]}s&&(e(t.target).attr("tabIndex",-1),e(s).attr("tabIndex",0),s.focus(),t.preventDefault())},_panelKeyDown:function(t){t.keyCode===e.ui.keyCode.UP&&t.ctrlKey&&e(t.currentTarget).prev().focus()},refresh:function(){var t,n,r=this.options.heightStyle,i=this.element.parent();this.element.css("height",this.originalHeight),r==="fill"?(e.support.minHeight||(n=i.css("overflow"),i.css("overflow","hidden")),t=i.height(),this.element.siblings(":visible").each(function(){var n=e(this),r=n.css("position");if(r==="absolute"||r==="fixed")return;t-=n.outerHeight(!0)}),n&&i.css("overflow",n),this.headers.each(function(){t-=e(this).outerHeight(!0)}),this.headers.next().each(function(){e(this).height(Math.max(0,t-e(this).innerHeight()+e(this).height()))}).css("overflow","auto")):r==="auto"&&(t=0,this.headers.next().each(function(){t=Math.max(t,e(this).height("").height())}).height(t)),r!=="content"&&this.element.height(this.element.height())},_activate:function(t){var n=this._findActive(t)[0];if(n===this.active[0])return;n=n||this.active[0],this._eventHandler({target:n,currentTarget:n,preventDefault:e.noop})},_findActive:function(t){return typeof t=="number"?this.headers.eq(t):e()},_setupEvents:function(t){var n={};if(!t)return;e.each(t.split(" "),function(e,t){n[t]="_eventHandler"}),this._on(this.headers,n)},_eventHandler:function(t){var n=this.options,r=this.active,i=e(t.currentTarget),s=i[0]===r[0],o=s&&n.collapsible,u=o?e():i.next(),a=r.next(),f={oldHeader:r,oldPanel:a,newHeader:o?e():i,newPanel:u};t.preventDefault();if(s&&!n.collapsible||this._trigger("beforeActivate",t,f)===!1)return;n.active=o?!1:this.headers.index(i),this.active=s?e():i,this._toggle(f),r.removeClass("ui-accordion-header-active ui-state-active"),n.icons&&r.children(".ui-accordion-header-icon").removeClass(n.icons.activeHeader).addClass(n.icons.header),s||(i.removeClass("ui-corner-all").addClass("ui-accordion-header-active ui-state-active ui-corner-top"),n.icons&&i.children(".ui-accordion-header-icon").removeClass(n.icons.header).addClass(n.icons.activeHeader),i.next().addClass("ui-accordion-content-active"))},_toggle:function(t){var n=t.newPanel,r=this.prevShow.length?this.prevShow:t.oldPanel;this.prevShow.add(this.prevHide).stop(!0,!0),this.prevShow=n,this.prevHide=r,this.options.animate?this._animate(n,r,t):(r.hide(),n.show(),this._toggleComplete(t)),r.attr({"aria-expanded":"false","aria-hidden":"true"}),r.prev().attr("aria-selected","false"),n.length&&r.length?r.prev().attr("tabIndex",-1):n.length&&this.headers.filter(function(){return e(this).attr("tabIndex")===0}).attr("tabIndex",-1),n.attr({"aria-expanded":"true","aria-hidden":"false"}).prev().attr({"aria-selected":"true",tabIndex:0})},_animate:function(e,t,n){var s,o,u,a=this,f=0,l=e.length&&(!t.length||e.index()<t.index()),c=this.options.animate||{},h=l&&c.down||c,p=function(){a._toggleComplete(n)};typeof h=="number"&&(u=h),typeof h=="string"&&(o=h),o=o||h.easing||c.easing,u=u||h.duration||c.duration;if(!t.length)return e.animate(i,u,o,p);if(!e.length)return t.animate(r,u,o,p);s=e.show().outerHeight(),t.animate(r,{duration:u,easing:o,step:function(e,t){t.now=Math.round(e)}}),e.hide().animate(i,{duration:u,easing:o,complete:p,step:function(e,n){n.now=Math.round(e),n.prop!=="height"?f+=n.now:a.options.heightStyle!=="content"&&(n.now=Math.round(s-t.outerHeight()-f),f=0)}})},_toggleComplete:function(e){var t=e.oldPanel;t.removeClass("ui-accordion-content-active").prev().removeClass("ui-corner-top").addClass("ui-corner-all"),t.length&&(t.parent()[0].className=t.parent()[0].className),this._trigger("activate",null,e)}}),e.uiBackCompat!==!1&&(function(e,t){e.extend(t.options,{navigation:!1,navigationFilter:function(){return this.href.toLowerCase()===location.href.toLowerCase()}});var n=t._create;t._create=function(){if(this.options.navigation){var t=this,r=this.element.find(this.options.header),i=r.next(),s=r.add(i).find("a").filter(this.options.navigationFilter)[0];s&&r.add(i).each(function(n){if(e.contains(this,s))return t.options.active=Math.floor(n/2),!1})}n.call(this)}}(jQuery,jQuery.ui.accordion.prototype),function(e,t){e.extend(t.options,{heightStyle:null,autoHeight:!0,clearStyle:!1,fillSpace:!1});var n=t._create,r=t._setOption;e.extend(t,{_create:function(){this.options.heightStyle=this.options.heightStyle||this._mergeHeightStyle(),n.call(this)},_setOption:function(e,t){if(e==="autoHeight"||e==="clearStyle"||e==="fillSpace")this.options.heightStyle=this._mergeHeightStyle();r.apply(this,arguments)},_mergeHeightStyle:function(){var e=this.options;if(e.fillSpace)return"fill";if(e.clearStyle)return"content";if(e.autoHeight)return"auto"}})}(jQuery,jQuery.ui.accordion.prototype),function(e,t){e.extend(t.options.icons,{activeHeader:null,headerSelected:"ui-icon-triangle-1-s"});var n=t._createIcons;t._createIcons=function(){this.options.icons&&(this.options.icons.activeHeader=this.options.icons.activeHeader||this.options.icons.headerSelected),n.call(this)}}(jQuery,jQuery.ui.accordion.prototype),function(e,t){t.activate=t._activate;var n=t._findActive;t._findActive=function(e){return e===-1&&(e=!1),e&&typeof e!="number"&&(e=this.headers.index(this.headers.filter(e)),e===-1&&(e=!1)),n.call(this,e)}}(jQuery,jQuery.ui.accordion.prototype),jQuery.ui.accordion.prototype.resize=jQuery.ui.accordion.prototype.refresh,function(e,t){e.extend(t.options,{change:null,changestart:null});var n=t._trigger;t._trigger=function(e,t,r){var i=n.apply(this,arguments);return i?(e==="beforeActivate"?i=n.call(this,"changestart",t,{oldHeader:r.oldHeader,oldContent:r.oldPanel,newHeader:r.newHeader,newContent:r.newPanel}):e==="activate"&&(i=n.call(this,"change",t,{oldHeader:r.oldHeader,oldContent:r.oldPanel,newHeader:r.newHeader,newContent:r.newPanel})),i):!1}}(jQuery,jQuery.ui.accordion.prototype),function(e,t){e.extend(t.options,{animate:null,animated:"slide"});var n=t._create;t._create=function(){var e=this.options;e.animate===null&&(e.animated?e.animated==="slide"?e.animate=300:e.animated==="bounceslide"?e.animate={duration:200,down:{easing:"easeOutBounce",duration:1e3}}:e.animate=e.animated:e.animate=!1),n.call(this)}}(jQuery,jQuery.ui.accordion.prototype))})(jQuery);(function(e,t){var n=0;e.widget("ui.autocomplete",{version:"1.9.0",defaultElement:"<input>",options:{appendTo:"body",autoFocus:!1,delay:300,minLength:1,position:{my:"left top",at:"left bottom",collision:"none"},source:null,change:null,close:null,focus:null,open:null,response:null,search:null,select:null},pending:0,_create:function(){var t,n,r;this.isMultiLine=this._isMultiLine(),this.valueMethod=this.element[this.element.is("input,textarea")?"val":"text"],this.isNewMenu=!0,this.element.addClass("ui-autocomplete-input").attr("autocomplete","off"),this._on({keydown:function(i){if(this.element.prop("readOnly")){t=!0,r=!0,n=!0;return}t=!1,r=!1,n=!1;var s=e.ui.keyCode;switch(i.keyCode){case s.PAGE_UP:t=!0,this._move("previousPage",i);break;case s.PAGE_DOWN:t=!0,this._move("nextPage",i);break;case s.UP:t=!0,this._keyEvent("previous",i);break;case s.DOWN:t=!0,this._keyEvent("next",i);break;case s.ENTER:case s.NUMPAD_ENTER:this.menu.active&&(t=!0,i.preventDefault(),this.menu.select(i));break;case s.TAB:this.menu.active&&this.menu.select(i);break;case s.ESCAPE:this.menu.element.is(":visible")&&(this._value(this.term),this.close(i),i.preventDefault());break;default:n=!0,this._searchTimeout(i)}},keypress:function(r){if(t){t=!1,r.preventDefault();return}if(n)return;var i=e.ui.keyCode;switch(r.keyCode){case i.PAGE_UP:this._move("previousPage",r);break;case i.PAGE_DOWN:this._move("nextPage",r);break;case i.UP:this._keyEvent("previous",r);break;case i.DOWN:this._keyEvent("next",r)}},input:function(e){if(r){r=!1,e.preventDefault();return}this._searchTimeout(e)},focus:function(){this.selectedItem=null,this.previous=this._value()},blur:function(e){if(this.cancelBlur){delete this.cancelBlur;return}clearTimeout(this.searching),this.close(e),this._change(e)}}),this._initSource(),this.menu=e("<ul>").addClass("ui-autocomplete").appendTo(this.document.find(this.options.appendTo||"body")[0]).menu({input:e(),role:null}).zIndex(this.element.zIndex()+1).hide().data("menu"),this._on(this.menu.element,{mousedown:function(t){t.preventDefault(),this.cancelBlur=!0,this._delay(function(){delete this.cancelBlur});var n=this.menu.element[0];e(t.target).closest(".ui-menu-item").length||this._delay(function(){var t=this;this.document.one("mousedown",function(r){r.target!==t.element[0]&&r.target!==n&&!e.contains(n,r.target)&&t.close()})})},menufocus:function(t,n){if(this.isNewMenu){this.isNewMenu=!1;if(t.originalEvent&&/^mouse/.test(t.originalEvent.type)){this.menu.blur(),this.document.one("mousemove",function(){e(t.target).trigger(t.originalEvent)});return}}var r=n.item.data("ui-autocomplete-item")||n.item.data("item.autocomplete");!1!==this._trigger("focus",t,{item:r})?t.originalEvent&&/^key/.test(t.originalEvent.type)&&this._value(r.value):this.liveRegion.text(r.value)},menuselect:function(e,t){var n=t.item.data("ui-autocomplete-item")||t.item.data("item.autocomplete"),r=this.previous;this.element[0]!==this.document[0].activeElement&&(this.element.focus(),this.previous=r,this._delay(function(){this.previous=r,this.selectedItem=n})),!1!==this._trigger("select",e,{item:n})&&this._value(n.value),this.term=this._value(),this.close(e),this.selectedItem=n}}),this.liveRegion=e("<span>",{role:"status","aria-live":"polite"}).addClass("ui-helper-hidden-accessible").insertAfter(this.element),e.fn.bgiframe&&this.menu.element.bgiframe(),this._on(this.window,{beforeunload:function(){this.element.removeAttr("autocomplete")}})},_destroy:function(){clearTimeout(this.searching),this.element.removeClass("ui-autocomplete-input").removeAttr("autocomplete"),this.menu.element.remove(),this.liveRegion.remove()},_setOption:function(e,t){this._super(e,t),e==="source"&&this._initSource(),e==="appendTo"&&this.menu.element.appendTo(this.document.find(t||"body")[0]),e==="disabled"&&t&&this.xhr&&this.xhr.abort()},_isMultiLine:function(){return this.element.is("textarea")?!0:this.element.is("input")?!1:this.element.prop("isContentEditable")},_initSource:function(){var t,n,r=this;e.isArray(this.options.source)?(t=this.options.source,this.source=function(n,r){r(e.ui.autocomplete.filter(t,n.term))}):typeof this.options.source=="string"?(n=this.options.source,this.source=function(t,i){r.xhr&&r.xhr.abort(),r.xhr=e.ajax({url:n,data:t,dataType:"json",success:function(e,t){i(e)},error:function(){i([])}})}):this.source=this.options.source},_searchTimeout:function(e){clearTimeout(this.searching),this.searching=this._delay(function(){this.term!==this._value()&&(this.selectedItem=null,this.search(null,e))},this.options.delay)},search:function(e,t){e=e!=null?e:this._value(),this.term=this._value();if(e.length<this.options.minLength)return this.close(t);if(this._trigger("search",t)===!1)return;return this._search(e)},_search:function(e){this.pending++,this.element.addClass("ui-autocomplete-loading"),this.cancelSearch=!1,this.source({term:e},this._response())},_response:function(){var e=this,t=++n;return function(r){t===n&&e.__response(r),e.pending--,e.pending||e.element.removeClass("ui-autocomplete-loading")}},__response:function(e){e&&(e=this._normalize(e)),this._trigger("response",null,{content:e}),!this.options.disabled&&e&&e.length&&!this.cancelSearch?(this._suggest(e),this._trigger("open")):this._close()},close:function(e){this.cancelSearch=!0,this._close(e)},_close:function(e){this.menu.element.is(":visible")&&(this.menu.element.hide(),this.menu.blur(),this.isNewMenu=!0,this._trigger("close",e))},_change:function(e){this.previous!==this._value()&&this._trigger("change",e,{item:this.selectedItem})},_normalize:function(t){return t.length&&t[0].label&&t[0].value?t:e.map(t,function(t){return typeof t=="string"?{label:t,value:t}:e.extend({label:t.label||t.value,value:t.value||t.label},t)})},_suggest:function(t){var n=this.menu.element.empty().zIndex(this.element.zIndex()+1);this._renderMenu(n,t),this.menu.refresh(),n.show(),this._resizeMenu(),n.position(e.extend({of:this.element},this.options.position)),this.options.autoFocus&&this.menu.next()},_resizeMenu:function(){var e=this.menu.element;e.outerWidth(Math.max(e.width("").outerWidth()+1,this.element.outerWidth()))},_renderMenu:function(t,n){var r=this;e.each(n,function(e,n){r._renderItemData(t,n)})},_renderItemData:function(e,t){return this._renderItem(e,t).data("ui-autocomplete-item",t)},_renderItem:function(t,n){return e("<li>").append(e("<a>").text(n.label)).appendTo(t)},_move:function(e,t){if(!this.menu.element.is(":visible")){this.search(null,t);return}if(this.menu.isFirstItem()&&/^previous/.test(e)||this.menu.isLastItem()&&/^next/.test(e)){this._value(this.term),this.menu.blur();return}this.menu[e](t)},widget:function(){return this.menu.element},_value:function(e){return this.valueMethod.apply(this.element,arguments)},_keyEvent:function(e,t){if(!this.isMultiLine||this.menu.element.is(":visible"))this._move(e,t),t.preventDefault()}}),e.extend(e.ui.autocomplete,{escapeRegex:function(e){return e.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g,"\\$&")},filter:function(t,n){var r=new RegExp(e.ui.autocomplete.escapeRegex(n),"i");return e.grep(t,function(e){return r.test(e.label||e.value||e)})}}),e.widget("ui.autocomplete",e.ui.autocomplete,{options:{messages:{noResults:"No search results.",results:function(e){return e+(e>1?" results are":" result is")+" available, use up and down arrow keys to navigate."}}},__response:function(e){var t;this._superApply(arguments);if(this.options.disabled||this.cancelSearch)return;e&&e.length?t=this.options.messages.results(e.length):t=this.options.messages.noResults,this.liveRegion.text(t)}})})(jQuery);(function(e,t){var n,r,i,s,o="ui-button ui-widget ui-state-default ui-corner-all",u="ui-state-hover ui-state-active ",a="ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",f=function(){var t=e(this).find(":ui-button");setTimeout(function(){t.button("refresh")},1)},l=function(t){var n=t.name,r=t.form,i=e([]);return n&&(r?i=e(r).find("[name='"+n+"']"):i=e("[name='"+n+"']",t.ownerDocument).filter(function(){return!this.form})),i};e.widget("ui.button",{version:"1.9.0",defaultElement:"<button>",options:{disabled:null,text:!0,label:null,icons:{primary:null,secondary:null}},_create:function(){this.element.closest("form").unbind("reset"+this.eventNamespace).bind("reset"+this.eventNamespace,f),typeof this.options.disabled!="boolean"?this.options.disabled=!!this.element.prop("disabled"):this.element.prop("disabled",this.options.disabled),this._determineButtonType(),this.hasTitle=!!this.buttonElement.attr("title");var t=this,u=this.options,a=this.type==="checkbox"||this.type==="radio",c="ui-state-hover"+(a?"":" ui-state-active"),h="ui-state-focus";u.label===null&&(u.label=this.type==="input"?this.buttonElement.val():this.buttonElement.html()),this.buttonElement.addClass(o).attr("role","button").bind("mouseenter"+this.eventNamespace,function(){if(u.disabled)return;e(this).addClass("ui-state-hover"),this===n&&e(this).addClass("ui-state-active")}).bind("mouseleave"+this.eventNamespace,function(){if(u.disabled)return;e(this).removeClass(c)}).bind("click"+this.eventNamespace,function(e){u.disabled&&(e.preventDefault(),e.stopImmediatePropagation())}),this.element.bind("focus"+this.eventNamespace,function(){t.buttonElement.addClass(h)}).bind("blur"+this.eventNamespace,function(){t.buttonElement.removeClass(h)}),a&&(this.element.bind("change"+this.eventNamespace,function(){if(s)return;t.refresh()}),this.buttonElement.bind("mousedown"+this.eventNamespace,function(e){if(u.disabled)return;s=!1,r=e.pageX,i=e.pageY}).bind("mouseup"+this.eventNamespace,function(e){if(u.disabled)return;if(r!==e.pageX||i!==e.pageY)s=!0})),this.type==="checkbox"?this.buttonElement.bind("click"+this.eventNamespace,function(){if(u.disabled||s)return!1;e(this).toggleClass("ui-state-active"),t.buttonElement.attr("aria-pressed",t.element[0].checked)}):this.type==="radio"?this.buttonElement.bind("click"+this.eventNamespace,function(){if(u.disabled||s)return!1;e(this).addClass("ui-state-active"),t.buttonElement.attr("aria-pressed","true");var n=t.element[0];l(n).not(n).map(function(){return e(this).button("widget")[0]}).removeClass("ui-state-active").attr("aria-pressed","false")}):(this.buttonElement.bind("mousedown"+this.eventNamespace,function(){if(u.disabled)return!1;e(this).addClass("ui-state-active"),n=this,t.document.one("mouseup",function(){n=null})}).bind("mouseup"+this.eventNamespace,function(){if(u.disabled)return!1;e(this).removeClass("ui-state-active")}).bind("keydown"+this.eventNamespace,function(t){if(u.disabled)return!1;(t.keyCode===e.ui.keyCode.SPACE||t.keyCode===e.ui.keyCode.ENTER)&&e(this).addClass("ui-state-active")}).bind("keyup"+this.eventNamespace,function(){e(this).removeClass("ui-state-active")}),this.buttonElement.is("a")&&this.buttonElement.keyup(function(t){t.keyCode===e.ui.keyCode.SPACE&&e(this).click()})),this._setOption("disabled",u.disabled),this._resetButton()},_determineButtonType:function(){var e,t,n;this.element.is("[type=checkbox]")?this.type="checkbox":this.element.is("[type=radio]")?this.type="radio":this.element.is("input")?this.type="input":this.type="button",this.type==="checkbox"||this.type==="radio"?(e=this.element.parents().last(),t="label[for='"+this.element.attr("id")+"']",this.buttonElement=e.find(t),this.buttonElement.length||(e=e.length?e.siblings():this.element.siblings(),this.buttonElement=e.filter(t),this.buttonElement.length||(this.buttonElement=e.find(t))),this.element.addClass("ui-helper-hidden-accessible"),n=this.element.is(":checked"),n&&this.buttonElement.addClass("ui-state-active"),this.buttonElement.prop("aria-pressed",n)):this.buttonElement=this.element},widget:function(){return this.buttonElement},_destroy:function(){this.element.removeClass("ui-helper-hidden-accessible"),this.buttonElement.removeClass(o+" "+u+" "+a).removeAttr("role").removeAttr("aria-pressed").html(this.buttonElement.find(".ui-button-text").html()),this.hasTitle||this.buttonElement.removeAttr("title")},_setOption:function(e,t){this._super(e,t);if(e==="disabled"){t?this.element.prop("disabled",!0):this.element.prop("disabled",!1);return}this._resetButton()},refresh:function(){var t=this.element.is(":disabled");t!==this.options.disabled&&this._setOption("disabled",t),this.type==="radio"?l(this.element[0]).each(function(){e(this).is(":checked")?e(this).button("widget").addClass("ui-state-active").attr("aria-pressed","true"):e(this).button("widget").removeClass("ui-state-active").attr("aria-pressed","false")}):this.type==="checkbox"&&(this.element.is(":checked")?this.buttonElement.addClass("ui-state-active").attr("aria-pressed","true"):this.buttonElement.removeClass("ui-state-active").attr("aria-pressed","false"))},_resetButton:function(){if(this.type==="input"){this.options.label&&this.element.val(this.options.label);return}var t=this.buttonElement.removeClass(a),n=e("<span></span>",this.document[0]).addClass("ui-button-text").html(this.options.label).appendTo(t.empty()).text(),r=this.options.icons,i=r.primary&&r.secondary,s=[];r.primary||r.secondary?(this.options.text&&s.push("ui-button-text-icon"+(i?"s":r.primary?"-primary":"-secondary")),r.primary&&t.prepend("<span class='ui-button-icon-primary ui-icon "+r.primary+"'></span>"),r.secondary&&t.append("<span class='ui-button-icon-secondary ui-icon "+r.secondary+"'></span>"),this.options.text||(s.push(i?"ui-button-icons-only":"ui-button-icon-only"),this.hasTitle||t.attr("title",e.trim(n)))):s.push("ui-button-text-only"),t.addClass(s.join(" "))}}),e.widget("ui.buttonset",{version:"1.9.0",options:{items:"button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(button)"},_create:function(){this.element.addClass("ui-buttonset")},_init:function(){this.refresh()},_setOption:function(e,t){e==="disabled"&&this.buttons.button("option",e,t),this._super(e,t)},refresh:function(){var t=this.element.css("direction")==="rtl";this.buttons=this.element.find(this.options.items).filter(":ui-button").button("refresh").end().not(":ui-button").button().end().map(function(){return e(this).button("widget")[0]}).removeClass("ui-corner-all ui-corner-left ui-corner-right").filter(":first").addClass(t?"ui-corner-right":"ui-corner-left").end().filter(":last").addClass(t?"ui-corner-left":"ui-corner-right").end().end()},_destroy:function(){this.element.removeClass("ui-buttonset"),this.buttons.map(function(){return e(this).button("widget")[0]}).removeClass("ui-corner-left ui-corner-right").end().button("destroy")}})})(jQuery);(function($,undefined){function Datepicker(){this.debug=!1,this._curInst=null,this._keyEvent=!1,this._disabledInputs=[],this._datepickerShowing=!1,this._inDialog=!1,this._mainDivId="ui-datepicker-div",this._inlineClass="ui-datepicker-inline",this._appendClass="ui-datepicker-append",this._triggerClass="ui-datepicker-trigger",this._dialogClass="ui-datepicker-dialog",this._disableClass="ui-datepicker-disabled",this._unselectableClass="ui-datepicker-unselectable",this._currentClass="ui-datepicker-current-day",this._dayOverClass="ui-datepicker-days-cell-over",this.regional=[],this.regional[""]={closeText:"Done",prevText:"Prev",nextText:"Next",currentText:"Today",monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],weekHeader:"Wk",dateFormat:"mm/dd/yy",firstDay:0,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""},this._defaults={showOn:"focus",showAnim:"fadeIn",showOptions:{},defaultDate:null,appendText:"",buttonText:"...",buttonImage:"",buttonImageOnly:!1,hideIfNoPrevNext:!1,navigationAsDateFormat:!1,gotoCurrent:!1,changeMonth:!1,changeYear:!1,yearRange:"c-10:c+10",showOtherMonths:!1,selectOtherMonths:!1,showWeek:!1,calculateWeek:this.iso8601Week,shortYearCutoff:"+10",minDate:null,maxDate:null,duration:"fast",beforeShowDay:null,beforeShow:null,onSelect:null,onChangeMonthYear:null,onClose:null,numberOfMonths:1,showCurrentAtPos:0,stepMonths:1,stepBigMonths:12,altField:"",altFormat:"",constrainInput:!0,showButtonPanel:!1,autoSize:!1,disabled:!1},$.extend(this._defaults,this.regional[""]),this.dpDiv=bindHover($('<div id="'+this._mainDivId+'" class="ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all"></div>'))}function bindHover(e){var t="button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";return e.delegate(t,"mouseout",function(){$(this).removeClass("ui-state-hover"),this.className.indexOf("ui-datepicker-prev")!=-1&&$(this).removeClass("ui-datepicker-prev-hover"),this.className.indexOf("ui-datepicker-next")!=-1&&$(this).removeClass("ui-datepicker-next-hover")}).delegate(t,"mouseover",function(){$.datepicker._isDisabledDatepicker(instActive.inline?e.parent()[0]:instActive.input[0])||($(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover"),$(this).addClass("ui-state-hover"),this.className.indexOf("ui-datepicker-prev")!=-1&&$(this).addClass("ui-datepicker-prev-hover"),this.className.indexOf("ui-datepicker-next")!=-1&&$(this).addClass("ui-datepicker-next-hover"))})}function extendRemove(e,t){$.extend(e,t);for(var n in t)if(t[n]==null||t[n]==undefined)e[n]=t[n];return e}$.extend($.ui,{datepicker:{version:"1.9.0"}});var PROP_NAME="datepicker",dpuuid=(new Date).getTime(),instActive;$.extend(Datepicker.prototype,{markerClassName:"hasDatepicker",maxRows:4,log:function(){this.debug&&console.log.apply("",arguments)},_widgetDatepicker:function(){return this.dpDiv},setDefaults:function(e){return extendRemove(this._defaults,e||{}),this},_attachDatepicker:function(target,settings){var inlineSettings=null;for(var attrName in this._defaults){var attrValue=target.getAttribute("date:"+attrName);if(attrValue){inlineSettings=inlineSettings||{};try{inlineSettings[attrName]=eval(attrValue)}catch(err){inlineSettings[attrName]=attrValue}}}var nodeName=target.nodeName.toLowerCase(),inline=nodeName=="div"||nodeName=="span";target.id||(this.uuid+=1,target.id="dp"+this.uuid);var inst=this._newInst($(target),inline);inst.settings=$.extend({},settings||{},inlineSettings||{}),nodeName=="input"?this._connectDatepicker(target,inst):inline&&this._inlineDatepicker(target,inst)},_newInst:function(e,t){var n=e[0].id.replace(/([^A-Za-z0-9_-])/g,"\\\\$1");return{id:n,input:e,selectedDay:0,selectedMonth:0,selectedYear:0,drawMonth:0,drawYear:0,inline:t,dpDiv:t?bindHover($('<div class="'+this._inlineClass+' ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all"></div>')):this.dpDiv}},_connectDatepicker:function(e,t){var n=$(e);t.append=$([]),t.trigger=$([]);if(n.hasClass(this.markerClassName))return;this._attachments(n,t),n.addClass(this.markerClassName).keydown(this._doKeyDown).keypress(this._doKeyPress).keyup(this._doKeyUp).bind("setData.datepicker",function(e,n,r){t.settings[n]=r}).bind("getData.datepicker",function(e,n){return this._get(t,n)}),this._autoSize(t),$.data(e,PROP_NAME,t),t.settings.disabled&&this._disableDatepicker(e)},_attachments:function(e,t){var n=this._get(t,"appendText"),r=this._get(t,"isRTL");t.append&&t.append.remove(),n&&(t.append=$('<span class="'+this._appendClass+'">'+n+"</span>"),e[r?"before":"after"](t.append)),e.unbind("focus",this._showDatepicker),t.trigger&&t.trigger.remove();var i=this._get(t,"showOn");(i=="focus"||i=="both")&&e.focus(this._showDatepicker);if(i=="button"||i=="both"){var s=this._get(t,"buttonText"),o=this._get(t,"buttonImage");t.trigger=$(this._get(t,"buttonImageOnly")?$("<img/>").addClass(this._triggerClass).attr({src:o,alt:s,title:s}):$('<button type="button"></button>').addClass(this._triggerClass).html(o==""?s:$("<img/>").attr({src:o,alt:s,title:s}))),e[r?"before":"after"](t.trigger),t.trigger.click(function(){return $.datepicker._datepickerShowing&&$.datepicker._lastInput==e[0]?$.datepicker._hideDatepicker():$.datepicker._datepickerShowing&&$.datepicker._lastInput!=e[0]?($.datepicker._hideDatepicker(),$.datepicker._showDatepicker(e[0])):$.datepicker._showDatepicker(e[0]),!1})}},_autoSize:function(e){if(this._get(e,"autoSize")&&!e.inline){var t=new Date(2009,11,20),n=this._get(e,"dateFormat");if(n.match(/[DM]/)){var r=function(e){var t=0,n=0;for(var r=0;r<e.length;r++)e[r].length>t&&(t=e[r].length,n=r);return n};t.setMonth(r(this._get(e,n.match(/MM/)?"monthNames":"monthNamesShort"))),t.setDate(r(this._get(e,n.match(/DD/)?"dayNames":"dayNamesShort"))+20-t.getDay())}e.input.attr("size",this._formatDate(e,t).length)}},_inlineDatepicker:function(e,t){var n=$(e);if(n.hasClass(this.markerClassName))return;n.addClass(this.markerClassName).append(t.dpDiv).bind("setData.datepicker",function(e,n,r){t.settings[n]=r}).bind("getData.datepicker",function(e,n){return this._get(t,n)}),$.data(e,PROP_NAME,t),this._setDate(t,this._getDefaultDate(t),!0),this._updateDatepicker(t),this._updateAlternate(t),t.settings.disabled&&this._disableDatepicker(e),t.dpDiv.css("display","block")},_dialogDatepicker:function(e,t,n,r,i){var s=this._dialogInst;if(!s){this.uuid+=1;var o="dp"+this.uuid;this._dialogInput=$('<input type="text" id="'+o+'" style="position: absolute; top: -100px; width: 0px;"/>'),this._dialogInput.keydown(this._doKeyDown),$("body").append(this._dialogInput),s=this._dialogInst=this._newInst(this._dialogInput,!1),s.settings={},$.data(this._dialogInput[0],PROP_NAME,s)}extendRemove(s.settings,r||{}),t=t&&t.constructor==Date?this._formatDate(s,t):t,this._dialogInput.val(t),this._pos=i?i.length?i:[i.pageX,i.pageY]:null;if(!this._pos){var u=document.documentElement.clientWidth,a=document.documentElement.clientHeight,f=document.documentElement.scrollLeft||document.body.scrollLeft,l=document.documentElement.scrollTop||document.body.scrollTop;this._pos=[u/2-100+f,a/2-150+l]}return this._dialogInput.css("left",this._pos[0]+20+"px").css("top",this._pos[1]+"px"),s.settings.onSelect=n,this._inDialog=!0,this.dpDiv.addClass(this._dialogClass),this._showDatepicker(this._dialogInput[0]),$.blockUI&&$.blockUI(this.dpDiv),$.data(this._dialogInput[0],PROP_NAME,s),this},_destroyDatepicker:function(e){var t=$(e),n=$.data(e,PROP_NAME);if(!t.hasClass(this.markerClassName))return;var r=e.nodeName.toLowerCase();$.removeData(e,PROP_NAME),r=="input"?(n.append.remove(),n.trigger.remove(),t.removeClass(this.markerClassName).unbind("focus",this._showDatepicker).unbind("keydown",this._doKeyDown).unbind("keypress",this._doKeyPress).unbind("keyup",this._doKeyUp)):(r=="div"||r=="span")&&t.removeClass(this.markerClassName).empty()},_enableDatepicker:function(e){var t=$(e),n=$.data(e,PROP_NAME);if(!t.hasClass(this.markerClassName))return;var r=e.nodeName.toLowerCase();if(r=="input")e.disabled=!1,n.trigger.filter("button").each(function(){this.disabled=!1}).end().filter("img").css({opacity:"1.0",cursor:""});else if(r=="div"||r=="span"){var i=t.children("."+this._inlineClass);i.children().removeClass("ui-state-disabled"),i.find("select.ui-datepicker-month, select.ui-datepicker-year").prop("disabled",!1)}this._disabledInputs=$.map(this._disabledInputs,function(t){return t==e?null:t})},_disableDatepicker:function(e){var t=$(e),n=$.data(e,PROP_NAME);if(!t.hasClass(this.markerClassName))return;var r=e.nodeName.toLowerCase();if(r=="input")e.disabled=!0,n.trigger.filter("button").each(function(){this.disabled=!0}).end().filter("img").css({opacity:"0.5",cursor:"default"});else if(r=="div"||r=="span"){var i=t.children("."+this._inlineClass);i.children().addClass("ui-state-disabled"),i.find("select.ui-datepicker-month, select.ui-datepicker-year").prop("disabled",!0)}this._disabledInputs=$.map(this._disabledInputs,function(t){return t==e?null:t}),this._disabledInputs[this._disabledInputs.length]=e},_isDisabledDatepicker:function(e){if(!e)return!1;for(var t=0;t<this._disabledInputs.length;t++)if(this._disabledInputs[t]==e)return!0;return!1},_getInst:function(e){try{return $.data(e,PROP_NAME)}catch(t){throw"Missing instance data for this datepicker"}},_optionDatepicker:function(e,t,n){var r=this._getInst(e);if(arguments.length==2&&typeof t=="string")return t=="defaults"?$.extend({},$.datepicker._defaults):r?t=="all"?$.extend({},r.settings):this._get(r,t):null;var i=t||{};typeof t=="string"&&(i={},i[t]=n);if(r){this._curInst==r&&this._hideDatepicker();var s=this._getDateDatepicker(e,!0),o=this._getMinMaxDate(r,"min"),u=this._getMinMaxDate(r,"max");extendRemove(r.settings,i),o!==null&&i.dateFormat!==undefined&&i.minDate===undefined&&(r.settings.minDate=this._formatDate(r,o)),u!==null&&i.dateFormat!==undefined&&i.maxDate===undefined&&(r.settings.maxDate=this._formatDate(r,u)),this._attachments($(e),r),this._autoSize(r),this._setDate(r,s),this._updateAlternate(r),this._updateDatepicker(r)}},_changeDatepicker:function(e,t,n){this._optionDatepicker(e,t,n)},_refreshDatepicker:function(e){var t=this._getInst(e);t&&this._updateDatepicker(t)},_setDateDatepicker:function(e,t){var n=this._getInst(e);n&&(this._setDate(n,t),this._updateDatepicker(n),this._updateAlternate(n))},_getDateDatepicker:function(e,t){var n=this._getInst(e);return n&&!n.inline&&this._setDateFromField(n,t),n?this._getDate(n):null},_doKeyDown:function(e){var t=$.datepicker._getInst(e.target),n=!0,r=t.dpDiv.is(".ui-datepicker-rtl");t._keyEvent=!0;if($.datepicker._datepickerShowing)switch(e.keyCode){case 9:$.datepicker._hideDatepicker(),n=!1;break;case 13:var i=$("td."+$.datepicker._dayOverClass+":not(."+$.datepicker._currentClass+")",t.dpDiv);i[0]&&$.datepicker._selectDay(e.target,t.selectedMonth,t.selectedYear,i[0]);var s=$.datepicker._get(t,"onSelect");if(s){var o=$.datepicker._formatDate(t);s.apply(t.input?t.input[0]:null,[o,t])}else $.datepicker._hideDatepicker();return!1;case 27:$.datepicker._hideDatepicker();break;case 33:$.datepicker._adjustDate(e.target,e.ctrlKey?-$.datepicker._get(t,"stepBigMonths"):-$.datepicker._get(t,"stepMonths"),"M");break;case 34:$.datepicker._adjustDate(e.target,e.ctrlKey?+$.datepicker._get(t,"stepBigMonths"):+$.datepicker._get(t,"stepMonths"),"M");break;case 35:(e.ctrlKey||e.metaKey)&&$.datepicker._clearDate(e.target),n=e.ctrlKey||e.metaKey;break;case 36:(e.ctrlKey||e.metaKey)&&$.datepicker._gotoToday(e.target),n=e.ctrlKey||e.metaKey;break;case 37:(e.ctrlKey||e.metaKey)&&$.datepicker._adjustDate(e.target,r?1:-1,"D"),n=e.ctrlKey||e.metaKey,e.originalEvent.altKey&&$.datepicker._adjustDate(e.target,e.ctrlKey?-$.datepicker._get(t,"stepBigMonths"):-$.datepicker._get(t,"stepMonths"),"M");break;case 38:(e.ctrlKey||e.metaKey)&&$.datepicker._adjustDate(e.target,-7,"D"),n=e.ctrlKey||e.metaKey;break;case 39:(e.ctrlKey||e.metaKey)&&$.datepicker._adjustDate(e.target,r?-1:1,"D"),n=e.ctrlKey||e.metaKey,e.originalEvent.altKey&&$.datepicker._adjustDate(e.target,e.ctrlKey?+$.datepicker._get(t,"stepBigMonths"):+$.datepicker._get(t,"stepMonths"),"M");break;case 40:(e.ctrlKey||e.metaKey)&&$.datepicker._adjustDate(e.target,7,"D"),n=e.ctrlKey||e.metaKey;break;default:n=!1}else e.keyCode==36&&e.ctrlKey?$.datepicker._showDatepicker(this):n=!1;n&&(e.preventDefault(),e.stopPropagation())},_doKeyPress:function(e){var t=$.datepicker._getInst(e.target);if($.datepicker._get(t,"constrainInput")){var n=$.datepicker._possibleChars($.datepicker._get(t,"dateFormat")),r=String.fromCharCode(e.charCode==undefined?e.keyCode:e.charCode);return e.ctrlKey||e.metaKey||r<" "||!n||n.indexOf(r)>-1}},_doKeyUp:function(e){var t=$.datepicker._getInst(e.target);if(t.input.val()!=t.lastVal)try{var n=$.datepicker.parseDate($.datepicker._get(t,"dateFormat"),t.input?t.input.val():null,$.datepicker._getFormatConfig(t));n&&($.datepicker._setDateFromField(t),$.datepicker._updateAlternate(t),$.datepicker._updateDatepicker(t))}catch(r){$.datepicker.log(r)}return!0},_showDatepicker:function(e){e=e.target||e,e.nodeName.toLowerCase()!="input"&&(e=$("input",e.parentNode)[0]);if($.datepicker._isDisabledDatepicker(e)||$.datepicker._lastInput==e)return;var t=$.datepicker._getInst(e);$.datepicker._curInst&&$.datepicker._curInst!=t&&($.datepicker._curInst.dpDiv.stop(!0,!0),t&&$.datepicker._datepickerShowing&&$.datepicker._hideDatepicker($.datepicker._curInst.input[0]));var n=$.datepicker._get(t,"beforeShow"),r=n?n.apply(e,[e,t]):{};if(r===!1)return;extendRemove(t.settings,r),t.lastVal=null,$.datepicker._lastInput=e,$.datepicker._setDateFromField(t),$.datepicker._inDialog&&(e.value=""),$.datepicker._pos||($.datepicker._pos=$.datepicker._findPos(e),$.datepicker._pos[1]+=e.offsetHeight);var i=!1;$(e).parents().each(function(){return i|=$(this).css("position")=="fixed",!i});var s={left:$.datepicker._pos[0],top:$.datepicker._pos[1]};$.datepicker._pos=null,t.dpDiv.empty(),t.dpDiv.css({position:"absolute",display:"block",top:"-1000px"}),$.datepicker._updateDatepicker(t),s=$.datepicker._checkOffset(t,s,i),t.dpDiv.css({position:$.datepicker._inDialog&&$.blockUI?"static":i?"fixed":"absolute",display:"none",left:s.left+"px",top:s.top+"px"});if(!t.inline){var o=$.datepicker._get(t,"showAnim"),u=$.datepicker._get(t,"duration"),a=function(){var e=t.dpDiv.find("iframe.ui-datepicker-cover");if(!!e.length){var n=$.datepicker._getBorders(t.dpDiv);e.css({left:-n[0],top:-n[1],width:t.dpDiv.outerWidth(),height:t.dpDiv.outerHeight()})}};t.dpDiv.zIndex($(e).zIndex()+1),$.datepicker._datepickerShowing=!0,$.effects&&($.effects.effect[o]||$.effects[o])?t.dpDiv.show(o,$.datepicker._get(t,"showOptions"),u,a):t.dpDiv[o||"show"](o?u:null,a),(!o||!u)&&a(),t.input.is(":visible")&&!t.input.is(":disabled")&&t.input.focus(),$.datepicker._curInst=t}},_updateDatepicker:function(e){this.maxRows=4;var t=$.datepicker._getBorders(e.dpDiv);instActive=e,e.dpDiv.empty().append(this._generateHTML(e)),this._attachHandlers(e);var n=e.dpDiv.find("iframe.ui-datepicker-cover");!n.length||n.css({left:-t[0],top:-t[1],width:e.dpDiv.outerWidth(),height:e.dpDiv.outerHeight()}),e.dpDiv.find("."+this._dayOverClass+" a").mouseover();var r=this._getNumberOfMonths(e),i=r[1],s=17;e.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width(""),i>1&&e.dpDiv.addClass("ui-datepicker-multi-"+i).css("width",s*i+"em"),e.dpDiv[(r[0]!=1||r[1]!=1?"add":"remove")+"Class"]("ui-datepicker-multi"),e.dpDiv[(this._get(e,"isRTL")?"add":"remove")+"Class"]("ui-datepicker-rtl"),e==$.datepicker._curInst&&$.datepicker._datepickerShowing&&e.input&&e.input.is(":visible")&&!e.input.is(":disabled")&&e.input[0]!=document.activeElement&&e.input.focus();if(e.yearshtml){var o=e.yearshtml;setTimeout(function(){o===e.yearshtml&&e.yearshtml&&e.dpDiv.find("select.ui-datepicker-year:first").replaceWith(e.yearshtml),o=e.yearshtml=null},0)}},_getBorders:function(e){var t=function(e){return{thin:1,medium:2,thick:3}[e]||e};return[parseFloat(t(e.css("border-left-width"))),parseFloat(t(e.css("border-top-width")))]},_checkOffset:function(e,t,n){var r=e.dpDiv.outerWidth(),i=e.dpDiv.outerHeight(),s=e.input?e.input.outerWidth():0,o=e.input?e.input.outerHeight():0,u=document.documentElement.clientWidth+(n?0:$(document).scrollLeft()),a=document.documentElement.clientHeight+(n?0:$(document).scrollTop());return t.left-=this._get(e,"isRTL")?r-s:0,t.left-=n&&t.left==e.input.offset().left?$(document).scrollLeft():0,t.top-=n&&t.top==e.input.offset().top+o?$(document).scrollTop():0,t.left-=Math.min(t.left,t.left+r>u&&u>r?Math.abs(t.left+r-u):0),t.top-=Math.min(t.top,t.top+i>a&&a>i?Math.abs(i+o):0),t},_findPos:function(e){var t=this._getInst(e),n=this._get(t,"isRTL");while(e&&(e.type=="hidden"||e.nodeType!=1||$.expr.filters.hidden(e)))e=e[n?"previousSibling":"nextSibling"];var r=$(e).offset();return[r.left,r.top]},_hideDatepicker:function(e){var t=this._curInst;if(!t||e&&t!=$.data(e,PROP_NAME))return;if(this._datepickerShowing){var n=this._get(t,"showAnim"),r=this._get(t,"duration"),i=function(){$.datepicker._tidyDialog(t)};$.effects&&($.effects.effect[n]||$.effects[n])?t.dpDiv.hide(n,$.datepicker._get(t,"showOptions"),r,i):t.dpDiv[n=="slideDown"?"slideUp":n=="fadeIn"?"fadeOut":"hide"](n?r:null,i),n||i(),this._datepickerShowing=!1;var s=this._get(t,"onClose");s&&s.apply(t.input?t.input[0]:null,[t.input?t.input.val():"",t]),this._lastInput=null,this._inDialog&&(this._dialogInput.css({position:"absolute",left:"0",top:"-100px"}),$.blockUI&&($.unblockUI(),$("body").append(this.dpDiv))),this._inDialog=!1}},_tidyDialog:function(e){e.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar")},_checkExternalClick:function(e){if(!$.datepicker._curInst)return;var t=$(e.target),n=$.datepicker._getInst(t[0]);(t[0].id!=$.datepicker._mainDivId&&t.parents("#"+$.datepicker._mainDivId).length==0&&!t.hasClass($.datepicker.markerClassName)&&!t.closest("."+$.datepicker._triggerClass).length&&$.datepicker._datepickerShowing&&(!$.datepicker._inDialog||!$.blockUI)||t.hasClass($.datepicker.markerClassName)&&$.datepicker._curInst!=n)&&$.datepicker._hideDatepicker()},_adjustDate:function(e,t,n){var r=$(e),i=this._getInst(r[0]);if(this._isDisabledDatepicker(r[0]))return;this._adjustInstDate(i,t+(n=="M"?this._get(i,"showCurrentAtPos"):0),n),this._updateDatepicker(i)},_gotoToday:function(e){var t=$(e),n=this._getInst(t[0]);if(this._get(n,"gotoCurrent")&&n.currentDay)n.selectedDay=n.currentDay,n.drawMonth=n.selectedMonth=n.currentMonth,n.drawYear=n.selectedYear=n.currentYear;else{var r=new Date;n.selectedDay=r.getDate(),n.drawMonth=n.selectedMonth=r.getMonth(),n.drawYear=n.selectedYear=r.getFullYear()}this._notifyChange(n),this._adjustDate(t)},_selectMonthYear:function(e,t,n){var r=$(e),i=this._getInst(r[0]);i["selected"+(n=="M"?"Month":"Year")]=i["draw"+(n=="M"?"Month":"Year")]=parseInt(t.options[t.selectedIndex].value,10),this._notifyChange(i),this._adjustDate(r)},_selectDay:function(e,t,n,r){var i=$(e);if($(r).hasClass(this._unselectableClass)||this._isDisabledDatepicker(i[0]))return;var s=this._getInst(i[0]);s.selectedDay=s.currentDay=$("a",r).html(),s.selectedMonth=s.currentMonth=t,s.selectedYear=s.currentYear=n,this._selectDate(e,this._formatDate(s,s.currentDay,s.currentMonth,s.currentYear))},_clearDate:function(e){var t=$(e),n=this._getInst(t[0]);this._selectDate(t,"")},_selectDate:function(e,t){var n=$(e),r=this._getInst(n[0]);t=t!=null?t:this._formatDate(r),r.input&&r.input.val(t),this._updateAlternate(r);var i=this._get(r,"onSelect");i?i.apply(r.input?r.input[0]:null,[t,r]):r.input&&r.input.trigger("change"),r.inline?this._updateDatepicker(r):(this._hideDatepicker(),this._lastInput=r.input[0],typeof r.input[0]!="object"&&r.input.focus(),this._lastInput=null)},_updateAlternate:function(e){var t=this._get(e,"altField");if(t){var n=this._get(e,"altFormat")||this._get(e,"dateFormat"),r=this._getDate(e),i=this.formatDate(n,r,this._getFormatConfig(e));$(t).each(function(){$(this).val(i)})}},noWeekends:function(e){var t=e.getDay();return[t>0&&t<6,""]},iso8601Week:function(e){var t=new Date(e.getTime());t.setDate(t.getDate()+4-(t.getDay()||7));var n=t.getTime();return t.setMonth(0),t.setDate(1),Math.floor(Math.round((n-t)/864e5)/7)+1},parseDate:function(e,t,n){if(e==null||t==null)throw"Invalid arguments";t=typeof t=="object"?t.toString():t+"";if(t=="")return null;var r=(n?n.shortYearCutoff:null)||this._defaults.shortYearCutoff;r=typeof r!="string"?r:(new Date).getFullYear()%100+parseInt(r,10);var i=(n?n.dayNamesShort:null)||this._defaults.dayNamesShort,s=(n?n.dayNames:null)||this._defaults.dayNames,o=(n?n.monthNamesShort:null)||this._defaults.monthNamesShort,u=(n?n.monthNames:null)||this._defaults.monthNames,a=-1,f=-1,l=-1,c=-1,h=!1,p=function(t){var n=y+1<e.length&&e.charAt(y+1)==t;return n&&y++,n},d=function(e){var n=p(e),r=e=="@"?14:e=="!"?20:e=="y"&&n?4:e=="o"?3:2,i=new RegExp("^\\d{1,"+r+"}"),s=t.substring(g).match(i);if(!s)throw"Missing number at position "+g;return g+=s[0].length,parseInt(s[0],10)},v=function(e,n,r){var i=$.map(p(e)?r:n,function(e,t){return[[t,e]]}).sort(function(e,t){return-(e[1].length-t[1].length)}),s=-1;$.each(i,function(e,n){var r=n[1];if(t.substr(g,r.length).toLowerCase()==r.toLowerCase())return s=n[0],g+=r.length,!1});if(s!=-1)return s+1;throw"Unknown name at position "+g},m=function(){if(t.charAt(g)!=e.charAt(y))throw"Unexpected literal at position "+g;g++},g=0;for(var y=0;y<e.length;y++)if(h)e.charAt(y)=="'"&&!p("'")?h=!1:m();else switch(e.charAt(y)){case"d":l=d("d");break;case"D":v("D",i,s);break;case"o":c=d("o");break;case"m":f=d("m");break;case"M":f=v("M",o,u);break;case"y":a=d("y");break;case"@":var b=new Date(d("@"));a=b.getFullYear(),f=b.getMonth()+1,l=b.getDate();break;case"!":var b=new Date((d("!")-this._ticksTo1970)/1e4);a=b.getFullYear(),f=b.getMonth()+1,l=b.getDate();break;case"'":p("'")?m():h=!0;break;default:m()}if(g<t.length){var w=t.substr(g);if(!/^\s+/.test(w))throw"Extra/unparsed characters found in date: "+w}a==-1?a=(new Date).getFullYear():a<100&&(a+=(new Date).getFullYear()-(new Date).getFullYear()%100+(a<=r?0:-100));if(c>-1){f=1,l=c;do{var E=this._getDaysInMonth(a,f-1);if(l<=E)break;f++,l-=E}while(!0)}var b=this._daylightSavingAdjust(new Date(a,f-1,l));if(b.getFullYear()!=a||b.getMonth()+1!=f||b.getDate()!=l)throw"Invalid date";return b},ATOM:"yy-mm-dd",COOKIE:"D, dd M yy",ISO_8601:"yy-mm-dd",RFC_822:"D, d M y",RFC_850:"DD, dd-M-y",RFC_1036:"D, d M y",RFC_1123:"D, d M yy",RFC_2822:"D, d M yy",RSS:"D, d M y",TICKS:"!",TIMESTAMP:"@",W3C:"yy-mm-dd",_ticksTo1970:(718685+Math.floor(492.5)-Math.floor(19.7)+Math.floor(4.925))*24*60*60*1e7,formatDate:function(e,t,n){if(!t)return"";var r=(n?n.dayNamesShort:null)||this._defaults.dayNamesShort,i=(n?n.dayNames:null)||this._defaults.dayNames,s=(n?n.monthNamesShort:null)||this._defaults.monthNamesShort,o=(n?n.monthNames:null)||this._defaults.monthNames,u=function(t){var n=h+1<e.length&&e.charAt(h+1)==t;return n&&h++,n},a=function(e,t,n){var r=""+t;if(u(e))while(r.length<n)r="0"+r;return r},f=function(e,t,n,r){return u(e)?r[t]:n[t]},l="",c=!1;if(t)for(var h=0;h<e.length;h++)if(c)e.charAt(h)=="'"&&!u("'")?c=!1:l+=e.charAt(h);else switch(e.charAt(h)){case"d":l+=a("d",t.getDate(),2);break;case"D":l+=f("D",t.getDay(),r,i);break;case"o":l+=a("o",Math.round(((new Date(t.getFullYear(),t.getMonth(),t.getDate())).getTime()-(new Date(t.getFullYear(),0,0)).getTime())/864e5),3);break;case"m":l+=a("m",t.getMonth()+1,2);break;case"M":l+=f("M",t.getMonth(),s,o);break;case"y":l+=u("y")?t.getFullYear():(t.getYear()%100<10?"0":"")+t.getYear()%100;break;case"@":l+=t.getTime();break;case"!":l+=t.getTime()*1e4+this._ticksTo1970;break;case"'":u("'")?l+="'":c=!0;break;default:l+=e.charAt(h)}return l},_possibleChars:function(e){var t="",n=!1,r=function(t){var n=i+1<e.length&&e.charAt(i+1)==t;return n&&i++,n};for(var i=0;i<e.length;i++)if(n)e.charAt(i)=="'"&&!r("'")?n=!1:t+=e.charAt(i);else switch(e.charAt(i)){case"d":case"m":case"y":case"@":t+="0123456789";break;case"D":case"M":return null;case"'":r("'")?t+="'":n=!0;break;default:t+=e.charAt(i)}return t},_get:function(e,t){return e.settings[t]!==undefined?e.settings[t]:this._defaults[t]},_setDateFromField:function(e,t){if(e.input.val()==e.lastVal)return;var n=this._get(e,"dateFormat"),r=e.lastVal=e.input?e.input.val():null,i,s;i=s=this._getDefaultDate(e);var o=this._getFormatConfig(e);try{i=this.parseDate(n,r,o)||s}catch(u){this.log(u),r=t?"":r}e.selectedDay=i.getDate(),e.drawMonth=e.selectedMonth=i.getMonth(),e.drawYear=e.selectedYear=i.getFullYear(),e.currentDay=r?i.getDate():0,e.currentMonth=r?i.getMonth():0,e.currentYear=r?i.getFullYear():0,this._adjustInstDate(e)},_getDefaultDate:function(e){return this._restrictMinMax(e,this._determineDate(e,this._get(e,"defaultDate"),new Date))},_determineDate:function(e,t,n){var r=function(e){var t=new Date;return t.setDate(t.getDate()+e),t},i=function(t){try{return $.datepicker.parseDate($.datepicker._get(e,"dateFormat"),t,$.datepicker._getFormatConfig(e))}catch(n){}var r=(t.toLowerCase().match(/^c/)?$.datepicker._getDate(e):null)||new Date,i=r.getFullYear(),s=r.getMonth(),o=r.getDate(),u=/([+-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,a=u.exec(t);while(a){switch(a[2]||"d"){case"d":case"D":o+=parseInt(a[1],10);break;case"w":case"W":o+=parseInt(a[1],10)*7;break;case"m":case"M":s+=parseInt(a[1],10),o=Math.min(o,$.datepicker._getDaysInMonth(i,s));break;case"y":case"Y":i+=parseInt(a[1],10),o=Math.min(o,$.datepicker._getDaysInMonth(i,s))}a=u.exec(t)}return new Date(i,s,o)},s=t==null||t===""?n:typeof t=="string"?i(t):typeof t=="number"?isNaN(t)?n:r(t):new Date(t.getTime());return s=s&&s.toString()=="Invalid Date"?n:s,s&&(s.setHours(0),s.setMinutes(0),s.setSeconds(0),s.setMilliseconds(0)),this._daylightSavingAdjust(s)},_daylightSavingAdjust:function(e){return e?(e.setHours(e.getHours()>12?e.getHours()+2:0),e):null},_setDate:function(e,t,n){var r=!t,i=e.selectedMonth,s=e.selectedYear,o=this._restrictMinMax(e,this._determineDate(e,t,new Date));e.selectedDay=e.currentDay=o.getDate(),e.drawMonth=e.selectedMonth=e.currentMonth=o.getMonth(),e.drawYear=e.selectedYear=e.currentYear=o.getFullYear(),(i!=e.selectedMonth||s!=e.selectedYear)&&!n&&this._notifyChange(e),this._adjustInstDate(e),e.input&&e.input.val(r?"":this._formatDate(e))},_getDate:function(e){var t=!e.currentYear||e.input&&e.input.val()==""?null:this._daylightSavingAdjust(new Date(e.currentYear,e.currentMonth,e.currentDay));return t},_attachHandlers:function(e){var t=this._get(e,"stepMonths"),n="#"+e.id.replace(/\\\\/g,"\\");e.dpDiv.find("[data-handler]").map(function(){var e={prev:function(){window["DP_jQuery_"+dpuuid].datepicker._adjustDate(n,-t,"M")},next:function(){window["DP_jQuery_"+dpuuid].datepicker._adjustDate(n,+t,"M")},hide:function(){window["DP_jQuery_"+dpuuid].datepicker._hideDatepicker()},today:function(){window["DP_jQuery_"+dpuuid].datepicker._gotoToday(n)},selectDay:function(){return window["DP_jQuery_"+dpuuid].datepicker._selectDay(n,+this.getAttribute("data-month"),+this.getAttribute("data-year"),this),!1},selectMonth:function(){return window["DP_jQuery_"+dpuuid].datepicker._selectMonthYear(n,this,"M"),!1},selectYear:function(){return window["DP_jQuery_"+dpuuid].datepicker._selectMonthYear(n,this,"Y"),!1}};$(this).bind(this.getAttribute("data-event"),e[this.getAttribute("data-handler")])})},_generateHTML:function(e){var t=new Date;t=this._daylightSavingAdjust(new Date(t.getFullYear(),t.getMonth(),t.getDate()));var n=this._get(e,"isRTL"),r=this._get(e,"showButtonPanel"),i=this._get(e,"hideIfNoPrevNext"),s=this._get(e,"navigationAsDateFormat"),o=this._getNumberOfMonths(e),u=this._get(e,"showCurrentAtPos"),a=this._get(e,"stepMonths"),f=o[0]!=1||o[1]!=1,l=this._daylightSavingAdjust(e.currentDay?new Date(e.currentYear,e.currentMonth,e.currentDay):new Date(9999,9,9)),c=this._getMinMaxDate(e,"min"),h=this._getMinMaxDate(e,"max"),p=e.drawMonth-u,d=e.drawYear;p<0&&(p+=12,d--);if(h){var v=this._daylightSavingAdjust(new Date(h.getFullYear(),h.getMonth()-o[0]*o[1]+1,h.getDate()));v=c&&v<c?c:v;while(this._daylightSavingAdjust(new Date(d,p,1))>v)p--,p<0&&(p=11,d--)}e.drawMonth=p,e.drawYear=d;var m=this._get(e,"prevText");m=s?this.formatDate(m,this._daylightSavingAdjust(new Date(d,p-a,1)),this._getFormatConfig(e)):m;var g=this._canAdjustMonth(e,-1,d,p)?'<a class="ui-datepicker-prev ui-corner-all" data-handler="prev" data-event="click" title="'+m+'"><span class="ui-icon ui-icon-circle-triangle-'+(n?"e":"w")+'">'+m+"</span></a>":i?"":'<a class="ui-datepicker-prev ui-corner-all ui-state-disabled" title="'+m+'"><span class="ui-icon ui-icon-circle-triangle-'+(n?"e":"w")+'">'+m+"</span></a>",y=this._get(e,"nextText");y=s?this.formatDate(y,this._daylightSavingAdjust(new Date(d,p+a,1)),this._getFormatConfig(e)):y;var b=this._canAdjustMonth(e,1,d,p)?'<a class="ui-datepicker-next ui-corner-all" data-handler="next" data-event="click" title="'+y+'"><span class="ui-icon ui-icon-circle-triangle-'+(n?"w":"e")+'">'+y+"</span></a>":i?"":'<a class="ui-datepicker-next ui-corner-all ui-state-disabled" title="'+y+'"><span class="ui-icon ui-icon-circle-triangle-'+(n?"w":"e")+'">'+y+"</span></a>",w=this._get(e,"currentText"),E=this._get(e,"gotoCurrent")&&e.currentDay?l:t;w=s?this.formatDate(w,E,this._getFormatConfig(e)):w;var S=e.inline?"":'<button type="button" class="ui-datepicker-close ui-state-default ui-priority-primary ui-corner-all" data-handler="hide" data-event="click">'+this._get(e,"closeText")+"</button>",x=r?'<div class="ui-datepicker-buttonpane ui-widget-content">'+(n?S:"")+(this._isInRange(e,E)?'<button type="button" class="ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all" data-handler="today" data-event="click">'+w+"</button>":"")+(n?"":S)+"</div>":"",T=parseInt(this._get(e,"firstDay"),10);T=isNaN(T)?0:T;var N=this._get(e,"showWeek"),C=this._get(e,"dayNames"),k=this._get(e,"dayNamesShort"),L=this._get(e,"dayNamesMin"),A=this._get(e,"monthNames"),O=this._get(e,"monthNamesShort"),M=this._get(e,"beforeShowDay"),_=this._get(e,"showOtherMonths"),D=this._get(e,"selectOtherMonths"),P=this._get(e,"calculateWeek")||this.iso8601Week,H=this._getDefaultDate(e),B="";for(var j=0;j<o[0];j++){var F="";this.maxRows=4;for(var I=0;I<o[1];I++){var q=this._daylightSavingAdjust(new Date(d,p,e.selectedDay)),R=" ui-corner-all",U="";if(f){U+='<div class="ui-datepicker-group';if(o[1]>1)switch(I){case 0:U+=" ui-datepicker-group-first",R=" ui-corner-"+(n?"right":"left");break;case o[1]-1:U+=" ui-datepicker-group-last",R=" ui-corner-"+(n?"left":"right");break;default:U+=" ui-datepicker-group-middle",R=""}U+='">'}U+='<div class="ui-datepicker-header ui-widget-header ui-helper-clearfix'+R+'">'+(/all|left/.test(R)&&j==0?n?b:g:"")+(/all|right/.test(R)&&j==0?n?g:b:"")+this._generateMonthYearHeader(e,p,d,c,h,j>0||I>0,A,O)+'</div><table class="ui-datepicker-calendar"><thead>'+"<tr>";var z=N?'<th class="ui-datepicker-week-col">'+this._get(e,"weekHeader")+"</th>":"";for(var W=0;W<7;W++){var X=(W+T)%7;z+="<th"+((W+T+6)%7>=5?' class="ui-datepicker-week-end"':"")+">"+'<span title="'+C[X]+'">'+L[X]+"</span></th>"}U+=z+"</tr></thead><tbody>";var V=this._getDaysInMonth(d,p);d==e.selectedYear&&p==e.selectedMonth&&(e.selectedDay=Math.min(e.selectedDay,V));var J=(this._getFirstDayOfMonth(d,p)-T+7)%7,K=Math.ceil((J+V)/7),Q=f?this.maxRows>K?this.maxRows:K:K;this.maxRows=Q;var G=this._daylightSavingAdjust(new Date(d,p,1-J));for(var Y=0;Y<Q;Y++){U+="<tr>";var Z=N?'<td class="ui-datepicker-week-col">'+this._get(e,"calculateWeek")(G)+"</td>":"";for(var W=0;W<7;W++){var et=M?M.apply(e.input?e.input[0]:null,[G]):[!0,""],tt=G.getMonth()!=p,nt=tt&&!D||!et[0]||c&&G<c||h&&G>h;Z+='<td class="'+((W+T+6)%7>=5?" ui-datepicker-week-end":"")+(tt?" ui-datepicker-other-month":"")+(G.getTime()==q.getTime()&&p==e.selectedMonth&&e._keyEvent||H.getTime()==G.getTime()&&H.getTime()==q.getTime()?" "+this._dayOverClass:"")+(nt?" "+this._unselectableClass+" ui-state-disabled":"")+(tt&&!_?"":" "+et[1]+(G.getTime()==l.getTime()?" "+this._currentClass:"")+(G.getTime()==t.getTime()?" ui-datepicker-today":""))+'"'+((!tt||_)&&et[2]?' title="'+et[2]+'"':"")+(nt?"":' data-handler="selectDay" data-event="click" data-month="'+G.getMonth()+'" data-year="'+G.getFullYear()+'"')+">"+(tt&&!_?"&#xa0;":nt?'<span class="ui-state-default">'+G.getDate()+"</span>":'<a class="ui-state-default'+(G.getTime()==t.getTime()?" ui-state-highlight":"")+(G.getTime()==l.getTime()?" ui-state-active":"")+(tt?" ui-priority-secondary":"")+'" href="#">'+G.getDate()+"</a>")+"</td>",G.setDate(G.getDate()+1),G=this._daylightSavingAdjust(G)}U+=Z+"</tr>"}p++,p>11&&(p=0,d++),U+="</tbody></table>"+(f?"</div>"+(o[0]>0&&I==o[1]-1?'<div class="ui-datepicker-row-break"></div>':""):""),F+=U}B+=F}return B+=x+($.browser.msie&&parseInt($.browser.version,10)<7&&!e.inline?'<iframe src="javascript:false;" class="ui-datepicker-cover" frameborder="0"></iframe>':""),e._keyEvent=!1,B},_generateMonthYearHeader:function(e,t,n,r,i,s,o,u){var a=this._get(e,"changeMonth"),f=this._get(e,"changeYear"),l=this._get(e,"showMonthAfterYear"),c='<div class="ui-datepicker-title">',h="";if(s||!a)h+='<span class="ui-datepicker-month">'+o[t]+"</span>";else{var p=r&&r.getFullYear()==n,d=i&&i.getFullYear()==n;h+='<select class="ui-datepicker-month" data-handler="selectMonth" data-event="change">';for(var v=0;v<12;v++)(!p||v>=r.getMonth())&&(!d||v<=i.getMonth())&&(h+='<option value="'+v+'"'+(v==t?' selected="selected"':"")+">"+u[v]+"</option>");h+="</select>"}l||(c+=h+(s||!a||!f?"&#xa0;":""));if(!e.yearshtml){e.yearshtml="";if(s||!f)c+='<span class="ui-datepicker-year">'+n+"</span>";else{var m=this._get(e,"yearRange").split(":"),g=(new Date).getFullYear(),y=function(e){var t=e.match(/c[+-].*/)?n+parseInt(e.substring(1),10):e.match(/[+-].*/)?g+parseInt(e,10):parseInt(e,10);return isNaN(t)?g:t},b=y(m[0]),w=Math.max(b,y(m[1]||""));b=r?Math.max(b,r.getFullYear()):b,w=i?Math.min(w,i.getFullYear()):w,e.yearshtml+='<select class="ui-datepicker-year" data-handler="selectYear" data-event="change">';for(;b<=w;b++)e.yearshtml+='<option value="'+b+'"'+(b==n?' selected="selected"':"")+">"+b+"</option>";e.yearshtml+="</select>",c+=e.yearshtml,e.yearshtml=null}}return c+=this._get(e,"yearSuffix"),l&&(c+=(s||!a||!f?"&#xa0;":"")+h),c+="</div>",c},_adjustInstDate:function(e,t,n){var r=e.drawYear+(n=="Y"?t:0),i=e.drawMonth+(n=="M"?t:0),s=Math.min(e.selectedDay,this._getDaysInMonth(r,i))+(n=="D"?t:0),o=this._restrictMinMax(e,this._daylightSavingAdjust(new Date(r,i,s)));e.selectedDay=o.getDate(),e.drawMonth=e.selectedMonth=o.getMonth(),e.drawYear=e.selectedYear=o.getFullYear(),(n=="M"||n=="Y")&&this._notifyChange(e)},_restrictMinMax:function(e,t){var n=this._getMinMaxDate(e,"min"),r=this._getMinMaxDate(e,"max"),i=n&&t<n?n:t;return i=r&&i>r?r:i,i},_notifyChange:function(e){var t=this._get(e,"onChangeMonthYear");t&&t.apply(e.input?e.input[0]:null,[e.selectedYear,e.selectedMonth+1,e])},_getNumberOfMonths:function(e){var t=this._get(e,"numberOfMonths");return t==null?[1,1]:typeof t=="number"?[1,t]:t},_getMinMaxDate:function(e,t){return this._determineDate(e,this._get(e,t+"Date"),null)},_getDaysInMonth:function(e,t){return 32-this._daylightSavingAdjust(new Date(e,t,32)).getDate()},_getFirstDayOfMonth:function(e,t){return(new Date(e,t,1)).getDay()},_canAdjustMonth:function(e,t,n,r){var i=this._getNumberOfMonths(e),s=this._daylightSavingAdjust(new Date(n,r+(t<0?t:i[0]*i[1]),1));return t<0&&s.setDate(this._getDaysInMonth(s.getFullYear(),s.getMonth())),this._isInRange(e,s)},_isInRange:function(e,t){var n=this._getMinMaxDate(e,"min"),r=this._getMinMaxDate(e,"max");return(!n||t.getTime()>=n.getTime())&&(!r||t.getTime()<=r.getTime())},_getFormatConfig:function(e){var t=this._get(e,"shortYearCutoff");return t=typeof t!="string"?t:(new Date).getFullYear()%100+parseInt(t,10),{shortYearCutoff:t,dayNamesShort:this._get(e,"dayNamesShort"),dayNames:this._get(e,"dayNames"),monthNamesShort:this._get(e,"monthNamesShort"),monthNames:this._get(e,"monthNames")}},_formatDate:function(e,t,n,r){t||(e.currentDay=e.selectedDay,e.currentMonth=e.selectedMonth,e.currentYear=e.selectedYear);var i=t?typeof t=="object"?t:this._daylightSavingAdjust(new Date(r,n,t)):this._daylightSavingAdjust(new Date(e.currentYear,e.currentMonth,e.currentDay));return this.formatDate(this._get(e,"dateFormat"),i,this._getFormatConfig(e))}}),$.fn.datepicker=function(e){if(!this.length)return this;$.datepicker.initialized||($(document).mousedown($.datepicker._checkExternalClick).find(document.body).append($.datepicker.dpDiv),$.datepicker.initialized=!0);var t=Array.prototype.slice.call(arguments,1);return typeof e!="string"||e!="isDisabled"&&e!="getDate"&&e!="widget"?e=="option"&&arguments.length==2&&typeof arguments[1]=="string"?$.datepicker["_"+e+"Datepicker"].apply($.datepicker,[this[0]].concat(t)):this.each(function(){typeof e=="string"?$.datepicker["_"+e+"Datepicker"].apply($.datepicker,[this].concat(t)):$.datepicker._attachDatepicker(this,e)}):$.datepicker["_"+e+"Datepicker"].apply($.datepicker,[this[0]].concat(t))},$.datepicker=new Datepicker,$.datepicker.initialized=!1,$.datepicker.uuid=(new Date).getTime(),$.datepicker.version="1.9.0",window["DP_jQuery_"+dpuuid]=$})(jQuery);(function(e,t){var n="ui-dialog ui-widget ui-widget-content ui-corner-all ",r={buttons:!0,height:!0,maxHeight:!0,maxWidth:!0,minHeight:!0,minWidth:!0,width:!0},i={maxHeight:!0,maxWidth:!0,minHeight:!0,minWidth:!0};e.widget("ui.dialog",{version:"1.9.0",options:{autoOpen:!0,buttons:{},closeOnEscape:!0,closeText:"close",dialogClass:"",draggable:!0,hide:null,height:"auto",maxHeight:!1,maxWidth:!1,minHeight:150,minWidth:150,modal:!1,position:{my:"center",at:"center",of:window,collision:"fit",using:function(t){var n=e(this).css(t).offset().top;n<0&&e(this).css("top",t.top-n)}},resizable:!0,show:null,stack:!0,title:"",width:300,zIndex:1e3},_create:function(){this.originalTitle=this.element.attr("title"),typeof this.originalTitle!="string"&&(this.originalTitle=""),this.oldPosition={parent:this.element.parent(),index:this.element.parent().children().index(this.element)},this.options.title=this.options.title||this.originalTitle;var t=this,r=this.options,i=r.title||"&#160;",s=(this.uiDialog=e("<div>")).addClass(n+r.dialogClass).css({display:"none",outline:0,zIndex:r.zIndex}).attr("tabIndex",-1).keydown(function(n){r.closeOnEscape&&!n.isDefaultPrevented()&&n.keyCode&&n.keyCode===e.ui.keyCode.ESCAPE&&(t.close(n),n.preventDefault())}).mousedown(function(e){t.moveToTop(!1,e)}).appendTo("body"),o=this.element.show().removeAttr("title").addClass("ui-dialog-content ui-widget-content").appendTo(s),u=(this.uiDialogTitlebar=e("<div>")).addClass("ui-dialog-titlebar  ui-widget-header  ui-corner-all  ui-helper-clearfix").prependTo(s),a=e("<a href='#'></a>").addClass("ui-dialog-titlebar-close  ui-corner-all").attr("role","button").click(function(e){e.preventDefault(),t.close(e)}).appendTo(u),f=(this.uiDialogTitlebarCloseText=e("<span>")).addClass("ui-icon ui-icon-closethick").text(r.closeText).appendTo(a),l=e("<span>").uniqueId().addClass("ui-dialog-title").html(i).prependTo(u),c=(this.uiDialogButtonPane=e("<div>")).addClass("ui-dialog-buttonpane ui-widget-content ui-helper-clearfix"),h=(this.uiButtonSet=e("<div>")).addClass("ui-dialog-buttonset").appendTo(c);s.attr({role:"dialog","aria-labelledby":l.attr("id")}),u.find("*").add(u).disableSelection(),this._hoverable(a),this._focusable(a),r.draggable&&e.fn.draggable&&this._makeDraggable(),r.resizable&&e.fn.resizable&&this._makeResizable(),this._createButtons(r.buttons),this._isOpen=!1,e.fn.bgiframe&&s.bgiframe(),this._on(s,{keydown:function(t){if(!r.modal||t.keyCode!==e.ui.keyCode.TAB)return;var n=e(":tabbable",s),i=n.filter(":first"),o=n.filter(":last");if(t.target===o[0]&&!t.shiftKey)return i.focus(1),!1;if(t.target===i[0]&&t.shiftKey)return o.focus(1),!1}})},_init:function(){this.options.autoOpen&&this.open()},_destroy:function(){var e,t=this.oldPosition;this.overlay&&this.overlay.destroy(),this.uiDialog.hide(),this.element.removeClass("ui-dialog-content ui-widget-content").hide().appendTo("body"),this.uiDialog.remove(),this.originalTitle&&this.element.attr("title",this.originalTitle),e=t.parent.children().eq(t.index),e.length&&e[0]!==this.element[0]?e.before(this.element):t.parent.append(this.element)},widget:function(){return this.uiDialog},close:function(t){var n=this,r,i;if(!this._isOpen)return;if(!1===this._trigger("beforeClose",t))return;return this._isOpen=!1,this.overlay&&this.overlay.destroy(),this.options.hide?this.uiDialog.hide(this.options.hide,function(){n._trigger("close",t)}):(this.uiDialog.hide(),this._trigger("close",t)),e.ui.dialog.overlay.resize(),this.options.modal&&(r=0,e(".ui-dialog").each(function(){this!==n.uiDialog[0]&&(i=e(this).css("z-index"),isNaN(i)||(r=Math.max(r,i)))}),e.ui.dialog.maxZ=r),this},isOpen:function(){return this._isOpen},moveToTop:function(t,n){var r=this.options,i;return r.modal&&!t||!r.stack&&!r.modal?this._trigger("focus",n):(r.zIndex>e.ui.dialog.maxZ&&(e.ui.dialog.maxZ=r.zIndex),this.overlay&&(e.ui.dialog.maxZ+=1,e.ui.dialog.overlay.maxZ=e.ui.dialog.maxZ,this.overlay.$el.css("z-index",e.ui.dialog.overlay.maxZ)),i={scrollTop:this.element.scrollTop(),scrollLeft:this.element.scrollLeft()},e.ui.dialog.maxZ+=1,this.uiDialog.css("z-index",e.ui.dialog.maxZ),this.element.attr(i),this._trigger("focus",n),this)},open:function(){if(this._isOpen)return;var t,n=this.options,r=this.uiDialog;return this._size(),this._position(n.position),r.show(n.show),this.overlay=n.modal?new e.ui.dialog.overlay(this):null,this.moveToTop(!0),t=this.element.find(":tabbable"),t.length||(t=this.uiDialogButtonPane.find(":tabbable"),t.length||(t=r)),t.eq(0).focus(),this._isOpen=!0,this._trigger("open"),this},_createButtons:function(t){var n,r,i=this,s=!1;this.uiDialogButtonPane.remove(),this.uiButtonSet.empty(),typeof t=="object"&&t!==null&&e.each(t,function(){return!(s=!0)}),s?(e.each(t,function(t,n){n=e.isFunction(n)?{click:n,text:t}:n;var r=e("<button type='button'>").attr(n,!0).unbind("click").click(function(){n.click.apply(i.element[0],arguments)}).appendTo(i.uiButtonSet);e.fn.button&&r.button()}),this.uiDialog.addClass("ui-dialog-buttons"),this.uiDialogButtonPane.appendTo(this.uiDialog)):this.uiDialog.removeClass("ui-dialog-buttons")},_makeDraggable:function(){function r(e){return{position:e.position,offset:e.offset}}var t=this,n=this.options;this.uiDialog.draggable({cancel:".ui-dialog-content, .ui-dialog-titlebar-close",handle:".ui-dialog-titlebar",containment:"document",start:function(n,i){e(this).addClass("ui-dialog-dragging"),t._trigger("dragStart",n,r(i))},drag:function(e,n){t._trigger("drag",e,r(n))},stop:function(i,s){n.position=[s.position.left-t.document.scrollLeft(),s.position.top-t.document.scrollTop()],e(this).removeClass("ui-dialog-dragging"),t._trigger("dragStop",i,r(s)),e.ui.dialog.overlay.resize()}})},_makeResizable:function(n){function u(e){return{originalPosition:e.originalPosition,originalSize:e.originalSize,position:e.position,size:e.size}}n=n===t?this.options.resizable:n;var r=this,i=this.options,s=this.uiDialog.css("position"),o=typeof n=="string"?n:"n,e,s,w,se,sw,ne,nw";this.uiDialog.resizable({cancel:".ui-dialog-content",containment:"document",alsoResize:this.element,maxWidth:i.maxWidth,maxHeight:i.maxHeight,minWidth:i.minWidth,minHeight:this._minHeight(),handles:o,start:function(t,n){e(this).addClass("ui-dialog-resizing"),r._trigger("resizeStart",t,u(n))},resize:function(e,t){r._trigger("resize",e,u(t))},stop:function(t,n){e(this).removeClass("ui-dialog-resizing"),i.height=e(this).height(),i.width=e(this).width(),r._trigger("resizeStop",t,u(n)),e.ui.dialog.overlay.resize()}}).css("position",s).find(".ui-resizable-se").addClass("ui-icon ui-icon-grip-diagonal-se")},_minHeight:function(){var e=this.options;return e.height==="auto"?e.minHeight:Math.min(e.minHeight,e.height)},_position:function(t){var n=[],r=[0,0],i;if(t){if(typeof t=="string"||typeof t=="object"&&"0"in t)n=t.split?t.split(" "):[t[0],t[1]],n.length===1&&(n[1]=n[0]),e.each(["left","top"],function(e,t){+n[e]===n[e]&&(r[e]=n[e],n[e]=t)}),t={my:n.join(" "),at:n.join(" "),offset:r.join(" ")};t=e.extend({},e.ui.dialog.prototype.options.position,t)}else t=e.ui.dialog.prototype.options.position;i=this.uiDialog.is(":visible"),i||this.uiDialog.show(),this.uiDialog.position(t),i||this.uiDialog.hide()},_setOptions:function(t){var n=this,s={},o=!1;e.each(t,function(e,t){n._setOption(e,t),e in r&&(o=!0),e in i&&(s[e]=t)}),o&&this._size(),this.uiDialog.is(":data(resizable)")&&this.uiDialog.resizable("option",s)},_setOption:function(t,r){var i,s,o=this.uiDialog;switch(t){case"buttons":this._createButtons(r);break;case"closeText":this.uiDialogTitlebarCloseText.text(""+r);break;case"dialogClass":o.removeClass(this.options.dialogClass).addClass(n+r);break;case"disabled":r?o.addClass("ui-dialog-disabled"):o.removeClass("ui-dialog-disabled");break;case"draggable":i=o.is(":data(draggable)"),i&&!r&&o.draggable("destroy"),!i&&r&&this._makeDraggable();break;case"position":this._position(r);break;case"resizable":s=o.is(":data(resizable)"),s&&!r&&o.resizable("destroy"),s&&typeof r=="string"&&o.resizable("option","handles",r),!s&&r!==!1&&this._makeResizable(r);break;case"title":e(".ui-dialog-title",this.uiDialogTitlebar).html(""+(r||"&#160;"))}this._super(t,r)},_size:function(){var t,n,r,i=this.options,s=this.uiDialog.is(":visible");this.element.show().css({width:"auto",minHeight:0,height:0}),i.minWidth>i.width&&(i.width=i.minWidth),t=this.uiDialog.css({height:"auto",width:i.width}).outerHeight(),n=Math.max(0,i.minHeight-t),i.height==="auto"?e.support.minHeight?this.element.css({minHeight:n,height:"auto"}):(this.uiDialog.show(),r=this.element.css("height","auto").height(),s||this.uiDialog.hide(),this.element.height(Math.max(r,n))):this.element.height(Math.max(i.height-t,0)),this.uiDialog.is(":data(resizable)")&&this.uiDialog.resizable("option","minHeight",this._minHeight())}}),e.extend(e.ui.dialog,{uuid:0,maxZ:0,getTitleId:function(e){var t=e.attr("id");return t||(this.uuid+=1,t=this.uuid),"ui-dialog-title-"+t},overlay:function(t){this.$el=e.ui.dialog.overlay.create(t)}}),e.extend(e.ui.dialog.overlay,{instances:[],oldInstances:[],maxZ:0,events:e.map("focus,mousedown,mouseup,keydown,keypress,click".split(","),function(e){return e+".dialog-overlay"}).join(" "),create:function(t){this.instances.length===0&&(setTimeout(function(){e.ui.dialog.overlay.instances.length&&e(document).bind(e.ui.dialog.overlay.events,function(t){if(e(t.target).zIndex()<e.ui.dialog.overlay.maxZ)return!1})},1),e(window).bind("resize.dialog-overlay",e.ui.dialog.overlay.resize));var n=this.oldInstances.pop()||e("<div>").addClass("ui-widget-overlay");return e(document).bind("keydown.dialog-overlay",function(r){var i=e.ui.dialog.overlay.instances;i.length!==0&&i[i.length-1]===n&&t.options.closeOnEscape&&!r.isDefaultPrevented()&&r.keyCode&&r.keyCode===e.ui.keyCode.ESCAPE&&(t.close(r),r.preventDefault())}),n.appendTo(document.body).css({width:this.width(),height:this.height()}),e.fn.bgiframe&&n.bgiframe(),this.instances.push(n),n},destroy:function(t){var n=e.inArray(t,this.instances),r=0;n!==-1&&this.oldInstances.push(this.instances.splice(n,1)[0]),this.instances.length===0&&e([document,window]).unbind(".dialog-overlay"),t.height(0).width(0).remove(),e.each(this.instances,function(){r=Math.max(r,this.css("z-index"))}),this.maxZ=r},height:function(){var t,n;return e.browser.msie?(t=Math.max(document.documentElement.scrollHeight,document.body.scrollHeight),n=Math.max(document.documentElement.offsetHeight,document.body.offsetHeight),t<n?e(window).height()+"px":t+"px"):e(document).height()+"px"},width:function(){var t,n;return e.browser.msie?(t=Math.max(document.documentElement.scrollWidth,document.body.scrollWidth),n=Math.max(document.documentElement.offsetWidth,document.body.offsetWidth),t<n?e(window).width()+"px":t+"px"):e(document).width()+"px"},resize:function(){var t=e([]);e.each(e.ui.dialog.overlay.instances,function(){t=t.add(this)}),t.css({width:0,height:0}).css({width:e.ui.dialog.overlay.width(),height:e.ui.dialog.overlay.height()})}}),e.extend(e.ui.dialog.overlay.prototype,{destroy:function(){e.ui.dialog.overlay.destroy(this.$el)}})})(jQuery);(function(e,t){e.widget("ui.draggable",e.ui.mouse,{version:"1.9.0",widgetEventPrefix:"drag",options:{addClasses:!0,appendTo:"parent",axis:!1,connectToSortable:!1,containment:!1,cursor:"auto",cursorAt:!1,grid:!1,handle:!1,helper:"original",iframeFix:!1,opacity:!1,refreshPositions:!1,revert:!1,revertDuration:500,scope:"default",scroll:!0,scrollSensitivity:20,scrollSpeed:20,snap:!1,snapMode:"both",snapTolerance:20,stack:!1,zIndex:!1},_create:function(){this.options.helper=="original"&&!/^(?:r|a|f)/.test(this.element.css("position"))&&(this.element[0].style.position="relative"),this.options.addClasses&&this.element.addClass("ui-draggable"),this.options.disabled&&this.element.addClass("ui-draggable-disabled"),this._mouseInit()},_destroy:function(){this.element.removeClass("ui-draggable ui-draggable-dragging ui-draggable-disabled"),this._mouseDestroy()},_mouseCapture:function(t){var n=this.options;return this.helper||n.disabled||e(t.target).is(".ui-resizable-handle")?!1:(this.handle=this._getHandle(t),this.handle?(e(n.iframeFix===!0?"iframe":n.iframeFix).each(function(){e('<div class="ui-draggable-iframeFix" style="background: #fff;"></div>').css({width:this.offsetWidth+"px",height:this.offsetHeight+"px",position:"absolute",opacity:"0.001",zIndex:1e3}).css(e(this).offset()).appendTo("body")}),!0):!1)},_mouseStart:function(t){var n=this.options;return this.helper=this._createHelper(t),this.helper.addClass("ui-draggable-dragging"),this._cacheHelperProportions(),e.ui.ddmanager&&(e.ui.ddmanager.current=this),this._cacheMargins(),this.cssPosition=this.helper.css("position"),this.scrollParent=this.helper.scrollParent(),this.offset=this.positionAbs=this.element.offset(),this.offset={top:this.offset.top-this.margins.top,left:this.offset.left-this.margins.left},e.extend(this.offset,{click:{left:t.pageX-this.offset.left,top:t.pageY-this.offset.top},parent:this._getParentOffset(),relative:this._getRelativeOffset()}),this.originalPosition=this.position=this._generatePosition(t),this.originalPageX=t.pageX,this.originalPageY=t.pageY,n.cursorAt&&this._adjustOffsetFromHelper(n.cursorAt),n.containment&&this._setContainment(),this._trigger("start",t)===!1?(this._clear(),!1):(this._cacheHelperProportions(),e.ui.ddmanager&&!n.dropBehaviour&&e.ui.ddmanager.prepareOffsets(this,t),this._mouseDrag(t,!0),e.ui.ddmanager&&e.ui.ddmanager.dragStart(this,t),!0)},_mouseDrag:function(t,n){this.position=this._generatePosition(t),this.positionAbs=this._convertPositionTo("absolute");if(!n){var r=this._uiHash();if(this._trigger("drag",t,r)===!1)return this._mouseUp({}),!1;this.position=r.position}if(!this.options.axis||this.options.axis!="y")this.helper[0].style.left=this.position.left+"px";if(!this.options.axis||this.options.axis!="x")this.helper[0].style.top=this.position.top+"px";return e.ui.ddmanager&&e.ui.ddmanager.drag(this,t),!1},_mouseStop:function(t){var n=!1;e.ui.ddmanager&&!this.options.dropBehaviour&&(n=e.ui.ddmanager.drop(this,t)),this.dropped&&(n=this.dropped,this.dropped=!1);var r=this.element[0],i=!1;while(r&&(r=r.parentNode))r==document&&(i=!0);if(!i&&this.options.helper==="original")return!1;if(this.options.revert=="invalid"&&!n||this.options.revert=="valid"&&n||this.options.revert===!0||e.isFunction(this.options.revert)&&this.options.revert.call(this.element,n)){var s=this;e(this.helper).animate(this.originalPosition,parseInt(this.options.revertDuration,10),function(){s._trigger("stop",t)!==!1&&s._clear()})}else this._trigger("stop",t)!==!1&&this._clear();return!1},_mouseUp:function(t){return e("div.ui-draggable-iframeFix").each(function(){this.parentNode.removeChild(this)}),e.ui.ddmanager&&e.ui.ddmanager.dragStop(this,t),e.ui.mouse.prototype._mouseUp.call(this,t)},cancel:function(){return this.helper.is(".ui-draggable-dragging")?this._mouseUp({}):this._clear(),this},_getHandle:function(t){var n=!this.options.handle||!e(this.options.handle,this.element).length?!0:!1;return e(this.options.handle,this.element).find("*").andSelf().each(function(){this==t.target&&(n=!0)}),n},_createHelper:function(t){var n=this.options,r=e.isFunction(n.helper)?e(n.helper.apply(this.element[0],[t])):n.helper=="clone"?this.element.clone().removeAttr("id"):this.element;return r.parents("body").length||r.appendTo(n.appendTo=="parent"?this.element[0].parentNode:n.appendTo),r[0]!=this.element[0]&&!/(fixed|absolute)/.test(r.css("position"))&&r.css("position","absolute"),r},_adjustOffsetFromHelper:function(t){typeof t=="string"&&(t=t.split(" ")),e.isArray(t)&&(t={left:+t[0],top:+t[1]||0}),"left"in t&&(this.offset.click.left=t.left+this.margins.left),"right"in t&&(this.offset.click.left=this.helperProportions.width-t.right+this.margins.left),"top"in t&&(this.offset.click.top=t.top+this.margins.top),"bottom"in t&&(this.offset.click.top=this.helperProportions.height-t.bottom+this.margins.top)},_getParentOffset:function(){this.offsetParent=this.helper.offsetParent();var t=this.offsetParent.offset();this.cssPosition=="absolute"&&this.scrollParent[0]!=document&&e.contains(this.scrollParent[0],this.offsetParent[0])&&(t.left+=this.scrollParent.scrollLeft(),t.top+=this.scrollParent.scrollTop());if(this.offsetParent[0]==document.body||this.offsetParent[0].tagName&&this.offsetParent[0].tagName.toLowerCase()=="html"&&e.browser.msie)t={top:0,left:0};return{top:t.top+(parseInt(this.offsetParent.css("borderTopWidth"),10)||0),left:t.left+(parseInt(this.offsetParent.css("borderLeftWidth"),10)||0)}},_getRelativeOffset:function(){if(this.cssPosition=="relative"){var e=this.element.position();return{top:e.top-(parseInt(this.helper.css("top"),10)||0)+this.scrollParent.scrollTop(),left:e.left-(parseInt(this.helper.css("left"),10)||0)+this.scrollParent.scrollLeft()}}return{top:0,left:0}},_cacheMargins:function(){this.margins={left:parseInt(this.element.css("marginLeft"),10)||0,top:parseInt(this.element.css("marginTop"),10)||0,right:parseInt(this.element.css("marginRight"),10)||0,bottom:parseInt(this.element.css("marginBottom"),10)||0}},_cacheHelperProportions:function(){this.helperProportions={width:this.helper.outerWidth(),height:this.helper.outerHeight()}},_setContainment:function(){var t=this.options;t.containment=="parent"&&(t.containment=this.helper[0].parentNode);if(t.containment=="document"||t.containment=="window")this.containment=[t.containment=="document"?0:e(window).scrollLeft()-this.offset.relative.left-this.offset.parent.left,t.containment=="document"?0:e(window).scrollTop()-this.offset.relative.top-this.offset.parent.top,(t.containment=="document"?0:e(window).scrollLeft())+e(t.containment=="document"?document:window).width()-this.helperProportions.width-this.margins.left,(t.containment=="document"?0:e(window).scrollTop())+(e(t.containment=="document"?document:window).height()||document.body.parentNode.scrollHeight)-this.helperProportions.height-this.margins.top];if(!/^(document|window|parent)$/.test(t.containment)&&t.containment.constructor!=Array){var n=e(t.containment),r=n[0];if(!r)return;var i=n.offset(),s=e(r).css("overflow")!="hidden";this.containment=[(parseInt(e(r).css("borderLeftWidth"),10)||0)+(parseInt(e(r).css("paddingLeft"),10)||0),(parseInt(e(r).css("borderTopWidth"),10)||0)+(parseInt(e(r).css("paddingTop"),10)||0),(s?Math.max(r.scrollWidth,r.offsetWidth):r.offsetWidth)-(parseInt(e(r).css("borderLeftWidth"),10)||0)-(parseInt(e(r).css("paddingRight"),10)||0)-this.helperProportions.width-this.margins.left-this.margins.right,(s?Math.max(r.scrollHeight,r.offsetHeight):r.offsetHeight)-(parseInt(e(r).css("borderTopWidth"),10)||0)-(parseInt(e(r).css("paddingBottom"),10)||0)-this.helperProportions.height-this.margins.top-this.margins.bottom],this.relative_container=n}else t.containment.constructor==Array&&(this.containment=t.containment)},_convertPositionTo:function(t,n){n||(n=this.position);var r=t=="absolute"?1:-1,i=this.options,s=this.cssPosition!="absolute"||this.scrollParent[0]!=document&&!!e.contains(this.scrollParent[0],this.offsetParent[0])?this.scrollParent:this.offsetParent,o=/(html|body)/i.test(s[0].tagName);return{top:n.top+this.offset.relative.top*r+this.offset.parent.top*r-(this.cssPosition=="fixed"?-this.scrollParent.scrollTop():o?0:s.scrollTop())*r,left:n.left+this.offset.relative.left*r+this.offset.parent.left*r-(this.cssPosition=="fixed"?-this.scrollParent.scrollLeft():o?0:s.scrollLeft())*r}},_generatePosition:function(t){var n=this.options,r=this.cssPosition!="absolute"||this.scrollParent[0]!=document&&!!e.contains(this.scrollParent[0],this.offsetParent[0])?this.scrollParent:this.offsetParent,i=/(html|body)/i.test(r[0].tagName),s=t.pageX,o=t.pageY;if(this.originalPosition){var u;if(this.containment){if(this.relative_container){var a=this.relative_container.offset();u=[this.containment[0]+a.left,this.containment[1]+a.top,this.containment[2]+a.left,this.containment[3]+a.top]}else u=this.containment;t.pageX-this.offset.click.left<u[0]&&(s=u[0]+this.offset.click.left),t.pageY-this.offset.click.top<u[1]&&(o=u[1]+this.offset.click.top),t.pageX-this.offset.click.left>u[2]&&(s=u[2]+this.offset.click.left),t.pageY-this.offset.click.top>u[3]&&(o=u[3]+this.offset.click.top)}if(n.grid){var f=n.grid[1]?this.originalPageY+Math.round((o-this.originalPageY)/n.grid[1])*n.grid[1]:this.originalPageY;o=u?f-this.offset.click.top<u[1]||f-this.offset.click.top>u[3]?f-this.offset.click.top<u[1]?f+n.grid[1]:f-n.grid[1]:f:f;var l=n.grid[0]?this.originalPageX+Math.round((s-this.originalPageX)/n.grid[0])*n.grid[0]:this.originalPageX;s=u?l-this.offset.click.left<u[0]||l-this.offset.click.left>u[2]?l-this.offset.click.left<u[0]?l+n.grid[0]:l-n.grid[0]:l:l}}return{top:o-this.offset.click.top-this.offset.relative.top-this.offset.parent.top+(this.cssPosition=="fixed"?-this.scrollParent.scrollTop():i?0:r.scrollTop()),left:s-this.offset.click.left-this.offset.relative.left-this.offset.parent.left+(this.cssPosition=="fixed"?-this.scrollParent.scrollLeft():i?0:r.scrollLeft())}},_clear:function(){this.helper.removeClass("ui-draggable-dragging"),this.helper[0]!=this.element[0]&&!this.cancelHelperRemoval&&this.helper.remove(),this.helper=null,this.cancelHelperRemoval=!1},_trigger:function(t,n,r){return r=r||this._uiHash(),e.ui.plugin.call(this,t,[n,r]),t=="drag"&&(this.positionAbs=this._convertPositionTo("absolute")),e.Widget.prototype._trigger.call(this,t,n,r)},plugins:{},_uiHash:function(e){return{helper:this.helper,position:this.position,originalPosition:this.originalPosition,offset:this.positionAbs}}}),e.ui.plugin.add("draggable","connectToSortable",{start:function(t,n){var r=e(this).data("draggable"),i=r.options,s=e.extend({},n,{item:r.element});r.sortables=[],e(i.connectToSortable).each(function(){var n=e.data(this,"sortable");n&&!n.options.disabled&&(r.sortables.push({instance:n,shouldRevert:n.options.revert}),n.refreshPositions(),n._trigger("activate",t,s))})},stop:function(t,n){var r=e(this).data("draggable"),i=e.extend({},n,{item:r.element});e.each(r.sortables,function(){this.instance.isOver?(this.instance.isOver=0,r.cancelHelperRemoval=!0,this.instance.cancelHelperRemoval=!1,this.shouldRevert&&(this.instance.options.revert=!0),this.instance._mouseStop(t),this.instance.options.helper=this.instance.options._helper,r.options.helper=="original"&&this.instance.currentItem.css({top:"auto",left:"auto"})):(this.instance.cancelHelperRemoval=!1,this.instance._trigger("deactivate",t,i))})},drag:function(t,n){var r=e(this).data("draggable"),i=this,s=function(t){var n=this.offset.click.top,r=this.offset.click.left,i=this.positionAbs.top,s=this.positionAbs.left,o=t.height,u=t.width,a=t.top,f=t.left;return e.ui.isOver(i+n,s+r,a,f,o,u)};e.each(r.sortables,function(s){this.instance.positionAbs=r.positionAbs,this.instance.helperProportions=r.helperProportions,this.instance.offset.click=r.offset.click,this.instance._intersectsWith(this.instance.containerCache)?(this.instance.isOver||(this.instance.isOver=1,this.instance.currentItem=e(i).clone().removeAttr("id").appendTo(this.instance.element).data("sortable-item",!0),this.instance.options._helper=this.instance.options.helper,this.instance.options.helper=function(){return n.helper[0]},t.target=this.instance.currentItem[0],this.instance._mouseCapture(t,!0),this.instance._mouseStart(t,!0,!0),this.instance.offset.click.top=r.offset.click.top,this.instance.offset.click.left=r.offset.click.left,this.instance.offset.parent.left-=r.offset.parent.left-this.instance.offset.parent.left,this.instance.offset.parent.top-=r.offset.parent.top-this.instance.offset.parent.top,r._trigger("toSortable",t),r.dropped=this.instance.element,r.currentItem=r.element,this.instance.fromOutside=r),this.instance.currentItem&&this.instance._mouseDrag(t)):this.instance.isOver&&(this.instance.isOver=0,this.instance.cancelHelperRemoval=!0,this.instance.options.revert=!1,this.instance._trigger("out",t,this.instance._uiHash(this.instance)),this.instance._mouseStop(t,!0),this.instance.options.helper=this.instance.options._helper,this.instance.currentItem.remove(),this.instance.placeholder&&this.instance.placeholder.remove(),r._trigger("fromSortable",t),r.dropped=!1)})}}),e.ui.plugin.add("draggable","cursor",{start:function(t,n){var r=e("body"),i=e(this).data("draggable").options;r.css("cursor")&&(i._cursor=r.css("cursor")),r.css("cursor",i.cursor)},stop:function(t,n){var r=e(this).data("draggable").options;r._cursor&&e("body").css("cursor",r._cursor)}}),e.ui.plugin.add("draggable","opacity",{start:function(t,n){var r=e(n.helper),i=e(this).data("draggable").options;r.css("opacity")&&(i._opacity=r.css("opacity")),r.css("opacity",i.opacity)},stop:function(t,n){var r=e(this).data("draggable").options;r._opacity&&e(n.helper).css("opacity",r._opacity)}}),e.ui.plugin.add("draggable","scroll",{start:function(t,n){var r=e(this).data("draggable");r.scrollParent[0]!=document&&r.scrollParent[0].tagName!="HTML"&&(r.overflowOffset=r.scrollParent.offset())},drag:function(t,n){var r=e(this).data("draggable"),i=r.options,s=!1;if(r.scrollParent[0]!=document&&r.scrollParent[0].tagName!="HTML"){if(!i.axis||i.axis!="x")r.overflowOffset.top+r.scrollParent[0].offsetHeight-t.pageY<i.scrollSensitivity?r.scrollParent[0].scrollTop=s=r.scrollParent[0].scrollTop+i.scrollSpeed:t.pageY-r.overflowOffset.top<i.scrollSensitivity&&(r.scrollParent[0].scrollTop=s=r.scrollParent[0].scrollTop-i.scrollSpeed);if(!i.axis||i.axis!="y")r.overflowOffset.left+r.scrollParent[0].offsetWidth-t.pageX<i.scrollSensitivity?r.scrollParent[0].scrollLeft=s=r.scrollParent[0].scrollLeft+i.scrollSpeed:t.pageX-r.overflowOffset.left<i.scrollSensitivity&&(r.scrollParent[0].scrollLeft=s=r.scrollParent[0].scrollLeft-i.scrollSpeed)}else{if(!i.axis||i.axis!="x")t.pageY-e(document).scrollTop()<i.scrollSensitivity?s=e(document).scrollTop(e(document).scrollTop()-i.scrollSpeed):e(window).height()-(t.pageY-e(document).scrollTop())<i.scrollSensitivity&&(s=e(document).scrollTop(e(document).scrollTop()+i.scrollSpeed));if(!i.axis||i.axis!="y")t.pageX-e(document).scrollLeft()<i.scrollSensitivity?s=e(document).scrollLeft(e(document).scrollLeft()-i.scrollSpeed):e(window).width()-(t.pageX-e(document).scrollLeft())<i.scrollSensitivity&&(s=e(document).scrollLeft(e(document).scrollLeft()+i.scrollSpeed))}s!==!1&&e.ui.ddmanager&&!i.dropBehaviour&&e.ui.ddmanager.prepareOffsets(r,t)}}),e.ui.plugin.add("draggable","snap",{start:function(t,n){var r=e(this).data("draggable"),i=r.options;r.snapElements=[],e(i.snap.constructor!=String?i.snap.items||":data(draggable)":i.snap).each(function(){var t=e(this),n=t.offset();this!=r.element[0]&&r.snapElements.push({item:this,width:t.outerWidth(),height:t.outerHeight(),top:n.top,left:n.left})})},drag:function(t,n){var r=e(this).data("draggable"),i=r.options,s=i.snapTolerance,o=n.offset.left,u=o+r.helperProportions.width,a=n.offset.top,f=a+r.helperProportions.height;for(var l=r.snapElements.length-1;l>=0;l--){var c=r.snapElements[l].left,h=c+r.snapElements[l].width,p=r.snapElements[l].top,d=p+r.snapElements[l].height;if(!(c-s<o&&o<h+s&&p-s<a&&a<d+s||c-s<o&&o<h+s&&p-s<f&&f<d+s||c-s<u&&u<h+s&&p-s<a&&a<d+s||c-s<u&&u<h+s&&p-s<f&&f<d+s)){r.snapElements[l].snapping&&r.options.snap.release&&r.options.snap.release.call(r.element,t,e.extend(r._uiHash(),{snapItem:r.snapElements[l].item})),r.snapElements[l].snapping=!1;continue}if(i.snapMode!="inner"){var v=Math.abs(p-f)<=s,m=Math.abs(d-a)<=s,g=Math.abs(c-u)<=s,y=Math.abs(h-o)<=s;v&&(n.position.top=r._convertPositionTo("relative",{top:p-r.helperProportions.height,left:0}).top-r.margins.top),m&&(n.position.top=r._convertPositionTo("relative",{top:d,left:0}).top-r.margins.top),g&&(n.position.left=r._convertPositionTo("relative",{top:0,left:c-r.helperProportions.width}).left-r.margins.left),y&&(n.position.left=r._convertPositionTo("relative",{top:0,left:h}).left-r.margins.left)}var b=v||m||g||y;if(i.snapMode!="outer"){var v=Math.abs(p-a)<=s,m=Math.abs(d-f)<=s,g=Math.abs(c-o)<=s,y=Math.abs(h-u)<=s;v&&(n.position.top=r._convertPositionTo("relative",{top:p,left:0}).top-r.margins.top),m&&(n.position.top=r._convertPositionTo("relative",{top:d-r.helperProportions.height,left:0}).top-r.margins.top),g&&(n.position.left=r._convertPositionTo("relative",{top:0,left:c}).left-r.margins.left),y&&(n.position.left=r._convertPositionTo("relative",{top:0,left:h-r.helperProportions.width}).left-r.margins.left)}!r.snapElements[l].snapping&&(v||m||g||y||b)&&r.options.snap.snap&&r.options.snap.snap.call(r.element,t,e.extend(r._uiHash(),{snapItem:r.snapElements[l].item})),r.snapElements[l].snapping=v||m||g||y||b}}}),e.ui.plugin.add("draggable","stack",{start:function(t,n){var r=e(this).data("draggable").options,i=e.makeArray(e(r.stack)).sort(function(t,n){return(parseInt(e(t).css("zIndex"),10)||0)-(parseInt(e(n).css("zIndex"),10)||0)});if(!i.length)return;var s=parseInt(i[0].style.zIndex)||0;e(i).each(function(e){this.style.zIndex=s+e}),this[0].style.zIndex=s+i.length}}),e.ui.plugin.add("draggable","zIndex",{start:function(t,n){var r=e(n.helper),i=e(this).data("draggable").options;r.css("zIndex")&&(i._zIndex=r.css("zIndex")),r.css("zIndex",i.zIndex)},stop:function(t,n){var r=e(this).data("draggable").options;r._zIndex&&e(n.helper).css("zIndex",r._zIndex)}})})(jQuery);(function(e,t){e.widget("ui.droppable",{version:"1.9.0",widgetEventPrefix:"drop",options:{accept:"*",activeClass:!1,addClasses:!0,greedy:!1,hoverClass:!1,scope:"default",tolerance:"intersect"},_create:function(){var t=this.options,n=t.accept;this.isover=0,this.isout=1,this.accept=e.isFunction(n)?n:function(e){return e.is(n)},this.proportions={width:this.element[0].offsetWidth,height:this.element[0].offsetHeight},e.ui.ddmanager.droppables[t.scope]=e.ui.ddmanager.droppables[t.scope]||[],e.ui.ddmanager.droppables[t.scope].push(this),t.addClasses&&this.element.addClass("ui-droppable")},_destroy:function(){var t=e.ui.ddmanager.droppables[this.options.scope];for(var n=0;n<t.length;n++)t[n]==this&&t.splice(n,1);this.element.removeClass("ui-droppable ui-droppable-disabled")},_setOption:function(t,n){t=="accept"&&(this.accept=e.isFunction(n)?n:function(e){return e.is(n)}),e.Widget.prototype._setOption.apply(this,arguments)},_activate:function(t){var n=e.ui.ddmanager.current;this.options.activeClass&&this.element.addClass(this.options.activeClass),n&&this._trigger("activate",t,this.ui(n))},_deactivate:function(t){var n=e.ui.ddmanager.current;this.options.activeClass&&this.element.removeClass(this.options.activeClass),n&&this._trigger("deactivate",t,this.ui(n))},_over:function(t){var n=e.ui.ddmanager.current;if(!n||(n.currentItem||n.element)[0]==this.element[0])return;this.accept.call(this.element[0],n.currentItem||n.element)&&(this.options.hoverClass&&this.element.addClass(this.options.hoverClass),this._trigger("over",t,this.ui(n)))},_out:function(t){var n=e.ui.ddmanager.current;if(!n||(n.currentItem||n.element)[0]==this.element[0])return;this.accept.call(this.element[0],n.currentItem||n.element)&&(this.options.hoverClass&&this.element.removeClass(this.options.hoverClass),this._trigger("out",t,this.ui(n)))},_drop:function(t,n){var r=n||e.ui.ddmanager.current;if(!r||(r.currentItem||r.element)[0]==this.element[0])return!1;var i=!1;return this.element.find(":data(droppable)").not(".ui-draggable-dragging").each(function(){var t=e.data(this,"droppable");if(t.options.greedy&&!t.options.disabled&&t.options.scope==r.options.scope&&t.accept.call(t.element[0],r.currentItem||r.element)&&e.ui.intersect(r,e.extend(t,{offset:t.element.offset()}),t.options.tolerance))return i=!0,!1}),i?!1:this.accept.call(this.element[0],r.currentItem||r.element)?(this.options.activeClass&&this.element.removeClass(this.options.activeClass),this.options.hoverClass&&this.element.removeClass(this.options.hoverClass),this._trigger("drop",t,this.ui(r)),this.element):!1},ui:function(e){return{draggable:e.currentItem||e.element,helper:e.helper,position:e.position,offset:e.positionAbs}}}),e.ui.intersect=function(t,n,r){if(!n.offset)return!1;var i=(t.positionAbs||t.position.absolute).left,s=i+t.helperProportions.width,o=(t.positionAbs||t.position.absolute).top,u=o+t.helperProportions.height,a=n.offset.left,f=a+n.proportions.width,l=n.offset.top,c=l+n.proportions.height;switch(r){case"fit":return a<=i&&s<=f&&l<=o&&u<=c;case"intersect":return a<i+t.helperProportions.width/2&&s-t.helperProportions.width/2<f&&l<o+t.helperProportions.height/2&&u-t.helperProportions.height/2<c;case"pointer":var h=(t.positionAbs||t.position.absolute).left+(t.clickOffset||t.offset.click).left,p=(t.positionAbs||t.position.absolute).top+(t.clickOffset||t.offset.click).top,d=e.ui.isOver(p,h,l,a,n.proportions.height,n.proportions.width);return d;case"touch":return(o>=l&&o<=c||u>=l&&u<=c||o<l&&u>c)&&(i>=a&&i<=f||s>=a&&s<=f||i<a&&s>f);default:return!1}},e.ui.ddmanager={current:null,droppables:{"default":[]},prepareOffsets:function(t,n){var r=e.ui.ddmanager.droppables[t.options.scope]||[],i=n?n.type:null,s=(t.currentItem||t.element).find(":data(droppable)").andSelf();e:for(var o=0;o<r.length;o++){if(r[o].options.disabled||t&&!r[o].accept.call(r[o].element[0],t.currentItem||t.element))continue;for(var u=0;u<s.length;u++)if(s[u]==r[o].element[0]){r[o].proportions.height=0;continue e}r[o].visible=r[o].element.css("display")!="none";if(!r[o].visible)continue;i=="mousedown"&&r[o]._activate.call(r[o],n),r[o].offset=r[o].element.offset(),r[o].proportions={width:r[o].element[0].offsetWidth,height:r[o].element[0].offsetHeight}}},drop:function(t,n){var r=!1;return e.each(e.ui.ddmanager.droppables[t.options.scope]||[],function(){if(!this.options)return;!this.options.disabled&&this.visible&&e.ui.intersect(t,this,this.options.tolerance)&&(r=this._drop.call(this,n)||r),!this.options.disabled&&this.visible&&this.accept.call(this.element[0],t.currentItem||t.element)&&(this.isout=1,this.isover=0,this._deactivate.call(this,n))}),r},dragStart:function(t,n){t.element.parentsUntil("body").bind("scroll.droppable",function(){t.options.refreshPositions||e.ui.ddmanager.prepareOffsets(t,n)})},drag:function(t,n){t.options.refreshPositions&&e.ui.ddmanager.prepareOffsets(t,n),e.each(e.ui.ddmanager.droppables[t.options.scope]||[],function(){if(this.options.disabled||this.greedyChild||!this.visible)return;var r=e.ui.intersect(t,this,this.options.tolerance),i=!r&&this.isover==1?"isout":r&&this.isover==0?"isover":null;if(!i)return;var s;if(this.options.greedy){var o=this.options.scope,u=this.element.parents(":data(droppable)").filter(function(){return e.data(this,"droppable").options.scope===o});u.length&&(s=e.data(u[0],"droppable"),s.greedyChild=i=="isover"?1:0)}s&&i=="isover"&&(s.isover=0,s.isout=1,s._out.call(s,n)),this[i]=1,this[i=="isout"?"isover":"isout"]=0,this[i=="isover"?"_over":"_out"].call(this,n),s&&i=="isout"&&(s.isout=0,s.isover=1,s._over.call(s,n))})},dragStop:function(t,n){t.element.parentsUntil("body").unbind("scroll.droppable"),t.options.refreshPositions||e.ui.ddmanager.prepareOffsets(t,n)}}})(jQuery);jQuery.effects||function(e,t){var n=e.uiBackCompat!==!1,r="ui-effects-";e.effects={effect:{}},function(t,n){function p(e,t,n){var r=a[t.type]||{};return e==null?n||!t.def?null:t.def:(e=r.floor?~~e:parseFloat(e),isNaN(e)?t.def:r.mod?(e+r.mod)%r.mod:0>e?0:r.max<e?r.max:e)}function d(e){var n=o(),r=n._rgba=[];return e=e.toLowerCase(),h(s,function(t,i){var s,o=i.re.exec(e),a=o&&i.parse(o),f=i.space||"rgba";if(a)return s=n[f](a),n[u[f].cache]=s[u[f].cache],r=n._rgba=s._rgba,!1}),r.length?(r.join()==="0,0,0,0"&&t.extend(r,c.transparent),n):c[e]}function v(e,t,n){return n=(n+1)%1,n*6<1?e+(t-e)*n*6:n*2<1?t:n*3<2?e+(t-e)*(2/3-n)*6:e}var r="backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor".split(" "),i=/^([\-+])=\s*(\d+\.?\d*)/,s=[{re:/rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(e){return[e[1],e[2],e[3],e[4]]}},{re:/rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,parse:function(e){return[e[1]*2.55,e[2]*2.55,e[3]*2.55,e[4]]}},{re:/#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,parse:function(e){return[parseInt(e[1],16),parseInt(e[2],16),parseInt(e[3],16)]}},{re:/#([a-f0-9])([a-f0-9])([a-f0-9])/,parse:function(e){return[parseInt(e[1]+e[1],16),parseInt(e[2]+e[2],16),parseInt(e[3]+e[3],16)]}},{re:/hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d+(?:\.\d+)?)\s*)?\)/,space:"hsla",parse:function(e){return[e[1],e[2]/100,e[3]/100,e[4]]}}],o=t.Color=function(e,n,r,i){return new t.Color.fn.parse(e,n,r,i)},u={rgba:{props:{red:{idx:0,type:"byte"},green:{idx:1,type:"byte"},blue:{idx:2,type:"byte"}}},hsla:{props:{hue:{idx:0,type:"degrees"},saturation:{idx:1,type:"percent"},lightness:{idx:2,type:"percent"}}}},a={"byte":{floor:!0,max:255},percent:{max:1},degrees:{mod:360,floor:!0}},f=o.support={},l=t("<p>")[0],c,h=t.each;l.style.cssText="background-color:rgba(1,1,1,.5)",f.rgba=l.style.backgroundColor.indexOf("rgba")>-1,h(u,function(e,t){t.cache="_"+e,t.props.alpha={idx:3,type:"percent",def:1}}),o.fn=t.extend(o.prototype,{parse:function(r,i,s,a){if(r===n)return this._rgba=[null,null,null,null],this;if(r.jquery||r.nodeType)r=t(r).css(i),i=n;var f=this,l=t.type(r),v=this._rgba=[],m;i!==n&&(r=[r,i,s,a],l="array");if(l==="string")return this.parse(d(r)||c._default);if(l==="array")return h(u.rgba.props,function(e,t){v[t.idx]=p(r[t.idx],t)}),this;if(l==="object")return r instanceof o?h(u,function(e,t){r[t.cache]&&(f[t.cache]=r[t.cache].slice())}):h(u,function(t,n){var i=n.cache;h(n.props,function(e,t){if(!f[i]&&n.to){if(e==="alpha"||r[e]==null)return;f[i]=n.to(f._rgba)}f[i][t.idx]=p(r[e],t,!0)}),f[i]&&e.inArray(null,f[i].slice(0,3))<0&&(f[i][3]=1,n.from&&(f._rgba=n.from(f[i])))}),this},is:function(e){var t=o(e),n=!0,r=this;return h(u,function(e,i){var s,o=t[i.cache];return o&&(s=r[i.cache]||i.to&&i.to(r._rgba)||[],h(i.props,function(e,t){if(o[t.idx]!=null)return n=o[t.idx]===s[t.idx],n})),n}),n},_space:function(){var e=[],t=this;return h(u,function(n,r){t[r.cache]&&e.push(n)}),e.pop()},transition:function(e,t){var n=o(e),r=n._space(),i=u[r],s=this.alpha()===0?o("transparent"):this,f=s[i.cache]||i.to(s._rgba),l=f.slice();return n=n[i.cache],h(i.props,function(e,r){var i=r.idx,s=f[i],o=n[i],u=a[r.type]||{};if(o===null)return;s===null?l[i]=o:(u.mod&&(o-s>u.mod/2?s+=u.mod:s-o>u.mod/2&&(s-=u.mod)),l[i]=p((o-s)*t+s,r))}),this[r](l)},blend:function(e){if(this._rgba[3]===1)return this;var n=this._rgba.slice(),r=n.pop(),i=o(e)._rgba;return o(t.map(n,function(e,t){return(1-r)*i[t]+r*e}))},toRgbaString:function(){var e="rgba(",n=t.map(this._rgba,function(e,t){return e==null?t>2?1:0:e});return n[3]===1&&(n.pop(),e="rgb("),e+n.join()+")"},toHslaString:function(){var e="hsla(",n=t.map(this.hsla(),function(e,t){return e==null&&(e=t>2?1:0),t&&t<3&&(e=Math.round(e*100)+"%"),e});return n[3]===1&&(n.pop(),e="hsl("),e+n.join()+")"},toHexString:function(e){var n=this._rgba.slice(),r=n.pop();return e&&n.push(~~(r*255)),"#"+t.map(n,function(e,t){return e=(e||0).toString(16),e.length===1?"0"+e:e}).join("")},toString:function(){return this._rgba[3]===0?"transparent":this.toRgbaString()}}),o.fn.parse.prototype=o.fn,u.hsla.to=function(e){if(e[0]==null||e[1]==null||e[2]==null)return[null,null,null,e[3]];var t=e[0]/255,n=e[1]/255,r=e[2]/255,i=e[3],s=Math.max(t,n,r),o=Math.min(t,n,r),u=s-o,a=s+o,f=a*.5,l,c;return o===s?l=0:t===s?l=60*(n-r)/u+360:n===s?l=60*(r-t)/u+120:l=60*(t-n)/u+240,f===0||f===1?c=f:f<=.5?c=u/a:c=u/(2-a),[Math.round(l)%360,c,f,i==null?1:i]},u.hsla.from=function(e){if(e[0]==null||e[1]==null||e[2]==null)return[null,null,null,e[3]];var t=e[0]/360,n=e[1],r=e[2],i=e[3],s=r<=.5?r*(1+n):r+n-r*n,o=2*r-s,u,a,f;return[Math.round(v(o,s,t+1/3)*255),Math.round(v(o,s,t)*255),Math.round(v(o,s,t-1/3)*255),i]},h(u,function(e,r){var s=r.props,u=r.cache,a=r.to,f=r.from;o.fn[e]=function(e){a&&!this[u]&&(this[u]=a(this._rgba));if(e===n)return this[u].slice();var r,i=t.type(e),l=i==="array"||i==="object"?e:arguments,c=this[u].slice();return h(s,function(e,t){var n=l[i==="object"?e:t.idx];n==null&&(n=c[t.idx]),c[t.idx]=p(n,t)}),f?(r=o(f(c)),r[u]=c,r):o(c)},h(s,function(n,r){if(o.fn[n])return;o.fn[n]=function(s){var o=t.type(s),u=n==="alpha"?this._hsla?"hsla":"rgba":e,a=this[u](),f=a[r.idx],l;return o==="undefined"?f:(o==="function"&&(s=s.call(this,f),o=t.type(s)),s==null&&r.empty?this:(o==="string"&&(l=i.exec(s),l&&(s=f+parseFloat(l[2])*(l[1]==="+"?1:-1))),a[r.idx]=s,this[u](a)))}})}),h(r,function(e,n){t.cssHooks[n]={set:function(e,r){var i,s,u="";if(t.type(r)!=="string"||(i=d(r))){r=o(i||r);if(!f.rgba&&r._rgba[3]!==1){s=n==="backgroundColor"?e.parentNode:e;while((u===""||u==="transparent")&&s&&s.style)try{u=t.css(s,"backgroundColor"),s=s.parentNode}catch(a){}r=r.blend(u&&u!=="transparent"?u:"_default")}r=r.toRgbaString()}try{e.style[n]=r}catch(r){}}},t.fx.step[n]=function(e){e.colorInit||(e.start=o(e.elem,n),e.end=o(e.end),e.colorInit=!0),t.cssHooks[n].set(e.elem,e.start.transition(e.end,e.pos))}}),t.cssHooks.borderColor={expand:function(e){var t={};return h(["Top","Right","Bottom","Left"],function(n,r){t["border"+r+"Color"]=e}),t}},c=t.Color.names={aqua:"#00ffff",black:"#000000",blue:"#0000ff",fuchsia:"#ff00ff",gray:"#808080",green:"#008000",lime:"#00ff00",maroon:"#800000",navy:"#000080",olive:"#808000",purple:"#800080",red:"#ff0000",silver:"#c0c0c0",teal:"#008080",white:"#ffffff",yellow:"#ffff00",transparent:[null,null,null,0],_default:"#ffffff"}}(jQuery),function(){function i(){var t=this.ownerDocument.defaultView?this.ownerDocument.defaultView.getComputedStyle(this,null):this.currentStyle,n={},r,i,s;if(t&&t.length&&t[0]&&t[t[0]]){s=t.length;while(s--)r=t[s],typeof t[r]=="string"&&(n[e.camelCase(r)]=t[r])}else for(r in t)typeof t[r]=="string"&&(n[r]=t[r]);return n}function s(t,n){var i={},s,o;for(s in n)o=n[s],t[s]!==o&&!r[s]&&(e.fx.step[s]||!isNaN(parseFloat(o)))&&(i[s]=o);return i}var n=["add","remove","toggle"],r={border:1,borderBottom:1,borderColor:1,borderLeft:1,borderRight:1,borderTop:1,borderWidth:1,margin:1,padding:1};e.each(["borderLeftStyle","borderRightStyle","borderBottomStyle","borderTopStyle"],function(t,n){e.fx.step[n]=function(e){if(e.end!=="none"&&!e.setAttr||e.pos===1&&!e.setAttr)jQuery.style(e.elem,n,e.end),e.setAttr=!0}}),e.effects.animateClass=function(t,r,o,u){var a=e.speed(r,o,u);return this.queue(function(){var r=e(this),o=r.attr("class")||"",u,f=a.children?r.find("*").andSelf():r;f=f.map(function(){var t=e(this);return{el:t,start:i.call(this)}}),u=function(){e.each(n,function(e,n){t[n]&&r[n+"Class"](t[n])})},u(),f=f.map(function(){return this.end=i.call(this.el[0]),this.diff=s(this.start,this.end),this}),r.attr("class",o),f=f.map(function(){var t=this,n=e.Deferred(),r=jQuery.extend({},a,{queue:!1,complete:function(){n.resolve(t)}});return this.el.animate(this.diff,r),n.promise()}),e.when.apply(e,f.get()).done(function(){u(),e.each(arguments,function(){var t=this.el;e.each(this.diff,function(e){t.css(e,"")})}),a.complete.call(r[0])})})},e.fn.extend({_addClass:e.fn.addClass,addClass:function(t,n,r,i){return n?e.effects.animateClass.call(this,{add:t},n,r,i):this._addClass(t)},_removeClass:e.fn.removeClass,removeClass:function(t,n,r,i){return n?e.effects.animateClass.call(this,{remove:t},n,r,i):this._removeClass(t)},_toggleClass:e.fn.toggleClass,toggleClass:function(n,r,i,s,o){return typeof r=="boolean"||r===t?i?e.effects.animateClass.call(this,r?{add:n}:{remove:n},i,s,o):this._toggleClass(n,r):e.effects.animateClass.call(this,{toggle:n},r,i,s)},switchClass:function(t,n,r,i,s){return e.effects.animateClass.call(this,{add:n,remove:t},r,i,s)}})}(),function(){function i(n,r,i,s){e.isPlainObject(n)&&(r=n,n=n.effect),n={effect:n},r===t&&(r={}),e.isFunction(r)&&(s=r,i=null,r={});if(typeof r=="number"||e.fx.speeds[r])s=i,i=r,r={};return e.isFunction(i)&&(s=i,i=null),r&&e.extend(n,r),i=i||r.duration,n.duration=e.fx.off?0:typeof i=="number"?i:i in e.fx.speeds?e.fx.speeds[i]:e.fx.speeds._default,n.complete=s||r.complete,n}function s(t){return!t||typeof t=="number"||e.fx.speeds[t]?!0:typeof t=="string"&&!e.effects.effect[t]?n&&e.effects[t]?!1:!0:!1}e.extend(e.effects,{version:"1.9.0",save:function(e,t){for(var n=0;n<t.length;n++)t[n]!==null&&e.data(r+t[n],e[0].style[t[n]])},restore:function(e,n){var i,s;for(s=0;s<n.length;s++)n[s]!==null&&(i=e.data(r+n[s]),i===t&&(i=""),e.css(n[s],i))},setMode:function(e,t){return t==="toggle"&&(t=e.is(":hidden")?"show":"hide"),t},getBaseline:function(e,t){var n,r;switch(e[0]){case"top":n=0;break;case"middle":n=.5;break;case"bottom":n=1;break;default:n=e[0]/t.height}switch(e[1]){case"left":r=0;break;case"center":r=.5;break;case"right":r=1;break;default:r=e[1]/t.width}return{x:r,y:n}},createWrapper:function(t){if(t.parent().is(".ui-effects-wrapper"))return t.parent();var n={width:t.outerWidth(!0),height:t.outerHeight(!0),"float":t.css("float")},r=e("<div></div>").addClass("ui-effects-wrapper").css({fontSize:"100%",background:"transparent",border:"none",margin:0,padding:0}),i={width:t.width(),height:t.height()},s=document.activeElement;try{s.id}catch(o){s=document.body}return t.wrap(r),(t[0]===s||e.contains(t[0],s))&&e(s).focus(),r=t.parent(),t.css("position")==="static"?(r.css({position:"relative"}),t.css({position:"relative"})):(e.extend(n,{position:t.css("position"),zIndex:t.css("z-index")}),e.each(["top","left","bottom","right"],function(e,r){n[r]=t.css(r),isNaN(parseInt(n[r],10))&&(n[r]="auto")}),t.css({position:"relative",top:0,left:0,right:"auto",bottom:"auto"})),t.css(i),r.css(n).show()},removeWrapper:function(t){var n=document.activeElement;return t.parent().is(".ui-effects-wrapper")&&(t.parent().replaceWith(t),(t[0]===n||e.contains(t[0],n))&&e(n).focus()),t},setTransition:function(t,n,r,i){return i=i||{},e.each(n,function(e,n){var s=t.cssUnit(n);s[0]>0&&(i[n]=s[0]*r+s[1])}),i}}),e.fn.extend({effect:function(t,r,s,o){function h(t){function s(){e.isFunction(r)&&r.call(n[0]),e.isFunction(t)&&t()}var n=e(this),r=u.complete,i=u.mode;(n.is(":hidden")?i==="hide":i==="show")?s():l.call(n[0],u,s)}var u=i.apply(this,arguments),a=u.mode,f=u.queue,l=e.effects.effect[u.effect],c=!l&&n&&e.effects[u.effect];return e.fx.off||!l&&!c?a?this[a](u.duration,u.complete):this.each(function(){u.complete&&u.complete.call(this)}):l?f===!1?this.each(h):this.queue(f||"fx",h):c.call(this,{options:u,duration:u.duration,callback:u.complete,mode:u.mode})},_show:e.fn.show,show:function(e){if(s(e))return this._show.apply(this,arguments);var t=i.apply(this,arguments);return t.mode="show",this.effect.call(this,t)},_hide:e.fn.hide,hide:function(e){if(s(e))return this._hide.apply(this,arguments);var t=i.apply(this,arguments);return t.mode="hide",this.effect.call(this,t)},__toggle:e.fn.toggle,toggle:function(t){if(s(t)||typeof t=="boolean"||e.isFunction(t))return this.__toggle.apply(this,arguments);var n=i.apply(this,arguments);return n.mode="toggle",this.effect.call(this,n)},cssUnit:function(t){var n=this.css(t),r=[];return e.each(["em","px","%","pt"],function(e,t){n.indexOf(t)>0&&(r=[parseFloat(n),t])}),r}})}(),function(){var t={};e.each(["Quad","Cubic","Quart","Quint","Expo"],function(e,n){t[n]=function(t){return Math.pow(t,e+2)}}),e.extend(t,{Sine:function(e){return 1-Math.cos(e*Math.PI/2)},Circ:function(e){return 1-Math.sqrt(1-e*e)},Elastic:function(e){return e===0||e===1?e:-Math.pow(2,8*(e-1))*Math.sin(((e-1)*80-7.5)*Math.PI/15)},Back:function(e){return e*e*(3*e-2)},Bounce:function(e){var t,n=4;while(e<((t=Math.pow(2,--n))-1)/11);return 1/Math.pow(4,3-n)-7.5625*Math.pow((t*3-2)/22-e,2)}}),e.each(t,function(t,n){e.easing["easeIn"+t]=n,e.easing["easeOut"+t]=function(e){return 1-n(1-e)},e.easing["easeInOut"+t]=function(e){return e<.5?n(e*2)/2:1-n(e*-2+2)/2}})}()}(jQuery);(function(e,t){var n=/up|down|vertical/,r=/up|left|vertical|horizontal/;e.effects.effect.blind=function(t,i){var s=e(this),o=["position","top","bottom","left","right","height","width"],u=e.effects.setMode(s,t.mode||"hide"),a=t.direction||"up",f=n.test(a),l=f?"height":"width",c=f?"top":"left",h=r.test(a),p={},d=u==="show",v,m,g;s.parent().is(".ui-effects-wrapper")?e.effects.save(s.parent(),o):e.effects.save(s,o),s.show(),v=e.effects.createWrapper(s).css({overflow:"hidden"}),m=v[l](),g=parseFloat(v.css(c))||0,p[l]=d?m:0,h||(s.css(f?"bottom":"right",0).css(f?"top":"left","auto").css({position:"absolute"}),p[c]=d?g:m+g),d&&(v.css(l,0),h||v.css(c,g+m)),v.animate(p,{duration:t.duration,easing:t.easing,queue:!1,complete:function(){u==="hide"&&s.hide(),e.effects.restore(s,o),e.effects.removeWrapper(s),i()}})}})(jQuery);(function(e,t){e.effects.effect.bounce=function(t,n){var r=e(this),i=["position","top","bottom","left","right","height","width"],s=e.effects.setMode(r,t.mode||"effect"),o=s==="hide",u=s==="show",a=t.direction||"up",f=t.distance,l=t.times||5,c=l*2+(u||o?1:0),h=t.duration/c,p=t.easing,d=a==="up"||a==="down"?"top":"left",v=a==="up"||a==="left",m,g,y,b=r.queue(),w=b.length;(u||o)&&i.push("opacity"),e.effects.save(r,i),r.show(),e.effects.createWrapper(r),f||(f=r[d==="top"?"outerHeight":"outerWidth"]()/3),u&&(y={opacity:1},y[d]=0,r.css("opacity",0).css(d,v?-f*2:f*2).animate(y,h,p)),o&&(f/=Math.pow(2,l-1)),y={},y[d]=0;for(m=0;m<l;m++)g={},g[d]=(v?"-=":"+=")+f,r.animate(g,h,p).animate(y,h,p),f=o?f*2:f/2;o&&(g={opacity:0},g[d]=(v?"-=":"+=")+f,r.animate(g,h,p)),r.queue(function(){o&&r.hide(),e.effects.restore(r,i),e.effects.removeWrapper(r),n()}),w>1&&b.splice.apply(b,[1,0].concat(b.splice(w,c+1))),r.dequeue()}})(jQuery);(function(e,t){e.effects.effect.clip=function(t,n){var r=e(this),i=["position","top","bottom","left","right","height","width"],s=e.effects.setMode(r,t.mode||"hide"),o=s==="show",u=t.direction||"vertical",a=u==="vertical",f=a?"height":"width",l=a?"top":"left",c={},h,p,d;e.effects.save(r,i),r.show(),h=e.effects.createWrapper(r).css({overflow:"hidden"}),p=r[0].tagName==="IMG"?h:r,d=p[f](),o&&(p.css(f,0),p.css(l,d/2)),c[f]=o?d:0,c[l]=o?0:d/2,p.animate(c,{queue:!1,duration:t.duration,easing:t.easing,complete:function(){o||r.hide(),e.effects.restore(r,i),e.effects.removeWrapper(r),n()}})}})(jQuery);(function(e,t){e.effects.effect.drop=function(t,n){var r=e(this),i=["position","top","bottom","left","right","opacity","height","width"],s=e.effects.setMode(r,t.mode||"hide"),o=s==="show",u=t.direction||"left",a=u==="up"||u==="down"?"top":"left",f=u==="up"||u==="left"?"pos":"neg",l={opacity:o?1:0},c;e.effects.save(r,i),r.show(),e.effects.createWrapper(r),c=t.distance||r[a==="top"?"outerHeight":"outerWidth"](!0)/2,o&&r.css("opacity",0).css(a,f==="pos"?-c:c),l[a]=(o?f==="pos"?"+=":"-=":f==="pos"?"-=":"+=")+c,r.animate(l,{queue:!1,duration:t.duration,easing:t.easing,complete:function(){s==="hide"&&r.hide(),e.effects.restore(r,i),e.effects.removeWrapper(r),n()}})}})(jQuery);(function(e,t){e.effects.effect.explode=function(t,n){function y(){c.push(this),c.length===r*i&&b()}function b(){s.css({visibility:"visible"}),e(c).remove(),u||s.hide(),n()}var r=t.pieces?Math.round(Math.sqrt(t.pieces)):3,i=r,s=e(this),o=e.effects.setMode(s,t.mode||"hide"),u=o==="show",a=s.show().css("visibility","hidden").offset(),f=Math.ceil(s.outerWidth()/i),l=Math.ceil(s.outerHeight()/r),c=[],h,p,d,v,m,g;for(h=0;h<r;h++){v=a.top+h*l,g=h-(r-1)/2;for(p=0;p<i;p++)d=a.left+p*f,m=p-(i-1)/2,s.clone().appendTo("body").wrap("<div></div>").css({position:"absolute",visibility:"visible",left:-p*f,top:-h*l}).parent().addClass("ui-effects-explode").css({position:"absolute",overflow:"hidden",width:f,height:l,left:d+(u?m*f:0),top:v+(u?g*l:0),opacity:u?0:1}).animate({left:d+(u?0:m*f),top:v+(u?0:g*l),opacity:u?1:0},t.duration||500,t.easing,y)}}})(jQuery);(function(e,t){e.effects.effect.fade=function(t,n){var r=e(this),i=e.effects.setMode(r,t.mode||"toggle");r.animate({opacity:i},{queue:!1,duration:t.duration,easing:t.easing,complete:n})}})(jQuery);(function(e,t){e.effects.effect.fold=function(t,n){var r=e(this),i=["position","top","bottom","left","right","height","width"],s=e.effects.setMode(r,t.mode||"hide"),o=s==="show",u=s==="hide",a=t.size||15,f=/([0-9]+)%/.exec(a),l=!!t.horizFirst,c=o!==l,h=c?["width","height"]:["height","width"],p=t.duration/2,d,v,m={},g={};e.effects.save(r,i),r.show(),d=e.effects.createWrapper(r).css({overflow:"hidden"}),v=c?[d.width(),d.height()]:[d.height(),d.width()],f&&(a=parseInt(f[1],10)/100*v[u?0:1]),o&&d.css(l?{height:0,width:a}:{height:a,width:0}),m[h[0]]=o?v[0]:a,g[h[1]]=o?v[1]:0,d.animate(m,p,t.easing).animate(g,p,t.easing,function(){u&&r.hide(),e.effects.restore(r,i),e.effects.removeWrapper(r),n()})}})(jQuery);(function(e,t){e.effects.effect.highlight=function(t,n){var r=e(this),i=["backgroundImage","backgroundColor","opacity"],s=e.effects.setMode(r,t.mode||"show"),o={backgroundColor:r.css("backgroundColor")};s==="hide"&&(o.opacity=0),e.effects.save(r,i),r.show().css({backgroundImage:"none",backgroundColor:t.color||"#ffff99"}).animate(o,{queue:!1,duration:t.duration,easing:t.easing,complete:function(){s==="hide"&&r.hide(),e.effects.restore(r,i),n()}})}})(jQuery);(function(e,t){e.effects.effect.pulsate=function(t,n){var r=e(this),i=e.effects.setMode(r,t.mode||"show"),s=i==="show",o=i==="hide",u=s||i==="hide",a=(t.times||5)*2+(u?1:0),f=t.duration/a,l=0,c=r.queue(),h=c.length,p;if(s||!r.is(":visible"))r.css("opacity",0).show(),l=1;for(p=1;p<a;p++)r.animate({opacity:l},f,t.easing),l=1-l;r.animate({opacity:l},f,t.easing),r.queue(function(){o&&r.hide(),n()}),h>1&&c.splice.apply(c,[1,0].concat(c.splice(h,a+1))),r.dequeue()}})(jQuery);(function(e,t){e.effects.effect.puff=function(t,n){var r=e(this),i=e.effects.setMode(r,t.mode||"hide"),s=i==="hide",o=parseInt(t.percent,10)||150,u=o/100,a={height:r.height(),width:r.width()};e.extend(t,{effect:"scale",queue:!1,fade:!0,mode:i,complete:n,percent:s?o:100,from:s?a:{height:a.height*u,width:a.width*u}}),r.effect(t)},e.effects.effect.scale=function(t,n){var r=e(this),i=e.extend(!0,{},t),s=e.effects.setMode(r,t.mode||"effect"),o=parseInt(t.percent,10)||(parseInt(t.percent,10)===0?0:s==="hide"?0:100),u=t.direction||"both",a=t.origin,f={height:r.height(),width:r.width(),outerHeight:r.outerHeight(),outerWidth:r.outerWidth()},l={y:u!=="horizontal"?o/100:1,x:u!=="vertical"?o/100:1};i.effect="size",i.queue=!1,i.complete=n,s!=="effect"&&(i.origin=a||["middle","center"],i.restore=!0),i.from=t.from||(s==="show"?{height:0,width:0}:f),i.to={height:f.height*l.y,width:f.width*l.x,outerHeight:f.outerHeight*l.y,outerWidth:f.outerWidth*l.x},i.fade&&(s==="show"&&(i.from.opacity=0,i.to.opacity=1),s==="hide"&&(i.from.opacity=1,i.to.opacity=0)),r.effect(i)},e.effects.effect.size=function(t,n){var r=e(this),i=["position","top","bottom","left","right","width","height","overflow","opacity"],s=["position","top","bottom","left","right","overflow","opacity"],o=["width","height","overflow"],u=["fontSize"],a=["borderTopWidth","borderBottomWidth","paddingTop","paddingBottom"],f=["borderLeftWidth","borderRightWidth","paddingLeft","paddingRight"],l=e.effects.setMode(r,t.mode||"effect"),c=t.restore||l!=="effect",h=t.scale||"both",p=t.origin||["middle","center"],d,v,m,g=r.css("position");l==="show"&&r.show(),d={height:r.height(),width:r.width(),outerHeight:r.outerHeight(),outerWidth:r.outerWidth()},r.from=t.from||d,r.to=t.to||d,m={from:{y:r.from.height/d.height,x:r.from.width/d.width},to:{y:r.to.height/d.height,x:r.to.width/d.width}};if(h==="box"||h==="both")m.from.y!==m.to.y&&(i=i.concat(a),r.from=e.effects.setTransition(r,a,m.from.y,r.from),r.to=e.effects.setTransition(r,a,m.to.y,r.to)),m.from.x!==m.to.x&&(i=i.concat(f),r.from=e.effects.setTransition(r,f,m.from.x,r.from),r.to=e.effects.setTransition(r,f,m.to.x,r.to));(h==="content"||h==="both")&&m.from.y!==m.to.y&&(i=i.concat(u),r.from=e.effects.setTransition(r,u,m.from.y,r.from),r.to=e.effects.setTransition(r,u,m.to.y,r.to)),e.effects.save(r,c?i:s),r.show(),e.effects.createWrapper(r),r.css("overflow","hidden").css(r.from),p&&(v=e.effects.getBaseline(p,d),r.from.top=(d.outerHeight-r.outerHeight())*v.y,r.from.left=(d.outerWidth-r.outerWidth())*v.x,r.to.top=(d.outerHeight-r.to.outerHeight)*v.y,r.to.left=(d.outerWidth-r.to.outerWidth)*v.x),r.css(r.from);if(h==="content"||h==="both")a=a.concat(["marginTop","marginBottom"]).concat(u),f=f.concat(["marginLeft","marginRight"]),o=i.concat(a).concat(f),r.find("*[width]").each(function(){var n=e(this),r={height:n.height(),width:n.width()};c&&e.effects.save(n,o),n.from={height:r.height*m.from.y,width:r.width*m.from.x},n.to={height:r.height*m.to.y,width:r.width*m.to.x},m.from.y!==m.to.y&&(n.from=e.effects.setTransition(n,a,m.from.y,n.from),n.to=e.effects.setTransition(n,a,m.to.y,n.to)),m.from.x!==m.to.x&&(n.from=e.effects.setTransition(n,f,m.from.x,n.from),n.to=e.effects.setTransition(n,f,m.to.x,n.to)),n.css(n.from),n.animate(n.to,t.duration,t.easing,function(){c&&e.effects.restore(n,o)})});r.animate(r.to,{queue:!1,duration:t.duration,easing:t.easing,complete:function(){r.to.opacity===0&&r.css("opacity",r.from.opacity),l==="hide"&&r.hide(),e.effects.restore(r,c?i:s),c||(g==="static"?r.css({position:"relative",top:r.to.top,left:r.to.left}):e.each(["top","left"],function(e,t){r.css(t,function(t,n){var i=parseInt(n,10),s=e?r.to.left:r.to.top;return n==="auto"?s+"px":i+s+"px"})})),e.effects.removeWrapper(r),n()}})}})(jQuery);(function(e,t){e.effects.effect.shake=function(t,n){var r=e(this),i=["position","top","bottom","left","right","height","width"],s=e.effects.setMode(r,t.mode||"effect"),o=t.direction||"left",u=t.distance||20,a=t.times||3,f=a*2+1,l=Math.round(t.duration/f),c=o==="up"||o==="down"?"top":"left",h=o==="up"||o==="left",p={},d={},v={},m,g=r.queue(),y=g.length;e.effects.save(r,i),r.show(),e.effects.createWrapper(r),p[c]=(h?"-=":"+=")+u,d[c]=(h?"+=":"-=")+u*2,v[c]=(h?"-=":"+=")+u*2,r.animate(p,l,t.easing);for(m=1;m<a;m++)r.animate(d,l,t.easing).animate(v,l,t.easing);r.animate(d,l,t.easing).animate(p,l/2,t.easing).queue(function(){s==="hide"&&r.hide(),e.effects.restore(r,i),e.effects.removeWrapper(r),n()}),y>1&&g.splice.apply(g,[1,0].concat(g.splice(y,f+1))),r.dequeue()}})(jQuery);(function(e,t){e.effects.effect.slide=function(t,n){var r=e(this),i=["position","top","bottom","left","right","width","height"],s=e.effects.setMode(r,t.mode||"show"),o=s==="show",u=t.direction||"left",a=u==="up"||u==="down"?"top":"left",f=u==="up"||u==="left",l,c={};e.effects.save(r,i),r.show(),l=t.distance||r[a==="top"?"outerHeight":"outerWidth"](!0),e.effects.createWrapper(r).css({overflow:"hidden"}),o&&r.css(a,f?isNaN(l)?"-"+l:-l:l),c[a]=(o?f?"+=":"-=":f?"-=":"+=")+l,r.animate(c,{queue:!1,duration:t.duration,easing:t.easing,complete:function(){s==="hide"&&r.hide(),e.effects.restore(r,i),e.effects.removeWrapper(r),n()}})}})(jQuery);(function(e,t){e.effects.effect.transfer=function(t,n){var r=e(this),i=e(t.to),s=i.css("position")==="fixed",o=e("body"),u=s?o.scrollTop():0,a=s?o.scrollLeft():0,f=i.offset(),l={top:f.top-u,left:f.left-a,height:i.innerHeight(),width:i.innerWidth()},c=r.offset(),h=e('<div class="ui-effects-transfer"></div>').appendTo(document.body).addClass(t.className).css({top:c.top-u,left:c.left-a,height:r.innerHeight(),width:r.innerWidth(),position:s?"fixed":"absolute"}).animate(l,t.duration,t.easing,function(){h.remove(),n()})}})(jQuery);(function(e,t){var n=!1;e.widget("ui.menu",{version:"1.9.0",defaultElement:"<ul>",delay:300,options:{icons:{submenu:"ui-icon-carat-1-e"},menus:"ul",position:{my:"left top",at:"right top"},role:"menu",blur:null,focus:null,select:null},_create:function(){this.activeMenu=this.element,this.element.uniqueId().addClass("ui-menu ui-widget ui-widget-content ui-corner-all").toggleClass("ui-menu-icons",!!this.element.find(".ui-icon").length).attr({role:this.options.role,tabIndex:0}).bind("click"+this.eventNamespace,e.proxy(function(e){this.options.disabled&&e.preventDefault()},this)),this.options.disabled&&this.element.addClass("ui-state-disabled").attr("aria-disabled","true"),this._on({"mousedown .ui-menu-item > a":function(e){e.preventDefault()},"click .ui-state-disabled > a":function(e){e.preventDefault()},"click .ui-menu-item:has(a)":function(t){var r=e(t.target).closest(".ui-menu-item");!n&&r.not(".ui-state-disabled").length&&(n=!0,this.select(t),r.has(".ui-menu").length?this.expand(t):this.element.is(":focus")||(this.element.trigger("focus",[!0]),this.active&&this.active.parents(".ui-menu").length===1&&clearTimeout(this.timer)))},"mouseenter .ui-menu-item":function(t){var n=e(t.currentTarget);n.siblings().children(".ui-state-active").removeClass("ui-state-active"),this.focus(t,n)},mouseleave:"collapseAll","mouseleave .ui-menu":"collapseAll",focus:function(e,t){var n=this.active||this.element.children(".ui-menu-item").eq(0);t||this.focus(e,n)},blur:function(t){this._delay(function(){e.contains(this.element[0],this.document[0].activeElement)||this.collapseAll(t)})},keydown:"_keydown"}),this.refresh(),this._on(this.document,{click:function(t){e(t.target).closest(".ui-menu").length||this.collapseAll(t),n=!1}})},_destroy:function(){this.element.removeAttr("aria-activedescendant").find(".ui-menu").andSelf().removeClass("ui-menu ui-widget ui-widget-content ui-corner-all ui-menu-icons").removeAttr("role").removeAttr("tabIndex").removeAttr("aria-labelledby").removeAttr("aria-expanded").removeAttr("aria-hidden").removeAttr("aria-disabled").removeUniqueId().show(),this.element.find(".ui-menu-item").removeClass("ui-menu-item").removeAttr("role").removeAttr("aria-disabled").children("a").removeUniqueId().removeClass("ui-corner-all ui-state-hover").removeAttr("tabIndex").removeAttr("role").removeAttr("aria-haspopup").children().each(function(){var t=e(this);t.data("ui-menu-submenu-carat")&&t.remove()}),this.element.find(".ui-menu-divider").removeClass("ui-menu-divider ui-widget-content")},_keydown:function(t){function a(e){return e.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g,"\\$&")}var n,r,i,s,o,u=!0;switch(t.keyCode){case e.ui.keyCode.PAGE_UP:this.previousPage(t);break;case e.ui.keyCode.PAGE_DOWN:this.nextPage(t);break;case e.ui.keyCode.HOME:this._move("first","first",t);break;case e.ui.keyCode.END:this._move("last","last",t);break;case e.ui.keyCode.UP:this.previous(t);break;case e.ui.keyCode.DOWN:this.next(t);break;case e.ui.keyCode.LEFT:this.collapse(t);break;case e.ui.keyCode.RIGHT:this.active&&!this.active.is(".ui-state-disabled")&&this.expand(t);break;case e.ui.keyCode.ENTER:case e.ui.keyCode.SPACE:this._activate(t);break;case e.ui.keyCode.ESCAPE:this.collapse(t);break;default:u=!1,r=this.previousFilter||"",i=String.fromCharCode(t.keyCode),s=!1,clearTimeout(this.filterTimer),i===r?s=!0:i=r+i,o=new RegExp("^"+a(i),"i"),n=this.activeMenu.children(".ui-menu-item").filter(function(){return o.test(e(this).children("a").text())}),n=s&&n.index(this.active.next())!==-1?this.active.nextAll(".ui-menu-item"):n,n.length||(i=String.fromCharCode(t.keyCode),o=new RegExp("^"+a(i),"i"),n=this.activeMenu.children(".ui-menu-item").filter(function(){return o.test(e(this).children("a").text())})),n.length?(this.focus(t,n),n.length>1?(this.previousFilter=i,this.filterTimer=this._delay(function(){delete this.previousFilter},1e3)):delete this.previousFilter):delete this.previousFilter}u&&t.preventDefault()},_activate:function(e){this.active.is(".ui-state-disabled")||(this.active.children("a[aria-haspopup='true']").length?this.expand(e):this.select(e))},refresh:function(){var t,n=this.options.icons.submenu,r=this.element.find(this.options.menus+":not(.ui-menu)").addClass("ui-menu ui-widget ui-widget-content ui-corner-all").hide().attr({role:this.options.role,"aria-hidden":"true","aria-expanded":"false"});t=r.add(this.element),t.children(":not(.ui-menu-item):has(a)").addClass("ui-menu-item").attr("role","presentation").children("a").uniqueId().addClass("ui-corner-all").attr({tabIndex:-1,role:this._itemRole()}),t.children(":not(.ui-menu-item)").each(function(){var t=e(this);/[^\-—–\s]/.test(t.text())||t.addClass("ui-widget-content ui-menu-divider")}),t.children(".ui-state-disabled").attr("aria-disabled","true"),r.each(function(){var t=e(this),r=t.prev("a"),i=e("<span>").addClass("ui-menu-icon ui-icon "+n).data("ui-menu-submenu-carat",!0);r.attr("aria-haspopup","true").prepend(i),t.attr("aria-labelledby",r.attr("id"))}),this.active&&!e.contains(this.element[0],this.active[0])&&this.blur()},_itemRole:function(){return{menu:"menuitem",listbox:"option"}[this.options.role]},focus:function(e,t){var n,r;this.blur(e,e&&e.type==="focus"),this._scrollIntoView(t),this.active=t.first(),r=this.active.children("a").addClass("ui-state-focus"),this.options.role&&this.element.attr("aria-activedescendant",r.attr("id")),this.active.parent().closest(".ui-menu-item").children("a:first").addClass("ui-state-active"),e&&e.type==="keydown"?this._close():this.timer=this._delay(function(){this._close()},this.delay),n=t.children(".ui-menu"),n.length&&/^mouse/.test(e.type)&&this._startOpening(n),this.activeMenu=t.parent(),this._trigger("focus",e,{item:t})},_scrollIntoView:function(t){var n,r,i,s,o,u;this._hasScroll()&&(n=parseFloat(e.css(this.activeMenu[0],"borderTopWidth"))||0,r=parseFloat(e.css(this.activeMenu[0],"paddingTop"))||0,i=t.offset().top-this.activeMenu.offset().top-n-r,s=this.activeMenu.scrollTop(),o=this.activeMenu.height(),u=t.height(),i<0?this.activeMenu.scrollTop(s+i):i+u>o&&this.activeMenu.scrollTop(s+i-o+u))},blur:function(e,t){t||clearTimeout(this.timer);if(!this.active)return;this.active.children("a").removeClass("ui-state-focus"),this.active=null,this._trigger("blur",e,{item:this.active})},_startOpening:function(e){clearTimeout(this.timer);if(e.attr("aria-hidden")!=="true")return;this.timer=this._delay(function(){this._close(),this._open(e)},this.delay)},_open:function(t){var n=e.extend({of:this.active},this.options.position);clearTimeout(this.timer),this.element.find(".ui-menu").not(t.parents(".ui-menu")).hide().attr("aria-hidden","true"),t.show().removeAttr("aria-hidden").attr("aria-expanded","true").position(n)},collapseAll:function(t,n){clearTimeout(this.timer),this.timer=this._delay(function(){var r=n?this.element:e(t&&t.target).closest(this.element.find(".ui-menu"));r.length||(r=this.element),this._close(r),this.blur(t),this.activeMenu=r},this.delay)},_close:function(e){e||(e=this.active?this.active.parent():this.element),e.find(".ui-menu").hide().attr("aria-hidden","true").attr("aria-expanded","false").end().find("a.ui-state-active").removeClass("ui-state-active")},collapse:function(e){var t=this.active&&this.active.parent().closest(".ui-menu-item",this.element);t&&t.length&&(this._close(),this.focus(e,t))},expand:function(e){var t=this.active&&this.active.children(".ui-menu ").children(".ui-menu-item").first();t&&t.length&&(this._open(t.parent()),this._delay(function(){this.focus(e,t)}))},next:function(e){this._move("next","first",e)},previous:function(e){this._move("prev","last",e)},isFirstItem:function(){return this.active&&!this.active.prevAll(".ui-menu-item").length},isLastItem:function(){return this.active&&!this.active.nextAll(".ui-menu-item").length},_move:function(e,t,n){var r;this.active&&(e==="first"||e==="last"?r=this.active[e==="first"?"prevAll":"nextAll"](".ui-menu-item").eq(-1):r=this.active[e+"All"](".ui-menu-item").eq(0));if(!r||!r.length||!this.active)r=this.activeMenu.children(".ui-menu-item")[t]();this.focus(n,r)},nextPage:function(t){var n,r,i;if(!this.active){this.next(t);return}if(this.isLastItem())return;this._hasScroll()?(r=this.active.offset().top,i=this.element.height(),this.active.nextAll(".ui-menu-item").each(function(){return n=e(this),n.offset().top-r-i<0}),this.focus(t,n)):this.focus(t,this.activeMenu.children(".ui-menu-item")[this.active?"last":"first"]())},previousPage:function(t){var n,r,i;if(!this.active){this.next(t);return}if(this.isFirstItem())return;this._hasScroll()?(r=this.active.offset().top,i=this.element.height(),this.active.prevAll(".ui-menu-item").each(function(){return n=e(this),n.offset().top-r+i>0}),this.focus(t,n)):this.focus(t,this.activeMenu.children(".ui-menu-item").first())},_hasScroll:function(){return this.element.outerHeight()<this.element.prop("scrollHeight")},select:function(t){this.active=this.active||e(t.target).closest(".ui-menu-item");var n={item:this.active};this.active.has(".ui-menu").length||this.collapseAll(t,!0),this._trigger("select",t,n)}})})(jQuery);(function(e,t){e.widget("ui.progressbar",{version:"1.9.0",options:{value:0,max:100},min:0,_create:function(){this.element.addClass("ui-progressbar ui-widget ui-widget-content ui-corner-all").attr({role:"progressbar","aria-valuemin":this.min,"aria-valuemax":this.options.max,"aria-valuenow":this._value()}),this.valueDiv=e("<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>").appendTo(this.element),this.oldValue=this._value(),this._refreshValue()},_destroy:function(){this.element.removeClass("ui-progressbar ui-widget ui-widget-content ui-corner-all").removeAttr("role").removeAttr("aria-valuemin").removeAttr("aria-valuemax").removeAttr("aria-valuenow"),this.valueDiv.remove()},value:function(e){return e===t?this._value():(this._setOption("value",e),this)},_setOption:function(e,t){e==="value"&&(this.options.value=t,this._refreshValue(),this._value()===this.options.max&&this._trigger("complete")),this._super(e,t)},_value:function(){var e=this.options.value;return typeof e!="number"&&(e=0),Math.min(this.options.max,Math.max(this.min,e))},_percentage:function(){return 100*this._value()/this.options.max},_refreshValue:function(){var e=this.value(),t=this._percentage();this.oldValue!==e&&(this.oldValue=e,this._trigger("change")),this.valueDiv.toggle(e>this.min).toggleClass("ui-corner-right",e===this.options.max).width(t.toFixed(0)+"%"),this.element.attr("aria-valuenow",e)}})})(jQuery);(function(e,t){e.widget("ui.resizable",e.ui.mouse,{version:"1.9.0",widgetEventPrefix:"resize",options:{alsoResize:!1,animate:!1,animateDuration:"slow",animateEasing:"swing",aspectRatio:!1,autoHide:!1,containment:!1,ghost:!1,grid:!1,handles:"e,s,se",helper:!1,maxHeight:null,maxWidth:null,minHeight:10,minWidth:10,zIndex:1e3},_create:function(){var t=this,n=this.options;this.element.addClass("ui-resizable"),e.extend(this,{_aspectRatio:!!n.aspectRatio,aspectRatio:n.aspectRatio,originalElement:this.element,_proportionallyResizeElements:[],_helper:n.helper||n.ghost||n.animate?n.helper||"ui-resizable-helper":null}),this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)&&(this.element.wrap(e('<div class="ui-wrapper" style="overflow: hidden;"></div>').css({position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")})),this.element=this.element.parent().data("resizable",this.element.data("resizable")),this.elementIsWrapper=!0,this.element.css({marginLeft:this.originalElement.css("marginLeft"),marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom")}),this.originalElement.css({marginLeft:0,marginTop:0,marginRight:0,marginBottom:0}),this.originalResizeStyle=this.originalElement.css("resize"),this.originalElement.css("resize","none"),this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"})),this.originalElement.css({margin:this.originalElement.css("margin")}),this._proportionallyResize()),this.handles=n.handles||(e(".ui-resizable-handle",this.element).length?{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"}:"e,s,se");if(this.handles.constructor==String){this.handles=="all"&&(this.handles="n,e,s,w,se,sw,ne,nw");var r=this.handles.split(",");this.handles={};for(var i=0;i<r.length;i++){var s=e.trim(r[i]),o="ui-resizable-"+s,u=e('<div class="ui-resizable-handle '+o+'"></div>');u.css({zIndex:n.zIndex}),"se"==s&&u.addClass("ui-icon ui-icon-gripsmall-diagonal-se"),this.handles[s]=".ui-resizable-"+s,this.element.append(u)}}this._renderAxis=function(t){t=t||this.element;for(var n in this.handles){this.handles[n].constructor==String&&(this.handles[n]=e(this.handles[n],this.element).show());if(this.elementIsWrapper&&this.originalElement[0].nodeName.match(/textarea|input|select|button/i)){var r=e(this.handles[n],this.element),i=0;i=/sw|ne|nw|se|n|s/.test(n)?r.outerHeight():r.outerWidth();var s=["padding",/ne|nw|n/.test(n)?"Top":/se|sw|s/.test(n)?"Bottom":/^e$/.test(n)?"Right":"Left"].join("");t.css(s,i),this._proportionallyResize()}if(!e(this.handles[n]).length)continue}},this._renderAxis(this.element),this._handles=e(".ui-resizable-handle",this.element).disableSelection(),this._handles.mouseover(function(){if(!t.resizing){if(this.className)var e=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);t.axis=e&&e[1]?e[1]:"se"}}),n.autoHide&&(this._handles.hide(),e(this.element).addClass("ui-resizable-autohide").mouseenter(function(){if(n.disabled)return;e(this).removeClass("ui-resizable-autohide"),t._handles.show()}).mouseleave(function(){if(n.disabled)return;t.resizing||(e(this).addClass("ui-resizable-autohide"),t._handles.hide())})),this._mouseInit()},_destroy:function(){this._mouseDestroy();var t=function(t){e(t).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing").removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove()};if(this.elementIsWrapper){t(this.element);var n=this.element;n.after(this.originalElement.css({position:n.css("position"),width:n.outerWidth(),height:n.outerHeight(),top:n.css("top"),left:n.css("left")})).remove()}return this.originalElement.css("resize",this.originalResizeStyle),t(this.originalElement),this},_mouseCapture:function(t){var n=!1;for(var r in this.handles)e(this.handles[r])[0]==t.target&&(n=!0);return!this.options.disabled&&n},_mouseStart:function(t){var r=this.options,i=this.element.position(),s=this.element;this.resizing=!0,this.documentScroll={top:e(document).scrollTop(),left:e(document).scrollLeft()},(s.is(".ui-draggable")||/absolute/.test(s.css("position")))&&s.css({position:"absolute",top:i.top,left:i.left}),this._renderProxy();var o=n(this.helper.css("left")),u=n(this.helper.css("top"));r.containment&&(o+=e(r.containment).scrollLeft()||0,u+=e(r.containment).scrollTop()||0),this.offset=this.helper.offset(),this.position={left:o,top:u},this.size=this._helper?{width:s.outerWidth(),height:s.outerHeight()}:{width:s.width(),height:s.height()},this.originalSize=this._helper?{width:s.outerWidth(),height:s.outerHeight()}:{width:s.width(),height:s.height()},this.originalPosition={left:o,top:u},this.sizeDiff={width:s.outerWidth()-s.width(),height:s.outerHeight()-s.height()},this.originalMousePosition={left:t.pageX,top:t.pageY},this.aspectRatio=typeof r.aspectRatio=="number"?r.aspectRatio:this.originalSize.width/this.originalSize.height||1;var a=e(".ui-resizable-"+this.axis).css("cursor");return e("body").css("cursor",a=="auto"?this.axis+"-resize":a),s.addClass("ui-resizable-resizing"),this._propagate("start",t),!0},_mouseDrag:function(e){var t=this.helper,n=this.options,r={},i=this,s=this.originalMousePosition,o=this.axis,u=e.pageX-s.left||0,a=e.pageY-s.top||0,f=this._change[o];if(!f)return!1;var l=f.apply(this,[e,u,a]);this._updateVirtualBoundaries(e.shiftKey);if(this._aspectRatio||e.shiftKey)l=this._updateRatio(l,e);return l=this._respectSize(l,e),this._propagate("resize",e),t.css({top:this.position.top+"px",left:this.position.left+"px",width:this.size.width+"px",height:this.size.height+"px"}),!this._helper&&this._proportionallyResizeElements.length&&this._proportionallyResize(),this._updateCache(l),this._trigger("resize",e,this.ui()),!1},_mouseStop:function(t){this.resizing=!1;var n=this.options,r=this;if(this._helper){var i=this._proportionallyResizeElements,s=i.length&&/textarea/i.test(i[0].nodeName),o=s&&e.ui.hasScroll(i[0],"left")?0:r.sizeDiff.height,u=s?0:r.sizeDiff.width,a={width:r.helper.width()-u,height:r.helper.height()-o},f=parseInt(r.element.css("left"),10)+(r.position.left-r.originalPosition.left)||null,l=parseInt(r.element.css("top"),10)+(r.position.top-r.originalPosition.top)||null;n.animate||this.element.css(e.extend(a,{top:l,left:f})),r.helper.height(r.size.height),r.helper.width(r.size.width),this._helper&&!n.animate&&this._proportionallyResize()}return e("body").css("cursor","auto"),this.element.removeClass("ui-resizable-resizing"),this._propagate("stop",t),this._helper&&this.helper.remove(),!1},_updateVirtualBoundaries:function(e){var t=this.options,n,i,s,o,u;u={minWidth:r(t.minWidth)?t.minWidth:0,maxWidth:r(t.maxWidth)?t.maxWidth:Infinity,minHeight:r(t.minHeight)?t.minHeight:0,maxHeight:r(t.maxHeight)?t.maxHeight:Infinity};if(this._aspectRatio||e)n=u.minHeight*this.aspectRatio,s=u.minWidth/this.aspectRatio,i=u.maxHeight*this.aspectRatio,o=u.maxWidth/this.aspectRatio,n>u.minWidth&&(u.minWidth=n),s>u.minHeight&&(u.minHeight=s),i<u.maxWidth&&(u.maxWidth=i),o<u.maxHeight&&(u.maxHeight=o);this._vBoundaries=u},_updateCache:function(e){var t=this.options;this.offset=this.helper.offset(),r(e.left)&&(this.position.left=e.left),r(e.top)&&(this.position.top=e.top),r(e.height)&&(this.size.height=e.height),r(e.width)&&(this.size.width=e.width)},_updateRatio:function(e,t){var n=this.options,i=this.position,s=this.size,o=this.axis;return r(e.height)?e.width=e.height*this.aspectRatio:r(e.width)&&(e.height=e.width/this.aspectRatio),o=="sw"&&(e.left=i.left+(s.width-e.width),e.top=null),o=="nw"&&(e.top=i.top+(s.height-e.height),e.left=i.left+(s.width-e.width)),e},_respectSize:function(e,t){var n=this.helper,i=this._vBoundaries,s=this._aspectRatio||t.shiftKey,o=this.axis,u=r(e.width)&&i.maxWidth&&i.maxWidth<e.width,a=r(e.height)&&i.maxHeight&&i.maxHeight<e.height,f=r(e.width)&&i.minWidth&&i.minWidth>e.width,l=r(e.height)&&i.minHeight&&i.minHeight>e.height;f&&(e.width=i.minWidth),l&&(e.height=i.minHeight),u&&(e.width=i.maxWidth),a&&(e.height=i.maxHeight);var c=this.originalPosition.left+this.originalSize.width,h=this.position.top+this.size.height,p=/sw|nw|w/.test(o),d=/nw|ne|n/.test(o);f&&p&&(e.left=c-i.minWidth),u&&p&&(e.left=c-i.maxWidth),l&&d&&(e.top=h-i.minHeight),a&&d&&(e.top=h-i.maxHeight);var v=!e.width&&!e.height;return v&&!e.left&&e.top?e.top=null:v&&!e.top&&e.left&&(e.left=null),e},_proportionallyResize:function(){var t=this.options;if(!this._proportionallyResizeElements.length)return;var n=this.helper||this.element;for(var r=0;r<this._proportionallyResizeElements.length;r++){var i=this._proportionallyResizeElements[r];if(!this.borderDif){var s=[i.css("borderTopWidth"),i.css("borderRightWidth"),i.css("borderBottomWidth"),i.css("borderLeftWidth")],o=[i.css("paddingTop"),i.css("paddingRight"),i.css("paddingBottom"),i.css("paddingLeft")];this.borderDif=e.map(s,function(e,t){var n=parseInt(e,10)||0,r=parseInt(o[t],10)||0;return n+r})}i.css({height:n.height()-this.borderDif[0]-this.borderDif[2]||0,width:n.width()-this.borderDif[1]-this.borderDif[3]||0})}},_renderProxy:function(){var t=this.element,n=this.options;this.elementOffset=t.offset();if(this._helper){this.helper=this.helper||e('<div style="overflow:hidden;"></div>');var r=e.browser.msie&&e.browser.version<7,i=r?1:0,s=r?2:-1;this.helper.addClass(this._helper).css({width:this.element.outerWidth()+s,height:this.element.outerHeight()+s,position:"absolute",left:this.elementOffset.left-i+"px",top:this.elementOffset.top-i+"px",zIndex:++n.zIndex}),this.helper.appendTo("body").disableSelection()}else this.helper=this.element},_change:{e:function(e,t,n){return{width:this.originalSize.width+t}},w:function(e,t,n){var r=this.options,i=this.originalSize,s=this.originalPosition;return{left:s.left+t,width:i.width-t}},n:function(e,t,n){var r=this.options,i=this.originalSize,s=this.originalPosition;return{top:s.top+n,height:i.height-n}},s:function(e,t,n){return{height:this.originalSize.height+n}},se:function(t,n,r){return e.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[t,n,r]))},sw:function(t,n,r){return e.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[t,n,r]))},ne:function(t,n,r){return e.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[t,n,r]))},nw:function(t,n,r){return e.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[t,n,r]))}},_propagate:function(t,n){e.ui.plugin.call(this,t,[n,this.ui()]),t!="resize"&&this._trigger(t,n,this.ui())},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}}),e.ui.plugin.add("resizable","alsoResize",{start:function(t,n){var r=e(this).data("resizable"),i=r.options,s=function(t){e(t).each(function(){var t=e(this);t.data("resizable-alsoresize",{width:parseInt(t.width(),10),height:parseInt(t.height(),10),left:parseInt(t.css("left"),10),top:parseInt(t.css("top"),10)})})};typeof i.alsoResize=="object"&&!i.alsoResize.parentNode?i.alsoResize.length?(i.alsoResize=i.alsoResize[0],s(i.alsoResize)):e.each(i.alsoResize,function(e){s(e)}):s(i.alsoResize)},resize:function(t,n){var r=e(this).data("resizable"),i=r.options,s=r.originalSize,o=r.originalPosition,u={height:r.size.height-s.height||0,width:r.size.width-s.width||0,top:r.position.top-o.top||0,left:r.position.left-o.left||0},a=function(t,r){e(t).each(function(){var t=e(this),i=e(this).data("resizable-alsoresize"),s={},o=r&&r.length?r:t.parents(n.originalElement[0]).length?["width","height"]:["width","height","top","left"];e.each(o,function(e,t){var n=(i[t]||0)+(u[t]||0);n&&n>=0&&(s[t]=n||null)}),t.css(s)})};typeof i.alsoResize=="object"&&!i.alsoResize.nodeType?e.each(i.alsoResize,function(e,t){a(e,t)}):a(i.alsoResize)},stop:function(t,n){e(this).removeData("resizable-alsoresize")}}),e.ui.plugin.add("resizable","animate",{stop:function(t,n){var r=e(this).data("resizable"),i=r.options,s=r._proportionallyResizeElements,o=s.length&&/textarea/i.test(s[0].nodeName),u=o&&e.ui.hasScroll(s[0],"left")?0:r.sizeDiff.height,a=o?0:r.sizeDiff.width,f={width:r.size.width-a,height:r.size.height-u},l=parseInt(r.element.css("left"),10)+(r.position.left-r.originalPosition.left)||null,c=parseInt(r.element.css("top"),10)+(r.position.top-r.originalPosition.top)||null;r.element.animate(e.extend(f,c&&l?{top:c,left:l}:{}),{duration:i.animateDuration,easing:i.animateEasing,step:function(){var n={width:parseInt(r.element.css("width"),10),height:parseInt(r.element.css("height"),10),top:parseInt(r.element.css("top"),10),left:parseInt(r.element.css("left"),10)};s&&s.length&&e(s[0]).css({width:n.width,height:n.height}),r._updateCache(n),r._propagate("resize",t)}})}}),e.ui.plugin.add("resizable","containment",{start:function(t,r){var i=e(this).data("resizable"),s=i.options,o=i.element,u=s.containment,a=u instanceof e?u.get(0):/parent/.test(u)?o.parent().get(0):u;if(!a)return;i.containerElement=e(a);if(/document/.test(u)||u==document)i.containerOffset={left:0,top:0},i.containerPosition={left:0,top:0},i.parentData={element:e(document),left:0,top:0,width:e(document).width(),height:e(document).height()||document.body.parentNode.scrollHeight};else{var f=e(a),l=[];e(["Top","Right","Left","Bottom"]).each(function(e,t){l[e]=n(f.css("padding"+t))}),i.containerOffset=f.offset(),i.containerPosition=f.position(),i.containerSize={height:f.innerHeight()-l[3],width:f.innerWidth()-l[1]};var c=i.containerOffset,h=i.containerSize.height,p=i.containerSize.width,d=e.ui.hasScroll(a,"left")?a.scrollWidth:p,v=e.ui.hasScroll(a)?a.scrollHeight:h;i.parentData={element:a,left:c.left,top:c.top,width:d,height:v}}},resize:function(t,n){var r=e(this).data("resizable"),i=r.options,s=r.containerSize,o=r.containerOffset,u=r.size,a=r.position,f=r._aspectRatio||t.shiftKey,l={top:0,left:0},c=r.containerElement;c[0]!=document&&/static/.test(c.css("position"))&&(l=o),a.left<(r._helper?o.left:0)&&(r.size.width=r.size.width+(r._helper?r.position.left-o.left:r.position.left-l.left),f&&(r.size.height=r.size.width/r.aspectRatio),r.position.left=i.helper?o.left:0),a.top<(r._helper?o.top:0)&&(r.size.height=r.size.height+(r._helper?r.position.top-o.top:r.position.top),f&&(r.size.width=r.size.height*r.aspectRatio),r.position.top=r._helper?o.top:0),r.offset.left=r.parentData.left+r.position.left,r.offset.top=r.parentData.top+r.position.top;var h=Math.abs((r._helper?r.offset.left-l.left:r.offset.left-l.left)+r.sizeDiff.width),p=Math.abs((r._helper?r.offset.top-l.top:r.offset.top-o.top)+r.sizeDiff.height),d=r.containerElement.get(0)==r.element.parent().get(0),v=/relative|absolute/.test(r.containerElement.css("position"));d&&v&&(h-=r.parentData.left),h+r.size.width>=r.parentData.width&&(r.size.width=r.parentData.width-h,f&&(r.size.height=r.size.width/r.aspectRatio)),p+r.size.height>=r.parentData.height&&(r.size.height=r.parentData.height-p,f&&(r.size.width=r.size.height*r.aspectRatio))},stop:function(t,n){var r=e(this).data("resizable"),i=r.options,s=r.position,o=r.containerOffset,u=r.containerPosition,a=r.containerElement,f=e(r.helper),l=f.offset(),c=f.outerWidth()-r.sizeDiff.width,h=f.outerHeight()-r.sizeDiff.height;r._helper&&!i.animate&&/relative/.test(a.css("position"))&&e(this).css({left:l.left-u.left-o.left,width:c,height:h}),r._helper&&!i.animate&&/static/.test(a.css("position"))&&e(this).css({left:l.left-u.left-o.left,width:c,height:h})}}),e.ui.plugin.add("resizable","ghost",{start:function(t,n){var r=e(this).data("resizable"),i=r.options,s=r.size;r.ghost=r.originalElement.clone(),r.ghost.css({opacity:.25,display:"block",position:"relative",height:s.height,width:s.width,margin:0,left:0,top:0}).addClass("ui-resizable-ghost").addClass(typeof i.ghost=="string"?i.ghost:""),r.ghost.appendTo(r.helper)},resize:function(t,n){var r=e(this).data("resizable"),i=r.options;r.ghost&&r.ghost.css({position:"relative",height:r.size.height,width:r.size.width})},stop:function(t,n){var r=e(this).data("resizable"),i=r.options;r.ghost&&r.helper&&r.helper.get(0).removeChild(r.ghost.get(0))}}),e.ui.plugin.add("resizable","grid",{resize:function(t,n){var r=e(this).data("resizable"),i=r.options,s=r.size,o=r.originalSize,u=r.originalPosition,a=r.axis,f=i._aspectRatio||t.shiftKey;i.grid=typeof i.grid=="number"?[i.grid,i.grid]:i.grid;var l=Math.round((s.width-o.width)/(i.grid[0]||1))*(i.grid[0]||1),c=Math.round((s.height-o.height)/(i.grid[1]||1))*(i.grid[1]||1);/^(se|s|e)$/.test(a)?(r.size.width=o.width+l,r.size.height=o.height+c):/^(ne)$/.test(a)?(r.size.width=o.width+l,r.size.height=o.height+c,r.position.top=u.top-c):/^(sw)$/.test(a)?(r.size.width=o.width+l,r.size.height=o.height+c,r.position.left=u.left-l):(r.size.width=o.width+l,r.size.height=o.height+c,r.position.top=u.top-c,r.position.left=u.left-l)}});var n=function(e){return parseInt(e,10)||0},r=function(e){return!isNaN(parseInt(e,10))}})(jQuery);(function(e,t){e.widget("ui.selectable",e.ui.mouse,{version:"1.9.0",options:{appendTo:"body",autoRefresh:!0,distance:0,filter:"*",tolerance:"touch"},_create:function(){var t=this;this.element.addClass("ui-selectable"),this.dragged=!1;var n;this.refresh=function(){n=e(t.options.filter,t.element[0]),n.addClass("ui-selectee"),n.each(function(){var t=e(this),n=t.offset();e.data(this,"selectable-item",{element:this,$element:t,left:n.left,top:n.top,right:n.left+t.outerWidth(),bottom:n.top+t.outerHeight(),startselected:!1,selected:t.hasClass("ui-selected"),selecting:t.hasClass("ui-selecting"),unselecting:t.hasClass("ui-unselecting")})})},this.refresh(),this.selectees=n.addClass("ui-selectee"),this._mouseInit(),this.helper=e("<div class='ui-selectable-helper'></div>")},_destroy:function(){this.selectees.removeClass("ui-selectee").removeData("selectable-item"),this.element.removeClass("ui-selectable ui-selectable-disabled"),this._mouseDestroy()},_mouseStart:function(t){var n=this;this.opos=[t.pageX,t.pageY];if(this.options.disabled)return;var r=this.options;this.selectees=e(r.filter,this.element[0]),this._trigger("start",t),e(r.appendTo).append(this.helper),this.helper.css({left:t.clientX,top:t.clientY,width:0,height:0}),r.autoRefresh&&this.refresh(),this.selectees.filter(".ui-selected").each(function(){var r=e.data(this,"selectable-item");r.startselected=!0,!t.metaKey&&!t.ctrlKey&&(r.$element.removeClass("ui-selected"),r.selected=!1,r.$element.addClass("ui-unselecting"),r.unselecting=!0,n._trigger("unselecting",t,{unselecting:r.element}))}),e(t.target).parents().andSelf().each(function(){var r=e.data(this,"selectable-item");if(r){var i=!t.metaKey&&!t.ctrlKey||!r.$element.hasClass("ui-selected");return r.$element.removeClass(i?"ui-unselecting":"ui-selected").addClass(i?"ui-selecting":"ui-unselecting"),r.unselecting=!i,r.selecting=i,r.selected=i,i?n._trigger("selecting",t,{selecting:r.element}):n._trigger("unselecting",t,{unselecting:r.element}),!1}})},_mouseDrag:function(t){var n=this;this.dragged=!0;if(this.options.disabled)return;var r=this.options,i=this.opos[0],s=this.opos[1],o=t.pageX,u=t.pageY;if(i>o){var a=o;o=i,i=a}if(s>u){var a=u;u=s,s=a}return this.helper.css({left:i,top:s,width:o-i,height:u-s}),this.selectees.each(function(){var a=e.data(this,"selectable-item");if(!a||a.element==n.element[0])return;var f=!1;r.tolerance=="touch"?f=!(a.left>o||a.right<i||a.top>u||a.bottom<s):r.tolerance=="fit"&&(f=a.left>i&&a.right<o&&a.top>s&&a.bottom<u),f?(a.selected&&(a.$element.removeClass("ui-selected"),a.selected=!1),a.unselecting&&(a.$element.removeClass("ui-unselecting"),a.unselecting=!1),a.selecting||(a.$element.addClass("ui-selecting"),a.selecting=!0,n._trigger("selecting",t,{selecting:a.element}))):(a.selecting&&((t.metaKey||t.ctrlKey)&&a.startselected?(a.$element.removeClass("ui-selecting"),a.selecting=!1,a.$element.addClass("ui-selected"),a.selected=!0):(a.$element.removeClass("ui-selecting"),a.selecting=!1,a.startselected&&(a.$element.addClass("ui-unselecting"),a.unselecting=!0),n._trigger("unselecting",t,{unselecting:a.element}))),a.selected&&!t.metaKey&&!t.ctrlKey&&!a.startselected&&(a.$element.removeClass("ui-selected"),a.selected=!1,a.$element.addClass("ui-unselecting"),a.unselecting=!0,n._trigger("unselecting",t,{unselecting:a.element})))}),!1},_mouseStop:function(t){var n=this;this.dragged=!1;var r=this.options;return e(".ui-unselecting",this.element[0]).each(function(){var r=e.data(this,"selectable-item");r.$element.removeClass("ui-unselecting"),r.unselecting=!1,r.startselected=!1,n._trigger("unselected",t,{unselected:r.element})}),e(".ui-selecting",this.element[0]).each(function(){var r=e.data(this,"selectable-item");r.$element.removeClass("ui-selecting").addClass("ui-selected"),r.selecting=!1,r.selected=!0,r.startselected=!0,n._trigger("selected",t,{selected:r.element})}),this._trigger("stop",t),this.helper.remove(),!1}})})(jQuery);(function(e,t){var n=5;e.widget("ui.slider",e.ui.mouse,{version:"1.9.0",widgetEventPrefix:"slide",options:{animate:!1,distance:0,max:100,min:0,orientation:"horizontal",range:!1,step:1,value:0,values:null},_create:function(){var t,r=this.options,i=this.element.find(".ui-slider-handle").addClass("ui-state-default ui-corner-all"),s="<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",o=r.values&&r.values.length||1,u=[];this._keySliding=!1,this._mouseSliding=!1,this._animateOff=!0,this._handleIndex=null,this._detectOrientation(),this._mouseInit(),this.element.addClass("ui-slider ui-slider-"+this.orientation+" ui-widget"+" ui-widget-content"+" ui-corner-all"+(r.disabled?" ui-slider-disabled ui-disabled":"")),this.range=e([]),r.range&&(r.range===!0&&(r.values||(r.values=[this._valueMin(),this._valueMin()]),r.values.length&&r.values.length!==2&&(r.values=[r.values[0],r.values[0]])),this.range=e("<div></div>").appendTo(this.element).addClass("ui-slider-range ui-widget-header"+(r.range==="min"||r.range==="max"?" ui-slider-range-"+r.range:"")));for(t=i.length;t<o;t++)u.push(s);this.handles=i.add(e(u.join("")).appendTo(this.element)),this.handle=this.handles.eq(0),this.handles.add(this.range).filter("a").click(function(e){e.preventDefault()}).mouseenter(function(){r.disabled||e(this).addClass("ui-state-hover")}).mouseleave(function(){e(this).removeClass("ui-state-hover")}).focus(function(){r.disabled?e(this).blur():(e(".ui-slider .ui-state-focus").removeClass("ui-state-focus"),e(this).addClass("ui-state-focus"))}).blur(function(){e(this).removeClass("ui-state-focus")}),this.handles.each(function(t){e(this).data("ui-slider-handle-index",t)}),this._on(this.handles,{keydown:function(t){var r,i,s,o,u=e(t.target).data("ui-slider-handle-index");switch(t.keyCode){case e.ui.keyCode.HOME:case e.ui.keyCode.END:case e.ui.keyCode.PAGE_UP:case e.ui.keyCode.PAGE_DOWN:case e.ui.keyCode.UP:case e.ui.keyCode.RIGHT:case e.ui.keyCode.DOWN:case e.ui.keyCode.LEFT:t.preventDefault();if(!this._keySliding){this._keySliding=!0,e(t.target).addClass("ui-state-active"),r=this._start(t,u);if(r===!1)return}}o=this.options.step,this.options.values&&this.options.values.length?i=s=this.values(u):i=s=this.value();switch(t.keyCode){case e.ui.keyCode.HOME:s=this._valueMin();break;case e.ui.keyCode.END:s=this._valueMax();break;case e.ui.keyCode.PAGE_UP:s=this._trimAlignValue(i+(this._valueMax()-this._valueMin())/n);break;case e.ui.keyCode.PAGE_DOWN:s=this._trimAlignValue(i-(this._valueMax()-this._valueMin())/n);break;case e.ui.keyCode.UP:case e.ui.keyCode.RIGHT:if(i===this._valueMax())return;s=this._trimAlignValue(i+o);break;case e.ui.keyCode.DOWN:case e.ui.keyCode.LEFT:if(i===this._valueMin())return;s=this._trimAlignValue(i-o)}this._slide(t,u,s)},keyup:function(t){var n=e(t.target).data("ui-slider-handle-index");this._keySliding&&(this._keySliding=!1,this._stop(t,n),this._change(t,n),e(t.target).removeClass("ui-state-active"))}}),this._refreshValue(),this._animateOff=!1},_destroy:function(){this.handles.remove(),this.range.remove(),this.element.removeClass("ui-slider ui-slider-horizontal ui-slider-vertical ui-slider-disabled ui-widget ui-widget-content ui-corner-all"),this._mouseDestroy()},_mouseCapture:function(t){var n,r,i,s,o,u,a,f,l=this,c=this.options;return c.disabled?!1:(this.elementSize={width:this.element.outerWidth(),height:this.element.outerHeight()},this.elementOffset=this.element.offset(),n={x:t.pageX,y:t.pageY},r=this._normValueFromMouse(n),i=this._valueMax()-this._valueMin()+1,this.handles.each(function(t){var n=Math.abs(r-l.values(t));i>n&&(i=n,s=e(this),o=t)}),c.range===!0&&this.values(1)===c.min&&(o+=1,s=e(this.handles[o])),u=this._start(t,o),u===!1?!1:(this._mouseSliding=!0,this._handleIndex=o,s.addClass("ui-state-active").focus(),a=s.offset(),f=!e(t.target).parents().andSelf().is(".ui-slider-handle"),this._clickOffset=f?{left:0,top:0}:{left:t.pageX-a.left-s.width()/2,top:t.pageY-a.top-s.height()/2-(parseInt(s.css("borderTopWidth"),10)||0)-(parseInt(s.css("borderBottomWidth"),10)||0)+(parseInt(s.css("marginTop"),10)||0)},this.handles.hasClass("ui-state-hover")||this._slide(t,o,r),this._animateOff=!0,!0))},_mouseStart:function(e){return!0},_mouseDrag:function(e){var t={x:e.pageX,y:e.pageY},n=this._normValueFromMouse(t);return this._slide(e,this._handleIndex,n),!1},_mouseStop:function(e){return this.handles.removeClass("ui-state-active"),this._mouseSliding=!1,this._stop(e,this._handleIndex),this._change(e,this._handleIndex),this._handleIndex=null,this._clickOffset=null,this._animateOff=!1,!1},_detectOrientation:function(){this.orientation=this.options.orientation==="vertical"?"vertical":"horizontal"},_normValueFromMouse:function(e){var t,n,r,i,s;return this.orientation==="horizontal"?(t=this.elementSize.width,n=e.x-this.elementOffset.left-(this._clickOffset?this._clickOffset.left:0)):(t=this.elementSize.height,n=e.y-this.elementOffset.top-(this._clickOffset?this._clickOffset.top:0)),r=n/t,r>1&&(r=1),r<0&&(r=0),this.orientation==="vertical"&&(r=1-r),i=this._valueMax()-this._valueMin(),s=this._valueMin()+r*i,this._trimAlignValue(s)},_start:function(e,t){var n={handle:this.handles[t],value:this.value()};return this.options.values&&this.options.values.length&&(n.value=this.values(t),n.values=this.values()),this._trigger("start",e,n)},_slide:function(e,t,n){var r,i,s;this.options.values&&this.options.values.length?(r=this.values(t?0:1),this.options.values.length===2&&this.options.range===!0&&(t===0&&n>r||t===1&&n<r)&&(n=r),n!==this.values(t)&&(i=this.values(),i[t]=n,s=this._trigger("slide",e,{handle:this.handles[t],value:n,values:i}),r=this.values(t?0:1),s!==!1&&this.values(t,n,!0))):n!==this.value()&&(s=this._trigger("slide",e,{handle:this.handles[t],value:n}),s!==!1&&this.value(n))},_stop:function(e,t){var n={handle:this.handles[t],value:this.value()};this.options.values&&this.options.values.length&&(n.value=this.values(t),n.values=this.values()),this._trigger("stop",e,n)},_change:function(e,t){if(!this._keySliding&&!this._mouseSliding){var n={handle:this.handles[t],value:this.value()};this.options.values&&this.options.values.length&&(n.value=this.values(t),n.values=this.values()),this._trigger("change",e,n)}},value:function(e){if(arguments.length){this.options.value=this._trimAlignValue(e),this._refreshValue(),this._change(null,0);return}return this._value()},values:function(t,n){var r,i,s;if(arguments.length>1){this.options.values[t]=this._trimAlignValue(n),this._refreshValue(),this._change(null,t);return}if(!arguments.length)return this._values();if(!e.isArray(arguments[0]))return this.options.values&&this.options.values.length?this._values(t):this.value();r=this.options.values,i=arguments[0];for(s=0;s<r.length;s+=1)r[s]=this._trimAlignValue(i[s]),this._change(null,s);this._refreshValue()},_setOption:function(t,n){var r,i=0;e.isArray(this.options.values)&&(i=this.options.values.length),e.Widget.prototype._setOption.apply(this,arguments);switch(t){case"disabled":n?(this.handles.filter(".ui-state-focus").blur(),this.handles.removeClass("ui-state-hover"),this.handles.prop("disabled",!0),this.element.addClass("ui-disabled")):(this.handles.prop("disabled",!1),this.element.removeClass("ui-disabled"));break;case"orientation":this._detectOrientation(),this.element.removeClass("ui-slider-horizontal ui-slider-vertical").addClass("ui-slider-"+this.orientation),this._refreshValue();break;case"value":this._animateOff=!0,this._refreshValue(),this._change(null,0),this._animateOff=!1;break;case"values":this._animateOff=!0,this._refreshValue();for(r=0;r<i;r+=1)this._change(null,r);this._animateOff=!1}},_value:function(){var e=this.options.value;return e=this._trimAlignValue(e),e},_values:function(e){var t,n,r;if(arguments.length)return t=this.options.values[e],t=this._trimAlignValue(t),t;n=this.options.values.slice();for(r=0;r<n.length;r+=1)n[r]=this._trimAlignValue(n[r]);return n},_trimAlignValue:function(e){if(e<=this._valueMin())return this._valueMin();if(e>=this._valueMax())return this._valueMax();var t=this.options.step>0?this.options.step:1,n=(e-this._valueMin())%t,r=e-n;return Math.abs(n)*2>=t&&(r+=n>0?t:-t),parseFloat(r.toFixed(5))},_valueMin:function(){return this.options.min},_valueMax:function(){return this.options.max},_refreshValue:function(){var t,n,r,i,s,o=this.options.range,u=this.options,a=this,f=this._animateOff?!1:u.animate,l={};this.options.values&&this.options.values.length?this.handles.each(function(r,i){n=(a.values(r)-a._valueMin())/(a._valueMax()-a._valueMin())*100,l[a.orientation==="horizontal"?"left":"bottom"]=n+"%",e(this).stop(1,1)[f?"animate":"css"](l,u.animate),a.options.range===!0&&(a.orientation==="horizontal"?(r===0&&a.range.stop(1,1)[f?"animate":"css"]({left:n+"%"},u.animate),r===1&&a.range[f?"animate":"css"]({width:n-t+"%"},{queue:!1,duration:u.animate})):(r===0&&a.range.stop(1,1)[f?"animate":"css"]({bottom:n+"%"},u.animate),r===1&&a.range[f?"animate":"css"]({height:n-t+"%"},{queue:!1,duration:u.animate}))),t=n}):(r=this.value(),i=this._valueMin(),s=this._valueMax(),n=s!==i?(r-i)/(s-i)*100:0,l[this.orientation==="horizontal"?"left":"bottom"]=n+"%",this.handle.stop(1,1)[f?"animate":"css"](l,u.animate),o==="min"&&this.orientation==="horizontal"&&this.range.stop(1,1)[f?"animate":"css"]({width:n+"%"},u.animate),o==="max"&&this.orientation==="horizontal"&&this.range[f?"animate":"css"]({width:100-n+"%"},{queue:!1,duration:u.animate}),o==="min"&&this.orientation==="vertical"&&this.range.stop(1,1)[f?"animate":"css"]({height:n+"%"},u.animate),o==="max"&&this.orientation==="vertical"&&this.range[f?"animate":"css"]({height:100-n+"%"},{queue:!1,duration:u.animate}))}})})(jQuery);(function(e,t){e.widget("ui.sortable",e.ui.mouse,{version:"1.9.0",widgetEventPrefix:"sort",ready:!1,options:{appendTo:"parent",axis:!1,connectWith:!1,containment:!1,cursor:"auto",cursorAt:!1,dropOnEmpty:!0,forcePlaceholderSize:!1,forceHelperSize:!1,grid:!1,handle:!1,helper:"original",items:"> *",opacity:!1,placeholder:!1,revert:!1,scroll:!0,scrollSensitivity:20,scrollSpeed:20,scope:"default",tolerance:"intersect",zIndex:1e3},_create:function(){var e=this.options;this.containerCache={},this.element.addClass("ui-sortable"),this.refresh(),this.floating=this.items.length?e.axis==="x"||/left|right/.test(this.items[0].item.css("float"))||/inline|table-cell/.test(this.items[0].item.css("display")):!1,this.offset=this.element.offset(),this._mouseInit(),this.ready=!0},_destroy:function(){this.element.removeClass("ui-sortable ui-sortable-disabled"),this._mouseDestroy();for(var e=this.items.length-1;e>=0;e--)this.items[e].item.removeData(this.widgetName+"-item");return this},_setOption:function(t,n){t==="disabled"?(this.options[t]=n,this.widget().toggleClass("ui-sortable-disabled",!!n)):e.Widget.prototype._setOption.apply(this,arguments)},_mouseCapture:function(t,n){var r=this;if(this.reverting)return!1;if(this.options.disabled||this.options.type=="static")return!1;this._refreshItems(t);var i=null,s=e(t.target).parents().each(function(){if(e.data(this,r.widgetName+"-item")==r)return i=e(this),!1});e.data(t.target,r.widgetName+"-item")==r&&(i=e(t.target));if(!i)return!1;if(this.options.handle&&!n){var o=!1;e(this.options.handle,i).find("*").andSelf().each(function(){this==t.target&&(o=!0)});if(!o)return!1}return this.currentItem=i,this._removeCurrentsFromItems(),!0},_mouseStart:function(t,n,r){var i=this.options;this.currentContainer=this,this.refreshPositions(),this.helper=this._createHelper(t),this._cacheHelperProportions(),this._cacheMargins(),this.scrollParent=this.helper.scrollParent(),this.offset=this.currentItem.offset(),this.offset={top:this.offset.top-this.margins.top,left:this.offset.left-this.margins.left},e.extend(this.offset,{click:{left:t.pageX-this.offset.left,top:t.pageY-this.offset.top},parent:this._getParentOffset(),relative:this._getRelativeOffset()}),this.helper.css("position","absolute"),this.cssPosition=this.helper.css("position"),this.originalPosition=this._generatePosition(t),this.originalPageX=t.pageX,this.originalPageY=t.pageY,i.cursorAt&&this._adjustOffsetFromHelper(i.cursorAt),this.domPosition={prev:this.currentItem.prev()[0],parent:this.currentItem.parent()[0]},this.helper[0]!=this.currentItem[0]&&this.currentItem.hide(),this._createPlaceholder(),i.containment&&this._setContainment(),i.cursor&&(e("body").css("cursor")&&(this._storedCursor=e("body").css("cursor")),e("body").css("cursor",i.cursor)),i.opacity&&(this.helper.css("opacity")&&(this._storedOpacity=this.helper.css("opacity")),this.helper.css("opacity",i.opacity)),i.zIndex&&(this.helper.css("zIndex")&&(this._storedZIndex=this.helper.css("zIndex")),this.helper.css("zIndex",i.zIndex)),this.scrollParent[0]!=document&&this.scrollParent[0].tagName!="HTML"&&(this.overflowOffset=this.scrollParent.offset()),this._trigger("start",t,this._uiHash()),this._preserveHelperProportions||this._cacheHelperProportions();if(!r)for(var s=this.containers.length-1;s>=0;s--)this.containers[s]._trigger("activate",t,this._uiHash(this));return e.ui.ddmanager&&(e.ui.ddmanager.current=this),e.ui.ddmanager&&!i.dropBehaviour&&e.ui.ddmanager.prepareOffsets(this,t),this.dragging=!0,this.helper.addClass("ui-sortable-helper"),this._mouseDrag(t),!0},_mouseDrag:function(t){this.position=this._generatePosition(t),this.positionAbs=this._convertPositionTo("absolute"),this.lastPositionAbs||(this.lastPositionAbs=this.positionAbs);if(this.options.scroll){var n=this.options,r=!1;this.scrollParent[0]!=document&&this.scrollParent[0].tagName!="HTML"?(this.overflowOffset.top+this.scrollParent[0].offsetHeight-t.pageY<n.scrollSensitivity?this.scrollParent[0].scrollTop=r=this.scrollParent[0].scrollTop+n.scrollSpeed:t.pageY-this.overflowOffset.top<n.scrollSensitivity&&(this.scrollParent[0].scrollTop=r=this.scrollParent[0].scrollTop-n.scrollSpeed),this.overflowOffset.left+this.scrollParent[0].offsetWidth-t.pageX<n.scrollSensitivity?this.scrollParent[0].scrollLeft=r=this.scrollParent[0].scrollLeft+n.scrollSpeed:t.pageX-this.overflowOffset.left<n.scrollSensitivity&&(this.scrollParent[0].scrollLeft=r=this.scrollParent[0].scrollLeft-n.scrollSpeed)):(t.pageY-e(document).scrollTop()<n.scrollSensitivity?r=e(document).scrollTop(e(document).scrollTop()-n.scrollSpeed):e(window).height()-(t.pageY-e(document).scrollTop())<n.scrollSensitivity&&(r=e(document).scrollTop(e(document).scrollTop()+n.scrollSpeed)),t.pageX-e(document).scrollLeft()<n.scrollSensitivity?r=e(document).scrollLeft(e(document).scrollLeft()-n.scrollSpeed):e(window).width()-(t.pageX-e(document).scrollLeft())<n.scrollSensitivity&&(r=e(document).scrollLeft(e(document).scrollLeft()+n.scrollSpeed))),r!==!1&&e.ui.ddmanager&&!n.dropBehaviour&&e.ui.ddmanager.prepareOffsets(this,t)}this.positionAbs=this._convertPositionTo("absolute");if(!this.options.axis||this.options.axis!="y")this.helper[0].style.left=this.position.left+"px";if(!this.options.axis||this.options.axis!="x")this.helper[0].style.top=this.position.top+"px";for(var i=this.items.length-1;i>=0;i--){var s=this.items[i],o=s.item[0],u=this._intersectsWithPointer(s);if(!u)continue;if(s.instance!==this.currentContainer)continue;if(o!=this.currentItem[0]&&this.placeholder[u==1?"next":"prev"]()[0]!=o&&!e.contains(this.placeholder[0],o)&&(this.options.type=="semi-dynamic"?!e.contains(this.element[0],o):!0)){this.direction=u==1?"down":"up";if(this.options.tolerance!="pointer"&&!this._intersectsWithSides(s))break;this._rearrange(t,s),this._trigger("change",t,this._uiHash());break}}return this._contactContainers(t),e.ui.ddmanager&&e.ui.ddmanager.drag(this,t),this._trigger("sort",t,this._uiHash()),this.lastPositionAbs=this.positionAbs,!1},_mouseStop:function(t,n){if(!t)return;e.ui.ddmanager&&!this.options.dropBehaviour&&e.ui.ddmanager.drop(this,t);if(this.options.revert){var r=this,i=this.placeholder.offset();this.reverting=!0,e(this.helper).animate({left:i.left-this.offset.parent.left-this.margins.left+(this.offsetParent[0]==document.body?0:this.offsetParent[0].scrollLeft),top:i.top-this.offset.parent.top-this.margins.top+(this.offsetParent[0]==document.body?0:this.offsetParent[0].scrollTop)},parseInt(this.options.revert,10)||500,function(){r._clear(t)})}else this._clear(t,n);return!1},cancel:function(){if(this.dragging){this._mouseUp({target:null}),this.options.helper=="original"?this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper"):this.currentItem.show();for(var t=this.containers.length-1;t>=0;t--)this.containers[t]._trigger("deactivate",null,this._uiHash(this)),this.containers[t].containerCache.over&&(this.containers[t]._trigger("out",null,this._uiHash(this)),this.containers[t].containerCache.over=0)}return this.placeholder&&(this.placeholder[0].parentNode&&this.placeholder[0].parentNode.removeChild(this.placeholder[0]),this.options.helper!="original"&&this.helper&&this.helper[0].parentNode&&this.helper.remove(),e.extend(this,{helper:null,dragging:!1,reverting:!1,_noFinalSort:null}),this.domPosition.prev?e(this.domPosition.prev).after(this.currentItem):e(this.domPosition.parent).prepend(this.currentItem)),this},serialize:function(t){var n=this._getItemsAsjQuery(t&&t.connected),r=[];return t=t||{},e(n).each(function(){var n=(e(t.item||this).attr(t.attribute||"id")||"").match(t.expression||/(.+)[-=_](.+)/);n&&r.push((t.key||n[1]+"[]")+"="+(t.key&&t.expression?n[1]:n[2]))}),!r.length&&t.key&&r.push(t.key+"="),r.join("&")},toArray:function(t){var n=this._getItemsAsjQuery(t&&t.connected),r=[];return t=t||{},n.each(function(){r.push(e(t.item||this).attr(t.attribute||"id")||"")}),r},_intersectsWith:function(e){var t=this.positionAbs.left,n=t+this.helperProportions.width,r=this.positionAbs.top,i=r+this.helperProportions.height,s=e.left,o=s+e.width,u=e.top,a=u+e.height,f=this.offset.click.top,l=this.offset.click.left,c=r+f>u&&r+f<a&&t+l>s&&t+l<o;return this.options.tolerance=="pointer"||this.options.forcePointerForContainers||this.options.tolerance!="pointer"&&this.helperProportions[this.floating?"width":"height"]>e[this.floating?"width":"height"]?c:s<t+this.helperProportions.width/2&&n-this.helperProportions.width/2<o&&u<r+this.helperProportions.height/2&&i-this.helperProportions.height/2<a},_intersectsWithPointer:function(t){var n=this.options.axis==="x"||e.ui.isOverAxis(this.positionAbs.top+this.offset.click.top,t.top,t.height),r=this.options.axis==="y"||e.ui.isOverAxis(this.positionAbs.left+this.offset.click.left,t.left,t.width),i=n&&r,s=this._getDragVerticalDirection(),o=this._getDragHorizontalDirection();return i?this.floating?o&&o=="right"||s=="down"?2:1:s&&(s=="down"?2:1):!1},_intersectsWithSides:function(t){var n=e.ui.isOverAxis(this.positionAbs.top+this.offset.click.top,t.top+t.height/2,t.height),r=e.ui.isOverAxis(this.positionAbs.left+this.offset.click.left,t.left+t.width/2,t.width),i=this._getDragVerticalDirection(),s=this._getDragHorizontalDirection();return this.floating&&s?s=="right"&&r||s=="left"&&!r:i&&(i=="down"&&n||i=="up"&&!n)},_getDragVerticalDirection:function(){var e=this.positionAbs.top-this.lastPositionAbs.top;return e!=0&&(e>0?"down":"up")},_getDragHorizontalDirection:function(){var e=this.positionAbs.left-this.lastPositionAbs.left;return e!=0&&(e>0?"right":"left")},refresh:function(e){return this._refreshItems(e),this.refreshPositions(),this},_connectWith:function(){var e=this.options;return e.connectWith.constructor==String?[e.connectWith]:e.connectWith},_getItemsAsjQuery:function(t){var n=[],r=[],i=this._connectWith();if(i&&t)for(var s=i.length-1;s>=0;s--){var o=e(i[s]);for(var u=o.length-1;u>=0;u--){var a=e.data(o[u],this.widgetName);a&&a!=this&&!a.options.disabled&&r.push([e.isFunction(a.options.items)?a.options.items.call(a.element):e(a.options.items,a.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"),a])}}r.push([e.isFunction(this.options.items)?this.options.items.call(this.element,null,{options:this.options,item:this.currentItem}):e(this.options.items,this.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"),this]);for(var s=r.length-1;s>=0;s--)r[s][0].each(function(){n.push(this)});return e(n)},_removeCurrentsFromItems:function(){var e=this.currentItem.find(":data("+this.widgetName+"-item)");for(var t=0;t<this.items.length;t++)for(var n=0;n<e.length;n++)e[n]==this.items[t].item[0]&&this.items.splice(t,1)},_refreshItems:function(t){this.items=[],this.containers=[this];var n=this.items,r=[[e.isFunction(this.options.items)?this.options.items.call(this.element[0],t,{item:this.currentItem}):e(this.options.items,this.element),this]],i=this._connectWith();if(i&&this.ready)for(var s=i.length-1;s>=0;s--){var o=e(i[s]);for(var u=o.length-1;u>=0;u--){var a=e.data(o[u],this.widgetName);a&&a!=this&&!a.options.disabled&&(r.push([e.isFunction(a.options.items)?a.options.items.call(a.element[0],t,{item:this.currentItem}):e(a.options.items,a.element),a]),this.containers.push(a))}}for(var s=r.length-1;s>=0;s--){var f=r[s][1],l=r[s][0];for(var u=0,c=l.length;u<c;u++){var h=e(l[u]);h.data(this.widgetName+"-item",f),n.push({item:h,instance:f,width:0,height:0,left:0,top:0})}}},refreshPositions:function(t){this.offsetParent&&this.helper&&(this.offset.parent=this._getParentOffset());for(var n=this.items.length-1;n>=0;n--){var r=this.items[n];if(r.instance!=this.currentContainer&&this.currentContainer&&r.item[0]!=this.currentItem[0])continue;var i=this.options.toleranceElement?e(this.options.toleranceElement,r.item):r.item;t||(r.width=i.outerWidth(),r.height=i.outerHeight());var s=i.offset();r.left=s.left,r.top=s.top}if(this.options.custom&&this.options.custom.refreshContainers)this.options.custom.refreshContainers.call(this);else for(var n=this.containers.length-1;n>=0;n--){var s=this.containers[n].element.offset();this.containers[n].containerCache.left=s.left,this.containers[n].containerCache.top=s.top,this.containers[n].containerCache.width=this.containers[n].element.outerWidth(),this.containers[n].containerCache.height=this.containers[n].element.outerHeight()}return this},_createPlaceholder:function(t){t=t||this;var n=t.options;if(!n.placeholder||n.placeholder.constructor==String){var r=n.placeholder;n.placeholder={element:function(){var n=e(document.createElement(t.currentItem[0].nodeName)).addClass(r||t.currentItem[0].className+" ui-sortable-placeholder").removeClass("ui-sortable-helper")[0];return r||(n.style.visibility="hidden"),n},update:function(e,i){if(r&&!n.forcePlaceholderSize)return;i.height()||i.height(t.currentItem.innerHeight()-parseInt(t.currentItem.css("paddingTop")||0,10)-parseInt(t.currentItem.css("paddingBottom")||0,10)),i.width()||i.width(t.currentItem.innerWidth()-parseInt(t.currentItem.css("paddingLeft")||0,10)-parseInt(t.currentItem.css("paddingRight")||0,10))}}}t.placeholder=e(n.placeholder.element.call(t.element,t.currentItem)),t.currentItem.after(t.placeholder),n.placeholder.update(t,t.placeholder)},_contactContainers:function(t){var n=null,r=null;for(var i=this.containers.length-1;i>=0;i--){if(e.contains(this.currentItem[0],this.containers[i].element[0]))continue;if(this._intersectsWith(this.containers[i].containerCache)){if(n&&e.contains(this.containers[i].element[0],n.element[0]))continue;n=this.containers[i],r=i}else this.containers[i].containerCache.over&&(this.containers[i]._trigger("out",t,this._uiHash(this)),this.containers[i].containerCache.over=0)}if(!n)return;if(this.containers.length===1)this.containers[r]._trigger("over",t,this._uiHash(this)),this.containers[r].containerCache.over=1;else if(this.currentContainer!=this.containers[r]){var s=1e4,o=null,u=this.positionAbs[this.containers[r].floating?"left":"top"];for(var a=this.items.length-1;a>=0;a--){if(!e.contains(this.containers[r].element[0],this.items[a].item[0]))continue;var f=this.containers[r].floating?this.items[a].item.offset().left:this.items[a].item.offset().top;Math.abs(f-u)<s&&(s=Math.abs(f-u),o=this.items[a],this.direction=f-u>0?"down":"up")}if(!o&&!this.options.dropOnEmpty)return;this.currentContainer=this.containers[r],o?this._rearrange(t,o,null,!0):this._rearrange(t,null,this.containers[r].element,!0),this._trigger("change",t,this._uiHash()),this.containers[r]._trigger("change",t,this._uiHash(this)),this.options.placeholder.update(this.currentContainer,this.placeholder),this.containers[r]._trigger("over",t,this._uiHash(this)),this.containers[r].containerCache.over=1}},_createHelper:function(t){var n=this.options,r=e.isFunction(n.helper)?e(n.helper.apply(this.element[0],[t,this.currentItem])):n.helper=="clone"?this.currentItem.clone():this.currentItem;return r.parents("body").length||e(n.appendTo!="parent"?n.appendTo:this.currentItem[0].parentNode)[0].appendChild(r[0]),r[0]==this.currentItem[0]&&(this._storedCSS={width:this.currentItem[0].style.width,height:this.currentItem[0].style.height,position:this.currentItem.css("position"),top:this.currentItem.css("top"),left:this.currentItem.css("left")}),(r[0].style.width==""||n.forceHelperSize)&&r.width(this.currentItem.width()),(r[0].style.height==""||n.forceHelperSize)&&r.height(this.currentItem.height()),r},_adjustOffsetFromHelper:function(t){typeof t=="string"&&(t=t.split(" ")),e.isArray(t)&&(t={left:+t[0],top:+t[1]||0}),"left"in t&&(this.offset.click.left=t.left+this.margins.left),"right"in t&&(this.offset.click.left=this.helperProportions.width-t.right+this.margins.left),"top"in t&&(this.offset.click.top=t.top+this.margins.top),"bottom"in t&&(this.offset.click.top=this.helperProportions.height-t.bottom+this.margins.top)},_getParentOffset:function(){this.offsetParent=this.helper.offsetParent();var t=this.offsetParent.offset();this.cssPosition=="absolute"&&this.scrollParent[0]!=document&&e.contains(this.scrollParent[0],this.offsetParent[0])&&(t.left+=this.scrollParent.scrollLeft(),t.top+=this.scrollParent.scrollTop());if(this.offsetParent[0]==document.body||this.offsetParent[0].tagName&&this.offsetParent[0].tagName.toLowerCase()=="html"&&e.browser.msie)t={top:0,left:0};return{top:t.top+(parseInt(this.offsetParent.css("borderTopWidth"),10)||0),left:t.left+(parseInt(this.offsetParent.css("borderLeftWidth"),10)||0)}},_getRelativeOffset:function(){if(this.cssPosition=="relative"){var e=this.currentItem.position();return{top:e.top-(parseInt(this.helper.css("top"),10)||0)+this.scrollParent.scrollTop(),left:e.left-(parseInt(this.helper.css("left"),10)||0)+this.scrollParent.scrollLeft()}}return{top:0,left:0}},_cacheMargins:function(){this.margins={left:parseInt(this.currentItem.css("marginLeft"),10)||0,top:parseInt(this.currentItem.css("marginTop"),10)||0}},_cacheHelperProportions:function(){this.helperProportions={width:this.helper.outerWidth(),height:this.helper.outerHeight()}},_setContainment:function(){var t=this.options;t.containment=="parent"&&(t.containment=this.helper[0].parentNode);if(t.containment=="document"||t.containment=="window")this.containment=[0-this.offset.relative.left-this.offset.parent.left,0-this.offset.relative.top-this.offset.parent.top,e(t.containment=="document"?document:window).width()-this.helperProportions.width-this.margins.left,(e(t.containment=="document"?document:window).height()||document.body.parentNode.scrollHeight)-this.helperProportions.height-this.margins.top];if(!/^(document|window|parent)$/.test(t.containment)){var n=e(t.containment)[0],r=e(t.containment).offset(),i=e(n).css("overflow")!="hidden";this.containment=[r.left+(parseInt(e(n).css("borderLeftWidth"),10)||0)+(parseInt(e(n).css("paddingLeft"),10)||0)-this.margins.left,r.top+(parseInt(e(n).css("borderTopWidth"),10)||0)+(parseInt(e(n).css("paddingTop"),10)||0)-this.margins.top,r.left+(i?Math.max(n.scrollWidth,n.offsetWidth):n.offsetWidth)-(parseInt(e(n).css("borderLeftWidth"),10)||0)-(parseInt(e(n).css("paddingRight"),10)||0)-this.helperProportions.width-this.margins.left,r.top+(i?Math.max(n.scrollHeight,n.offsetHeight):n.offsetHeight)-(parseInt(e(n).css("borderTopWidth"),10)||0)-(parseInt(e(n).css("paddingBottom"),10)||0)-this.helperProportions.height-this.margins.top]}},_convertPositionTo:function(t,n){n||(n=this.position);var r=t=="absolute"?1:-1,i=this.options,s=this.cssPosition!="absolute"||this.scrollParent[0]!=document&&!!e.contains(this.scrollParent[0],this.offsetParent[0])?this.scrollParent:this.offsetParent,o=/(html|body)/i.test(s[0].tagName);return{top:n.top+this.offset.relative.top*r+this.offset.parent.top*r-(this.cssPosition=="fixed"?-this.scrollParent.scrollTop():o?0:s.scrollTop())*r,left:n.left+this.offset.relative.left*r+this.offset.parent.left*r-(this.cssPosition=="fixed"?-this.scrollParent.scrollLeft():o?0:s.scrollLeft())*r}},_generatePosition:function(t){var n=this.options,r=this.cssPosition!="absolute"||this.scrollParent[0]!=document&&!!e.contains(this.scrollParent[0],this.offsetParent[0])?this.scrollParent:this.offsetParent,i=/(html|body)/i.test(r[0].tagName);this.cssPosition=="relative"&&(this.scrollParent[0]==document||this.scrollParent[0]==this.offsetParent[0])&&(this.offset.relative=this._getRelativeOffset());var s=t.pageX,o=t.pageY;if(this.originalPosition){this.containment&&(t.pageX-this.offset.click.left<this.containment[0]&&(s=this.containment[0]+this.offset.click.left),t.pageY-this.offset.click.top<this.containment[1]&&(o=this.containment[1]+this.offset.click.top),t.pageX-this.offset.click.left>this.containment[2]&&(s=this.containment[2]+this.offset.click.left),t.pageY-this.offset.click.top>this.containment[3]&&(o=this.containment[3]+this.offset.click.top));if(n.grid){var u=this.originalPageY+Math.round((o-this.originalPageY)/n.grid[1])*n.grid[1];o=this.containment?u-this.offset.click.top<this.containment[1]||u-this.offset.click.top>this.containment[3]?u-this.offset.click.top<this.containment[1]?u+n.grid[1]:u-n.grid[1]:u:u;var a=this.originalPageX+Math.round((s-this.originalPageX)/n.grid[0])*n.grid[0];s=this.containment?a-this.offset.click.left<this.containment[0]||a-this.offset.click.left>this.containment[2]?a-this.offset.click.left<this.containment[0]?a+n.grid[0]:a-n.grid[0]:a:a}}return{top:o-this.offset.click.top-this.offset.relative.top-this.offset.parent.top+(this.cssPosition=="fixed"?-this.scrollParent.scrollTop():i?0:r.scrollTop()),left:s-this.offset.click.left-this.offset.relative.left-this.offset.parent.left+(this.cssPosition=="fixed"?-this.scrollParent.scrollLeft():i?0:r.scrollLeft())}},_rearrange:function(e,t,n,r){n?n[0].appendChild(this.placeholder[0]):t.item[0].parentNode.insertBefore(this.placeholder[0],this.direction=="down"?t.item[0]:t.item[0].nextSibling),this.counter=this.counter?++this.counter:1;var i=this.counter;this._delay(function(){i==this.counter&&this.refreshPositions(!r)})},_clear:function(t,n){this.reverting=!1;var r=[];!this._noFinalSort&&this.currentItem.parent().length&&this.placeholder.before(this.currentItem),this._noFinalSort=null;if(this.helper[0]==this.currentItem[0]){for(var i in this._storedCSS)if(this._storedCSS[i]=="auto"||this._storedCSS[i]=="static")this._storedCSS[i]="";this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper")}else this.currentItem.show();this.fromOutside&&!n&&r.push(function(e){this._trigger("receive",e,this._uiHash(this.fromOutside))}),(this.fromOutside||this.domPosition.prev!=this.currentItem.prev().not(".ui-sortable-helper")[0]||this.domPosition.parent!=this.currentItem.parent()[0])&&!n&&r.push(function(e){this._trigger("update",e,this._uiHash())}),this!==this.currentContainer&&(n||(r.push(function(e){this._trigger("remove",e,this._uiHash())}),r.push(function(e){return function(t){e._trigger("receive",t,this._uiHash(this))}}.call(this,this.currentContainer)),r.push(function(e){return function(t){e._trigger("update",t,this._uiHash(this))}}.call(this,this.currentContainer))));for(var i=this.containers.length-1;i>=0;i--)n||r.push(function(e){return function(t){e._trigger("deactivate",t,this._uiHash(this))}}.call(this,this.containers[i])),this.containers[i].containerCache.over&&(r.push(function(e){return function(t){e._trigger("out",t,this._uiHash(this))}}.call(this,this.containers[i])),this.containers[i].containerCache.over=0);this._storedCursor&&e("body").css("cursor",this._storedCursor),this._storedOpacity&&this.helper.css("opacity",this._storedOpacity),this._storedZIndex&&this.helper.css("zIndex",this._storedZIndex=="auto"?"":this._storedZIndex),this.dragging=!1;if(this.cancelHelperRemoval){if(!n){this._trigger("beforeStop",t,this._uiHash());for(var i=0;i<r.length;i++)r[i].call(this,t);this._trigger("stop",t,this._uiHash())}return this.fromOutside=!1,!1}n||this._trigger("beforeStop",t,this._uiHash()),this.placeholder[0].parentNode.removeChild(this.placeholder[0]),this.helper[0]!=this.currentItem[0]&&this.helper.remove(),this.helper=null;if(!n){for(var i=0;i<r.length;i++)r[i].call(this,t);this._trigger("stop",t,this._uiHash())}return this.fromOutside=!1,!0},_trigger:function(){e.Widget.prototype._trigger.apply(this,arguments)===!1&&this.cancel()},_uiHash:function(t){var n=t||this;return{helper:n.helper,placeholder:n.placeholder||e([]),position:n.position,originalPosition:n.originalPosition,offset:n.positionAbs,item:n.currentItem,sender:t?t.element:null}}})})(jQuery);(function(e){function t(e){return function(){var t=this.element.val();e.apply(this,arguments),this._refresh(),t!==this.element.val()&&this._trigger("change")}}e.widget("ui.spinner",{version:"1.9.0",defaultElement:"<input>",widgetEventPrefix:"spin",options:{culture:null,icons:{down:"ui-icon-triangle-1-s",up:"ui-icon-triangle-1-n"},incremental:!0,max:null,min:null,numberFormat:null,page:10,step:1,change:null,spin:null,start:null,stop:null},_create:function(){this._setOption("max",this.options.max),this._setOption("min",this.options.min),this._setOption("step",this.options.step),this._value(this.element.val(),!0),this._draw(),this._on(this._events),this._refresh(),this._on(this.window,{beforeunload:function(){this.element.removeAttr("autocomplete")}})},_getCreateOptions:function(){var t={},n=this.element;return e.each(["min","max","step"],function(e,r){var i=n.attr(r);i!==undefined&&i.length&&(t[r]=i)}),t},_events:{keydown:function(e){this._start(e)&&this._keydown(e)&&e.preventDefault()},keyup:"_stop",focus:function(){this.uiSpinner.addClass("ui-state-active"),this.previous=this.element.val()},blur:function(e){if(this.cancelBlur){delete this.cancelBlur;return}this._refresh(),this.uiSpinner.removeClass("ui-state-active"),this.previous!==this.element.val()&&this._trigger("change",e)},mousewheel:function(e,t){if(!t)return;if(!this.spinning&&!this._start(e))return!1;this._spin((t>0?1:-1)*this.options.step,e),clearTimeout(this.mousewheelTimer),this.mousewheelTimer=this._delay(function(){this.spinning&&this._stop(e)},100),e.preventDefault()},"mousedown .ui-spinner-button":function(t){function r(){var e=this.element[0]===this.document[0].activeElement;e||(this.element.focus(),this.previous=n,this._delay(function(){this.previous=n}))}var n;n=this.element[0]===this.document[0].activeElement?this.previous:this.element.val(),t.preventDefault(),r.call(this),this.cancelBlur=!0,this._delay(function(){delete this.cancelBlur,r.call(this)});if(this._start(t)===!1)return;this._repeat(null,e(t.currentTarget).hasClass("ui-spinner-up")?1:-1,t)},"mouseup .ui-spinner-button":"_stop","mouseenter .ui-spinner-button":function(t){if(!e(t.currentTarget).hasClass("ui-state-active"))return;if(this._start(t)===!1)return!1;this._repeat(null,e(t.currentTarget).hasClass("ui-spinner-up")?1:-1,t)},"mouseleave .ui-spinner-button":"_stop"},_draw:function(){var e=this.uiSpinner=this.element.addClass("ui-spinner-input").attr("autocomplete","off").wrap(this._uiSpinnerHtml()).parent().append(this._buttonHtml());this._hoverable(e),this.element.attr("role","spinbutton"),this.buttons=e.find(".ui-spinner-button").attr("tabIndex",-1).button().removeClass("ui-corner-all"),this.buttons.height()>Math.ceil(e.height()*.5)&&e.height()>0&&e.height(e.height()),this.options.disabled&&this.disable()},_keydown:function(t){var n=this.options,r=e.ui.keyCode;switch(t.keyCode){case r.UP:return this._repeat(null,1,t),!0;case r.DOWN:return this._repeat(null,-1,t),!0;case r.PAGE_UP:return this._repeat(null,n.page,t),!0;case r.PAGE_DOWN:return this._repeat(null,-n.page,t),!0}return!1},_uiSpinnerHtml:function(){return"<span class='ui-spinner ui-state-default ui-widget ui-widget-content ui-corner-all'></span>"},_buttonHtml:function(){return"<a class='ui-spinner-button ui-spinner-up ui-corner-tr'><span class='ui-icon "+this.options.icons.up+"'>&#9650;</span>"+"</a>"+"<a class='ui-spinner-button ui-spinner-down ui-corner-br'>"+"<span class='ui-icon "+this.options.icons.down+"'>&#9660;</span>"+"</a>"},_start:function(e){return!this.spinning&&this._trigger("start",e)===!1?!1:(this.counter||(this.counter=1),this.spinning=!0,!0)},_repeat:function(e,t,n){e=e||500,clearTimeout(this.timer),this.timer=this._delay(function(){this._repeat(40,t,n)},e),this._spin(t*this.options.step,n)},_spin:function(e,t){var n=this.value()||0;this.counter||(this.counter=1),n=this._adjustValue(n+e*this._increment(this.counter));if(!this.spinning||this._trigger("spin",t,{value:n})!==!1)this._value(n),this.counter++},_increment:function(t){var n=this.options.incremental;return n?e.isFunction(n)?n(t):Math.floor(t*t*t/5e4-t*t/500+17*t/200+1):1},_precision:function(){var e=this._precisionOf(this.options.step);return this.options.min!==null&&(e=Math.max(e,this._precisionOf(this.options.min))),e},_precisionOf:function(e){var t=e.toString(),n=t.indexOf(".");return n===-1?0:t.length-n-1},_adjustValue:function(e){var t,n,r=this.options;return t=r.min!==null?r.min:0,n=e-t,n=Math.round(n/r.step)*r.step,e=t+n,e=parseFloat(e.toFixed(this._precision())),r.max!==null&&e>r.max?r.max:r.min!==null&&e<r.min?r.min:e},_stop:function(e){if(!this.spinning)return;clearTimeout(this.timer),clearTimeout(this.mousewheelTimer),this.counter=0,this.spinning=!1,this._trigger("stop",e)},_setOption:function(e,t){if(e==="culture"||e==="numberFormat"){var n=this._parse(this.element.val());this.options[e]=t,this.element.val(this._format(n));return}(e==="max"||e==="min"||e==="step")&&typeof t=="string"&&(t=this._parse(t)),this._super(e,t),e==="disabled"&&(t?(this.element.prop("disabled",!0),this.buttons.button("disable")):(this.element.prop("disabled",!1),this.buttons.button("enable")))},_setOptions:t(function(e){this._super(e),this._value(this.element.val())}),_parse:function(e){return typeof e=="string"&&e!==""&&(e=window.Globalize&&this.options.numberFormat?Globalize.parseFloat(e,10,this.options.culture):+e),e===""||isNaN(e)?null:e},_format:function(e){return e===""?"":window.Globalize&&this.options.numberFormat?Globalize.format(e,this.options.numberFormat,this.options.culture):e},_refresh:function(){this.element.attr({"aria-valuemin":this.options.min,"aria-valuemax":this.options.max,"aria-valuenow":this._parse(this.element.val())})},_value:function(e,t){var n;e!==""&&(n=this._parse(e),n!==null&&(t||(n=this._adjustValue(n)),e=this._format(n))),this.element.val(e),this._refresh()},_destroy:function(){this.element.removeClass("ui-spinner-input").prop("disabled",!1).removeAttr("autocomplete").removeAttr("role").removeAttr("aria-valuemin").removeAttr("aria-valuemax").removeAttr("aria-valuenow"),this.uiSpinner.replaceWith(this.element)},stepUp:t(function(e){this._stepUp(e)}),_stepUp:function(e){this._spin((e||1)*this.options.step)},stepDown:t(function(e){this._stepDown(e)}),_stepDown:function(e){this._spin((e||1)*-this.options.step)},pageUp:t(function(e){this._stepUp((e||1)*this.options.page)}),pageDown:t(function(e){this._stepDown((e||1)*this.options.page)}),value:function(e){if(!arguments.length)return this._parse(this.element.val());t(this._value).call(this,e)},widget:function(){return this.uiSpinner}})})(jQuery);(function(e,t){function i(){return++n}function s(e){return e=e.cloneNode(!1),e.hash.length>1&&e.href.replace(r,"")===location.href.replace(r,"")}var n=0,r=/#.*$/;e.widget("ui.tabs",{version:"1.9.0",delay:300,options:{active:null,collapsible:!1,event:"click",heightStyle:"content",hide:null,show:null,activate:null,beforeActivate:null,beforeLoad:null,load:null},_create:function(){var t,n=this,r=this.options,i=r.active;this.running=!1,this.element.addClass("ui-tabs ui-widget ui-widget-content ui-corner-all").toggleClass("ui-tabs-collapsible",r.collapsible).delegate(".ui-tabs-nav > li","mousedown"+this.eventNamespace,function(t){e(this).is(".ui-state-disabled")&&t.preventDefault()}).delegate(".ui-tabs-anchor","focus"+this.eventNamespace,function(){e(this).closest("li").is(".ui-state-disabled")&&this.blur()}),this._processTabs();if(i===null){location.hash&&this.anchors.each(function(e,t){if(t.hash===location.hash)return i=e,!1}),i===null&&(i=this.tabs.filter(".ui-tabs-active").index());if(i===null||i===-1)i=this.tabs.length?0:!1}i!==!1&&(i=this.tabs.index(this.tabs.eq(i)),i===-1&&(i=r.collapsible?!1:0)),r.active=i,!r.collapsible&&r.active===!1&&this.anchors.length&&(r.active=0),e.isArray(r.disabled)&&(r.disabled=e.unique(r.disabled.concat(e.map(this.tabs.filter(".ui-state-disabled"),function(e){return n.tabs.index(e)}))).sort()),this.options.active!==!1&&this.anchors.length?this.active=this._findActive(this.options.active):this.active=e(),this._refresh(),this.active.length&&this.load(r.active)},_getCreateEventData:function(){return{tab:this.active,panel:this.active.length?this._getPanelForTab(this.active):e()}},_tabKeydown:function(t){var n=e(this.document[0].activeElement).closest("li"),r=this.tabs.index(n),i=!0;if(this._handlePageNav(t))return;switch(t.keyCode){case e.ui.keyCode.RIGHT:case e.ui.keyCode.DOWN:r++;break;case e.ui.keyCode.UP:case e.ui.keyCode.LEFT:i=!1,r--;break;case e.ui.keyCode.END:r=this.anchors.length-1;break;case e.ui.keyCode.HOME:r=0;break;case e.ui.keyCode.SPACE:t.preventDefault(),clearTimeout(this.activating),this._activate(r);return;case e.ui.keyCode.ENTER:t.preventDefault(),clearTimeout(this.activating),this._activate(r===this.options.active?!1:r);return;default:return}t.preventDefault(),clearTimeout(this.activating),r=this._focusNextTab(r,i),t.ctrlKey||(n.attr("aria-selected","false"),this.tabs.eq(r).attr("aria-selected","true"),this.activating=this._delay(function(){this.option("active",r)},this.delay))},_panelKeydown:function(t){if(this._handlePageNav(t))return;t.ctrlKey&&t.keyCode===e.ui.keyCode.UP&&(t.preventDefault(),this.active.focus())},_handlePageNav:function(t){if(t.altKey&&t.keyCode===e.ui.keyCode.PAGE_UP)return this._activate(this._focusNextTab(this.options.active-1,!1)),!0;if(t.altKey&&t.keyCode===e.ui.keyCode.PAGE_DOWN)return this._activate(this._focusNextTab(this.options.active+1,!0)),!0},_findNextTab:function(t,n){function i(){return t>r&&(t=0),t<0&&(t=r),t}var r=this.tabs.length-1;while(e.inArray(i(),this.options.disabled)!==-1)t=n?t+1:t-1;return t},_focusNextTab:function(e,t){return e=this._findNextTab(e,t),this.tabs.eq(e).focus(),e},_setOption:function(e,t){if(e==="active"){this._activate(t);return}if(e==="disabled"){this._setupDisabled(t);return}this._super(e,t),e==="collapsible"&&(this.element.toggleClass("ui-tabs-collapsible",t),!t&&this.options.active===!1&&this._activate(0)),e==="event"&&this._setupEvents(t),e==="heightStyle"&&this._setupHeightStyle(t)},_tabId:function(e){return e.attr("aria-controls")||"ui-tabs-"+i()},_sanitizeSelector:function(e){return e?e.replace(/[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g,"\\$&"):""},refresh:function(){var t,n=this.options,r=this.tablist.children(":has(a[href])");n.disabled=e.map(r.filter(".ui-state-disabled"),function(e){return r.index(e)}),this._processTabs(),n.active===!1||!this.anchors.length?(n.active=!1,this.active=e()):this.active.length&&!e.contains(this.tablist[0],this.active[0])?this.tabs.length===n.disabled.length?(n.active=!1,this.active=e()):this._activate(this._findNextTab(Math.max(0,n.active-1),!1)):n.active=this.tabs.index(this.active),this._refresh()},_refresh:function(){this._setupDisabled(this.options.disabled),this._setupEvents(this.options.event),this._setupHeightStyle(this.options.heightStyle),this.tabs.not(this.active).attr({"aria-selected":"false",tabIndex:-1}),this.panels.not(this._getPanelForTab(this.active)).hide().attr({"aria-expanded":"false","aria-hidden":"true"}),this.active.length?(this.active.addClass("ui-tabs-active ui-state-active").attr({"aria-selected":"true",tabIndex:0}),this._getPanelForTab(this.active).show().attr({"aria-expanded":"true","aria-hidden":"false"})):this.tabs.eq(0).attr("tabIndex",0)},_processTabs:function(){var t=this;this.tablist=this._getList().addClass("ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all").attr("role","tablist"),this.tabs=this.tablist.find("> li:has(a[href])").addClass("ui-state-default ui-corner-top").attr({role:"tab",tabIndex:-1}),this.anchors=this.tabs.map(function(){return e("a",this)[0]}).addClass("ui-tabs-anchor").attr({role:"presentation",tabIndex:-1}),this.panels=e(),this.anchors.each(function(n,r){var i,o,u,a=e(r).uniqueId().attr("id"),f=e(r).closest("li"),l=f.attr("aria-controls");s(r)?(i=r.hash,o=t.element.find(t._sanitizeSelector(i))):(u=t._tabId(f),i="#"+u,o=t.element.find(i),o.length||(o=t._createPanel(u),o.insertAfter(t.panels[n-1]||t.tablist)),o.attr("aria-live","polite")),o.length&&(t.panels=t.panels.add(o)),l&&f.data("ui-tabs-aria-controls",l),f.attr({"aria-controls":i.substring(1),"aria-labelledby":a}),o.attr("aria-labelledby",a)}),this.panels.addClass("ui-tabs-panel ui-widget-content ui-corner-bottom").attr("role","tabpanel")},_getList:function(){return this.element.find("ol,ul").eq(0)},_createPanel:function(t){return e("<div>").attr("id",t).addClass("ui-tabs-panel ui-widget-content ui-corner-bottom").data("ui-tabs-destroy",!0)},_setupDisabled:function(t){e.isArray(t)&&(t.length?t.length===this.anchors.length&&(t=!0):t=!1);for(var n=0,r;r=this.tabs[n];n++)t===!0||e.inArray(n,t)!==-1?e(r).addClass("ui-state-disabled").attr("aria-disabled","true"):e(r).removeClass("ui-state-disabled").removeAttr("aria-disabled");this.options.disabled=t},_setupEvents:function(t){var n={click:function(e){e.preventDefault()}};t&&e.each(t.split(" "),function(e,t){n[t]="_eventHandler"}),this._off(this.anchors.add(this.tabs).add(this.panels)),this._on(this.anchors,n),this._on(this.tabs,{keydown:"_tabKeydown"}),this._on(this.panels,{keydown:"_panelKeydown"}),this._focusable(this.tabs),this._hoverable(this.tabs)},_setupHeightStyle:function(t){var n,r,i=this.element.parent();t==="fill"?(e.support.minHeight||(r=i.css("overflow"),i.css("overflow","hidden")),n=i.height(),this.element.siblings(":visible").each(function(){var t=e(this),r=t.css("position");if(r==="absolute"||r==="fixed")return;n-=t.outerHeight(!0)}),r&&i.css("overflow",r),this.element.children().not(this.panels).each(function(){n-=e(this).outerHeight(!0)}),this.panels.each(function(){e(this).height(Math.max(0,n-e(this).innerHeight()+e(this).height()))}).css("overflow","auto")):t==="auto"&&(n=0,this.panels.each(function(){n=Math.max(n,e(this).height("").height())}).height(n))},_eventHandler:function(t){var n=this.options,r=this.active,i=e(t.currentTarget),s=i.closest("li"),o=s[0]===r[0],u=o&&n.collapsible,a=u?e():this._getPanelForTab(s),f=r.length?this._getPanelForTab(r):e(),l={oldTab:r,oldPanel:f,newTab:u?e():s,newPanel:a};t.preventDefault();if(s.hasClass("ui-state-disabled")||s.hasClass("ui-tabs-loading")||this.running||o&&!n.collapsible||this._trigger("beforeActivate",t,l)===!1)return;n.active=u?!1:this.tabs.index(s),this.active=o?e():s,this.xhr&&this.xhr.abort(),!f.length&&!a.length&&e.error("jQuery UI Tabs: Mismatching fragment identifier."),a.length&&this.load(this.tabs.index(s),t),this._toggle(t,l)},_toggle:function(t,n){function o(){r.running=!1,r._trigger("activate",t,n)}function u(){n.newTab.closest("li").addClass("ui-tabs-active ui-state-active"),i.length&&r.options.show?r._show(i,r.options.show,o):(i.show(),o())}var r=this,i=n.newPanel,s=n.oldPanel;this.running=!0,s.length&&this.options.hide?this._hide(s,this.options.hide,function(){n.oldTab.closest("li").removeClass("ui-tabs-active ui-state-active"),u()}):(n.oldTab.closest("li").removeClass("ui-tabs-active ui-state-active"),s.hide(),u()),s.attr({"aria-expanded":"false","aria-hidden":"true"}),n.oldTab.attr("aria-selected","false"),i.length&&s.length?n.oldTab.attr("tabIndex",-1):i.length&&this.tabs.filter(function(){return e(this).attr("tabIndex")===0}).attr("tabIndex",-1),i.attr({"aria-expanded":"true","aria-hidden":"false"}),n.newTab.attr({"aria-selected":"true",tabIndex:0})},_activate:function(t){var n,r=this._findActive(t);if(r[0]===this.active[0])return;r.length||(r=this.active),n=r.find(".ui-tabs-anchor")[0],this._eventHandler({target:n,currentTarget:n,preventDefault:e.noop})},_findActive:function(t){return t===!1?e():this.tabs.eq(t)},_getIndex:function(e){return typeof e=="string"&&(e=this.anchors.index(this.anchors.filter("[href$='"+e+"']"))),e},_destroy:function(){this.xhr&&this.xhr.abort(),this.element.removeClass("ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible"),this.tablist.removeClass("ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all").removeAttr("role"),this.anchors.removeClass("ui-tabs-anchor").removeAttr("role").removeAttr("tabIndex").removeData("href.tabs").removeData("load.tabs").removeUniqueId(),this.tabs.add(this.panels).each(function(){e.data(this,"ui-tabs-destroy")?e(this).remove():e(this).removeClass("ui-state-default ui-state-active ui-state-disabled ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel").removeAttr("tabIndex").removeAttr("aria-live").removeAttr("aria-busy").removeAttr("aria-selected").removeAttr("aria-labelledby").removeAttr("aria-hidden").removeAttr("aria-expanded").removeAttr("role")}),this.tabs.each(function(){var t=e(this),n=t.data("ui-tabs-aria-controls");n?t.attr("aria-controls",n):t.removeAttr("aria-controls")}),this.options.heightStyle!=="content"&&this.panels.css("height","")},enable:function(n){var r=this.options.disabled;if(r===!1)return;n===t?r=!1:(n=this._getIndex(n),e.isArray(r)?r=e.map(r,function(e){return e!==n?e:null}):r=e.map(this.tabs,function(e,t){return t!==n?t:null})),this._setupDisabled(r)},disable:function(n){var r=this.options.disabled;if(r===!0)return;if(n===t)r=!0;else{n=this._getIndex(n);if(e.inArray(n,r)!==-1)return;e.isArray(r)?r=e.merge([n],r).sort():r=[n]}this._setupDisabled(r)},load:function(t,n){t=this._getIndex(t);var r=this,i=this.tabs.eq(t),o=i.find(".ui-tabs-anchor"),u=this._getPanelForTab(i),a={tab:i,panel:u};if(s(o[0]))return;this.xhr=e.ajax(this._ajaxSettings(o,n,a)),this.xhr&&this.xhr.statusText!=="canceled"&&(i.addClass("ui-tabs-loading"),u.attr("aria-busy","true"),this.xhr.success(function(e){setTimeout(function(){u.html(e),r._trigger("load",n,a)},1)}).complete(function(e,t){setTimeout(function(){t==="abort"&&r.panels.stop(!1,!0),i.removeClass("ui-tabs-loading"),u.removeAttr("aria-busy"),e===r.xhr&&delete r.xhr},1)}))},_ajaxSettings:function(t,n,r){var i=this;return{url:t.attr("href"),beforeSend:function(t,s){return i._trigger("beforeLoad",n,e.extend({jqXHR:t,ajaxSettings:s},r))}}},_getPanelForTab:function(t){var n=e(t).attr("aria-controls");return this.element.find(this._sanitizeSelector("#"+n))}}),e.uiBackCompat!==!1&&(e.ui.tabs.prototype._ui=function(e,t){return{tab:e,panel:t,index:this.anchors.index(e)}},e.widget("ui.tabs",e.ui.tabs,{url:function(e,t){this.anchors.eq(e).attr("href",t)}}),e.widget("ui.tabs",e.ui.tabs,{options:{ajaxOptions:null,cache:!1},_create:function(){this._super();var t=this;this._on({tabsbeforeload:function(n,r){if(e.data(r.tab[0],"cache.tabs")){n.preventDefault();return}r.jqXHR.success(function(){t.options.cache&&e.data(r.tab[0],"cache.tabs",!0)})}})},_ajaxSettings:function(t,n,r){var i=this.options.ajaxOptions;return e.extend({},i,{error:function(e,t,n){try{i.error(e,t,r.tab.closest("li").index(),r.tab[0])}catch(n){}}},this._superApply(arguments))},_setOption:function(e,t){e==="cache"&&t===!1&&this.anchors.removeData("cache.tabs"),this._super(e,t)},_destroy:function(){this.anchors.removeData("cache.tabs"),this._super()},url:function(e,t){this.anchors.eq(e).removeData("cache.tabs"),this._superApply(arguments)}}),e.widget("ui.tabs",e.ui.tabs,{abort:function(){this.xhr&&this.xhr.abort()}}),e.widget("ui.tabs",e.ui.tabs,{options:{spinner:"<em>Loading&#8230;</em>"},_create:function(){this._super(),this._on({tabsbeforeload:function(e,t){if(e.target!==this.element[0]||!this.options.spinner)return;var n=t.tab.find("span"),r=n.html();n.html(this.options.spinner),t.jqXHR.complete(function(){n.html(r)})}})}}),e.widget("ui.tabs",e.ui.tabs,{options:{enable:null,disable:null},enable:function(t){var n=this.options,r;if(t&&n.disabled===!0||e.isArray(n.disabled)&&e.inArray(t,n.disabled)!==-1)r=!0;this._superApply(arguments),r&&this._trigger("enable",null,this._ui(this.anchors[t],this.panels[t]))},disable:function(t){var n=this.options,r;if(t&&n.disabled===!1||e.isArray(n.disabled)&&e.inArray(t,n.disabled)===-1)r=!0;this._superApply(arguments),r&&this._trigger("disable",null,this._ui(this.anchors[t],this.panels[t]))}}),e.widget("ui.tabs",e.ui.tabs,{options:{add:null,remove:null,tabTemplate:"<li><a href='#{href}'><span>#{label}</span></a></li>"},add:function(n,r,i){i===t&&(i=this.anchors.length);var s,o,u=this.options,a=e(u.tabTemplate.replace(/#\{href\}/g,n).replace(/#\{label\}/g,r)),f=n.indexOf("#")?this._tabId(a):n.replace("#","");return a.addClass("ui-state-default ui-corner-top").data("ui-tabs-destroy",!0),a.attr("aria-controls",f),s=i>=this.tabs.length,o=this.element.find("#"+f),o.length||(o=this._createPanel(f),s?i>0?o.insertAfter(this.panels.eq(-1)):o.appendTo(this.element):o.insertBefore(this.panels[i])),o.addClass("ui-tabs-panel ui-widget-content ui-corner-bottom").hide(),s?a.appendTo(this.tablist):a.insertBefore(this.tabs[i]),u.disabled=e.map(u.disabled,function(e){return e>=i?++e:e}),this.refresh(),this.tabs.length===1&&u.active===!1&&this.option("active",0),this._trigger("add",null,this._ui(this.anchors[i],this.panels[i])),this},remove:function(t){t=this._getIndex(t);var n=this.options,r=this.tabs.eq(t).remove(),i=this._getPanelForTab(r).remove();return r.hasClass("ui-tabs-active")&&this.anchors.length>2&&this._activate(t+(t+1<this.anchors.length?1:-1)),n.disabled=e.map(e.grep(n.disabled,function(e){return e!==t}),function(e){return e>=t?--e:e}),this.refresh(),this._trigger("remove",null,this._ui(r.find("a")[0],i[0])),this}}),e.widget("ui.tabs",e.ui.tabs,{length:function(){return this.anchors.length}}),e.widget("ui.tabs",e.ui.tabs,{options:{idPrefix:"ui-tabs-"},_tabId:function(t){var n=t.is("li")?t.find("a[href]"):t;return n=n[0],e(n).closest("li").attr("aria-controls")||n.title&&n.title.replace(/\s/g,"_").replace(/[^\w\u00c0-\uFFFF\-]/g,"")||this.options.idPrefix+i()}}),e.widget("ui.tabs",e.ui.tabs,{options:{panelTemplate:"<div></div>"},_createPanel:function(t){return e(this.options.panelTemplate).attr("id",t).addClass("ui-tabs-panel ui-widget-content ui-corner-bottom").data("ui-tabs-destroy",!0)}}),e.widget("ui.tabs",e.ui.tabs,{_create:function(){var e=this.options;e.active===null&&e.selected!==t&&(e.active=e.selected===-1?!1:e.selected),this._super(),e.selected=e.active,e.selected===!1&&(e.selected=-1)},_setOption:function(e,t){if(e!=="selected")return this._super(e,t);var n=this.options;this._super("active",t===-1?!1:t),n.selected=n.active,n.selected===!1&&(n.selected=-1)},_eventHandler:function(e){this._superApply(arguments),this.options.selected=this.options.active,this.options.selected===!1&&(this.options.selected=-1)}}),e.widget("ui.tabs",e.ui.tabs,{options:{show:null,select:null},_create:function(){this._super(),this.options.active!==!1&&this._trigger("show",null,this._ui(this.active.find(".ui-tabs-anchor")[0],this._getPanelForTab(this.active)[0]))},_trigger:function(e,t,n){var r=this._superApply(arguments);return r?(e==="beforeActivate"&&n.newTab.length?r=this._super("select",t,{tab:n.newTab.find(".ui-tabs-anchor")[0],panel:n.newPanel[0],index:n.newTab.closest("li").index()}):e==="activate"&&n.newTab.length&&(r=this._super("show",t,{tab:n.newTab.find(".ui-tabs-anchor")[0],panel:n.newPanel[0],index:n.newTab.closest("li").index()})),r):!1}}),e.widget("ui.tabs",e.ui.tabs,{select:function(e){e=this._getIndex(e);if(e===-1){if(!this.options.collapsible||this.options.selected===-1)return;e=this.options.selected}this.anchors.eq(e).trigger(this.options.event+this.eventNamespace)}}),function(){var t=0;e.widget("ui.tabs",e.ui.tabs,{options:{cookie:null},_create:function(){var e=this.options,t;e.active==null&&e.cookie&&(t=parseInt(this._cookie(),10),t===-1&&(t=!1),e.active=t),this._super()},_cookie:function(n){var r=[this.cookie||(this.cookie=this.options.cookie.name||"ui-tabs-"+ ++t)];return arguments.length&&(r.push(n===!1?-1:n),r.push(this.options.cookie)),e.cookie.apply(null,r)},_refresh:function(){this._super(),this.options.cookie&&this._cookie(this.options.active,this.options.cookie)},_eventHandler:function(e){this._superApply(arguments),this.options.cookie&&this._cookie(this.options.active,this.options.cookie)},_destroy:function(){this._super(),this.options.cookie&&this._cookie(null,this.options.cookie)}})}(),e.widget("ui.tabs",e.ui.tabs,{_trigger:function(t,n,r){var i=e.extend({},r);return t==="load"&&(i.panel=i.panel[0],i.tab=i.tab.find(".ui-tabs-anchor")[0]),this._super(t,n,i)}}),e.widget("ui.tabs",e.ui.tabs,{options:{fx:null},_getFx:function(){var t,n,r=this.options.fx;return r&&(e.isArray(r)?(t=r[0],n=r[1]):t=n=r),r?{show:n,hide:t}:null},_toggle:function(e,t){function o(){n.running=!1,n._trigger("activate",e,t)}function u(){t.newTab.closest("li").addClass("ui-tabs-active ui-state-active"),r.length&&s.show?r.animate(s.show,s.show.duration,function(){o()}):(r.show(),o())}var n=this,r=t.newPanel,i=t.oldPanel,s=this._getFx();if(!s)return this._super(e,t);n.running=!0,i.length&&s.hide?i.animate(s.hide,s.hide.duration,function(){t.oldTab.closest("li").removeClass("ui-tabs-active ui-state-active"),u()}):(t.oldTab.closest("li").removeClass("ui-tabs-active ui-state-active"),i.hide(),u())}}))})(jQuery);(function(e){function n(t,n){var r=(t.attr("aria-describedby")||"").split(/\s+/);r.push(n),t.data("ui-tooltip-id",n).attr("aria-describedby",e.trim(r.join(" ")))}function r(t){var n=t.data("ui-tooltip-id"),r=(t.attr("aria-describedby")||"").split(/\s+/),i=e.inArray(n,r);i!==-1&&r.splice(i,1),t.removeData("ui-tooltip-id"),r=e.trim(r.join(" ")),r?t.attr("aria-describedby",r):t.removeAttr("aria-describedby")}var t=0;e.widget("ui.tooltip",{version:"1.9.0",options:{content:function(){return e(this).attr("title")},hide:!0,items:"[title]",position:{my:"left+15 center",at:"right center",collision:"flipfit flipfit"},show:!0,tooltipClass:null,track:!1,close:null,open:null},_create:function(){this._on({mouseover:"open",focusin:"open"}),this.tooltips={}},_setOption:function(t,n){var r=this;if(t==="disabled"){this[n?"_disable":"_enable"](),this.options[t]=n;return}this._super(t,n),t==="content"&&e.each(this.tooltips,function(e,t){r._updateContent(t)})},_disable:function(){var t=this;e.each(this.tooltips,function(n,r){var i=e.Event("blur");i.target=i.currentTarget=r[0],t.close(i,!0)}),this.element.find(this.options.items).andSelf().each(function(){var t=e(this);t.is("[title]")&&t.data("ui-tooltip-title",t.attr("title")).attr("title","")})},_enable:function(){this.element.find(this.options.items).andSelf().each(function(){var t=e(this);t.data("ui-tooltip-title")&&t.attr("title",t.data("ui-tooltip-title"))})},open:function(t){var n=e(t?t.target:this.element).closest(this.options.items);if(!n.length)return;if(this.options.track&&n.data("ui-tooltip-id")){this._find(n).position(e.extend({of:n},this.options.position)),this._off(this.document,"mousemove");return}n.attr("title")&&n.data("ui-tooltip-title",n.attr("title")),n.data("tooltip-open",!0),this._updateContent(n,t)},_updateContent:function(e,t){var n,r=this.options.content,i=this;if(typeof r=="string")return this._open(t,e,r);n=r.call(e[0],function(n){if(!e.data("tooltip-open"))return;i._delay(function(){this._open(t,e,n)})}),n&&this._open(t,e,n)},_open:function(t,r,i){function u(e){o.of=e,s.position(o)}var s,o;if(!i)return;s=this._find(r);if(s.length){s.find(".ui-tooltip-content").html(i);return}r.is("[title]")&&(t&&t.type==="mouseover"?r.attr("title",""):r.removeAttr("title")),s=this._tooltip(r),n(r,s.attr("id")),s.find(".ui-tooltip-content").html(i),this.options.track&&t&&/^mouse/.test(t.originalEvent.type)?(o=e.extend({},this.options.position),this._on(this.document,{mousemove:u}),u(t)):s.position(e.extend({of:r},this.options.position)),s.hide(),this._show(s,this.options.show),this._trigger("open",t,{tooltip:s}),this._on(r,{mouseleave:"close",focusout:"close",keyup:function(t){if(t.keyCode===e.ui.keyCode.ESCAPE){var n=e.Event(t);n.currentTarget=r[0],this.close(n,!0)}}})},close:function(t,n){var i=this,s=e(t?t.currentTarget:this.element),o=this._find(s);if(this.closing)return;if(!n&&t&&t.type!=="focusout"&&this.document[0].activeElement===s[0])return;s.data("ui-tooltip-title")&&s.attr("title",s.data("ui-tooltip-title")),r(s),o.stop(!0),this._hide(o,this.options.hide,function(){e(this).remove(),delete i.tooltips[this.id]}),s.removeData("tooltip-open"),this._off(s,"mouseleave focusout keyup"),this._off(this.document,"mousemove"),this.closing=!0,this._trigger("close",t,{tooltip:o}),this.closing=!1},_tooltip:function(n){var r="ui-tooltip-"+t++,i=e("<div>").attr({id:r,role:"tooltip"}).addClass("ui-tooltip ui-widget ui-corner-all ui-widget-content "+(this.options.tooltipClass||""));return e("<div>").addClass("ui-tooltip-content").appendTo(i),i.appendTo(this.document[0].body),e.fn.bgiframe&&i.bgiframe(),this.tooltips[r]=n,i},_find:function(t){var n=t.data("ui-tooltip-id");return n?e("#"+n):e()},_destroy:function(){var t=this;e.each(this.tooltips,function(n,r){var i=e.Event("blur");i.target=i.currentTarget=r[0],t.close(i,!0),e("#"+n).remove(),r.data("ui-tooltip-title")&&(r.attr("title",r.data("ui-tooltip-title")),r.removeData("ui-tooltip-title"))})}})})(jQuery);
\ No newline at end of file
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/jquery.layout.js b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/jquery.layout.js
deleted file mode 100644
index 4dd48675b7..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/jquery.layout.js
+++ /dev/null
@@ -1,5486 +0,0 @@
-/**
- * @preserve jquery.layout 1.3.0 - Release Candidate 30.62
- * $Date: 2012-08-04 08:00:00 (Thu, 23 Aug 2012) $
- * $Rev: 303006 $
- *
- * Copyright (c) 2012 
- *   Fabrizio Balliano (http://www.fabrizioballiano.net)
- *   Kevin Dalman (http://allpro.net)
- *
- * Dual licensed under the GPL (http://www.gnu.org/licenses/gpl.html)
- * and MIT (http://www.opensource.org/licenses/mit-license.php) licenses.
- *
- * Changelog: http://layout.jquery-dev.net/changelog.cfm#1.3.0.rc30.62
- * NOTE: This is a short-term release to patch a couple of bugs.
- * These bugs are listed as officially fixed in RC30.7, which will be released shortly.
- *
- * Docs: http://layout.jquery-dev.net/documentation.html
- * Tips: http://layout.jquery-dev.net/tips.html
- * Help: http://groups.google.com/group/jquery-ui-layout
- */
-
-/* JavaDoc Info: http://code.google.com/closure/compiler/docs/js-for-compiler.html
- * {!Object}	non-nullable type (never NULL)
- * {?string}	nullable type (sometimes NULL) - default for {Object}
- * {number=}	optional parameter
- * {*}			ALL types
- */
-
-// NOTE: For best readability, view with a fixed-width font and tabs equal to 4-chars
-
-;(function ($) {
-
-// alias Math methods - used a lot!
-var	min		= Math.min
-,	max		= Math.max
-,	round	= Math.floor
-
-,	isStr	=  function (v) { return $.type(v) === "string"; }
-
-,	runPluginCallbacks = function (Instance, a_fn) {
-		if ($.isArray(a_fn))
-			for (var i=0, c=a_fn.length; i<c; i++) {
-				var fn = a_fn[i];
-				try {
-					if (isStr(fn)) // 'name' of a function
-						fn = eval(fn);
-					if ($.isFunction(fn))
-						fn( Instance );
-				} catch (ex) {}
-			}
-	}
-
-;
-
-
-/*
- *	GENERIC $.layout METHODS - used by all layouts
- */
-$.layout = {
-
-	version:	"1.3.rc30.62"
-,	revision:	0.033006 // 1.3.0 final = 1.0300 - major(n+).minor(nn)+patch(nn+)
-
-	// can update code here if $.browser is phased out
-,	browser: {
-		mozilla:	!!$.browser.mozilla
-	,	webkit:		!!$.browser.webkit || !!$.browser.safari // webkit = jQ 1.4
-	,	msie:		!!$.browser.msie
-	,	isIE6:		$.browser.msie && $.browser.version == 6
-	,	boxModel:	$.support.boxModel !== false || !$.browser.msie // ONLY IE reverts to old box-model - update for older jQ onReady
-	,	version:	$.browser.version // not used in Layout core, but may be used by plugins
-	}
-
-	// *PREDEFINED* EFFECTS & DEFAULTS 
-	// MUST list effect here - OR MUST set an fxSettings option (can be an empty hash: {})
-,	effects: {
-
-	//	Pane Open/Close Animations
-		slide: {
-			all:	{ duration:  "fast"	} // eg: duration: 1000, easing: "easeOutBounce"
-		,	north:	{ direction: "up"	}
-		,	south:	{ direction: "down"	}
-		,	east:	{ direction: "right"}
-		,	west:	{ direction: "left"	}
-		}
-	,	drop: {
-			all:	{ duration:  "slow"	}
-		,	north:	{ direction: "up"	}
-		,	south:	{ direction: "down"	}
-		,	east:	{ direction: "right"}
-		,	west:	{ direction: "left"	}
-		}
-	,	scale: {
-			all:	{ duration:	"fast"	}
-		}
-	//	these are not recommended, but can be used
-	,	blind:		{}
-	,	clip:		{}
-	,	explode:	{}
-	,	fade:		{}
-	,	fold:		{}
-	,	puff:		{}
-
-	//	Pane Resize Animations
-	,	size: {
-			all:	{ easing:	"swing"	}
-		}
-	}
-
-	// INTERNAL CONFIG DATA - DO NOT CHANGE THIS!
-,	config: {
-		optionRootKeys:	"effects,panes,north,south,west,east,center".split(",")
-	,	allPanes:		"north,south,west,east,center".split(",")
-	,	borderPanes:	"north,south,west,east".split(",")
-	,	oppositeEdge: {
-			north:	"south"
-		,	south:	"north"
-		,	east: 	"west"
-		,	west: 	"east"
-		}
-	//	offscreen data
-	,	offscreenCSS:	{ left: "-99999px", right: "auto" } // used by hide/close if useOffscreenClose=true
-	,	offscreenReset:	"offscreenReset" // key used for data
-	//	CSS used in multiple places
-	,	hidden:		{ visibility: "hidden" }
-	,	visible:	{ visibility: "visible" }
-	//	layout element settings
-	,	resizers: {
-			cssReq: {
-				position: 	"absolute"
-			,	padding: 	0
-			,	margin: 	0
-			,	fontSize:	"1px"
-			,	textAlign:	"left"	// to counter-act "center" alignment!
-			,	overflow: 	"hidden" // prevent toggler-button from overflowing
-			//	SEE $.layout.defaults.zIndexes.resizer_normal
-			}
-		,	cssDemo: { // DEMO CSS - applied if: options.PANE.applyDemoStyles=true
-				background: "#DDD"
-			,	border:		"none"
-			}
-		}
-	,	togglers: {
-			cssReq: {
-				position: 	"absolute"
-			,	display: 	"block"
-			,	padding: 	0
-			,	margin: 	0
-			,	overflow:	"hidden"
-			,	textAlign:	"center"
-			,	fontSize:	"1px"
-			,	cursor: 	"pointer"
-			,	zIndex: 	1
-			}
-		,	cssDemo: { // DEMO CSS - applied if: options.PANE.applyDemoStyles=true
-				background: "#AAA"
-			}
-		}
-	,	content: {
-			cssReq: {
-				position:	"relative" /* contain floated or positioned elements */
-			}
-		,	cssDemo: { // DEMO CSS - applied if: options.PANE.applyDemoStyles=true
-				overflow:	"auto"
-			,	padding:	"10px"
-			}
-		,	cssDemoPane: { // DEMO CSS - REMOVE scrolling from 'pane' when it has a content-div
-				overflow:	"hidden"
-			,	padding:	0
-			}
-		}
-	,	panes: { // defaults for ALL panes - overridden by 'per-pane settings' below
-			cssReq: {
-				position: 	"absolute"
-			,	margin:		0
-			//	$.layout.defaults.zIndexes.pane_normal
-			}
-		,	cssDemo: { // DEMO CSS - applied if: options.PANE.applyDemoStyles=true
-				padding:	"10px"
-			,	background:	"#FFF"
-			,	border:		"1px solid #BBB"
-			,	overflow:	"auto"
-			}
-		}
-	,	north: {
-			side:			"Top"
-		,	sizeType:		"Height"
-		,	dir:			"horz"
-		,	cssReq: {
-				top: 		0
-			,	bottom: 	"auto"
-			,	left: 		0
-			,	right: 		0
-			,	width: 		"auto"
-			//	height: 	DYNAMIC
-			}
-		}
-	,	south: {
-			side:			"Bottom"
-		,	sizeType:		"Height"
-		,	dir:			"horz"
-		,	cssReq: {
-				top: 		"auto"
-			,	bottom: 	0
-			,	left: 		0
-			,	right: 		0
-			,	width: 		"auto"
-			//	height: 	DYNAMIC
-			}
-		}
-	,	east: {
-			side:			"Right"
-		,	sizeType:		"Width"
-		,	dir:			"vert"
-		,	cssReq: {
-				left: 		"auto"
-			,	right: 		0
-			,	top: 		"auto" // DYNAMIC
-			,	bottom: 	"auto" // DYNAMIC
-			,	height: 	"auto"
-			//	width: 		DYNAMIC
-			}
-		}
-	,	west: {
-			side:			"Left"
-		,	sizeType:		"Width"
-		,	dir:			"vert"
-		,	cssReq: {
-				left: 		0
-			,	right: 		"auto"
-			,	top: 		"auto" // DYNAMIC
-			,	bottom: 	"auto" // DYNAMIC
-			,	height: 	"auto"
-			//	width: 		DYNAMIC
-			}
-		}
-	,	center: {
-			dir:			"center"
-		,	cssReq: {
-				left: 		"auto" // DYNAMIC
-			,	right: 		"auto" // DYNAMIC
-			,	top: 		"auto" // DYNAMIC
-			,	bottom: 	"auto" // DYNAMIC
-			,	height: 	"auto"
-			,	width: 		"auto"
-			}
-		}
-	}
-
-	// CALLBACK FUNCTION NAMESPACE - used to store reusable callback functions
-,	callbacks: {}
-
-,	getParentPaneElem: function (el) {
-		// must pass either a container or pane element
-		var $el = $(el)
-		,	layout = $el.data("layout") || $el.data("parentLayout");
-		if (layout) {
-			var $cont = layout.container;
-			// see if this container is directly-nested inside an outer-pane
-			if ($cont.data("layoutPane")) return $cont;
-			var $pane = $cont.closest("."+ $.layout.defaults.panes.paneClass);
-			// if a pane was found, return it
-			if ($pane.data("layoutPane")) return $pane;
-		}
-		return null;
-	}
-
-,	getParentPaneInstance: function (el) {
-		// must pass either a container or pane element
-		var $pane = $.layout.getParentPaneElem(el);
-		return $pane ? $pane.data("layoutPane") : null;
-	}
-
-,	getParentLayoutInstance: function (el) {
-		// must pass either a container or pane element
-		var $pane = $.layout.getParentPaneElem(el);
-		return $pane ? $pane.data("parentLayout") : null;
-	}
-
-,	getEventObject: function (evt) {
-		return typeof evt === "object" && evt.stopPropagation ? evt : null;
-	}
-,	parsePaneName: function (evt_or_pane) {
-		// getEventObject() automatically calls .stopPropagation(), WHICH MUST BE DONE!
-		var evt = $.layout.getEventObject( evt_or_pane );
-		if (evt) {
-			// ALWAYS stop propagation of events triggered in Layout!
-			evt.stopPropagation();
-			return $(this).data("layoutEdge");
-		}
-		else
-			return evt_or_pane;
-	}
-
-
-	// LAYOUT-PLUGIN REGISTRATION
-	// more plugins can added beyond this default list
-,	plugins: {
-		draggable:		!!$.fn.draggable // resizing
-	,	effects: {
-			core:		!!$.effects		// animimations (specific effects tested by initOptions)
-		,	slide:		$.effects && $.effects.slide // default effect
-		}
-	}
-
-//	arrays of plugin or other methods to be triggered for events in *each layout* - will be passed 'Instance'
-,	onCreate:	[]	// runs when layout is just starting to be created - right after options are set
-,	onLoad:		[]	// runs after layout container and global events init, but before initPanes is called
-,	onReady:	[]	// runs after initialization *completes* - ie, after initPanes completes successfully
-,	onDestroy:	[]	// runs after layout is destroyed
-,	onUnload:	[]	// runs after layout is destroyed OR when page unloads
-,	afterOpen:	[]	// runs after setAsOpen() completes
-,	afterClose:	[]	// runs after setAsClosed() completes
-
-	/*
-	*	GENERIC UTILITY METHODS
-	*/
-
-	// calculate and return the scrollbar width, as an integer
-,	scrollbarWidth:		function () { return window.scrollbarWidth  || $.layout.getScrollbarSize('width'); }
-,	scrollbarHeight:	function () { return window.scrollbarHeight || $.layout.getScrollbarSize('height'); }
-,	getScrollbarSize:	function (dim) {
-		var $c	= $('<div style="position: absolute; top: -10000px; left: -10000px; width: 100px; height: 100px; overflow: scroll;"></div>').appendTo("body");
-		var d	= { width: $c.width() - $c[0].clientWidth, height: $c.height() - $c[0].clientHeight };
-		$c.remove();
-		window.scrollbarWidth	= d.width;
-		window.scrollbarHeight	= d.height;
-		return dim.match(/^(width|height)$/) ? d[dim] : d;
-	}
-
-
-	/**
-	* Returns hash container 'display' and 'visibility'
-	*
-	* @see	$.swap() - swaps CSS, runs callback, resets CSS
-	*/
-,	showInvisibly: function ($E, force) {
-		if ($E && $E.length && (force || $E.css('display') === "none")) { // only if not *already hidden*
-			var s = $E[0].style
-				// save ONLY the 'style' props because that is what we must restore
-			,	CSS = { display: s.display || '', visibility: s.visibility || '' };
-			// show element 'invisibly' so can be measured
-			$E.css({ display: "block", visibility: "hidden" });
-			return CSS;
-		}
-		return {};
-	}
-
-	/**
-	* Returns data for setting size of an element (container or a pane).
-	*
-	* @see  _create(), onWindowResize() for container, plus others for pane
-	* @return JSON  Returns a hash of all dimensions: top, bottom, left, right, outerWidth, innerHeight, etc
-	*/
-,	getElementDimensions: function ($E) {
-		var
-			d	= {}			// dimensions hash
-		,	x	= d.css = {}	// CSS hash
-		,	i	= {}			// TEMP insets
-		,	b, p				// TEMP border, padding
-		,	N	= $.layout.cssNum
-		,	off = $E.offset()
-		;
-		d.offsetLeft = off.left;
-		d.offsetTop  = off.top;
-
-		$.each("Left,Right,Top,Bottom".split(","), function (idx, e) { // e = edge
-			b = x["border" + e] = $.layout.borderWidth($E, e);
-			p = x["padding"+ e] = $.layout.cssNum($E, "padding"+e);
-			i[e] = b + p; // total offset of content from outer side
-			d["inset"+ e] = p;	// eg: insetLeft = paddingLeft
-		});
-
-		d.offsetWidth	= $E.innerWidth();	// offsetWidth is used in calc when doing manual resize
-		d.offsetHeight	= $E.innerHeight();	// ditto
-		d.outerWidth	= $E.outerWidth();
-		d.outerHeight	= $E.outerHeight();
-		d.innerWidth	= max(0, d.outerWidth  - i.Left - i.Right);
-		d.innerHeight	= max(0, d.outerHeight - i.Top  - i.Bottom);
-
-		x.width		= $E.width();
-		x.height	= $E.height();
-		x.top		= N($E,"top",true);
-		x.bottom	= N($E,"bottom",true);
-		x.left		= N($E,"left",true);
-		x.right		= N($E,"right",true);
-
-		//d.visible	= $E.is(":visible");// && x.width > 0 && x.height > 0;
-
-		return d;
-	}
-
-,	getElementCSS: function ($E, list) {
-		var
-			CSS	= {}
-		,	style	= $E[0].style
-		,	props	= list.split(",")
-		,	sides	= "Top,Bottom,Left,Right".split(",")
-		,	attrs	= "Color,Style,Width".split(",")
-		,	p, s, a, i, j, k
-		;
-		for (i=0; i < props.length; i++) {
-			p = props[i];
-			if (p.match(/(border|padding|margin)$/))
-				for (j=0; j < 4; j++) {
-					s = sides[j];
-					if (p === "border")
-						for (k=0; k < 3; k++) {
-							a = attrs[k];
-							CSS[p+s+a] = style[p+s+a];
-						}
-					else
-						CSS[p+s] = style[p+s];
-				}
-			else
-				CSS[p] = style[p];
-		};
-		return CSS
-	}
-
-	/**
-	* Return the innerWidth for the current browser/doctype
-	*
-	* @see  initPanes(), sizeMidPanes(), initHandles(), sizeHandles()
-	* @param  {Array.<Object>}	$E  Must pass a jQuery object - first element is processed
-	* @param  {number=}			outerWidth (optional) Can pass a width, allowing calculations BEFORE element is resized
-	* @return {number}			Returns the innerWidth of the elem by subtracting padding and borders
-	*/
-,	cssWidth: function ($E, outerWidth) {
-		// a 'calculated' outerHeight can be passed so borders and/or padding are removed if needed
-		if (outerWidth <= 0) return 0;
-
-		if (!$.layout.browser.boxModel) return outerWidth;
-
-		// strip border and padding from outerWidth to get CSS Width
-		var b = $.layout.borderWidth
-		,	n = $.layout.cssNum
-		,	W = outerWidth
-				- b($E, "Left")
-				- b($E, "Right")
-				- n($E, "paddingLeft")		
-				- n($E, "paddingRight");
-
-		return max(0,W);
-	}
-
-	/**
-	* Return the innerHeight for the current browser/doctype
-	*
-	* @see  initPanes(), sizeMidPanes(), initHandles(), sizeHandles()
-	* @param  {Array.<Object>}	$E  Must pass a jQuery object - first element is processed
-	* @param  {number=}			outerHeight  (optional) Can pass a width, allowing calculations BEFORE element is resized
-	* @return {number}			Returns the innerHeight of the elem by subtracting padding and borders
-	*/
-,	cssHeight: function ($E, outerHeight) {
-		// a 'calculated' outerHeight can be passed so borders and/or padding are removed if needed
-		if (outerHeight <= 0) return 0;
-
-		if (!$.layout.browser.boxModel) return outerHeight;
-
-		// strip border and padding from outerHeight to get CSS Height
-		var b = $.layout.borderWidth
-		,	n = $.layout.cssNum
-		,	H = outerHeight
-			- b($E, "Top")
-			- b($E, "Bottom")
-			- n($E, "paddingTop")
-			- n($E, "paddingBottom");
-
-		return max(0,H);
-	}
-
-	/**
-	* Returns the 'current CSS numeric value' for a CSS property - 0 if property does not exist
-	*
-	* @see  Called by many methods
-	* @param {Array.<Object>}	$E					Must pass a jQuery object - first element is processed
-	* @param {string}			prop				The name of the CSS property, eg: top, width, etc.
-	* @param {boolean=}			[allowAuto=false]	true = return 'auto' if that is value; false = return 0
-	* @return {(string|number)}						Usually used to get an integer value for position (top, left) or size (height, width)
-	*/
-,	cssNum: function ($E, prop, allowAuto) {
-		if (!$E.jquery) $E = $($E);
-		var CSS = $.layout.showInvisibly($E)
-		,	p	= $.css($E[0], prop, true)
-		,	v	= allowAuto && p=="auto" ? p : (parseInt(p, 10) || 0);
-		$E.css( CSS ); // RESET
-		return v;
-	}
-
-,	borderWidth: function (el, side) {
-		if (el.jquery) el = el[0];
-		var b = "border"+ side.substr(0,1).toUpperCase() + side.substr(1); // left => Left
-		return $.css(el, b+"Style", true) === "none" ? 0 : (parseInt($.css(el, b+"Width", true), 10) || 0);
-	}
-
-	/**
-	* Mouse-tracking utility - FUTURE REFERENCE
-	*
-	* init: if (!window.mouse) {
-	*			window.mouse = { x: 0, y: 0 };
-	*			$(document).mousemove( $.layout.trackMouse );
-	*		}
-	*
-	* @param {Object}		evt
-	*
-,	trackMouse: function (evt) {
-		window.mouse = { x: evt.clientX, y: evt.clientY };
-	}
-	*/
-
-	/**
-	* SUBROUTINE for preventPrematureSlideClose option
-	*
-	* @param {Object}		evt
-	* @param {Object=}		el
-	*/
-,	isMouseOverElem: function (evt, el) {
-		var
-			$E	= $(el || this)
-		,	d	= $E.offset()
-		,	T	= d.top
-		,	L	= d.left
-		,	R	= L + $E.outerWidth()
-		,	B	= T + $E.outerHeight()
-		,	x	= evt.pageX	// evt.clientX ?
-		,	y	= evt.pageY	// evt.clientY ?
-		;
-		// if X & Y are < 0, probably means is over an open SELECT
-		return ($.layout.browser.msie && x < 0 && y < 0) || ((x >= L && x <= R) && (y >= T && y <= B));
-	}
-
-	/**
-	* Message/Logging Utility
-	*
-	* @example $.layout.msg("My message");				// log text
-	* @example $.layout.msg("My message", true);		// alert text
-	* @example $.layout.msg({ foo: "bar" }, "Title");	// log hash-data, with custom title
-	* @example $.layout.msg({ foo: "bar" }, true, "Title", { sort: false }); -OR-
-	* @example $.layout.msg({ foo: "bar" }, "Title", { sort: false, display: true }); // alert hash-data
-	*
-	* @param {(Object|string)}			info			String message OR Hash/Array
-	* @param {(Boolean|string|Object)=}	[popup=false]	True means alert-box - can be skipped
-	* @param {(Object|string)=}			[debugTitle=""]	Title for Hash data - can be skipped
-	* @param {Object=}					[debugOpts]		Extra options for debug output
-	*/
-,	msg: function (info, popup, debugTitle, debugOpts) {
-		if ($.isPlainObject(info) && window.debugData) {
-			if (typeof popup === "string") {
-				debugOpts	= debugTitle;
-				debugTitle	= popup;
-			}
-			else if (typeof debugTitle === "object") {
-				debugOpts	= debugTitle;
-				debugTitle	= null;
-			}
-			var t = debugTitle || "log( <object> )"
-			,	o = $.extend({ sort: false, returnHTML: false, display: false }, debugOpts);
-			if (popup === true || o.display)
-				debugData( info, t, o );
-			else if (window.console)
-				console.log(debugData( info, t, o ));
-		}
-		else if (popup)
-			alert(info);
-		else if (window.console)
-			console.log(info);
-		else {
-			var id	= "#layoutLogger"
-			,	$l = $(id);
-			if (!$l.length)
-				$l = createLog();
-			$l.children("ul").append('<li style="padding: 4px 10px; margin: 0; border-top: 1px solid #CCC;">'+ info.replace(/\</g,"&lt;").replace(/\>/g,"&gt;") +'</li>');
-		}
-
-		function createLog () {
-			var pos = $.support.fixedPosition ? 'fixed' : 'absolute'
-			,	$e = $('<div id="layoutLogger" style="position: '+ pos +'; top: 5px; z-index: 999999; max-width: 25%; overflow: hidden; border: 1px solid #000; border-radius: 5px; background: #FBFBFB; box-shadow: 0 2px 10px rgba(0,0,0,0.3);">'
-				+	'<div style="font-size: 13px; font-weight: bold; padding: 5px 10px; background: #F6F6F6; border-radius: 5px 5px 0 0; cursor: move;">'
-				+	'<span style="float: right; padding-left: 7px; cursor: pointer;" title="Remove Console" onclick="$(this).closest(\'#layoutLogger\').remove()">X</span>Layout console.log</div>'
-				+	'<ul style="font-size: 13px; font-weight: none; list-style: none; margin: 0; padding: 0 0 2px;"></ul>'
-				+ '</div>'
-				).appendTo("body");
-			$e.css('left', $(window).width() - $e.outerWidth() - 5)
-			if ($.ui.draggable) $e.draggable({ handle: ':first-child' });
-			return $e;
-		};
-	}
-
-};
-
-// DEFAULT OPTIONS
-$.layout.defaults = {
-/*
- *	LAYOUT & LAYOUT-CONTAINER OPTIONS
- *	- none of these options are applicable to individual panes
- */
-	name:						""			// Not required, but useful for buttons and used for the state-cookie
-,	containerSelector:			""			// ONLY used when specifying a childOptions - to find container-element that is NOT directly-nested
-,	containerClass:				"ui-layout-container" // layout-container element
-,	scrollToBookmarkOnLoad:		true		// after creating a layout, scroll to bookmark in URL (.../page.htm#myBookmark)
-,	resizeWithWindow:			true		// bind thisLayout.resizeAll() to the window.resize event
-,	resizeWithWindowDelay:		200			// delay calling resizeAll because makes window resizing very jerky
-,	resizeWithWindowMaxDelay:	0			// 0 = none - force resize every XX ms while window is being resized
-,	onresizeall_start:			null		// CALLBACK when resizeAll() STARTS	- NOT pane-specific
-,	onresizeall_end:			null		// CALLBACK when resizeAll() ENDS	- NOT pane-specific
-,	onload_start:				null		// CALLBACK when Layout inits - after options initialized, but before elements
-,	onload_end:					null		// CALLBACK when Layout inits - after EVERYTHING has been initialized
-,	onunload_start:				null		// CALLBACK when Layout is destroyed OR onWindowUnload
-,	onunload_end:				null		// CALLBACK when Layout is destroyed OR onWindowUnload
-,	initPanes:					true		// false = DO NOT initialize the panes onLoad - will init later
-,	showErrorMessages:			true		// enables fatal error messages to warn developers of common errors
-,	showDebugMessages:			false		// display console-and-alert debug msgs - IF this Layout version _has_ debugging code!
-//	Changing this zIndex value will cause other zIndex values to automatically change
-,	zIndex:						null		// the PANE zIndex - resizers and masks will be +1
-//	DO NOT CHANGE the zIndex values below unless you clearly understand their relationships
-,	zIndexes: {								// set _default_ z-index values here...
-		pane_normal:			0			// normal z-index for panes
-	,	content_mask:			1			// applied to overlays used to mask content INSIDE panes during resizing
-	,	resizer_normal:			2			// normal z-index for resizer-bars
-	,	pane_sliding:			100			// applied to *BOTH* the pane and its resizer when a pane is 'slid open'
-	,	pane_animate:			1000		// applied to the pane when being animated - not applied to the resizer
-	,	resizer_drag:			10000		// applied to the CLONED resizer-bar when being 'dragged'
-	}
-,	errors: {
-		pane:					"pane"		// description of "layout pane element" - used only in error messages
-	,	selector:				"selector"	// description of "jQuery-selector" - used only in error messages
-	,	addButtonError:			"Error Adding Button \n\nInvalid "
-	,	containerMissing:		"UI Layout Initialization Error\n\nThe specified layout-container does not exist."
-	,	centerPaneMissing:		"UI Layout Initialization Error\n\nThe center-pane element does not exist.\n\nThe center-pane is a required element."
-	,	noContainerHeight:		"UI Layout Initialization Warning\n\nThe layout-container \"CONTAINER\" has no height.\n\nTherefore the layout is 0-height and hence 'invisible'!"
-	,	callbackError:			"UI Layout Callback Error\n\nThe EVENT callback is not a valid function."
-	}
-/*
- *	PANE DEFAULT SETTINGS
- *	- settings under the 'panes' key become the default settings for *all panes*
- *	- ALL pane-options can also be set specifically for each panes, which will override these 'default values'
- */
-,	panes: { // default options for 'all panes' - will be overridden by 'per-pane settings'
-		applyDemoStyles: 		false		// NOTE: renamed from applyDefaultStyles for clarity
-	,	closable:				true		// pane can open & close
-	,	resizable:				true		// when open, pane can be resized 
-	,	slidable:				true		// when closed, pane can 'slide open' over other panes - closes on mouse-out
-	,	initClosed:				false		// true = init pane as 'closed'
-	,	initHidden: 			false 		// true = init pane as 'hidden' - no resizer-bar/spacing
-	//	SELECTORS
-	//,	paneSelector:			""			// MUST be pane-specific - jQuery selector for pane
-	,	contentSelector:		".ui-layout-content" // INNER div/element to auto-size so only it scrolls, not the entire pane!
-	,	contentIgnoreSelector:	".ui-layout-ignore"	// element(s) to 'ignore' when measuring 'content'
-	,	findNestedContent:		false		// true = $P.find(contentSelector), false = $P.children(contentSelector)
-	//	GENERIC ROOT-CLASSES - for auto-generated classNames
-	,	paneClass:				"ui-layout-pane"	// Layout Pane
-	,	resizerClass:			"ui-layout-resizer"	// Resizer Bar
-	,	togglerClass:			"ui-layout-toggler"	// Toggler Button
-	,	buttonClass:			"ui-layout-button"	// CUSTOM Buttons	- eg: '[ui-layout-button]-toggle/-open/-close/-pin'
-	//	ELEMENT SIZE & SPACING
-	//,	size:					100			// MUST be pane-specific -initial size of pane
-	,	minSize:				0			// when manually resizing a pane
-	,	maxSize:				0			// ditto, 0 = no limit
-	,	spacing_open:			6			// space between pane and adjacent panes - when pane is 'open'
-	,	spacing_closed:			6			// ditto - when pane is 'closed'
-	,	togglerLength_open:		50			// Length = WIDTH of toggler button on north/south sides - HEIGHT on east/west sides
-	,	togglerLength_closed: 	50			// 100% OR -1 means 'full height/width of resizer bar' - 0 means 'hidden'
-	,	togglerAlign_open:		"center"	// top/left, bottom/right, center, OR...
-	,	togglerAlign_closed:	"center"	// 1 => nn = offset from top/left, -1 => -nn == offset from bottom/right
-	,	togglerContent_open:	""			// text or HTML to put INSIDE the toggler
-	,	togglerContent_closed:	""			// ditto
-	//	RESIZING OPTIONS
-	,	resizerDblClickToggle:	true		// 
-	,	autoResize:				true		// IF size is 'auto' or a percentage, then recalc 'pixel size' whenever the layout resizes
-	,	autoReopen:				true		// IF a pane was auto-closed due to noRoom, reopen it when there is room? False = leave it closed
-	,	resizerDragOpacity:		1			// option for ui.draggable
-	//,	resizerCursor:			""			// MUST be pane-specific - cursor when over resizer-bar
-	,	maskContents:			false		// true = add DIV-mask over-or-inside this pane so can 'drag' over IFRAMES
-	,	maskObjects:			false		// true = add IFRAME-mask over-or-inside this pane to cover objects/applets - content-mask will overlay this mask
-	,	maskZindex:				null		// will override zIndexes.content_mask if specified - not applicable to iframe-panes
-	,	resizingGrid:			false		// grid size that the resizers will snap-to during resizing, eg: [20,20]
-	,	livePaneResizing:		false		// true = LIVE Resizing as resizer is dragged
-	,	liveContentResizing:	false		// true = re-measure header/footer heights as resizer is dragged
-	,	liveResizingTolerance:	1			// how many px change before pane resizes, to control performance
-	//	SLIDING OPTIONS
-	,	sliderCursor:			"pointer"	// cursor when resizer-bar will trigger 'sliding'
-	,	slideTrigger_open:		"click"		// click, dblclick, mouseenter
-	,	slideTrigger_close:		"mouseleave"// click, mouseleave
-	,	slideDelay_open:		300			// applies only for mouseenter event - 0 = instant open
-	,	slideDelay_close:		300			// applies only for mouseleave event (300ms is the minimum!)
-	,	hideTogglerOnSlide:		false		// when pane is slid-open, should the toggler show?
-	,	preventQuickSlideClose:	$.layout.browser.webkit // Chrome triggers slideClosed as it is opening
-	,	preventPrematureSlideClose: false	// handle incorrect mouseleave trigger, like when over a SELECT-list in IE
-	//	PANE-SPECIFIC TIPS & MESSAGES
-	,	tips: {
-			Open:				"Open"		// eg: "Open Pane"
-		,	Close:				"Close"
-		,	Resize:				"Resize"
-		,	Slide:				"Slide Open"
-		,	Pin:				"Pin"
-		,	Unpin:				"Un-Pin"
-		,	noRoomToOpen:		"Not enough room to show this panel."	// alert if user tries to open a pane that cannot
-		,	minSizeWarning:		"Panel has reached its minimum size"	// displays in browser statusbar
-		,	maxSizeWarning:		"Panel has reached its maximum size"	// ditto
-		}
-	//	HOT-KEYS & MISC
-	,	showOverflowOnHover:	false		// will bind allowOverflow() utility to pane.onMouseOver
-	,	enableCursorHotkey:		true		// enabled 'cursor' hotkeys
-	//,	customHotkey:			""			// MUST be pane-specific - EITHER a charCode OR a character
-	,	customHotkeyModifier:	"SHIFT"		// either 'SHIFT', 'CTRL' or 'CTRL+SHIFT' - NOT 'ALT'
-	//	PANE ANIMATION
-	//	NOTE: fxSss_open, fxSss_close & fxSss_size options (eg: fxName_open) are auto-generated if not passed
-	,	fxName:					"slide" 	// ('none' or blank), slide, drop, scale -- only relevant to 'open' & 'close', NOT 'size'
-	,	fxSpeed:				null		// slow, normal, fast, 200, nnn - if passed, will OVERRIDE fxSettings.duration
-	,	fxSettings:				{}			// can be passed, eg: { easing: "easeOutBounce", duration: 1500 }
-	,	fxOpacityFix:			true		// tries to fix opacity in IE to restore anti-aliasing after animation
-	,	animatePaneSizing:		false		// true = animate resizing after dragging resizer-bar OR sizePane() is called
-	/*  NOTE: Action-specific FX options are auto-generated from the options above if not specifically set:
-		fxName_open:			"slide"		// 'Open' pane animation
-		fnName_close:			"slide"		// 'Close' pane animation
-		fxName_size:			"slide"		// 'Size' pane animation - when animatePaneSizing = true
-		fxSpeed_open:			null
-		fxSpeed_close:			null
-		fxSpeed_size:			null
-		fxSettings_open:		{}
-		fxSettings_close:		{}
-		fxSettings_size:		{}
-	*/
-	//	CHILD/NESTED LAYOUTS
-	,	childOptions:			null		// Layout-options for nested/child layout - even {} is valid as options
-	,	initChildLayout:		true		// true = child layout will be created as soon as _this_ layout completes initialization
-	,	destroyChildLayout:		true		// true = destroy child-layout if this pane is destroyed
-	,	resizeChildLayout:		true		// true = trigger child-layout.resizeAll() when this pane is resized
-	//	EVENT TRIGGERING
-	,	triggerEventsOnLoad:	false		// true = trigger onopen OR onclose callbacks when layout initializes
-	,	triggerEventsDuringLiveResize: true	// true = trigger onresize callback REPEATEDLY if livePaneResizing==true
-	//	PANE CALLBACKS
-	,	onshow_start:			null		// CALLBACK when pane STARTS to Show	- BEFORE onopen/onhide_start
-	,	onshow_end:				null		// CALLBACK when pane ENDS being Shown	- AFTER  onopen/onhide_end
-	,	onhide_start:			null		// CALLBACK when pane STARTS to Close	- BEFORE onclose_start
-	,	onhide_end:				null		// CALLBACK when pane ENDS being Closed	- AFTER  onclose_end
-	,	onopen_start:			null		// CALLBACK when pane STARTS to Open
-	,	onopen_end:				null		// CALLBACK when pane ENDS being Opened
-	,	onclose_start:			null		// CALLBACK when pane STARTS to Close
-	,	onclose_end:			null		// CALLBACK when pane ENDS being Closed
-	,	onresize_start:			null		// CALLBACK when pane STARTS being Resized ***FOR ANY REASON***
-	,	onresize_end:			null		// CALLBACK when pane ENDS being Resized ***FOR ANY REASON***
-	,	onsizecontent_start:	null		// CALLBACK when sizing of content-element STARTS
-	,	onsizecontent_end:		null		// CALLBACK when sizing of content-element ENDS
-	,	onswap_start:			null		// CALLBACK when pane STARTS to Swap
-	,	onswap_end:				null		// CALLBACK when pane ENDS being Swapped
-	,	ondrag_start:			null		// CALLBACK when pane STARTS being ***MANUALLY*** Resized
-	,	ondrag_end:				null		// CALLBACK when pane ENDS being ***MANUALLY*** Resized
-	}
-/*
- *	PANE-SPECIFIC SETTINGS
- *	- options listed below MUST be specified per-pane - they CANNOT be set under 'panes'
- *	- all options under the 'panes' key can also be set specifically for any pane
- *	- most options under the 'panes' key apply only to 'border-panes' - NOT the the center-pane
- */
-,	north: {
-		paneSelector:			".ui-layout-north"
-	,	size:					"auto"		// eg: "auto", "30%", .30, 200
-	,	resizerCursor:			"n-resize"	// custom = url(myCursor.cur)
-	,	customHotkey:			""			// EITHER a charCode (43) OR a character ("o")
-	}
-,	south: {
-		paneSelector:			".ui-layout-south"
-	,	size:					"auto"
-	,	resizerCursor:			"s-resize"
-	,	customHotkey:			""
-	}
-,	east: {
-		paneSelector:			".ui-layout-east"
-	,	size:					200
-	,	resizerCursor:			"e-resize"
-	,	customHotkey:			""
-	}
-,	west: {
-		paneSelector:			".ui-layout-west"
-	,	size:					200
-	,	resizerCursor:			"w-resize"
-	,	customHotkey:			""
-	}
-,	center: {
-		paneSelector:			".ui-layout-center"
-	,	minWidth:				0
-	,	minHeight:				0
-	}
-};
-
-$.layout.optionsMap = {
-	// layout/global options - NOT pane-options
-	layout: ("stateManagement,effects,zIndexes,errors,"
-	+	"name,zIndex,scrollToBookmarkOnLoad,showErrorMessages,"
-	+	"resizeWithWindow,resizeWithWindowDelay,resizeWithWindowMaxDelay,"
-	+	"onresizeall,onresizeall_start,onresizeall_end,onload,onunload").split(",")
-//	borderPanes: [ ALL options that are NOT specified as 'layout' ]
-	// default.panes options that apply to the center-pane (most options apply _only_ to border-panes)
-,	center: ("paneClass,contentSelector,contentIgnoreSelector,findNestedContent,applyDemoStyles,triggerEventsOnLoad,"
-	+	"showOverflowOnHover,maskContents,maskObjects,liveContentResizing,"
-	+	"childOptions,initChildLayout,resizeChildLayout,destroyChildLayout,"
-	+	"onresize,onresize_start,onresize_end,onsizecontent,onsizecontent_start,onsizecontent_end").split(",")
-	// options that MUST be specifically set 'per-pane' - CANNOT set in the panes (defaults) key
-,	noDefault: ("paneSelector,resizerCursor,customHotkey").split(",")
-};
-
-/**
- * Processes options passed in converts flat-format data into subkey (JSON) format
- * In flat-format, subkeys are _currently_ separated with 2 underscores, like north__optName
- * Plugins may also call this method so they can transform their own data
- *
- * @param  {!Object}	hash	Data/options passed by user - may be a single level or nested levels
- * @return {Object}				Returns hash of minWidth & minHeight
- */
-$.layout.transformData = function (hash) {
-	var	json = { panes: {}, center: {} } // init return object
-	,	data, branch, optKey, keys, key, val, i, c;
-
-	if (typeof hash !== "object") return json; // no options passed
-
-	// convert all 'flat-keys' to 'sub-key' format
-	for (optKey in hash) {
-		branch	= json;
-		data	= $.layout.optionsMap.layout;
-		val		= hash[ optKey ];
-		keys	= optKey.split("__"); // eg: west__size or north__fxSettings__duration
-		c		= keys.length - 1;
-		// convert underscore-delimited to subkeys
-		for (i=0; i <= c; i++) {
-			key = keys[i];
-			if (i === c)
-				branch[key] = val;
-			else if (!branch[key])
-				branch[key] = {}; // create the subkey
-			// recurse to sub-key for next loop - if not done
-			branch = branch[key];
-		}
-	}
-
-	return json;
-};
-
-// INTERNAL CONFIG DATA - DO NOT CHANGE THIS!
-$.layout.backwardCompatibility = {
-	// data used by renameOldOptions()
-	map: {
-	//	OLD Option Name:			NEW Option Name
-		applyDefaultStyles:			"applyDemoStyles"
-	,	resizeNestedLayout:			"resizeChildLayout"
-	,	resizeWhileDragging:		"livePaneResizing"
-	,	resizeContentWhileDragging:	"liveContentResizing"
-	,	triggerEventsWhileDragging:	"triggerEventsDuringLiveResize"
-	,	maskIframesOnResize:		"maskContents"
-	,	useStateCookie:				"stateManagement.enabled"
-	,	"cookie.autoLoad":			"stateManagement.autoLoad"
-	,	"cookie.autoSave":			"stateManagement.autoSave"
-	,	"cookie.keys":				"stateManagement.stateKeys"
-	,	"cookie.name":				"stateManagement.cookie.name"
-	,	"cookie.domain":			"stateManagement.cookie.domain"
-	,	"cookie.path":				"stateManagement.cookie.path"
-	,	"cookie.expires":			"stateManagement.cookie.expires"
-	,	"cookie.secure":			"stateManagement.cookie.secure"
-	//	OLD Language options
-	,	noRoomToOpenTip:			"tips.noRoomToOpen"
-	,	togglerTip_open:			"tips.Close"	// open   = Close
-	,	togglerTip_closed:			"tips.Open"		// closed = Open
-	,	resizerTip:					"tips.Resize"
-	,	sliderTip:					"tips.Slide"
-	}
-
-/**
-* @param {Object}	opts
-*/
-,	renameOptions: function (opts) {
-		var map = $.layout.backwardCompatibility.map
-		,	oldData, newData, value
-		;
-		for (var itemPath in map) {
-			oldData	= getBranch( itemPath );
-			value	= oldData.branch[ oldData.key ];
-			if (value !== undefined) {
-				newData = getBranch( map[itemPath], true );
-				newData.branch[ newData.key ] = value;
-				delete oldData.branch[ oldData.key ];
-			}
-		}
-
-		/**
-		* @param {string}	path
-		* @param {boolean=}	[create=false]	Create path if does not exist
-		*/
-		function getBranch (path, create) {
-			var a = path.split(".") // split keys into array
-			,	c = a.length - 1
-			,	D = { branch: opts, key: a[c] } // init branch at top & set key (last item)
-			,	i = 0, k, undef;
-			for (; i<c; i++) { // skip the last key (data)
-				k = a[i];
-				if (D.branch[ k ] == undefined) { // child-key does not exist
-					if (create) {
-						D.branch = D.branch[ k ] = {}; // create child-branch
-					}
-					else // can't go any farther
-						D.branch = {}; // branch is undefined
-				}
-				else
-					D.branch = D.branch[ k ]; // get child-branch
-			}
-			return D;
-		};
-	}
-
-/**
-* @param {Object}	opts
-*/
-,	renameAllOptions: function (opts) {
-		var ren = $.layout.backwardCompatibility.renameOptions;
-		// rename root (layout) options
-		ren( opts );
-		// rename 'defaults' to 'panes'
-		if (opts.defaults) {
-			if (typeof opts.panes !== "object")
-				opts.panes = {};
-			$.extend(true, opts.panes, opts.defaults);
-			delete opts.defaults;
-		}
-		// rename options in the the options.panes key
-		if (opts.panes) ren( opts.panes );
-		// rename options inside *each pane key*, eg: options.west
-		$.each($.layout.config.allPanes, function (i, pane) {
-			if (opts[pane]) ren( opts[pane] );
-		});	
-		return opts;
-	}
-};
-
-
-
-
-/*	============================================================
- *	BEGIN WIDGET: $( selector ).layout( {options} );
- *	============================================================
- */
-$.fn.layout = function (opts) {
-	var
-
-	// local aliases to global data
-	browser	= $.layout.browser
-,	_c		= $.layout.config
-
-	// local aliases to utlity methods
-,	cssW	= $.layout.cssWidth
-,	cssH	= $.layout.cssHeight
-,	elDims	= $.layout.getElementDimensions
-,	elCSS	= $.layout.getElementCSS
-,	evtObj	= $.layout.getEventObject
-,	evtPane	= $.layout.parsePaneName
-
-/**
- * options - populated by initOptions()
- */
-,	options = $.extend(true, {}, $.layout.defaults)
-,	effects	= options.effects = $.extend(true, {}, $.layout.effects)
-
-/**
- * layout-state object
- */
-,	state = {
-		// generate unique ID to use for event.namespace so can unbind only events added by 'this layout'
-		id:			"layout"+ $.now()	// code uses alias: sID
-	,	initialized: false
-	,	container:	{} // init all keys
-	,	north:		{}
-	,	south:		{}
-	,	east:		{}
-	,	west:		{}
-	,	center:		{}
-	}
-
-/**
- * parent/child-layout pointers
- */
-//,	hasParentLayout	= false	- exists ONLY inside Instance so can be set externally
-,	children = {
-		north:		null
-	,	south:		null
-	,	east:		null
-	,	west:		null
-	,	center:		null
-	}
-
-/*
- * ###########################
- *  INTERNAL HELPER FUNCTIONS
- * ###########################
- */
-
-	/**
-	* Manages all internal timers
-	*/
-,	timer = {
-		data:	{}
-	,	set:	function (s, fn, ms) { timer.clear(s); timer.data[s] = setTimeout(fn, ms); }
-	,	clear:	function (s) { var t=timer.data; if (t[s]) {clearTimeout(t[s]); delete t[s];} }
-	}
-
-	/**
-	* Alert or console.log a message - IF option is enabled.
-	*
-	* @param {(string|!Object)}	msg		Message (or debug-data) to display
-	* @param {?boolean}			popup	True by default, means 'alert', false means use console.log
-	* @param {?boolean}			debug	True means is a widget debugging message
-	*/
-,	_log = function (msg, popup, debug) {
-		var o = options;
-		if ((o.showErrorMessages && !debug) || (debug && o.showDebugMessages))
-			$.layout.msg( o.name +' / '+ msg, (popup !== false) );
-		return false;
-	}
-
-	/**
-	* Executes a Callback function after a trigger event, like resize, open or close
-	*
-	* @param {string}			evtName			Name of the layout callback, eg "onresize_start"
-	* @param {?string}			pane			This is passed only so we can pass the 'pane object' to the callback
-	* @param {?string|?boolean}	skipBoundEvents	True = do not run events bound to the elements - only the callbacks set in options
-	*/
-,	_runCallbacks = function (evtName, pane, skipBoundEvents) {
-		var	paneCB	= pane && isStr(pane)
-		,	s		= paneCB ? state[pane] : state
-		,	o		= paneCB ? options[pane] : options
-		,	lName	= options.name
-			// names like onopen and onopen_end separate are interchangeable in options...
-		,	lng		= evtName + (evtName.match(/_/) ? "" : "_end")
-		,	shrt	= lng.match(/_end$/) ? lng.substr(0, lng.length - 4) : ""
-		,	fn		= o[lng] || o[shrt]
-		,	retVal	= "NC" // NC = No Callback
-		,	args	= []
-		,	$P
-		;
-		if ( !paneCB && $.type(skipBoundEvents) !== 'boolean' )
-			skipBoundEvents = pane; // allow pane param to be skipped for Layout callback
-
-		// first trigger the callback set in the options
-		if (fn) {
-			try {
-				// convert function name (string) to function object
-				if (isStr( fn )) {
-					if (fn.match(/,/)) {
-						// function name cannot contain a comma, 
-						// so must be a function name AND a parameter to pass
-						args = fn.split(",")
-						,	fn = eval(args[0]);
-					}
-					else // just the name of an external function?
-						fn = eval(fn);
-				}
-				// execute the callback, if exists
-				if ($.isFunction( fn )) {
-					if (args.length)
-						retVal = fn(args[1]); // pass the argument parsed from 'list'
-					else if ( paneCB )
-						// pass data: pane-name, pane-element, pane-state, pane-options, and layout-name
-						retVal = fn( pane, $Ps[pane], s, o, lName );
-					else // must be a layout/container callback - pass suitable info
-						retVal = fn( Instance, s, o, lName );
-				}
-			}
-			catch (ex) {
-				_log( options.errors.callbackError.replace(/EVENT/, $.trim(pane +" "+ lng)), false );
-			}
-		}
-
-		// trigger additional events bound directly to the pane
-		if (!skipBoundEvents && retVal !== false) {
-			if ( paneCB ) { // PANE events can be bound to each pane-elements
-				$P	= $Ps[pane];
-				o	= options[pane];
-				s	= state[pane];
-				$P.triggerHandler('layoutpane'+ lng, [ pane, $P, s, o, lName ]);
-				if (shrt)
-					$P.triggerHandler('layoutpane'+ shrt, [ pane, $P, s, o, lName ]);
-			}
-			else { // LAYOUT events can be bound to the container-element
-				$N.triggerHandler('layout'+ lng, [ Instance, s, o, lName ]);
-				if (shrt)
-					$N.triggerHandler('layout'+ shrt, [ Instance, s, o, lName ]);
-			}
-		}
-
-		// ALWAYS resizeChildLayout after a resize event - even during initialization
-		if (evtName === "onresize_end" || evtName === "onsizecontent_end")
-			resizeChildLayout(pane); 
-
-		return retVal;
-	}
-
-
-	/**
-	* cure iframe display issues in IE & other browsers
-	*/
-,	_fixIframe = function (pane) {
-		if (browser.mozilla) return; // skip FireFox - it auto-refreshes iframes onShow
-		var $P = $Ps[pane];
-		// if the 'pane' is an iframe, do it
-		if (state[pane].tagName === "IFRAME")
-			$P.css(_c.hidden).css(_c.visible); 
-		else // ditto for any iframes INSIDE the pane
-			$P.find('IFRAME').css(_c.hidden).css(_c.visible);
-	}
-
-	/**
-	* @param  {string}		pane		Can accept ONLY a 'pane' (east, west, etc)
-	* @param  {number=}		outerSize	(optional) Can pass a width, allowing calculations BEFORE element is resized
-	* @return {number}		Returns the innerHeight/Width of el by subtracting padding and borders
-	*/
-,	cssSize = function (pane, outerSize) {
-		var fn = _c[pane].dir=="horz" ? cssH : cssW;
-		return fn($Ps[pane], outerSize);
-	}
-
-	/**
-	* @param  {string}		pane		Can accept ONLY a 'pane' (east, west, etc)
-	* @return {Object}		Returns hash of minWidth & minHeight
-	*/
-,	cssMinDims = function (pane) {
-		// minWidth/Height means CSS width/height = 1px
-		var	$P	= $Ps[pane]
-		,	dir	= _c[pane].dir
-		,	d	= {
-				minWidth:	1001 - cssW($P, 1000)
-			,	minHeight:	1001 - cssH($P, 1000)
-			}
-		;
-		if (dir === "horz") d.minSize = d.minHeight;
-		if (dir === "vert") d.minSize = d.minWidth;
-		return d;
-	}
-
-	// TODO: see if these methods can be made more useful...
-	// TODO: *maybe* return cssW/H from these so caller can use this info
-
-	/**
-	* @param {(string|!Object)}		el
-	* @param {number=}				outerWidth
-	* @param {boolean=}				[autoHide=false]
-	*/
-,	setOuterWidth = function (el, outerWidth, autoHide) {
-		var $E = el, w;
-		if (isStr(el)) $E = $Ps[el]; // west
-		else if (!el.jquery) $E = $(el);
-		w = cssW($E, outerWidth);
-		$E.css({ width: w });
-		if (w > 0) {
-			if (autoHide && $E.data('autoHidden') && $E.innerHeight() > 0) {
-				$E.show().data('autoHidden', false);
-				if (!browser.mozilla) // FireFox refreshes iframes - IE does not
-					// make hidden, then visible to 'refresh' display after animation
-					$E.css(_c.hidden).css(_c.visible);
-			}
-		}
-		else if (autoHide && !$E.data('autoHidden'))
-			$E.hide().data('autoHidden', true);
-	}
-
-	/**
-	* @param {(string|!Object)}		el
-	* @param {number=}				outerHeight
-	* @param {boolean=}				[autoHide=false]
-	*/
-,	setOuterHeight = function (el, outerHeight, autoHide) {
-		var $E = el, h;
-		if (isStr(el)) $E = $Ps[el]; // west
-		else if (!el.jquery) $E = $(el);
-		h = cssH($E, outerHeight);
-		$E.css({ height: h, visibility: "visible" }); // may have been 'hidden' by sizeContent
-		if (h > 0 && $E.innerWidth() > 0) {
-			if (autoHide && $E.data('autoHidden')) {
-				$E.show().data('autoHidden', false);
-				if (!browser.mozilla) // FireFox refreshes iframes - IE does not
-					$E.css(_c.hidden).css(_c.visible);
-			}
-		}
-		else if (autoHide && !$E.data('autoHidden'))
-			$E.hide().data('autoHidden', true);
-	}
-
-	/**
-	* @param {(string|!Object)}		el
-	* @param {number=}				outerSize
-	* @param {boolean=}				[autoHide=false]
-	*/
-,	setOuterSize = function (el, outerSize, autoHide) {
-		if (_c[pane].dir=="horz") // pane = north or south
-			setOuterHeight(el, outerSize, autoHide);
-		else // pane = east or west
-			setOuterWidth(el, outerSize, autoHide);
-	}
-
-
-	/**
-	* Converts any 'size' params to a pixel/integer size, if not already
-	* If 'auto' or a decimal/percentage is passed as 'size', a pixel-size is calculated
-	*
-	/**
-	* @param  {string}				pane
-	* @param  {(string|number)=}	size
-	* @param  {string=}				[dir]
-	* @return {number}
-	*/
-,	_parseSize = function (pane, size, dir) {
-		if (!dir) dir = _c[pane].dir;
-
-		if (isStr(size) && size.match(/%/))
-			size = (size === '100%') ? -1 : parseInt(size, 10) / 100; // convert % to decimal
-
-		if (size === 0)
-			return 0;
-		else if (size >= 1)
-			return parseInt(size, 10);
-
-		var o = options, avail = 0;
-		if (dir=="horz") // north or south or center.minHeight
-			avail = sC.innerHeight - ($Ps.north ? o.north.spacing_open : 0) - ($Ps.south ? o.south.spacing_open : 0);
-		else if (dir=="vert") // east or west or center.minWidth
-			avail = sC.innerWidth - ($Ps.west ? o.west.spacing_open : 0) - ($Ps.east ? o.east.spacing_open : 0);
-
-		if (size === -1) // -1 == 100%
-			return avail;
-		else if (size > 0) // percentage, eg: .25
-			return round(avail * size);
-		else if (pane=="center")
-			return 0;
-		else { // size < 0 || size=='auto' || size==Missing || size==Invalid
-			// auto-size the pane
-			var	dim	= (dir === "horz" ? "height" : "width")
-			,	$P	= $Ps[pane]
-			,	$C	= dim === 'height' ? $Cs[pane] : false
-			,	vis	= $.layout.showInvisibly($P) // show pane invisibly if hidden
-			,	szP	= $P.css(dim) // SAVE current pane size
-			,	szC	= $C ? $C.css(dim) : 0 // SAVE current content size
-			;
-			$P.css(dim, "auto");
-			if ($C) $C.css(dim, "auto");
-			size = (dim === "height") ? $P.outerHeight() : $P.outerWidth(); // MEASURE
-			$P.css(dim, szP).css(vis); // RESET size & visibility
-			if ($C) $C.css(dim, szC);
-			return size;
-		}
-	}
-
-	/**
-	* Calculates current 'size' (outer-width or outer-height) of a border-pane - optionally with 'pane-spacing' added
-	*
-	* @param  {(string|!Object)}	pane
-	* @param  {boolean=}			[inclSpace=false]
-	* @return {number}				Returns EITHER Width for east/west panes OR Height for north/south panes
-	*/
-,	getPaneSize = function (pane, inclSpace) {
-		var 
-			$P	= $Ps[pane]
-		,	o	= options[pane]
-		,	s	= state[pane]
-		,	oSp	= (inclSpace ? o.spacing_open : 0)
-		,	cSp	= (inclSpace ? o.spacing_closed : 0)
-		;
-		if (!$P || s.isHidden)
-			return 0;
-		else if (s.isClosed || (s.isSliding && inclSpace))
-			return cSp;
-		else if (_c[pane].dir === "horz")
-			return $P.outerHeight() + oSp;
-		else // dir === "vert"
-			return $P.outerWidth() + oSp;
-	}
-
-	/**
-	* Calculate min/max pane dimensions and limits for resizing
-	*
-	* @param  {string}		pane
-	* @param  {boolean=}	[slide=false]
-	*/
-,	setSizeLimits = function (pane, slide) {
-		if (!isInitialized()) return;
-		var 
-			o				= options[pane]
-		,	s				= state[pane]
-		,	c				= _c[pane]
-		,	dir				= c.dir
-		,	side			= c.side.toLowerCase()
-		,	type			= c.sizeType.toLowerCase()
-		,	isSliding		= (slide != undefined ? slide : s.isSliding) // only open() passes 'slide' param
-		,	$P				= $Ps[pane]
-		,	paneSpacing		= o.spacing_open
-		//	measure the pane on the *opposite side* from this pane
-		,	altPane			= _c.oppositeEdge[pane]
-		,	altS			= state[altPane]
-		,	$altP			= $Ps[altPane]
-		,	altPaneSize		= (!$altP || altS.isVisible===false || altS.isSliding ? 0 : (dir=="horz" ? $altP.outerHeight() : $altP.outerWidth()))
-		,	altPaneSpacing	= ((!$altP || altS.isHidden ? 0 : options[altPane][ altS.isClosed !== false ? "spacing_closed" : "spacing_open" ]) || 0)
-		//	limitSize prevents this pane from 'overlapping' opposite pane
-		,	containerSize	= (dir=="horz" ? sC.innerHeight : sC.innerWidth)
-		,	minCenterDims	= cssMinDims("center")
-		,	minCenterSize	= dir=="horz" ? max(options.center.minHeight, minCenterDims.minHeight) : max(options.center.minWidth, minCenterDims.minWidth)
-		//	if pane is 'sliding', then ignore center and alt-pane sizes - because 'overlays' them
-		,	limitSize		= (containerSize - paneSpacing - (isSliding ? 0 : (_parseSize("center", minCenterSize, dir) + altPaneSize + altPaneSpacing)))
-		,	minSize			= s.minSize = max( _parseSize(pane, o.minSize), cssMinDims(pane).minSize )
-		,	maxSize			= s.maxSize = min( (o.maxSize ? _parseSize(pane, o.maxSize) : 100000), limitSize )
-		,	r				= s.resizerPosition = {} // used to set resizing limits
-		,	top				= sC.insetTop
-		,	left			= sC.insetLeft
-		,	W				= sC.innerWidth
-		,	H				= sC.innerHeight
-		,	rW				= o.spacing_open // subtract resizer-width to get top/left position for south/east
-		;
-		switch (pane) {
-			case "north":	r.min = top + minSize;
-							r.max = top + maxSize;
-							break;
-			case "west":	r.min = left + minSize;
-							r.max = left + maxSize;
-							break;
-			case "south":	r.min = top + H - maxSize - rW;
-							r.max = top + H - minSize - rW;
-							break;
-			case "east":	r.min = left + W - maxSize - rW;
-							r.max = left + W - minSize - rW;
-							break;
-		};
-	}
-
-	/**
-	* Returns data for setting the size/position of center pane. Also used to set Height for east/west panes
-	*
-	* @return JSON  Returns a hash of all dimensions: top, bottom, left, right, (outer) width and (outer) height
-	*/
-,	calcNewCenterPaneDims = function () {
-		var d = {
-			top:	getPaneSize("north", true) // true = include 'spacing' value for pane
-		,	bottom:	getPaneSize("south", true)
-		,	left:	getPaneSize("west", true)
-		,	right:	getPaneSize("east", true)
-		,	width:	0
-		,	height:	0
-		};
-
-		// NOTE: sC = state.container
-		// calc center-pane outer dimensions
-		d.width		= sC.innerWidth - d.left - d.right;  // outerWidth
-		d.height	= sC.innerHeight - d.bottom - d.top; // outerHeight
-		// add the 'container border/padding' to get final positions relative to the container
-		d.top		+= sC.insetTop;
-		d.bottom	+= sC.insetBottom;
-		d.left		+= sC.insetLeft;
-		d.right		+= sC.insetRight;
-
-		return d;
-	}
-
-
-	/**
-	* @param {!Object}		el
-	* @param {boolean=}		[allStates=false]
-	*/
-,	getHoverClasses = function (el, allStates) {
-		var
-			$El		= $(el)
-		,	type	= $El.data("layoutRole")
-		,	pane	= $El.data("layoutEdge")
-		,	o		= options[pane]
-		,	root	= o[type +"Class"]
-		,	_pane	= "-"+ pane // eg: "-west"
-		,	_open	= "-open"
-		,	_closed	= "-closed"
-		,	_slide	= "-sliding"
-		,	_hover	= "-hover " // NOTE the trailing space
-		,	_state	= $El.hasClass(root+_closed) ? _closed : _open
-		,	_alt	= _state === _closed ? _open : _closed
-		,	classes = (root+_hover) + (root+_pane+_hover) + (root+_state+_hover) + (root+_pane+_state+_hover)
-		;
-		if (allStates) // when 'removing' classes, also remove alternate-state classes
-			classes += (root+_alt+_hover) + (root+_pane+_alt+_hover);
-
-		if (type=="resizer" && $El.hasClass(root+_slide))
-			classes += (root+_slide+_hover) + (root+_pane+_slide+_hover);
-
-		return $.trim(classes);
-	}
-,	addHover	= function (evt, el) {
-		var $E = $(el || this);
-		if (evt && $E.data("layoutRole") === "toggler")
-			evt.stopPropagation(); // prevent triggering 'slide' on Resizer-bar
-		$E.addClass( getHoverClasses($E) );
-	}
-,	removeHover	= function (evt, el) {
-		var $E = $(el || this);
-		$E.removeClass( getHoverClasses($E, true) );
-	}
-
-,	onResizerEnter	= function (evt) { // ALSO called by toggler.mouseenter
-		if ($.fn.disableSelection)
-			$("body").disableSelection();
-	}
-,	onResizerLeave	= function (evt, el) {
-		var
-			e = el || this // el is only passed when called by the timer
-		,	pane = $(e).data("layoutEdge")
-		,	name = pane +"ResizerLeave"
-		;
-		timer.clear(pane+"_openSlider"); // cancel slideOpen timer, if set
-		timer.clear(name); // cancel enableSelection timer - may re/set below
-		// this method calls itself on a timer because it needs to allow
-		// enough time for dragging to kick-in and set the isResizing flag
-		// dragging has a 100ms delay set, so this delay must be >100
-		if (!el) // 1st call - mouseleave event
-			timer.set(name, function(){ onResizerLeave(evt, e); }, 200);
-		// if user is resizing, then dragStop will enableSelection(), so can skip it here
-		else if (!state[pane].isResizing && $.fn.enableSelection) // 2nd call - by timer
-			$("body").enableSelection();
-	}
-
-/*
- * ###########################
- *   INITIALIZATION METHODS
- * ###########################
- */
-
-	/**
-	* Initialize the layout - called automatically whenever an instance of layout is created
-	*
-	* @see  none - triggered onInit
-	* @return  mixed	true = fully initialized | false = panes not initialized (yet) | 'cancel' = abort
-	*/
-,	_create = function () {
-		// initialize config/options
-		initOptions();
-		var o = options;
-
-		// TEMP state so isInitialized returns true during init process
-		state.creatingLayout = true;
-
-		// init plugins for this layout, if there are any (eg: stateManagement)
-		runPluginCallbacks( Instance, $.layout.onCreate );
-
-		// options & state have been initialized, so now run beforeLoad callback
-		// onload will CANCEL layout creation if it returns false
-		if (false === _runCallbacks("onload_start"))
-			return 'cancel';
-
-		// initialize the container element
-		_initContainer();
-
-		// bind hotkey function - keyDown - if required
-		initHotkeys();
-
-		// bind window.onunload
-		$(window).bind("unload."+ sID, unload);
-
-		// init plugins for this layout, if there are any (eg: customButtons)
-		runPluginCallbacks( Instance, $.layout.onLoad );
-
-		// if layout elements are hidden, then layout WILL NOT complete initialization!
-		// initLayoutElements will set initialized=true and run the onload callback IF successful
-		if (o.initPanes) _initLayoutElements();
-
-		delete state.creatingLayout;
-
-		return state.initialized;
-	}
-
-	/**
-	* Initialize the layout IF not already
-	*
-	* @see  All methods in Instance run this test
-	* @return  boolean	true = layoutElements have been initialized | false = panes are not initialized (yet)
-	*/
-,	isInitialized = function () {
-		if (state.initialized || state.creatingLayout) return true;	// already initialized
-		else return _initLayoutElements();	// try to init panes NOW
-	}
-
-	/**
-	* Initialize the layout - called automatically whenever an instance of layout is created
-	*
-	* @see  _create() & isInitialized
-	* @return  An object pointer to the instance created
-	*/
-,	_initLayoutElements = function (retry) {
-		// initialize config/options
-		var o = options;
-
-		// CANNOT init panes inside a hidden container!
-		if (!$N.is(":visible")) {
-			// handle Chrome bug where popup window 'has no height'
-			// if layout is BODY element, try again in 50ms
-			// SEE: http://layout.jquery-dev.net/samples/test_popup_window.html
-			if ( !retry && browser.webkit && $N[0].tagName === "BODY" )
-				setTimeout(function(){ _initLayoutElements(true); }, 50);
-			return false;
-		}
-
-		// a center pane is required, so make sure it exists
-		if (!getPane("center").length) {
-			return _log( o.errors.centerPaneMissing );
-		}
-
-		// TEMP state so isInitialized returns true during init process
-		state.creatingLayout = true;
-
-		// update Container dims
-		$.extend(sC, elDims( $N ));
-
-		// initialize all layout elements
-		initPanes();	// size & position panes - calls initHandles() - which calls initResizable()
-
-		if (o.scrollToBookmarkOnLoad) {
-			var l = self.location;
-			if (l.hash) l.replace( l.hash ); // scrollTo Bookmark
-		}
-
-		// check to see if this layout 'nested' inside a pane
-		if (Instance.hasParentLayout)
-			o.resizeWithWindow = false;
-		// bind resizeAll() for 'this layout instance' to window.resize event
-		else if (o.resizeWithWindow)
-			$(window).bind("resize."+ sID, windowResize);
-
-		delete state.creatingLayout;
-		state.initialized = true;
-
-		// init plugins for this layout, if there are any
-		runPluginCallbacks( Instance, $.layout.onReady );
-
-		// now run the onload callback, if exists
-		_runCallbacks("onload_end");
-
-		return true; // elements initialized successfully
-	}
-
-	/**
-	* Initialize nested layouts - called when _initLayoutElements completes
-	*
-	* NOT CURRENTLY USED
-	*
-	* @see _initLayoutElements
-	* @return  An object pointer to the instance created
-	*/
-,	_initChildLayouts = function () {
-		$.each(_c.allPanes, function (idx, pane) {
-			if (options[pane].initChildLayout)
-				createChildLayout( pane );
-		});
-	}
-
-	/**
-	* Initialize nested layouts for a specific pane - can optionally pass layout-options
-	*
-	* @see _initChildLayouts
-	* @param {string|Object}	evt_or_pane	The pane being opened, ie: north, south, east, or west
-	* @param {Object=}			[opts]		Layout-options - if passed, will OVERRRIDE options[pane].childOptions
-	* @return  An object pointer to the layout instance created - or null
-	*/
-,	createChildLayout = function (evt_or_pane, opts) {
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	$P	= $Ps[pane]
-		,	C	= children
-		;
-		if ($P) {
-			var	$C	= $Cs[pane]
-			,	o	= opts || options[pane].childOptions
-			,	d	= "layout"
-			//	determine which element is supposed to be the 'child container'
-			//	if pane has a 'containerSelector' OR a 'content-div', use those instead of the pane
-			,	$Cont = o.containerSelector ? $P.find( o.containerSelector ) : ($C || $P)
-			,	containerFound = $Cont.length
-			//	see if a child-layout ALREADY exists on this element
-			,	child = containerFound ? (C[pane] = $Cont.data(d) || null) : null
-			;
-			// if no layout exists, but childOptions are set, try to create the layout now
-			if (!child && containerFound && o)
-				child = C[pane] = $Cont.eq(0).layout(o) || null;
-			if (child)
-				child.hasParentLayout = true;	// set parent-flag in child
-		}
-		Instance[pane].child = C[pane]; // ALWAYS set pane-object pointer, even if null
-	}
-
-,	windowResize = function () {
-		var delay = Number(options.resizeWithWindowDelay);
-		if (delay < 10) delay = 100; // MUST have a delay!
-		// resizing uses a delay-loop because the resize event fires repeatly - except in FF, but delay anyway
-		timer.clear("winResize"); // if already running
-		timer.set("winResize", function(){
-			timer.clear("winResize");
-			timer.clear("winResizeRepeater");
-			var dims = elDims( $N );
-			// only trigger resizeAll() if container has changed size
-			if (dims.innerWidth !== sC.innerWidth || dims.innerHeight !== sC.innerHeight)
-				resizeAll();
-		}, delay);
-		// ALSO set fixed-delay timer, if not already running
-		if (!timer.data["winResizeRepeater"]) setWindowResizeRepeater();
-	}
-
-,	setWindowResizeRepeater = function () {
-		var delay = Number(options.resizeWithWindowMaxDelay);
-		if (delay > 0)
-			timer.set("winResizeRepeater", function(){ setWindowResizeRepeater(); resizeAll(); }, delay);
-	}
-
-,	unload = function () {
-		var o = options;
-
-		_runCallbacks("onunload_start");
-
-		// trigger plugin callabacks for this layout (eg: stateManagement)
-		runPluginCallbacks( Instance, $.layout.onUnload );
-
-		_runCallbacks("onunload_end");
-	}
-
-	/**
-	* Validate and initialize container CSS and events
-	*
-	* @see  _create()
-	*/
-,	_initContainer = function () {
-		var
-			N		= $N[0]
-		,	tag		= sC.tagName = N.tagName
-		,	id		= sC.id = N.id
-		,	cls		= sC.className = N.className
-		,	o		= options
-		,	name	= o.name
-		,	fullPage= (tag === "BODY")
-		,	props	= "overflow,position,margin,padding,border"
-		,	css		= "layoutCSS"
-		,	CSS		= {}
-		,	hid		= "hidden" // used A LOT!
-		//	see if this container is a 'pane' inside an outer-layout
-		,	parent	= $N.data("parentLayout")	// parent-layout Instance
-		,	pane	= $N.data("layoutEdge")		// pane-name in parent-layout
-		,	isChild	= parent && pane
-		;
-		// sC -> state.container
-		sC.selector = $N.selector.split(".slice")[0];
-		sC.ref		= (o.name ? o.name +' layout / ' : '') + tag + (id ? "#"+id : cls ? '.['+cls+']' : ''); // used in messages
-
-		$N	.data({
-				layout: Instance
-			,	layoutContainer: sID // FLAG to indicate this is a layout-container - contains unique internal ID
-			})
-			.addClass(o.containerClass)
-		;
-		var layoutMethods = {
-			destroy:	''
-		,	initPanes:	''
-		,	resizeAll:	'resizeAll'
-		,	resize:		'resizeAll'
-		};
-		// loop hash and bind all methods - include layoutID namespacing
-		for (name in layoutMethods) {
-			$N.bind("layout"+ name.toLowerCase() +"."+ sID, Instance[ layoutMethods[name] || name ]);
-		}
-
-		// if this container is another layout's 'pane', then set child/parent pointers
-		if (isChild) {
-			// update parent flag
-			Instance.hasParentLayout = true;
-			// set pointers to THIS child-layout (Instance) in parent-layout
-			// NOTE: parent.PANE.child is an ALIAS to parent.children.PANE
-			parent[pane].child = parent.children[pane] = $N.data("layout");
-		}
-
-		// SAVE original container CSS for use in destroy()
-		if (!$N.data(css)) {
-			// handle props like overflow different for BODY & HTML - has 'system default' values
-			if (fullPage) {
-				CSS = $.extend( elCSS($N, props), {
-					height:		$N.css("height")
-				,	overflow:	$N.css("overflow")
-				,	overflowX:	$N.css("overflowX")
-				,	overflowY:	$N.css("overflowY")
-				});
-				// ALSO SAVE <HTML> CSS
-				var $H = $("html");
-				$H.data(css, {
-					height:		"auto" // FF would return a fixed px-size!
-				,	overflow:	$H.css("overflow")
-				,	overflowX:	$H.css("overflowX")
-				,	overflowY:	$H.css("overflowY")
-				});
-			}
-			else // handle props normally for non-body elements
-				CSS = elCSS($N, props+",top,bottom,left,right,width,height,overflow,overflowX,overflowY");
-
-			$N.data(css, CSS);
-		}
-
-		try { // format html/body if this is a full page layout
-			if (fullPage) {
-				$("html").css({
-					height:		"100%"
-				,	overflow:	hid
-				,	overflowX:	hid
-				,	overflowY:	hid
-				});
-				$("body").css({
-					position:	"relative"
-				,	height:		"100%"
-				,	overflow:	hid
-				,	overflowX:	hid
-				,	overflowY:	hid
-				,	margin:		0
-				,	padding:	0		// TODO: test whether body-padding could be handled?
-				,	border:		"none"	// a body-border creates problems because it cannot be measured!
-				});
-
-				// set current layout-container dimensions
-				$.extend(sC, elDims( $N ));
-			}
-			else { // set required CSS for overflow and position
-				// ENSURE container will not 'scroll'
-				CSS = { overflow: hid, overflowX: hid, overflowY: hid }
-				var
-					p = $N.css("position")
-				,	h = $N.css("height")
-				;
-				// if this is a NESTED layout, then container/outer-pane ALREADY has position and height
-				if (!isChild) {
-					if (!p || !p.match(/fixed|absolute|relative/))
-						CSS.position = "relative"; // container MUST have a 'position'
-					/*
-					if (!h || h=="auto")
-						CSS.height = "100%"; // container MUST have a 'height'
-					*/
-				}
-				$N.css( CSS );
-
-				// set current layout-container dimensions
-				if ( $N.is(":visible") ) {
-					$.extend(sC, elDims( $N ));
-					if (sC.innerHeight < 1)
-						_log( o.errors.noContainerHeight.replace(/CONTAINER/, sC.ref) );
-				}
-			}
-		} catch (ex) {}
-	}
-
-	/**
-	* Bind layout hotkeys - if options enabled
-	*
-	* @see  _create() and addPane()
-	* @param {string=}	[panes=""]	The edge(s) to process
-	*/
-,	initHotkeys = function (panes) {
-		panes = panes ? panes.split(",") : _c.borderPanes;
-		// bind keyDown to capture hotkeys, if option enabled for ANY pane
-		$.each(panes, function (i, pane) {
-			var o = options[pane];
-			if (o.enableCursorHotkey || o.customHotkey) {
-				$(document).bind("keydown."+ sID, keyDown); // only need to bind this ONCE
-				return false; // BREAK - binding was done
-			}
-		});
-	}
-
-	/**
-	* Build final OPTIONS data
-	*
-	* @see  _create()
-	*/
-,	initOptions = function () {
-		var data, d, pane, key, val, i, c, o;
-
-		// reprocess user's layout-options to have correct options sub-key structure
-		opts = $.layout.transformData( opts ); // panes = default subkey
-
-		// auto-rename old options for backward compatibility
-		opts = $.layout.backwardCompatibility.renameAllOptions( opts );
-
-		// if user-options has 'panes' key (pane-defaults), clean it...
-		if (!$.isEmptyObject(opts.panes)) {
-			// REMOVE any pane-defaults that MUST be set per-pane
-			data = $.layout.optionsMap.noDefault;
-			for (i=0, c=data.length; i<c; i++) {
-				key = data[i];
-				delete opts.panes[key]; // OK if does not exist
-			}
-			// REMOVE any layout-options specified under opts.panes
-			data = $.layout.optionsMap.layout;
-			for (i=0, c=data.length; i<c; i++) {
-				key = data[i];
-				delete opts.panes[key]; // OK if does not exist
-			}
-		}
-
-		// MOVE any NON-layout-options from opts-root to opts.panes
-		data = $.layout.optionsMap.layout;
-		var rootKeys = $.layout.config.optionRootKeys;
-		for (key in opts) {
-			val = opts[key];
-			if ($.inArray(key, rootKeys) < 0 && $.inArray(key, data) < 0) {
-				if (!opts.panes[key])
-					opts.panes[key] = $.isPlainObject(val) ? $.extend(true, {}, val) : val;
-				delete opts[key]
-			}
-		}
-
-		// START by updating ALL options from opts
-		$.extend(true, options, opts);
-
-		// CREATE final options (and config) for EACH pane
-		$.each(_c.allPanes, function (i, pane) {
-
-			// apply 'pane-defaults' to CONFIG.[PANE]
-			_c[pane] = $.extend(true, {}, _c.panes, _c[pane]);
-
-			d = options.panes;
-			o = options[pane];
-
-			// center-pane uses SOME keys in defaults.panes branch
-			if (pane === 'center') {
-				// ONLY copy keys from opts.panes listed in: $.layout.optionsMap.center
-				data = $.layout.optionsMap.center;		// list of 'center-pane keys'
-				for (i=0, c=data.length; i<c; i++) {	// loop the list...
-					key = data[i];
-					// only need to use pane-default if pane-specific value not set
-					if (!opts.center[key] && (opts.panes[key] || !o[key]))
-						o[key] = d[key]; // pane-default
-				}
-			}
-			else {
-				// border-panes use ALL keys in defaults.panes branch
-				o = options[pane] = $.extend(true, {}, d, o); // re-apply pane-specific opts AFTER pane-defaults
-				createFxOptions( pane );
-				// ensure all border-pane-specific base-classes exist
-				if (!o.resizerClass)	o.resizerClass	= "ui-layout-resizer";
-				if (!o.togglerClass)	o.togglerClass	= "ui-layout-toggler";
-			}
-			// ensure we have base pane-class (ALL panes)
-			if (!o.paneClass) o.paneClass = "ui-layout-pane";
-		});
-
-		// update options.zIndexes if a zIndex-option specified
-		var zo	= opts.zIndex
-		,	z	= options.zIndexes;
-		if (zo > 0) {
-			z.pane_normal		= zo;
-			z.content_mask		= max(zo+1, z.content_mask);	// MIN = +1
-			z.resizer_normal	= max(zo+2, z.resizer_normal);	// MIN = +2
-		}
-
-		// DELETE 'panes' key now that we are done - values were copied to EACH pane
-		delete options.panes;
-
-
-		function createFxOptions ( pane ) {
-			var	o = options[pane]
-			,	d = options.panes;
-			// ensure fxSettings key to avoid errors
-			if (!o.fxSettings) o.fxSettings = {};
-			if (!d.fxSettings) d.fxSettings = {};
-
-			$.each(["_open","_close","_size"], function (i,n) { 
-				var
-					sName		= "fxName"+ n
-				,	sSpeed		= "fxSpeed"+ n
-				,	sSettings	= "fxSettings"+ n
-					// recalculate fxName according to specificity rules
-				,	fxName = o[sName] =
-						o[sName]	// options.west.fxName_open
-					||	d[sName]	// options.panes.fxName_open
-					||	o.fxName	// options.west.fxName
-					||	d.fxName	// options.panes.fxName
-					||	"none"		// MEANS $.layout.defaults.panes.fxName == "" || false || null || 0
-				;
-				// validate fxName to ensure is valid effect - MUST have effect-config data in options.effects
-				if (fxName === "none" || !$.effects || !$.effects[fxName] || !options.effects[fxName])
-					fxName = o[sName] = "none"; // effect not loaded OR unrecognized fxName
-
-				// set vars for effects subkeys to simplify logic
-				var	fx		= options.effects[fxName] || {}	// effects.slide
-				,	fx_all	= fx.all	|| null				// effects.slide.all
-				,	fx_pane	= fx[pane]	|| null				// effects.slide.west
-				;
-				// create fxSpeed[_open|_close|_size]
-				o[sSpeed] =
-					o[sSpeed]				// options.west.fxSpeed_open
-				||	d[sSpeed]				// options.west.fxSpeed_open
-				||	o.fxSpeed				// options.west.fxSpeed
-				||	d.fxSpeed				// options.panes.fxSpeed
-				||	null					// DEFAULT - let fxSetting.duration control speed
-				;
-				// create fxSettings[_open|_close|_size]
-				o[sSettings] = $.extend(
-					true
-				,	{}
-				,	fx_all					// effects.slide.all
-				,	fx_pane					// effects.slide.west
-				,	d.fxSettings			// options.panes.fxSettings
-				,	o.fxSettings			// options.west.fxSettings
-				,	d[sSettings]			// options.panes.fxSettings_open
-				,	o[sSettings]			// options.west.fxSettings_open
-				);
-			});
-
-			// DONE creating action-specific-settings for this pane,
-			// so DELETE generic options - are no longer meaningful
-			delete o.fxName;
-			delete o.fxSpeed;
-			delete o.fxSettings;
-		}
-	}
-
-	/**
-	* Initialize module objects, styling, size and position for all panes
-	*
-	* @see  _initElements()
-	* @param {string}	pane		The pane to process
-	*/
-,	getPane = function (pane) {
-		var sel = options[pane].paneSelector
-		if (sel.substr(0,1)==="#") // ID selector
-			// NOTE: elements selected 'by ID' DO NOT have to be 'children'
-			return $N.find(sel).eq(0);
-		else { // class or other selector
-			var $P = $N.children(sel).eq(0);
-			// look for the pane nested inside a 'form' element
-			return $P.length ? $P : $N.children("form:first").children(sel).eq(0);
-		}
-	}
-
-,	initPanes = function (evt) {
-		// stopPropagation if called by trigger("layoutinitpanes") - use evtPane utility 
-		evtPane(evt);
-
-		// NOTE: do north & south FIRST so we can measure their height - do center LAST
-		$.each(_c.allPanes, function (idx, pane) {
-			addPane( pane, true );
-		});
-
-		// init the pane-handles NOW in case we have to hide or close the pane below
-		initHandles();
-
-		// now that all panes have been initialized and initially-sized,
-		// make sure there is really enough space available for each pane
-		$.each(_c.borderPanes, function (i, pane) {
-			if ($Ps[pane] && state[pane].isVisible) { // pane is OPEN
-				setSizeLimits(pane);
-				makePaneFit(pane); // pane may be Closed, Hidden or Resized by makePaneFit()
-			}
-		});
-		// size center-pane AGAIN in case we 'closed' a border-pane in loop above
-		sizeMidPanes("center");
-
-		//	Chrome/Webkit sometimes fires callbacks BEFORE it completes resizing!
-		//	Before RC30.3, there was a 10ms delay here, but that caused layout 
-		//	to load asynchrously, which is BAD, so try skipping delay for now
-
-		// process pane contents and callbacks, and init/resize child-layout if exists
-		$.each(_c.allPanes, function (i, pane) {
-			var o = options[pane];
-			if ($Ps[pane]) {
-				if (state[pane].isVisible) { // pane is OPEN
-					sizeContent(pane);
-					// trigger pane.onResize if triggerEventsOnLoad = true
-					if (o.triggerEventsOnLoad)
-						_runCallbacks("onresize_end", pane);
-				else // automatic if onresize called, otherwise call it specifically
-					// resize child - IF inner-layout already exists (created before this layout)
-					resizeChildLayout(pane);
-				}
-				// init childLayout - even if pane is not visible
-				if (o.initChildLayout && o.childOptions)
-					createChildLayout(pane);
-			}
-		});
-	}
-
-	/**
-	* Add a pane to the layout - subroutine of initPanes()
-	*
-	* @see  initPanes()
-	* @param {string}	pane			The pane to process
-	* @param {boolean=}	[force=false]	Size content after init
-	*/
-,	addPane = function (pane, force) {
-		if (!force && !isInitialized()) return;
-		var
-			o		= options[pane]
-		,	s		= state[pane]
-		,	c		= _c[pane]
-		,	fx		= s.fx
-		,	dir		= c.dir
-		,	spacing	= o.spacing_open || 0
-		,	isCenter = (pane === "center")
-		,	CSS		= {}
-		,	$P		= $Ps[pane]
-		,	size, minSize, maxSize
-		;
-		// if pane-pointer already exists, remove the old one first
-		if ($P)
-			removePane( pane, false, true, false );
-		else
-			$Cs[pane] = false; // init
-
-		$P = $Ps[pane] = getPane(pane);
-		if (!$P.length) {
-			$Ps[pane] = false; // logic
-			return;
-		}
-
-		// SAVE original Pane CSS
-		if (!$P.data("layoutCSS")) {
-			var props = "position,top,left,bottom,right,width,height,overflow,zIndex,display,backgroundColor,padding,margin,border";
-			$P.data("layoutCSS", elCSS($P, props));
-		}
-
-		// create alias for pane data in Instance - initHandles will add more
-		Instance[pane] = { name: pane, pane: $Ps[pane], content: $Cs[pane], options: options[pane], state: state[pane], child: children[pane] };
-
-		// add classes, attributes & events
-		$P	.data({
-				parentLayout:	Instance		// pointer to Layout Instance
-			,	layoutPane:		Instance[pane]	// NEW pointer to pane-alias-object
-			,	layoutEdge:		pane
-			,	layoutRole:		"pane"
-			})
-			.css(c.cssReq).css("zIndex", options.zIndexes.pane_normal)
-			.css(o.applyDemoStyles ? c.cssDemo : {}) // demo styles
-			.addClass( o.paneClass +" "+ o.paneClass+"-"+pane ) // default = "ui-layout-pane ui-layout-pane-west" - may be a dupe of 'paneSelector'
-			.bind("mouseenter."+ sID, addHover )
-			.bind("mouseleave."+ sID, removeHover )
-			;
-		var paneMethods = {
-				hide:				''
-			,	show:				''
-			,	toggle:				''
-			,	close:				''
-			,	open:				''
-			,	slideOpen:			''
-			,	slideClose:			''
-			,	slideToggle:		''
-			,	size:				'sizePane'
-			,	sizePane:			'sizePane'
-			,	sizeContent:		''
-			,	sizeHandles:		''
-			,	enableClosable:		''
-			,	disableClosable:	''
-			,	enableSlideable:	''
-			,	disableSlideable:	''
-			,	enableResizable:	''
-			,	disableResizable:	''
-			,	swapPanes:			'swapPanes'
-			,	swap:				'swapPanes'
-			,	move:				'swapPanes'
-			,	removePane:			'removePane'
-			,	remove:				'removePane'
-			,	createChildLayout:	''
-			,	resizeChildLayout:	''
-			,	resizeAll:			'resizeAll'
-			,	resizeLayout:		'resizeAll'
-			}
-		,	name;
-		// loop hash and bind all methods - include layoutID namespacing
-		for (name in paneMethods) {
-			$P.bind("layoutpane"+ name.toLowerCase() +"."+ sID, Instance[ paneMethods[name] || name ]);
-		}
-
-		// see if this pane has a 'scrolling-content element'
-		initContent(pane, false); // false = do NOT sizeContent() - called later
-
-		if (!isCenter) {
-			// call _parseSize AFTER applying pane classes & styles - but before making visible (if hidden)
-			// if o.size is auto or not valid, then MEASURE the pane and use that as its 'size'
-			size	= s.size = _parseSize(pane, o.size);
-			minSize	= _parseSize(pane,o.minSize) || 1;
-			maxSize	= _parseSize(pane,o.maxSize) || 100000;
-			if (size > 0) size = max(min(size, maxSize), minSize);
-
-			// state for border-panes
-			s.isClosed  = false; // true = pane is closed
-			s.isSliding = false; // true = pane is currently open by 'sliding' over adjacent panes
-			s.isResizing= false; // true = pane is in process of being resized
-			s.isHidden	= false; // true = pane is hidden - no spacing, resizer or toggler is visible!
-
-			// array for 'pin buttons' whose classNames are auto-updated on pane-open/-close
-			if (!s.pins) s.pins = [];
-		}
-		//	states common to ALL panes
-		s.tagName	= $P[0].tagName;
-		s.edge		= pane;		// useful if pane is (or about to be) 'swapped' - easy find out where it is (or is going)
-		s.noRoom	= false;	// true = pane 'automatically' hidden due to insufficient room - will unhide automatically
-		s.isVisible	= true;		// false = pane is invisible - closed OR hidden - simplify logic
-
-		// set css-position to account for container borders & padding
-		switch (pane) {
-			case "north": 	CSS.top 	= sC.insetTop;
-							CSS.left 	= sC.insetLeft;
-							CSS.right	= sC.insetRight;
-							break;
-			case "south": 	CSS.bottom	= sC.insetBottom;
-							CSS.left 	= sC.insetLeft;
-							CSS.right 	= sC.insetRight;
-							break;
-			case "west": 	CSS.left 	= sC.insetLeft; // top, bottom & height set by sizeMidPanes()
-							break;
-			case "east": 	CSS.right 	= sC.insetRight; // ditto
-							break;
-			case "center":	// top, left, width & height set by sizeMidPanes()
-		}
-
-		if (dir === "horz") // north or south pane
-			CSS.height = cssH($P, size);
-		else if (dir === "vert") // east or west pane
-			CSS.width = cssW($P, size);
-		//else if (isCenter) {}
-
-		$P.css(CSS); // apply size -- top, bottom & height will be set by sizeMidPanes
-		if (dir != "horz") sizeMidPanes(pane, true); // true = skipCallback
-
-		// close or hide the pane if specified in settings
-		if (o.initClosed && o.closable && !o.initHidden)
-			close(pane, true, true); // true, true = force, noAnimation
-		else if (o.initHidden || o.initClosed)
-			hide(pane); // will be completely invisible - no resizer or spacing
-		else if (!s.noRoom)
-			// make the pane visible - in case was initially hidden
-			$P.css("display","block");
-		// ELSE setAsOpen() - called later by initHandles()
-
-		// RESET visibility now - pane will appear IF display:block
-		$P.css("visibility","visible");
-
-		// check option for auto-handling of pop-ups & drop-downs
-		if (o.showOverflowOnHover)
-			$P.hover( allowOverflow, resetOverflow );
-
-		// if manually adding a pane AFTER layout initialization, then...
-		if (state.initialized) {
-			initHandles( pane );
-			initHotkeys( pane );
-			resizeAll(); // will sizeContent if pane is visible
-			if (s.isVisible) { // pane is OPEN
-				if (o.triggerEventsOnLoad)
-					_runCallbacks("onresize_end", pane);
-				else // automatic if onresize called, otherwise call it specifically
-					// resize child - IF inner-layout already exists (created before this layout)
-					resizeChildLayout(pane); // a previously existing childLayout
-			}
-			if (o.initChildLayout && o.childOptions)
-				createChildLayout(pane);
-		}
-	}
-
-	/**
-	* Initialize module objects, styling, size and position for all resize bars and toggler buttons
-	*
-	* @see  _create()
-	* @param {string=}	[panes=""]	The edge(s) to process
-	*/
-,	initHandles = function (panes) {
-		panes = panes ? panes.split(",") : _c.borderPanes;
-
-		// create toggler DIVs for each pane, and set object pointers for them, eg: $R.north = north toggler DIV
-		$.each(panes, function (i, pane) {
-			var $P		= $Ps[pane];
-			$Rs[pane]	= false; // INIT
-			$Ts[pane]	= false;
-			if (!$P) return; // pane does not exist - skip
-
-			var 
-				o		= options[pane]
-			,	s		= state[pane]
-			,	c		= _c[pane]
-			,	paneId	= o.paneSelector.substr(0,1) === "#" ? o.paneSelector.substr(1) : ""
-			,	rClass	= o.resizerClass
-			,	tClass	= o.togglerClass
-			,	side	= c.side.toLowerCase()
-			,	spacing	= (s.isVisible ? o.spacing_open : o.spacing_closed)
-			,	_pane	= "-"+ pane // used for classNames
-			,	_state	= (s.isVisible ? "-open" : "-closed") // used for classNames
-			,	I		= Instance[pane]
-				// INIT RESIZER BAR
-			,	$R		= I.resizer = $Rs[pane] = $("<div></div>")
-				// INIT TOGGLER BUTTON
-			,	$T		= I.toggler = (o.closable ? $Ts[pane] = $("<div></div>") : false)
-			;
-
-			//if (s.isVisible && o.resizable) ... handled by initResizable
-			if (!s.isVisible && o.slidable)
-				$R.attr("title", o.tips.Slide).css("cursor", o.sliderCursor);
-
-			$R	// if paneSelector is an ID, then create a matching ID for the resizer, eg: "#paneLeft" => "paneLeft-resizer"
-				.attr("id", paneId ? paneId +"-resizer" : "" )
-				.data({
-					parentLayout:	Instance
-				,	layoutPane:		Instance[pane]	// NEW pointer to pane-alias-object
-				,	layoutEdge:		pane
-				,	layoutRole:		"resizer"
-				})
-				.css(_c.resizers.cssReq).css("zIndex", options.zIndexes.resizer_normal)
-				.css(o.applyDemoStyles ? _c.resizers.cssDemo : {}) // add demo styles
-				.addClass(rClass +" "+ rClass+_pane)
-				.hover(addHover, removeHover) // ALWAYS add hover-classes, even if resizing is not enabled - handle with CSS instead
-				.hover(onResizerEnter, onResizerLeave) // ALWAYS NEED resizer.mouseleave to balance toggler.mouseenter
-				.appendTo($N) // append DIV to container
-			;
-
-			if ($T) {
-				$T	// if paneSelector is an ID, then create a matching ID for the resizer, eg: "#paneLeft" => "#paneLeft-toggler"
-					.attr("id", paneId ? paneId +"-toggler" : "" )
-					.data({
-						parentLayout:	Instance
-					,	layoutPane:		Instance[pane]	// NEW pointer to pane-alias-object
-					,	layoutEdge:		pane
-					,	layoutRole:		"toggler"
-					})
-					.css(_c.togglers.cssReq) // add base/required styles
-					.css(o.applyDemoStyles ? _c.togglers.cssDemo : {}) // add demo styles
-					.addClass(tClass +" "+ tClass+_pane)
-					.hover(addHover, removeHover) // ALWAYS add hover-classes, even if toggling is not enabled - handle with CSS instead
-					.bind("mouseenter", onResizerEnter) // NEED toggler.mouseenter because mouseenter MAY NOT fire on resizer
-					.appendTo($R) // append SPAN to resizer DIV
-				;
-				// ADD INNER-SPANS TO TOGGLER
-				if (o.togglerContent_open) // ui-layout-open
-					$("<span>"+ o.togglerContent_open +"</span>")
-						.data({
-							layoutEdge:		pane
-						,	layoutRole:		"togglerContent"
-						})
-						.data("layoutRole", "togglerContent")
-						.data("layoutEdge", pane)
-						.addClass("content content-open")
-						.css("display","none")
-						.appendTo( $T )
-						//.hover( addHover, removeHover ) // use ui-layout-toggler-west-hover .content-open instead!
-					;
-				if (o.togglerContent_closed) // ui-layout-closed
-					$("<span>"+ o.togglerContent_closed +"</span>")
-						.data({
-							layoutEdge:		pane
-						,	layoutRole:		"togglerContent"
-						})
-						.addClass("content content-closed")
-						.css("display","none")
-						.appendTo( $T )
-						//.hover( addHover, removeHover ) // use ui-layout-toggler-west-hover .content-closed instead!
-					;
-				// ADD TOGGLER.click/.hover
-				enableClosable(pane);
-			}
-
-			// add Draggable events
-			initResizable(pane);
-
-			// ADD CLASSNAMES & SLIDE-BINDINGS - eg: class="resizer resizer-west resizer-open"
-			if (s.isVisible)
-				setAsOpen(pane);	// onOpen will be called, but NOT onResize
-			else {
-				setAsClosed(pane);	// onClose will be called
-				bindStartSlidingEvent(pane, true); // will enable events IF option is set
-			}
-
-		});
-
-		// SET ALL HANDLE DIMENSIONS
-		sizeHandles();
-	}
-
-
-	/**
-	* Initialize scrolling ui-layout-content div - if exists
-	*
-	* @see  initPane() - or externally after an Ajax injection
-	* @param {string}	[pane]			The pane to process
-	* @param {boolean=}	[resize=true]	Size content after init
-	*/
-,	initContent = function (pane, resize) {
-		if (!isInitialized()) return;
-		var 
-			o	= options[pane]
-		,	sel	= o.contentSelector
-		,	I	= Instance[pane]
-		,	$P	= $Ps[pane]
-		,	$C
-		;
-		if (sel) $C = I.content = $Cs[pane] = (o.findNestedContent)
-			? $P.find(sel).eq(0) // match 1-element only
-			: $P.children(sel).eq(0)
-		;
-		if ($C && $C.length) {
-			$C.data("layoutRole", "content");
-			// SAVE original Pane CSS
-			if (!$C.data("layoutCSS"))
-				$C.data("layoutCSS", elCSS($C, "height"));
-			$C.css( _c.content.cssReq );
-			if (o.applyDemoStyles) {
-				$C.css( _c.content.cssDemo ); // add padding & overflow: auto to content-div
-				$P.css( _c.content.cssDemoPane ); // REMOVE padding/scrolling from pane
-			}
-			state[pane].content = {}; // init content state
-			if (resize !== false) sizeContent(pane);
-			// sizeContent() is called AFTER init of all elements
-		}
-		else
-			I.content = $Cs[pane] = false;
-	}
-
-
-	/**
-	* Add resize-bars to all panes that specify it in options
-	* -dependancy: $.fn.resizable - will skip if not found
-	*
-	* @see  _create()
-	* @param {string=}	[panes=""]	The edge(s) to process
-	*/
-,	initResizable = function (panes) {
-		var	draggingAvailable = $.layout.plugins.draggable
-		,	side // set in start()
-		;
-		panes = panes ? panes.split(",") : _c.borderPanes;
-
-		$.each(panes, function (idx, pane) {
-			var o = options[pane];
-			if (!draggingAvailable || !$Ps[pane] || !o.resizable) {
-				o.resizable = false;
-				return true; // skip to next
-			}
-
-			var s		= state[pane]
-			,	z		= options.zIndexes
-			,	c		= _c[pane]
-			,	side	= c.dir=="horz" ? "top" : "left"
-			,	opEdge	= _c.oppositeEdge[pane]
-			,	masks	=  pane +",center,"+ opEdge + (c.dir=="horz" ? ",west,east" : "")
-			,	$P 		= $Ps[pane]
-			,	$R		= $Rs[pane]
-			,	base	= o.resizerClass
-			,	lastPos	= 0 // used when live-resizing
-			,	r, live // set in start because may change
-			//	'drag' classes are applied to the ORIGINAL resizer-bar while dragging is in process
-			,	resizerClass		= base+"-drag"				// resizer-drag
-			,	resizerPaneClass	= base+"-"+pane+"-drag"		// resizer-north-drag
-			//	'helper' class is applied to the CLONED resizer-bar while it is being dragged
-			,	helperClass			= base+"-dragging"			// resizer-dragging
-			,	helperPaneClass		= base+"-"+pane+"-dragging" // resizer-north-dragging
-			,	helperLimitClass	= base+"-dragging-limit"	// resizer-drag
-			,	helperPaneLimitClass = base+"-"+pane+"-dragging-limit"	// resizer-north-drag
-			,	helperClassesSet	= false 					// logic var
-			;
-
-			if (!s.isClosed)
-				$R.attr("title", o.tips.Resize)
-				  .css("cursor", o.resizerCursor); // n-resize, s-resize, etc
-
-			$R.draggable({
-				containment:	$N[0] // limit resizing to layout container
-			,	axis:			(c.dir=="horz" ? "y" : "x") // limit resizing to horz or vert axis
-			,	delay:			0
-			,	distance:		1
-			,	grid:			o.resizingGrid
-			//	basic format for helper - style it using class: .ui-draggable-dragging
-			,	helper:			"clone"
-			,	opacity:		o.resizerDragOpacity
-			,	addClasses:		false // avoid ui-state-disabled class when disabled
-			//,	iframeFix:		o.draggableIframeFix // TODO: consider using when bug is fixed
-			,	zIndex:			z.resizer_drag
-
-			,	start: function (e, ui) {
-					// REFRESH options & state pointers in case we used swapPanes
-					o = options[pane];
-					s = state[pane];
-					// re-read options
-					live = o.livePaneResizing;
-
-					// ondrag_start callback - will CANCEL hide if returns false
-					// TODO: dragging CANNOT be cancelled like this, so see if there is a way?
-					if (false === _runCallbacks("ondrag_start", pane)) return false;
-
-					s.isResizing	= true; // prevent pane from closing while resizing
-					timer.clear(pane+"_closeSlider"); // just in case already triggered
-
-					// SET RESIZER LIMITS - used in drag()
-					setSizeLimits(pane); // update pane/resizer state
-					r = s.resizerPosition;
-					lastPos = ui.position[ side ]
-
-					$R.addClass( resizerClass +" "+ resizerPaneClass ); // add drag classes
-					helperClassesSet = false; // reset logic var - see drag()
-
-					// DISABLE TEXT SELECTION (probably already done by resizer.mouseOver)
-					$('body').disableSelection(); 
-
-					// MASK PANES CONTAINING IFRAMES, APPLETS OR OTHER TROUBLESOME ELEMENTS
-					showMasks( masks );
-				}
-
-			,	drag: function (e, ui) {
-					if (!helperClassesSet) { // can only add classes after clone has been added to the DOM
-						//$(".ui-draggable-dragging")
-						ui.helper
-							.addClass( helperClass +" "+ helperPaneClass ) // add helper classes
-							.css({ right: "auto", bottom: "auto" })	// fix dir="rtl" issue
-							.children().css("visibility","hidden")	// hide toggler inside dragged resizer-bar
-						;
-						helperClassesSet = true;
-						// draggable bug!? RE-SET zIndex to prevent E/W resize-bar showing through N/S pane!
-						if (s.isSliding) $Ps[pane].css("zIndex", z.pane_sliding);
-					}
-					// CONTAIN RESIZER-BAR TO RESIZING LIMITS
-					var limit = 0;
-					if (ui.position[side] < r.min) {
-						ui.position[side] = r.min;
-						limit = -1;
-					}
-					else if (ui.position[side] > r.max) {
-						ui.position[side] = r.max;
-						limit = 1;
-					}
-					// ADD/REMOVE dragging-limit CLASS
-					if (limit) {
-						ui.helper.addClass( helperLimitClass +" "+ helperPaneLimitClass ); // at dragging-limit
-						window.defaultStatus = (limit>0 && pane.match(/(north|west)/)) || (limit<0 && pane.match(/(south|east)/)) ? o.tips.maxSizeWarning : o.tips.minSizeWarning;
-					}
-					else {
-						ui.helper.removeClass( helperLimitClass +" "+ helperPaneLimitClass ); // not at dragging-limit
-						window.defaultStatus = "";
-					}
-					// DYNAMICALLY RESIZE PANES IF OPTION ENABLED
-					// won't trigger unless resizer has actually moved!
-					if (live && Math.abs(ui.position[side] - lastPos) >= o.liveResizingTolerance) {
-						lastPos = ui.position[side];
-						resizePanes(e, ui, pane)
-					}
-				}
-
-			,	stop: function (e, ui) {
-					$('body').enableSelection(); // RE-ENABLE TEXT SELECTION
-					window.defaultStatus = ""; // clear 'resizing limit' message from statusbar
-					$R.removeClass( resizerClass +" "+ resizerPaneClass ); // remove drag classes from Resizer
-					s.isResizing = false;
-					resizePanes(e, ui, pane, true, masks); // true = resizingDone
-				}
-
-			});
-		});
-
-		/**
-		* resizePanes
-		*
-		* Sub-routine called from stop() - and drag() if livePaneResizing
-		*
-		* @param {!Object}		evt
-		* @param {!Object}		ui
-		* @param {string}		pane
-		* @param {boolean=}		[resizingDone=false]
-		*/
-		var resizePanes = function (evt, ui, pane, resizingDone, masks) {
-			var	dragPos	= ui.position
-			,	c		= _c[pane]
-			,	o		= options[pane]
-			,	s		= state[pane]
-			,	resizerPos
-			;
-			switch (pane) {
-				case "north":	resizerPos = dragPos.top; break;
-				case "west":	resizerPos = dragPos.left; break;
-				case "south":	resizerPos = sC.offsetHeight - dragPos.top  - o.spacing_open; break;
-				case "east":	resizerPos = sC.offsetWidth  - dragPos.left - o.spacing_open; break;
-			};
-			// remove container margin from resizer position to get the pane size
-			var newSize = resizerPos - sC["inset"+ c.side];
-
-			// Disable OR Resize Mask(s) created in drag.start
-			if (!resizingDone) {
-				// ensure we meet liveResizingTolerance criteria
-				if (Math.abs(newSize - s.size) < o.liveResizingTolerance)
-					return; // SKIP resize this time
-				// resize the pane
-				manualSizePane(pane, newSize, false, true); // true = noAnimation
-				sizeMasks(); // resize all visible masks
-			}
-			else { // resizingDone
-				// ondrag_end callback
-				if (false !== _runCallbacks("ondrag_end", pane))
-					manualSizePane(pane, newSize, false, true); // true = noAnimation
-				hideMasks(); // hide all masks, which include panes with 'content/iframe-masks'
-				if (s.isSliding && masks) // RE-SHOW only 'object-masks' so objects won't show through sliding pane
-					showMasks( masks, true ); // true = onlyForObjects
-			}
-		};
-	}
-
-	/**
-	 *	sizeMask
-	 *
-	 *	Needed to overlay a DIV over an IFRAME-pane because mask CANNOT be *inside* the pane
-	 *	Called when mask created, and during livePaneResizing
-	 */
-,	sizeMask = function () {
-		var $M		= $(this)
-		,	pane	= $M.data("layoutMask") // eg: "west"
-		,	s		= state[pane]
-		;
-		// only masks over an IFRAME-pane need manual resizing
-		if (s.tagName == "IFRAME" && s.isVisible) // no need to mask closed/hidden panes
-			$M.css({
-				top:	s.offsetTop
-			,	left:	s.offsetLeft
-			,	width:	s.outerWidth
-			,	height:	s.outerHeight
-			});
-		/* ALT Method...
-		var $P = $Ps[pane];
-		$M.css( $P.position() ).css({ width: $P[0].offsetWidth, height: $P[0].offsetHeight });
-		*/
-	}
-,	sizeMasks = function () {
-		$Ms.each( sizeMask ); // resize all 'visible' masks
-	}
-
-,	showMasks = function (panes, onlyForObjects) {
-		var a	= panes ? panes.split(",") : $.layout.config.allPanes
-		,	z	= options.zIndexes
-		,	o, s;
-		$.each(a, function(i,p){
-			s = state[p];
-			o = options[p];
-			if (s.isVisible && ( (!onlyForObjects && o.maskContents) || o.maskObjects )) {
-				getMasks(p).each(function(){
-					sizeMask.call(this);
-					this.style.zIndex = s.isSliding ? z.pane_sliding+1 : z.pane_normal+1
-					this.style.display = "block";
-				});
-			}
-		});
-	}
-
-,	hideMasks = function () {
-		// ensure no pane is resizing - could be a timing issue
-		var skip;
-		$.each( $.layout.config.borderPanes, function(i,p){
-			if (state[p].isResizing) {
-				skip = true;
-				return false; // BREAK
-			}
-		});
-		if (!skip)
-			$Ms.hide(); // hide ALL masks
-	}
-
-,	getMasks = function (pane) {
-		var $Masks	= $([])
-		,	$M, i = 0, c = $Ms.length
-		;
-		for (; i<c; i++) {
-			$M = $Ms.eq(i);
-			if ($M.data("layoutMask") === pane)
-				$Masks = $Masks.add( $M );
-		}
-		if ($Masks.length)
-			return $Masks;
-		else
-			return createMasks(pane);
-	}
-
-	/**
-	 *	createMasks
-	 *
-	 *	Generates both DIV (ALWAYS used) and IFRAME (optional) elements as masks
-	 *	An IFRAME mask is created *under* the DIV when maskObjects=true, because a DIV cannot mask an applet
-	 */
-,	createMasks = function (pane) {
-		var
-			$P		= $Ps[pane]
-		,	s		= state[pane]
-		,	o		= options[pane]
-		,	z		= options.zIndexes
-		//,	objMask	= o.maskObjects && s.tagName != "IFRAME" // check for option
-		,	$Masks	= $([])
-		,	isIframe, el, $M, css, i
-		;
-		if (!o.maskContents && !o.maskObjects) return $Masks;
-		// if o.maskObjects=true, then loop TWICE to create BOTH kinds of mask, else only create a DIV
-		for (i=0; i < (o.maskObjects ? 2 : 1); i++) {
-			isIframe = o.maskObjects && i==0;
-			el = document.createElement( isIframe ? "iframe" : "div" );
-			$M = $(el).data("layoutMask", pane); // add data to relate mask to pane
-			el.className = "ui-layout-mask ui-layout-mask-"+ pane; // for user styling
-			css = el.style;
-			// styles common to both DIVs and IFRAMES
-			css.display		= "block";
-			css.position	= "absolute";
-			if (isIframe) { // IFRAME-only props
-				el.frameborder = 0;
-				el.src		= "about:blank";
-				css.opacity	= 0;
-				css.filter	= "Alpha(Opacity='0')";
-				css.border	= 0;
-			}
-			// if pane is an IFRAME, then must mask the pane itself
-			if (s.tagName == "IFRAME") {
-				// NOTE sizing done by a subroutine so can be called during live-resizing
-				css.zIndex	= z.pane_normal+1; // 1-higher than pane
-				$N.append( el ); // append to LAYOUT CONTAINER
-			}
-			// otherwise put masks *inside the pane* to mask its contents
-			else {
-				$M.addClass("ui-layout-mask-inside-pane");
-				css.zIndex	= o.maskZindex || z.content_mask; // usually 1, but customizable
-				css.top		= 0;
-				css.left	= 0;
-				css.width	= "100%";
-				css.height	= "100%";
-				$P.append( el ); // append INSIDE pane element
-			}
-			// add to return object
-			$Masks = $Masks.add( el );
-			// add Mask to cached array so can be resized & reused
-			$Ms = $Ms.add( el );
-		}
-		return $Masks;
-	}
-
-
-	/**
-	* Destroy this layout and reset all elements
-	*
-	* @param {boolean=}	[destroyChildren=false]		Destory Child-Layouts first?
-	*/
-,	destroy = function (evt_or_destroyChildren, destroyChildren) {
-		// UNBIND layout events and remove global object
-		$(window).unbind("."+ sID);		// resize & unload
-		$(document).unbind("."+ sID);	// keyDown (hotkeys)
-
-		if (typeof evt_or_destroyChildren === "object")
-			// stopPropagation if called by trigger("layoutdestroy") - use evtPane utility 
-			evtPane(evt_or_destroyChildren);
-		else // no event, so transfer 1st param to destroyChildren param
-			destroyChildren = evt_or_destroyChildren;
-
-		// need to look for parent layout BEFORE we remove the container data, else skips a level
-		//var parentPane = Instance.hasParentLayout ? $.layout.getParentPaneInstance( $N ) : null;
-
-		// reset layout-container
-		$N	.clearQueue()
-			.removeData("layout")
-			.removeData("layoutContainer")
-			.removeClass(options.containerClass)
-			.unbind("."+ sID) // remove ALL Layout events
-		;
-
-		// remove all mask elements that have been created
-		$Ms.remove();
-
-		// loop all panes to remove layout classes, attributes and bindings
-		$.each(_c.allPanes, function (i, pane) {
-			removePane( pane, false, true, destroyChildren ); // true = skipResize
-		});
-
-		// do NOT reset container CSS if is a 'pane' (or 'content') in an outer-layout - ie, THIS layout is 'nested'
-		var css = "layoutCSS";
-		if ($N.data(css) && !$N.data("layoutRole")) // RESET CSS
-			$N.css( $N.data(css) ).removeData(css);
-
-		// for full-page layouts, also reset the <HTML> CSS
-		if (sC.tagName === "BODY" && ($N = $("html")).data(css)) // RESET <HTML> CSS
-			$N.css( $N.data(css) ).removeData(css);
-
-		// trigger plugins for this layout, if there are any
-		runPluginCallbacks( Instance, $.layout.onDestroy );
-
-		// trigger state-management and onunload callback
-		unload();
-
-		// clear the Instance of everything except for container & options (so could recreate)
-		// RE-CREATE: myLayout = myLayout.container.layout( myLayout.options );
-		for (n in Instance)
-			if (!n.match(/^(container|options)$/)) delete Instance[ n ];
-		// add a 'destroyed' flag to make it easy to check
-		Instance.destroyed = true;
-
-		// if this is a child layout, CLEAR the child-pointer in the parent
-		/* for now the pointer REMAINS, but with only container, options and destroyed keys
-		if (parentPane) {
-			var layout = parentPane.pane.data("parentLayout");
-			parentPane.child = layout.children[ parentPane.name ] = null;
-		}
-		*/
-
-		return Instance; // for coding convenience
-	}
-
-	/**
-	* Remove a pane from the layout - subroutine of destroy()
-	*
-	* @see  destroy()
-	* @param {string|Object}	evt_or_pane			The pane to process
-	* @param {boolean=}			[remove=false]		Remove the DOM element?
-	* @param {boolean=}			[skipResize=false]	Skip calling resizeAll()?
-	* @param {boolean=}			[destroyChild=true]	Destroy Child-layouts? If not passed, obeys options setting
-	*/
-,	removePane = function (evt_or_pane, remove, skipResize, destroyChild) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	$P	= $Ps[pane]
-		,	$C	= $Cs[pane]
-		,	$R	= $Rs[pane]
-		,	$T	= $Ts[pane]
-		;
-		// NOTE: elements can still exist even after remove()
-		//		so check for missing data(), which is cleared by removed()
-		if ($P && $.isEmptyObject( $P.data() )) $P = false;
-		if ($C && $.isEmptyObject( $C.data() )) $C = false;
-		if ($R && $.isEmptyObject( $R.data() )) $R = false;
-		if ($T && $.isEmptyObject( $T.data() )) $T = false;
-
-		if ($P) $P.stop(true, true);
-
-		//	check for a child layout
-		var	o	= options[pane]
-		,	s	= state[pane]
-		,	d	= "layout"
-		,	css	= "layoutCSS"
-		,	child	= children[pane] || ($P ? $P.data(d) : 0) || ($C ? $C.data(d) : 0) || null
-		,	destroy	= destroyChild !== undefined ? destroyChild : o.destroyChildLayout
-		;
-
-		// FIRST destroy the child-layout(s)
-		if (destroy && child && !child.destroyed) {
-			child.destroy(true);	// tell child-layout to destroy ALL its child-layouts too
-			if (child.destroyed)	// destroy was successful
-				child = null;		// clear pointer for logic below 
-		}
-
-		if ($P && remove && !child)
-			$P.remove();
-		else if ($P && $P[0]) {
-			//	create list of ALL pane-classes that need to be removed
-			var	root	= o.paneClass // default="ui-layout-pane"
-			,	pRoot	= root +"-"+ pane // eg: "ui-layout-pane-west"
-			,	_open	= "-open"
-			,	_sliding= "-sliding"
-			,	_closed	= "-closed"
-			,	classes	= [	root, root+_open, root+_closed, root+_sliding,		// generic classes
-							pRoot, pRoot+_open, pRoot+_closed, pRoot+_sliding ]	// pane-specific classes
-			;
-			$.merge(classes, getHoverClasses($P, true)); // ADD hover-classes
-			// remove all Layout classes from pane-element
-			$P	.removeClass( classes.join(" ") ) // remove ALL pane-classes
-				.removeData("parentLayout")
-				.removeData("layoutPane")
-				.removeData("layoutRole")
-				.removeData("layoutEdge")
-				.removeData("autoHidden")	// in case set
-				.unbind("."+ sID) // remove ALL Layout events
-				// TODO: remove these extra unbind commands when jQuery is fixed
-				//.unbind("mouseenter"+ sID)
-				//.unbind("mouseleave"+ sID)
-			;
-			// do NOT reset CSS if this pane/content is STILL the container of a nested layout!
-			// the nested layout will reset its 'container' CSS when/if it is destroyed
-			if ($C && $C.data(d)) {
-				// a content-div may not have a specific width, so give it one to contain the Layout
-				$C.width( $C.width() );
-				child.resizeAll(); // now resize the Layout
-			}
-			else if ($C)
-				$C.css( $C.data(css) ).removeData(css).removeData("layoutRole");
-			// remove pane AFTER content in case there was a nested layout
-			if (!$P.data(d))
-				$P.css( $P.data(css) ).removeData(css);
-		}
-
-		// REMOVE pane resizer and toggler elements
-		if ($T) $T.remove();
-		if ($R) $R.remove();
-
-		// CLEAR all pointers and state data
-		Instance[pane] = $Ps[pane] = $Cs[pane] = $Rs[pane] = $Ts[pane] = children[pane] = false;
-		s = { removed: true };
-
-		if (!skipResize)
-			resizeAll();
-	}
-
-
-/*
- * ###########################
- *	   ACTION METHODS
- * ###########################
- */
-
-,	_hidePane = function (pane) {
-		var $P	= $Ps[pane]
-		,	o	= options[pane]
-		,	s	= $P[0].style
-		;
-		if (o.useOffscreenClose) {
-			if (!$P.data(_c.offscreenReset))
-				$P.data(_c.offscreenReset, { left: s.left, right: s.right });
-			$P.css( _c.offscreenCSS );
-		}
-		else
-			$P.hide().removeData(_c.offscreenReset);
-	}
-
-,	_showPane = function (pane) {
-		var $P	= $Ps[pane]
-		,	o	= options[pane]
-		,	off	= _c.offscreenCSS
-		,	old	= $P.data(_c.offscreenReset)
-		,	s	= $P[0].style
-		;
-		$P	.show() // ALWAYS show, just in case
-			.removeData(_c.offscreenReset);
-		if (o.useOffscreenClose && old) {
-			if (s.left == off.left)
-				s.left = old.left;
-			if (s.right == off.right)
-				s.right = old.right;
-		}
-	}
-
-
-	/**
-	* Completely 'hides' a pane, including its spacing - as if it does not exist
-	* The pane is not actually 'removed' from the source, so can use 'show' to un-hide it
-	*
-	* @param {string|Object}	evt_or_pane			The pane being hidden, ie: north, south, east, or west
-	* @param {boolean=}			[noAnimation=false]	
-	*/
-,	hide = function (evt_or_pane, noAnimation) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	o	= options[pane]
-		,	s	= state[pane]
-		,	$P	= $Ps[pane]
-		,	$R	= $Rs[pane]
-		;
-		if (!$P || s.isHidden) return; // pane does not exist OR is already hidden
-
-		// onhide_start callback - will CANCEL hide if returns false
-		if (state.initialized && false === _runCallbacks("onhide_start", pane)) return;
-
-		s.isSliding = false; // just in case
-
-		// now hide the elements
-		if ($R) $R.hide(); // hide resizer-bar
-		if (!state.initialized || s.isClosed) {
-			s.isClosed = true; // to trigger open-animation on show()
-			s.isHidden  = true;
-			s.isVisible = false;
-			if (!state.initialized)
-				_hidePane(pane); // no animation when loading page
-			sizeMidPanes(_c[pane].dir === "horz" ? "" : "center");
-			if (state.initialized || o.triggerEventsOnLoad)
-				_runCallbacks("onhide_end", pane);
-		}
-		else {
-			s.isHiding = true; // used by onclose
-			close(pane, false, noAnimation); // adjust all panes to fit
-		}
-	}
-
-	/**
-	* Show a hidden pane - show as 'closed' by default unless openPane = true
-	*
-	* @param {string|Object}	evt_or_pane			The pane being opened, ie: north, south, east, or west
-	* @param {boolean=}			[openPane=false]
-	* @param {boolean=}			[noAnimation=false]
-	* @param {boolean=}			[noAlert=false]
-	*/
-,	show = function (evt_or_pane, openPane, noAnimation, noAlert) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	o	= options[pane]
-		,	s	= state[pane]
-		,	$P	= $Ps[pane]
-		,	$R	= $Rs[pane]
-		;
-		if (!$P || !s.isHidden) return; // pane does not exist OR is not hidden
-
-		// onshow_start callback - will CANCEL show if returns false
-		if (false === _runCallbacks("onshow_start", pane)) return;
-
-		s.isSliding = false; // just in case
-		s.isShowing = true; // used by onopen/onclose
-		//s.isHidden  = false; - will be set by open/close - if not cancelled
-
-		// now show the elements
-		//if ($R) $R.show(); - will be shown by open/close
-		if (openPane === false)
-			close(pane, true); // true = force
-		else
-			open(pane, false, noAnimation, noAlert); // adjust all panes to fit
-	}
-
-
-	/**
-	* Toggles a pane open/closed by calling either open or close
-	*
-	* @param {string|Object}	evt_or_pane		The pane being toggled, ie: north, south, east, or west
-	* @param {boolean=}			[slide=false]
-	*/
-,	toggle = function (evt_or_pane, slide) {
-		if (!isInitialized()) return;
-		var	evt		= evtObj(evt_or_pane)
-		,	pane	= evtPane.call(this, evt_or_pane)
-		,	s		= state[pane]
-		;
-		if (evt) // called from to $R.dblclick OR triggerPaneEvent
-			evt.stopImmediatePropagation();
-		if (s.isHidden)
-			show(pane); // will call 'open' after unhiding it
-		else if (s.isClosed)
-			open(pane, !!slide);
-		else
-			close(pane);
-	}
-
-
-	/**
-	* Utility method used during init or other auto-processes
-	*
-	* @param {string}	pane   The pane being closed
-	* @param {boolean=}	[setHandles=false]
-	*/
-,	_closePane = function (pane, setHandles) {
-		var
-			$P	= $Ps[pane]
-		,	s	= state[pane]
-		;
-		_hidePane(pane);
-		s.isClosed = true;
-		s.isVisible = false;
-		// UNUSED: if (setHandles) setAsClosed(pane, true); // true = force
-	}
-
-	/**
-	* Close the specified pane (animation optional), and resize all other panes as needed
-	*
-	* @param {string|Object}	evt_or_pane			The pane being closed, ie: north, south, east, or west
-	* @param {boolean=}			[force=false]
-	* @param {boolean=}			[noAnimation=false]
-	* @param {boolean=}			[skipCallback=false]
-	*/
-,	close = function (evt_or_pane, force, noAnimation, skipCallback) {
-		var	pane = evtPane.call(this, evt_or_pane);
-		// if pane has been initialized, but NOT the complete layout, close pane instantly
-		if (!state.initialized && $Ps[pane]) {
-			_closePane(pane); // INIT pane as closed
-			return;
-		}
-		if (!isInitialized()) return;
-
-		var
-			$P	= $Ps[pane]
-		,	$R	= $Rs[pane]
-		,	$T	= $Ts[pane]
-		,	o	= options[pane]
-		,	s	= state[pane]
-		,	c	= _c[pane]
-		,	doFX, isShowing, isHiding, wasSliding;
-
-		// QUEUE in case another action/animation is in progress
-		$N.queue(function( queueNext ){
-	
-			if ( !$P
-			||	(!o.closable && !s.isShowing && !s.isHiding)	// invalid request // (!o.resizable && !o.closable) ???
-			||	(!force && s.isClosed && !s.isShowing)			// already closed
-			) return queueNext();
-
-			// onclose_start callback - will CANCEL hide if returns false
-			// SKIP if just 'showing' a hidden pane as 'closed'
-			var abort = !s.isShowing && false === _runCallbacks("onclose_start", pane);
-
-			// transfer logic vars to temp vars
-			isShowing	= s.isShowing;
-			isHiding	= s.isHiding;
-			wasSliding	= s.isSliding;
-			// now clear the logic vars (REQUIRED before aborting)
-			delete s.isShowing;
-			delete s.isHiding;
-
-			if (abort) return queueNext();
-
-			doFX		= !noAnimation && !s.isClosed && (o.fxName_close != "none");
-			s.isMoving	= true;
-			s.isClosed	= true;
-			s.isVisible	= false;
-			// update isHidden BEFORE sizing panes
-			if (isHiding) s.isHidden = true;
-			else if (isShowing) s.isHidden = false;
-
-			if (s.isSliding) // pane is being closed, so UNBIND trigger events
-				bindStopSlidingEvents(pane, false); // will set isSliding=false
-			else // resize panes adjacent to this one
-				sizeMidPanes(_c[pane].dir === "horz" ? "" : "center", false); // false = NOT skipCallback
-
-			// if this pane has a resizer bar, move it NOW - before animation
-			setAsClosed(pane);
-
-			// CLOSE THE PANE
-			if (doFX) { // animate the close
-				// mask panes with objects
-				var masks = "center"+ (c.dir=="horz" ? ",west,east" : "");
-				showMasks( masks, true );	// true = ONLY mask panes with maskObjects=true
-				lockPaneForFX(pane, true);	// need to set left/top so animation will work
-				$P.hide( o.fxName_close, o.fxSettings_close, o.fxSpeed_close, function () {
-					lockPaneForFX(pane, false); // undo
-					if (s.isClosed) close_2();
-					queueNext();
-				});
-			}
-			else { // hide the pane without animation
-				_hidePane(pane);
-				close_2();
-				queueNext();
-			};
-		});
-
-		// SUBROUTINE
-		function close_2 () {
-			s.isMoving	= false;
-			bindStartSlidingEvent(pane, true); // will enable if o.slidable = true
-
-			// if opposite-pane was autoClosed, see if it can be autoOpened now
-			var altPane = _c.oppositeEdge[pane];
-			if (state[ altPane ].noRoom) {
-				setSizeLimits( altPane );
-				makePaneFit( altPane );
-			}
-
-			// hide any masks shown while closing
-			hideMasks();
-
-			if (!skipCallback && (state.initialized || o.triggerEventsOnLoad)) {
-				// onclose callback - UNLESS just 'showing' a hidden pane as 'closed'
-				if (!isShowing)	_runCallbacks("onclose_end", pane);
-				// onhide OR onshow callback
-				if (isShowing)	_runCallbacks("onshow_end", pane);
-				if (isHiding)	_runCallbacks("onhide_end", pane);
-			}
-		}
-	}
-
-	/**
-	* @param {string}	pane	The pane just closed, ie: north, south, east, or west
-	*/
-,	setAsClosed = function (pane) {
-		var
-			$P		= $Ps[pane]
-		,	$R		= $Rs[pane]
-		,	$T		= $Ts[pane]
-		,	o		= options[pane]
-		,	s		= state[pane]
-		,	side	= _c[pane].side.toLowerCase()
-		,	inset	= "inset"+ _c[pane].side
-		,	rClass	= o.resizerClass
-		,	tClass	= o.togglerClass
-		,	_pane	= "-"+ pane // used for classNames
-		,	_open	= "-open"
-		,	_sliding= "-sliding"
-		,	_closed	= "-closed"
-		;
-		$R
-			.css(side, sC[inset]) // move the resizer
-			.removeClass( rClass+_open +" "+ rClass+_pane+_open )
-			.removeClass( rClass+_sliding +" "+ rClass+_pane+_sliding )
-			.addClass( rClass+_closed +" "+ rClass+_pane+_closed )
-			.unbind("dblclick."+ sID)
-		;
-		// DISABLE 'resizing' when closed - do this BEFORE bindStartSlidingEvent?
-		if (o.resizable && $.layout.plugins.draggable)
-			$R
-				.draggable("disable")
-				.removeClass("ui-state-disabled") // do NOT apply disabled styling - not suitable here
-				.css("cursor", "default")
-				.attr("title","")
-			;
-
-		// if pane has a toggler button, adjust that too
-		if ($T) {
-			$T
-				.removeClass( tClass+_open +" "+ tClass+_pane+_open )
-				.addClass( tClass+_closed +" "+ tClass+_pane+_closed )
-				.attr("title", o.tips.Open) // may be blank
-			;
-			// toggler-content - if exists
-			$T.children(".content-open").hide();
-			$T.children(".content-closed").css("display","block");
-		}
-
-		// sync any 'pin buttons'
-		syncPinBtns(pane, false);
-
-		if (state.initialized) {
-			// resize 'length' and position togglers for adjacent panes
-			sizeHandles();
-		}
-	}
-
-	/**
-	* Open the specified pane (animation optional), and resize all other panes as needed
-	*
-	* @param {string|Object}	evt_or_pane			The pane being opened, ie: north, south, east, or west
-	* @param {boolean=}			[slide=false]
-	* @param {boolean=}			[noAnimation=false]
-	* @param {boolean=}			[noAlert=false]
-	*/
-,	open = function (evt_or_pane, slide, noAnimation, noAlert) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	$P	= $Ps[pane]
-		,	$R	= $Rs[pane]
-		,	$T	= $Ts[pane]
-		,	o	= options[pane]
-		,	s	= state[pane]
-		,	c	= _c[pane]
-		,	doFX, isShowing
-		;
-		// QUEUE in case another action/animation is in progress
-		$N.queue(function( queueNext ){
-
-			if ( !$P
-			||	(!o.resizable && !o.closable && !s.isShowing)	// invalid request
-			||	(s.isVisible && !s.isSliding)					// already open
-			) return queueNext();
-
-			// pane can ALSO be unhidden by just calling show(), so handle this scenario
-			if (s.isHidden && !s.isShowing) {
-				queueNext(); // call before show() because it needs the queue free
-				show(pane, true);
-				return;
-			}
-
-			if (o.autoResize && s.size != o.size) // resize pane to original size set in options
-				sizePane(pane, o.size, true, true, true); // true=skipCallback/forceResize/noAnimation
-			else
-				// make sure there is enough space available to open the pane
-				setSizeLimits(pane, slide);
-
-			// onopen_start callback - will CANCEL open if returns false
-			var cbReturn = _runCallbacks("onopen_start", pane);
-
-			if (cbReturn === "abort")
-				return queueNext();
-
-			// update pane-state again in case options were changed in onopen_start
-			if (cbReturn !== "NC") // NC = "No Callback"
-				setSizeLimits(pane, slide);
-
-			if (s.minSize > s.maxSize) { // INSUFFICIENT ROOM FOR PANE TO OPEN!
-				syncPinBtns(pane, false); // make sure pin-buttons are reset
-				if (!noAlert && o.tips.noRoomToOpen)
-					alert(o.tips.noRoomToOpen);
-				return queueNext(); // ABORT
-			}
-
-			if (slide) // START Sliding - will set isSliding=true
-				bindStopSlidingEvents(pane, true); // BIND trigger events to close sliding-pane
-			else if (s.isSliding) // PIN PANE (stop sliding) - open pane 'normally' instead
-				bindStopSlidingEvents(pane, false); // UNBIND trigger events - will set isSliding=false
-			else if (o.slidable)
-				bindStartSlidingEvent(pane, false); // UNBIND trigger events
-
-			s.noRoom = false; // will be reset by makePaneFit if 'noRoom'
-			makePaneFit(pane);
-
-			// transfer logic var to temp var
-			isShowing = s.isShowing;
-			// now clear the logic var
-			delete s.isShowing;
-
-			doFX		= !noAnimation && s.isClosed && (o.fxName_open != "none");
-			s.isMoving	= true;
-			s.isVisible	= true;
-			s.isClosed	= false;
-			// update isHidden BEFORE sizing panes - WHY??? Old?
-			if (isShowing) s.isHidden = false;
-
-			if (doFX) { // ANIMATE
-				// mask panes with objects
-				var masks = "center"+ (c.dir=="horz" ? ",west,east" : "");
-				if (s.isSliding) masks += ","+ _c.oppositeEdge[pane];
-				showMasks( masks, true );	// true = ONLY mask panes with maskObjects=true
-				lockPaneForFX(pane, true);	// need to set left/top so animation will work
-				$P.show( o.fxName_open, o.fxSettings_open, o.fxSpeed_open, function() {
-					lockPaneForFX(pane, false); // undo
-					if (s.isVisible) open_2(); // continue
-					queueNext();
-				});
-			}
-			else { // no animation
-				_showPane(pane);// just show pane and...
-				open_2();		// continue
-				queueNext();
-			};
-		});
-
-		// SUBROUTINE
-		function open_2 () {
-			s.isMoving	= false;
-
-			// cure iframe display issues
-			_fixIframe(pane);
-
-			// NOTE: if isSliding, then other panes are NOT 'resized'
-			if (!s.isSliding) { // resize all panes adjacent to this one
-				hideMasks(); // remove any masks shown while opening
-				sizeMidPanes(_c[pane].dir=="vert" ? "center" : "", false); // false = NOT skipCallback
-			}
-
-			// set classes, position handles and execute callbacks...
-			setAsOpen(pane);
-		};
-	
-	}
-
-	/**
-	* @param {string}	pane		The pane just opened, ie: north, south, east, or west
-	* @param {boolean=}	[skipCallback=false]
-	*/
-,	setAsOpen = function (pane, skipCallback) {
-		var 
-			$P		= $Ps[pane]
-		,	$R		= $Rs[pane]
-		,	$T		= $Ts[pane]
-		,	o		= options[pane]
-		,	s		= state[pane]
-		,	side	= _c[pane].side.toLowerCase()
-		,	inset	= "inset"+ _c[pane].side
-		,	rClass	= o.resizerClass
-		,	tClass	= o.togglerClass
-		,	_pane	= "-"+ pane // used for classNames
-		,	_open	= "-open"
-		,	_closed	= "-closed"
-		,	_sliding= "-sliding"
-		;
-		$R
-			.css(side, sC[inset] + getPaneSize(pane)) // move the resizer
-			.removeClass( rClass+_closed +" "+ rClass+_pane+_closed )
-			.addClass( rClass+_open +" "+ rClass+_pane+_open )
-		;
-		if (s.isSliding)
-			$R.addClass( rClass+_sliding +" "+ rClass+_pane+_sliding )
-		else // in case 'was sliding'
-			$R.removeClass( rClass+_sliding +" "+ rClass+_pane+_sliding )
-
-		if (o.resizerDblClickToggle)
-			$R.bind("dblclick", toggle );
-		removeHover( 0, $R ); // remove hover classes
-		if (o.resizable && $.layout.plugins.draggable)
-			$R	.draggable("enable")
-				.css("cursor", o.resizerCursor)
-				.attr("title", o.tips.Resize);
-		else if (!s.isSliding)
-			$R.css("cursor", "default"); // n-resize, s-resize, etc
-
-		// if pane also has a toggler button, adjust that too
-		if ($T) {
-			$T	.removeClass( tClass+_closed +" "+ tClass+_pane+_closed )
-				.addClass( tClass+_open +" "+ tClass+_pane+_open )
-				.attr("title", o.tips.Close); // may be blank
-			removeHover( 0, $T ); // remove hover classes
-			// toggler-content - if exists
-			$T.children(".content-closed").hide();
-			$T.children(".content-open").css("display","block");
-		}
-
-		// sync any 'pin buttons'
-		syncPinBtns(pane, !s.isSliding);
-
-		// update pane-state dimensions - BEFORE resizing content
-		$.extend(s, elDims($P));
-
-		if (state.initialized) {
-			// resize resizer & toggler sizes for all panes
-			sizeHandles();
-			// resize content every time pane opens - to be sure
-			sizeContent(pane, true); // true = remeasure headers/footers, even if 'pane.isMoving'
-		}
-
-		if (!skipCallback && (state.initialized || o.triggerEventsOnLoad) && $P.is(":visible")) {
-			// onopen callback
-			_runCallbacks("onopen_end", pane);
-			// onshow callback - TODO: should this be here?
-			if (s.isShowing) _runCallbacks("onshow_end", pane);
-
-			// ALSO call onresize because layout-size *may* have changed while pane was closed
-			if (state.initialized)
-				_runCallbacks("onresize_end", pane);
-		}
-
-		// TODO: Somehow sizePane("north") is being called after this point???
-	}
-
-
-	/**
-	* slideOpen / slideClose / slideToggle
-	*
-	* Pass-though methods for sliding
-	*/
-,	slideOpen = function (evt_or_pane) {
-		if (!isInitialized()) return;
-		var	evt		= evtObj(evt_or_pane)
-		,	pane	= evtPane.call(this, evt_or_pane)
-		,	s		= state[pane]
-		,	delay	= options[pane].slideDelay_open
-		;
-		// prevent event from triggering on NEW resizer binding created below
-		if (evt) evt.stopImmediatePropagation();
-
-		if (s.isClosed && evt && evt.type === "mouseenter" && delay > 0)
-			// trigger = mouseenter - use a delay
-			timer.set(pane+"_openSlider", open_NOW, delay);
-		else
-			open_NOW(); // will unbind events if is already open
-
-		/**
-		* SUBROUTINE for timed open
-		*/
-		function open_NOW () {
-			if (!s.isClosed) // skip if no longer closed!
-				bindStopSlidingEvents(pane, true); // BIND trigger events to close sliding-pane
-			else if (!s.isMoving)
-				open(pane, true); // true = slide - open() will handle binding
-		};
-	}
-
-,	slideClose = function (evt_or_pane) {
-		if (!isInitialized()) return;
-		var	evt		= evtObj(evt_or_pane)
-		,	pane	= evtPane.call(this, evt_or_pane)
-		,	o		= options[pane]
-		,	s		= state[pane]
-		,	delay	= s.isMoving ? 1000 : 300 // MINIMUM delay - option may override
-		;
-		if (s.isClosed || s.isResizing)
-			return; // skip if already closed OR in process of resizing
-		else if (o.slideTrigger_close === "click")
-			close_NOW(); // close immediately onClick
-		else if (o.preventQuickSlideClose && s.isMoving)
-			return; // handle Chrome quick-close on slide-open
-		else if (o.preventPrematureSlideClose && evt && $.layout.isMouseOverElem(evt, $Ps[pane]))
-			return; // handle incorrect mouseleave trigger, like when over a SELECT-list in IE
-		else if (evt) // trigger = mouseleave - use a delay
-			// 1 sec delay if 'opening', else .3 sec
-			timer.set(pane+"_closeSlider", close_NOW, max(o.slideDelay_close, delay));
-		else // called programically
-			close_NOW();
-
-		/**
-		* SUBROUTINE for timed close
-		*/
-		function close_NOW () {
-			if (s.isClosed) // skip 'close' if already closed!
-				bindStopSlidingEvents(pane, false); // UNBIND trigger events - TODO: is this needed here?
-			else if (!s.isMoving)
-				close(pane); // close will handle unbinding
-		};
-	}
-
-	/**
-	* @param {string|Object}	evt_or_pane		The pane being opened, ie: north, south, east, or west
-	*/
-,	slideToggle = function (evt_or_pane) {
-		var pane = evtPane.call(this, evt_or_pane);
-		toggle(pane, true);
-	}
-
-
-	/**
-	* Must set left/top on East/South panes so animation will work properly
-	*
-	* @param {string}	pane	The pane to lock, 'east' or 'south' - any other is ignored!
-	* @param {boolean}	doLock  true = set left/top, false = remove
-	*/
-,	lockPaneForFX = function (pane, doLock) {
-		var $P	= $Ps[pane]
-		,	s	= state[pane]
-		,	o	= options[pane]
-		,	z	= options.zIndexes
-		;
-		if (doLock) {
-			$P.css({ zIndex: z.pane_animate }); // overlay all elements during animation
-			if (pane=="south")
-				$P.css({ top: sC.insetTop + sC.innerHeight - $P.outerHeight() });
-			else if (pane=="east")
-				$P.css({ left: sC.insetLeft + sC.innerWidth - $P.outerWidth() });
-		}
-		else { // animation DONE - RESET CSS
-			// TODO: see if this can be deleted. It causes a quick-close when sliding in Chrome
-			$P.css({ zIndex: (s.isSliding ? z.pane_sliding : z.pane_normal) });
-			if (pane=="south")
-				$P.css({ top: "auto" });
-			// if pane is positioned 'off-screen', then DO NOT screw with it!
-			else if (pane=="east" && !$P.css("left").match(/\-99999/))
-				$P.css({ left: "auto" });
-			// fix anti-aliasing in IE - only needed for animations that change opacity
-			if (browser.msie && o.fxOpacityFix && o.fxName_open != "slide" && $P.css("filter") && $P.css("opacity") == 1)
-				$P[0].style.removeAttribute('filter');
-		}
-	}
-
-
-	/**
-	* Toggle sliding functionality of a specific pane on/off by adding removing 'slide open' trigger
-	*
-	* @see  open(), close()
-	* @param {string}	pane	The pane to enable/disable, 'north', 'south', etc.
-	* @param {boolean}	enable	Enable or Disable sliding?
-	*/
-,	bindStartSlidingEvent = function (pane, enable) {
-		var o		= options[pane]
-		,	$P		= $Ps[pane]
-		,	$R		= $Rs[pane]
-		,	evtName	= o.slideTrigger_open.toLowerCase()
-		;
-		if (!$R || (enable && !o.slidable)) return;
-
-		// make sure we have a valid event
-		if (evtName.match(/mouseover/))
-			evtName = o.slideTrigger_open = "mouseenter";
-		else if (!evtName.match(/(click|dblclick|mouseenter)/)) 
-			evtName = o.slideTrigger_open = "click";
-
-		$R
-			// add or remove event
-			[enable ? "bind" : "unbind"](evtName +'.'+ sID, slideOpen)
-			// set the appropriate cursor & title/tip
-			.css("cursor", enable ? o.sliderCursor : "default")
-			.attr("title", enable ? o.tips.Slide : "")
-		;
-	}
-
-	/**
-	* Add or remove 'mouseleave' events to 'slide close' when pane is 'sliding' open or closed
-	* Also increases zIndex when pane is sliding open
-	* See bindStartSlidingEvent for code to control 'slide open'
-	*
-	* @see  slideOpen(), slideClose()
-	* @param {string}	pane	The pane to process, 'north', 'south', etc.
-	* @param {boolean}	enable	Enable or Disable events?
-	*/
-,	bindStopSlidingEvents = function (pane, enable) {
-		var	o		= options[pane]
-		,	s		= state[pane]
-		,	c		= _c[pane]
-		,	z		= options.zIndexes
-		,	evtName	= o.slideTrigger_close.toLowerCase()
-		,	action	= (enable ? "bind" : "unbind")
-		,	$P		= $Ps[pane]
-		,	$R		= $Rs[pane]
-		;
-		s.isSliding = enable; // logic
-		timer.clear(pane+"_closeSlider"); // just in case
-
-		// remove 'slideOpen' event from resizer
-		// ALSO will raise the zIndex of the pane & resizer
-		if (enable) bindStartSlidingEvent(pane, false);
-
-		// RE/SET zIndex - increases when pane is sliding-open, resets to normal when not
-		$P.css("zIndex", enable ? z.pane_sliding : z.pane_normal);
-		$R.css("zIndex", enable ? z.pane_sliding+2 : z.resizer_normal); // NOTE: mask = pane_sliding+1
-
-		// make sure we have a valid event
-		if (!evtName.match(/(click|mouseleave)/))
-			evtName = o.slideTrigger_close = "mouseleave"; // also catches 'mouseout'
-
-		// add/remove slide triggers
-		$R[action](evtName, slideClose); // base event on resize
-		// need extra events for mouseleave
-		if (evtName === "mouseleave") {
-			// also close on pane.mouseleave
-			$P[action]("mouseleave."+ sID, slideClose);
-			// cancel timer when mouse moves between 'pane' and 'resizer'
-			$R[action]("mouseenter."+ sID, cancelMouseOut);
-			$P[action]("mouseenter."+ sID, cancelMouseOut);
-		}
-
-		if (!enable)
-			timer.clear(pane+"_closeSlider");
-		else if (evtName === "click" && !o.resizable) {
-			// IF pane is not resizable (which already has a cursor and tip) 
-			// then set the a cursor & title/tip on resizer when sliding
-			$R.css("cursor", enable ? o.sliderCursor : "default");
-			$R.attr("title", enable ? o.tips.Close : ""); // use Toggler-tip, eg: "Close Pane"
-		}
-
-		// SUBROUTINE for mouseleave timer clearing
-		function cancelMouseOut (evt) {
-			timer.clear(pane+"_closeSlider");
-			evt.stopPropagation();
-		}
-	}
-
-
-	/**
-	* Hides/closes a pane if there is insufficient room - reverses this when there is room again
-	* MUST have already called setSizeLimits() before calling this method
-	*
-	* @param {string}	pane					The pane being resized
-	* @param {boolean=}	[isOpening=false]		Called from onOpen?
-	* @param {boolean=}	[skipCallback=false]	Should the onresize callback be run?
-	* @param {boolean=}	[force=false]
-	*/
-,	makePaneFit = function (pane, isOpening, skipCallback, force) {
-		var
-			o	= options[pane]
-		,	s	= state[pane]
-		,	c	= _c[pane]
-		,	$P	= $Ps[pane]
-		,	$R	= $Rs[pane]
-		,	isSidePane 	= c.dir==="vert"
-		,	hasRoom		= false
-		;
-		// special handling for center & east/west panes
-		if (pane === "center" || (isSidePane && s.noVerticalRoom)) {
-			// see if there is enough room to display the pane
-			// ERROR: hasRoom = s.minHeight <= s.maxHeight && (isSidePane || s.minWidth <= s.maxWidth);
-			hasRoom = (s.maxHeight >= 0);
-			if (hasRoom && s.noRoom) { // previously hidden due to noRoom, so show now
-				_showPane(pane);
-				if ($R) $R.show();
-				s.isVisible = true;
-				s.noRoom = false;
-				if (isSidePane) s.noVerticalRoom = false;
-				_fixIframe(pane);
-			}
-			else if (!hasRoom && !s.noRoom) { // not currently hidden, so hide now
-				_hidePane(pane);
-				if ($R) $R.hide();
-				s.isVisible = false;
-				s.noRoom = true;
-			}
-		}
-
-		// see if there is enough room to fit the border-pane
-		if (pane === "center") {
-			// ignore center in this block
-		}
-		else if (s.minSize <= s.maxSize) { // pane CAN fit
-			hasRoom = true;
-			if (s.size > s.maxSize) // pane is too big - shrink it
-				sizePane(pane, s.maxSize, skipCallback, force, true); // true = noAnimation
-			else if (s.size < s.minSize) // pane is too small - enlarge it
-				sizePane(pane, s.minSize, skipCallback, force, true);
-			// need s.isVisible because new pseudoClose method keeps pane visible, but off-screen
-			else if ($R && s.isVisible && $P.is(":visible")) {
-				// make sure resizer-bar is positioned correctly
-				// handles situation where nested layout was 'hidden' when initialized
-				var	side = c.side.toLowerCase()
-				,	pos  = s.size + sC["inset"+ c.side]
-				;
-				if ($.layout.cssNum($R, side) != pos) $R.css( side, pos );
-			}
-
-			// if was previously hidden due to noRoom, then RESET because NOW there is room
-			if (s.noRoom) {
-				// s.noRoom state will be set by open or show
-				if (s.wasOpen && o.closable) {
-					if (o.autoReopen)
-						open(pane, false, true, true); // true = noAnimation, true = noAlert
-					else // leave the pane closed, so just update state
-						s.noRoom = false;
-				}
-				else
-					show(pane, s.wasOpen, true, true); // true = noAnimation, true = noAlert
-			}
-		}
-		else { // !hasRoom - pane CANNOT fit
-			if (!s.noRoom) { // pane not set as noRoom yet, so hide or close it now...
-				s.noRoom = true; // update state
-				s.wasOpen = !s.isClosed && !s.isSliding;
-				if (s.isClosed){} // SKIP
-				else if (o.closable) // 'close' if possible
-					close(pane, true, true); // true = force, true = noAnimation
-				else // 'hide' pane if cannot just be closed
-					hide(pane, true); // true = noAnimation
-			}
-		}
-	}
-
-
-	/**
-	* sizePane / manualSizePane
-	* sizePane is called only by internal methods whenever a pane needs to be resized
-	* manualSizePane is an exposed flow-through method allowing extra code when pane is 'manually resized'
-	*
-	* @param {string|Object}	evt_or_pane				The pane being resized
-	* @param {number}			size					The *desired* new size for this pane - will be validated
-	* @param {boolean=}			[skipCallback=false]	Should the onresize callback be run?
-	* @param {boolean=}			[noAnimation=false]
-	*/
-,	manualSizePane = function (evt_or_pane, size, skipCallback, noAnimation) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	o	= options[pane]
-		,	s	= state[pane]
-		//	if resizing callbacks have been delayed and resizing is now DONE, force resizing to complete...
-		,	forceResize = o.livePaneResizing && !s.isResizing
-		;
-		// ANY call to manualSizePane disables autoResize - ie, percentage sizing
-		o.autoResize = false;
-		// flow-through...
-		sizePane(pane, size, skipCallback, forceResize, noAnimation); // will animate resize if option enabled
-	}
-
-	/**
-	* @param {string|Object}	evt_or_pane				The pane being resized
-	* @param {number}			size					The *desired* new size for this pane - will be validated
-	* @param {boolean=}			[skipCallback=false]	Should the onresize callback be run?
-	* @param {boolean=}			[force=false]			Force resizing even if does not seem necessary
-	* @param {boolean=}			[noAnimation=false]
-	*/
-,	sizePane = function (evt_or_pane, size, skipCallback, force, noAnimation) {
-		if (!isInitialized()) return;
-		var	pane	= evtPane.call(this, evt_or_pane) // probably NEVER called from event?
-		,	o		= options[pane]
-		,	s		= state[pane]
-		,	$P		= $Ps[pane]
-		,	$R		= $Rs[pane]
-		,	side	= _c[pane].side.toLowerCase()
-		,	dimName	= _c[pane].sizeType.toLowerCase()
-		,	inset	= "inset"+ _c[pane].side
-		,	skipResizeWhileDragging = s.isResizing && !o.triggerEventsDuringLiveResize
-		,	doFX	= noAnimation !== true && o.animatePaneSizing
-		,	oldSize, newSize
-		;
-		// QUEUE in case another action/animation is in progress
-		$N.queue(function( queueNext ){
-			// calculate 'current' min/max sizes
-			setSizeLimits(pane); // update pane-state
-			oldSize = s.size;
-			size = _parseSize(pane, size); // handle percentages & auto
-			size = max(size, _parseSize(pane, o.minSize));
-			size = min(size, s.maxSize);
-			if (size < s.minSize) { // not enough room for pane!
-				queueNext(); // call before makePaneFit() because it needs the queue free
-				makePaneFit(pane, false, skipCallback);	// will hide or close pane
-				return;
-			}
-
-			// IF newSize is same as oldSize, then nothing to do - abort
-			if (!force && size === oldSize)
-				return queueNext();
-
-			// onresize_start callback CANNOT cancel resizing because this would break the layout!
-			if (!skipCallback && state.initialized && s.isVisible)
-				_runCallbacks("onresize_start", pane);
-
-			// resize the pane, and make sure its visible
-			newSize = cssSize(pane, size);
-
-			if (doFX && $P.is(":visible")) { // ANIMATE
-				var fx		= $.layout.effects.size[pane] || $.layout.effects.size.all
-				,	easing	= o.fxSettings_size.easing || fx.easing
-				,	z		= options.zIndexes
-				,	props	= {};
-				props[ dimName ] = newSize +'px';
-				s.isMoving = true;
-				// overlay all elements during animation
-				$P.css({ zIndex: z.pane_animate })
-				  .show().animate( props, o.fxSpeed_size, easing, function(){
-					// reset zIndex after animation
-					$P.css({ zIndex: (s.isSliding ? z.pane_sliding : z.pane_normal) });
-					s.isMoving = false;
-					sizePane_2(); // continue
-					queueNext();
-				});
-			}
-			else { // no animation
-				$P.css( dimName, newSize );	// resize pane
-				// if pane is visible, then 
-				if ($P.is(":visible"))
-					sizePane_2(); // continue
-				else {
-					// pane is NOT VISIBLE, so just update state data...
-					// when pane is *next opened*, it will have the new size
-					s.size = size;				// update state.size
-					$.extend(s, elDims($P));	// update state dimensions
-				}
-				queueNext();
-			};
-
-		});
-
-		// SUBROUTINE
-		function sizePane_2 () {
-			/*	Panes are sometimes not sized precisely in some browsers!?
-			 *	This code will resize the pane up to 3 times to nudge the pane to the correct size
-			 */
-			var	actual	= dimName==='width' ? $P.outerWidth() : $P.outerHeight()
-			,	tries	= [{
-						   	pane:		pane
-						,	count:		1
-						,	target:		size
-						,	actual:		actual
-						,	correct:	(size === actual)
-						,	attempt:	size
-						,	cssSize:	newSize
-						}]
-			,	lastTry = tries[0]
-			,	thisTry	= {}
-			,	msg		= 'Inaccurate size after resizing the '+ pane +'-pane.'
-			;
-			while ( !lastTry.correct ) {
-				thisTry = { pane: pane, count: lastTry.count+1, target: size };
-
-				if (lastTry.actual > size)
-					thisTry.attempt = max(0, lastTry.attempt - (lastTry.actual - size));
-				else // lastTry.actual < size
-					thisTry.attempt = max(0, lastTry.attempt + (size - lastTry.actual));
-
-				thisTry.cssSize = cssSize(pane, thisTry.attempt);
-				$P.css( dimName, thisTry.cssSize );
-
-				thisTry.actual	= dimName=='width' ? $P.outerWidth() : $P.outerHeight();
-				thisTry.correct	= (size === thisTry.actual);
-
-				// log attempts and alert the user of this *non-fatal error* (if showDebugMessages)
-				if ( tries.length === 1) {
-					_log(msg, false, true);
-					_log(lastTry, false, true);
-				}
-				_log(thisTry, false, true);
-				// after 4 tries, is as close as its gonna get!
-				if (tries.length > 3) break;
-
-				tries.push( thisTry );
-				lastTry = tries[ tries.length - 1 ];
-			}
-			// END TESTING CODE
-
-			// update pane-state dimensions
-			s.size	= size;
-			$.extend(s, elDims($P));
-
-			if (s.isVisible && $P.is(":visible")) {
-				// reposition the resizer-bar
-				if ($R) $R.css( side, size + sC[inset] );
-				// resize the content-div
-				sizeContent(pane);
-			}
-
-			if (!skipCallback && !skipResizeWhileDragging && state.initialized && s.isVisible)
-				_runCallbacks("onresize_end", pane);
-
-			// resize all the adjacent panes, and adjust their toggler buttons
-			// when skipCallback passed, it means the controlling method will handle 'other panes'
-			if (!skipCallback) {
-				// also no callback if live-resize is in progress and NOT triggerEventsDuringLiveResize
-				if (!s.isSliding) sizeMidPanes(_c[pane].dir=="horz" ? "" : "center", skipResizeWhileDragging, force);
-				sizeHandles();
-			}
-
-			// if opposite-pane was autoClosed, see if it can be autoOpened now
-			var altPane = _c.oppositeEdge[pane];
-			if (size < oldSize && state[ altPane ].noRoom) {
-				setSizeLimits( altPane );
-				makePaneFit( altPane, false, skipCallback );
-			}
-
-			// DEBUG - ALERT user/developer so they know there was a sizing problem
-			if (tries.length > 1)
-				_log(msg +'\nSee the Error Console for details.', true, true);
-		}
-	}
-
-	/**
-	* @see  initPanes(), sizePane(), resizeAll(), open(), close(), hide()
-	* @param {Array.<string>|string} panes					The pane(s) being resized, comma-delmited string
-	* @param {boolean=}				[skipCallback=false]	Should the onresize callback be run?
-	* @param {boolean=}				[force=false]
-	*/
-,	sizeMidPanes = function (panes, skipCallback, force) {
-		panes = (panes ? panes : "east,west,center").split(",");
-
-		$.each(panes, function (i, pane) {
-			if (!$Ps[pane]) return; // NO PANE - skip
-			var 
-				o		= options[pane]
-			,	s		= state[pane]
-			,	$P		= $Ps[pane]
-			,	$R		= $Rs[pane]
-			,	isCenter= (pane=="center")
-			,	hasRoom	= true
-			,	CSS		= {}
-			,	newCenter	= calcNewCenterPaneDims()
-			;
-			// update pane-state dimensions
-			$.extend(s, elDims($P));
-
-			if (pane === "center") {
-				if (!force && s.isVisible && newCenter.width === s.outerWidth && newCenter.height === s.outerHeight)
-					return true; // SKIP - pane already the correct size
-				// set state for makePaneFit() logic
-				$.extend(s, cssMinDims(pane), {
-					maxWidth:	newCenter.width
-				,	maxHeight:	newCenter.height
-				});
-				CSS = newCenter;
-				// convert OUTER width/height to CSS width/height 
-				CSS.width	= cssW($P, CSS.width);
-				// NEW - allow pane to extend 'below' visible area rather than hide it
-				CSS.height	= cssH($P, CSS.height);
-				hasRoom		= CSS.width >= 0 && CSS.height >= 0; // height >= 0 = ALWAYS TRUE NOW
-				// during layout init, try to shrink east/west panes to make room for center
-				if (!state.initialized && o.minWidth > s.outerWidth) {
-					var
-						reqPx	= o.minWidth - s.outerWidth
-					,	minE	= options.east.minSize || 0
-					,	minW	= options.west.minSize || 0
-					,	sizeE	= state.east.size
-					,	sizeW	= state.west.size
-					,	newE	= sizeE
-					,	newW	= sizeW
-					;
-					if (reqPx > 0 && state.east.isVisible && sizeE > minE) {
-						newE = max( sizeE-minE, sizeE-reqPx );
-						reqPx -= sizeE-newE;
-					}
-					if (reqPx > 0 && state.west.isVisible && sizeW > minW) {
-						newW = max( sizeW-minW, sizeW-reqPx );
-						reqPx -= sizeW-newW;
-					}
-					// IF we found enough extra space, then resize the border panes as calculated
-					if (reqPx === 0) {
-						if (sizeE && sizeE != minE)
-							sizePane('east', newE, true, force, true); // true = skipCallback/noAnimation - initPanes will handle when done
-						if (sizeW && sizeW != minW)
-							sizePane('west', newW, true, force, true);
-						// now start over!
-						sizeMidPanes('center', skipCallback, force);
-						return; // abort this loop
-					}
-				}
-			}
-			else { // for east and west, set only the height, which is same as center height
-				// set state.min/maxWidth/Height for makePaneFit() logic
-				if (s.isVisible && !s.noVerticalRoom)
-					$.extend(s, elDims($P), cssMinDims(pane))
-				if (!force && !s.noVerticalRoom && newCenter.height === s.outerHeight)
-					return true; // SKIP - pane already the correct size
-				// east/west have same top, bottom & height as center
-				CSS.top		= newCenter.top;
-				CSS.bottom	= newCenter.bottom;
-				// NEW - allow pane to extend 'below' visible area rather than hide it
-				CSS.height	= cssH($P, newCenter.height);
-				s.maxHeight	= CSS.height;
-				hasRoom		= (s.maxHeight >= 0); // ALWAYS TRUE NOW
-				if (!hasRoom) s.noVerticalRoom = true; // makePaneFit() logic
-			}
-
-			if (hasRoom) {
-				// resizeAll passes skipCallback because it triggers callbacks after ALL panes are resized
-				if (!skipCallback && state.initialized)
-					_runCallbacks("onresize_start", pane);
-
-				$P.css(CSS); // apply the CSS to pane
-				if (pane !== "center")
-					sizeHandles(pane); // also update resizer length
-				if (s.noRoom && !s.isClosed && !s.isHidden)
-					makePaneFit(pane); // will re-open/show auto-closed/hidden pane
-				if (s.isVisible) {
-					$.extend(s, elDims($P)); // update pane dimensions
-					if (state.initialized) sizeContent(pane); // also resize the contents, if exists
-				}
-			}
-			else if (!s.noRoom && s.isVisible) // no room for pane
-				makePaneFit(pane); // will hide or close pane
-
-			if (!s.isVisible)
-				return true; // DONE - next pane
-
-			/*
-			* Extra CSS for IE6 or IE7 in Quirks-mode - add 'width' to NORTH/SOUTH panes
-			* Normally these panes have only 'left' & 'right' positions so pane auto-sizes
-			* ALSO required when pane is an IFRAME because will NOT default to 'full width'
-			*	TODO: Can I use width:100% for a north/south iframe?
-			*	TODO: Sounds like a job for $P.outerWidth( sC.innerWidth ) SETTER METHOD
-			*/
-			if (pane === "center") { // finished processing midPanes
-				var fix = browser.isIE6 || !browser.boxModel;
-				if ($Ps.north && (fix || state.north.tagName=="IFRAME")) 
-					$Ps.north.css("width", cssW($Ps.north, sC.innerWidth));
-				if ($Ps.south && (fix || state.south.tagName=="IFRAME"))
-					$Ps.south.css("width", cssW($Ps.south, sC.innerWidth));
-			}
-
-			// resizeAll passes skipCallback because it triggers callbacks after ALL panes are resized
-			if (!skipCallback && state.initialized)
-				_runCallbacks("onresize_end", pane);
-		});
-	}
-
-
-	/**
-	* @see  window.onresize(), callbacks or custom code
-	*/
-,	resizeAll = function (evt) {
-		// stopPropagation if called by trigger("layoutdestroy") - use evtPane utility 
-		evtPane(evt);
-
-		if (!state.initialized) {
-			_initLayoutElements();
-			return; // no need to resize since we just initialized!
-		}
-		var	oldW	= sC.innerWidth
-		,	oldH	= sC.innerHeight
-		;
-		// cannot size layout when 'container' is hidden or collapsed
-		if (!$N.is(":visible") ) return;
-		$.extend(state.container, elDims( $N )); // UPDATE container dimensions
-		if (!sC.outerHeight) return;
-
-		// onresizeall_start will CANCEL resizing if returns false
-		// state.container has already been set, so user can access this info for calcuations
-		if (false === _runCallbacks("onresizeall_start")) return false;
-
-		var	// see if container is now 'smaller' than before
-			shrunkH	= (sC.innerHeight < oldH)
-		,	shrunkW	= (sC.innerWidth < oldW)
-		,	$P, o, s, dir
-		;
-		// NOTE special order for sizing: S-N-E-W
-		$.each(["south","north","east","west"], function (i, pane) {
-			if (!$Ps[pane]) return; // no pane - SKIP
-			s	= state[pane];
-			o	= options[pane];
-			dir	= _c[pane].dir;
-
-			if (o.autoResize && s.size != o.size) // resize pane to original size set in options
-				sizePane(pane, o.size, true, true, true); // true=skipCallback/forceResize/noAnimation
-			else {
-				setSizeLimits(pane);
-				makePaneFit(pane, false, true, true); // true=skipCallback/forceResize
-			}
-		});
-
-		sizeMidPanes("", true, true); // true=skipCallback, true=forceResize
-		sizeHandles(); // reposition the toggler elements
-
-		// trigger all individual pane callbacks AFTER layout has finished resizing
-		o = options; // reuse alias
-		$.each(_c.allPanes, function (i, pane) {
-			$P = $Ps[pane];
-			if (!$P) return; // SKIP
-			if (state[pane].isVisible) // undefined for non-existent panes
-				_runCallbacks("onresize_end", pane); // callback - if exists
-		});
-
-		_runCallbacks("onresizeall_end");
-		//_triggerLayoutEvent(pane, 'resizeall');
-	}
-
-	/**
-	* Whenever a pane resizes or opens that has a nested layout, trigger resizeAll
-	*
-	* @param {string|Object}	evt_or_pane		The pane just resized or opened
-	*/
-,	resizeChildLayout = function (evt_or_pane) {
-		var	pane = evtPane.call(this, evt_or_pane);
-		if (!options[pane].resizeChildLayout) return;
-		var	$P	= $Ps[pane]
-		,	$C	= $Cs[pane]
-		,	d	= "layout"
-		,	P	= Instance[pane]
-		,	L	= children[pane]
-		;
-		// user may have manually set EITHER instance pointer, so handle that
-		if (P.child && !L) {
-			// have to reverse the pointers!
-			var el = P.child.container;
-			L = children[pane] = (el ? el.data(d) : 0) || null; // set pointer _directly_ to layout instance
-		}
-
-		// if a layout-pointer exists, see if child has been destroyed
-		if (L && L.destroyed)
-			L = children[pane] = null; // clear child pointers
-		// no child layout pointer is set - see if there is a child layout NOW
-		if (!L)	L = children[pane] = $P.data(d) || ($C ? $C.data(d) : 0) || null; // set/update child pointers
-
-		// ALWAYS refresh the pane.child alias
-		P.child = children[pane];
-
-		if (L) L.resizeAll();
-	}
-
-
-	/**
-	* IF pane has a content-div, then resize all elements inside pane to fit pane-height
-	*
-	* @param {string|Object}	evt_or_panes		The pane(s) being resized
-	* @param {boolean=}			[remeasure=false]	Should the content (header/footer) be remeasured?
-	*/
-,	sizeContent = function (evt_or_panes, remeasure) {
-		if (!isInitialized()) return;
-
-		var panes = evtPane.call(this, evt_or_panes);
-		panes = panes ? panes.split(",") : _c.allPanes;
-
-		$.each(panes, function (idx, pane) {
-			var
-				$P	= $Ps[pane]
-			,	$C	= $Cs[pane]
-			,	o	= options[pane]
-			,	s	= state[pane]
-			,	m	= s.content // m = measurements
-			;
-			if (!$P || !$C || !$P.is(":visible")) return true; // NOT VISIBLE - skip
-
-			// if content-element was REMOVED, update OR remove the pointer
-			if (!$C.length) {
-				initContent(pane, false);	// false = do NOT sizeContent() - already there!
-				if (!$C) return;			// no replacement element found - pointer have been removed
-			}
-
-			// onsizecontent_start will CANCEL resizing if returns false
-			if (false === _runCallbacks("onsizecontent_start", pane)) return;
-
-			// skip re-measuring offsets if live-resizing
-			if ((!s.isMoving && !s.isResizing) || o.liveContentResizing || remeasure || m.top == undefined) {
-				_measure();
-				// if any footers are below pane-bottom, they may not measure correctly,
-				// so allow pane overflow and re-measure
-				if (m.hiddenFooters > 0 && $P.css("overflow") === "hidden") {
-					$P.css("overflow", "visible");
-					_measure(); // remeasure while overflowing
-					$P.css("overflow", "hidden");
-				}
-			}
-			// NOTE: spaceAbove/Below *includes* the pane paddingTop/Bottom, but not pane.borders
-			var newH = s.innerHeight - (m.spaceAbove - s.css.paddingTop) - (m.spaceBelow - s.css.paddingBottom);
-
-			if (!$C.is(":visible") || m.height != newH) {
-				// size the Content element to fit new pane-size - will autoHide if not enough room
-				setOuterHeight($C, newH, true); // true=autoHide
-				m.height = newH; // save new height
-			};
-
-			if (state.initialized)
-				_runCallbacks("onsizecontent_end", pane);
-
-			function _below ($E) {
-				return max(s.css.paddingBottom, (parseInt($E.css("marginBottom"), 10) || 0));
-			};
-
-			function _measure () {
-				var
-					ignore	= options[pane].contentIgnoreSelector
-				,	$Fs		= $C.nextAll().not(ignore || ':lt(0)') // not :lt(0) = ALL
-				,	$Fs_vis	= $Fs.filter(':visible')
-				,	$F		= $Fs_vis.filter(':last')
-				;
-				m = {
-					top:			$C[0].offsetTop
-				,	height:			$C.outerHeight()
-				,	numFooters:		$Fs.length
-				,	hiddenFooters:	$Fs.length - $Fs_vis.length
-				,	spaceBelow:		0 // correct if no content footer ($E)
-				}
-					m.spaceAbove	= m.top; // just for state - not used in calc
-					m.bottom		= m.top + m.height;
-				if ($F.length)
-					//spaceBelow = (LastFooter.top + LastFooter.height) [footerBottom] - Content.bottom + max(LastFooter.marginBottom, pane.paddingBotom)
-					m.spaceBelow = ($F[0].offsetTop + $F.outerHeight()) - m.bottom + _below($F);
-				else // no footer - check marginBottom on Content element itself
-					m.spaceBelow = _below($C);
-			};
-		});
-	}
-
-
-	/**
-	* Called every time a pane is opened, closed, or resized to slide the togglers to 'center' and adjust their length if necessary
-	*
-	* @see  initHandles(), open(), close(), resizeAll()
-	* @param {string|Object}	evt_or_panes		The pane(s) being resized
-	*/
-,	sizeHandles = function (evt_or_panes) {
-		var panes = evtPane.call(this, evt_or_panes)
-		panes = panes ? panes.split(",") : _c.borderPanes;
-
-		$.each(panes, function (i, pane) {
-			var 
-				o	= options[pane]
-			,	s	= state[pane]
-			,	$P	= $Ps[pane]
-			,	$R	= $Rs[pane]
-			,	$T	= $Ts[pane]
-			,	$TC
-			;
-			if (!$P || !$R) return;
-
-			var
-				dir			= _c[pane].dir
-			,	_state		= (s.isClosed ? "_closed" : "_open")
-			,	spacing		= o["spacing"+ _state]
-			,	togAlign	= o["togglerAlign"+ _state]
-			,	togLen		= o["togglerLength"+ _state]
-			,	paneLen
-			,	left
-			,	offset
-			,	CSS = {}
-			;
-
-			if (spacing === 0) {
-				$R.hide();
-				return;
-			}
-			else if (!s.noRoom && !s.isHidden) // skip if resizer was hidden for any reason
-				$R.show(); // in case was previously hidden
-
-			// Resizer Bar is ALWAYS same width/height of pane it is attached to
-			if (dir === "horz") { // north/south
-				//paneLen = $P.outerWidth(); // s.outerWidth || 
-				paneLen = sC.innerWidth; // handle offscreen-panes
-				s.resizerLength = paneLen;
-				left = $.layout.cssNum($P, "left")
-				$R.css({
-					width:	cssW($R, paneLen) // account for borders & padding
-				,	height:	cssH($R, spacing) // ditto
-				,	left:	left > -9999 ? left : sC.insetLeft // handle offscreen-panes
-				});
-			}
-			else { // east/west
-				paneLen = $P.outerHeight(); // s.outerHeight || 
-				s.resizerLength = paneLen;
-				$R.css({
-					height:	cssH($R, paneLen) // account for borders & padding
-				,	width:	cssW($R, spacing) // ditto
-				,	top:	sC.insetTop + getPaneSize("north", true) // TODO: what if no North pane?
-				//,	top:	$.layout.cssNum($Ps["center"], "top")
-				});
-			}
-
-			// remove hover classes
-			removeHover( o, $R );
-
-			if ($T) {
-				if (togLen === 0 || (s.isSliding && o.hideTogglerOnSlide)) {
-					$T.hide(); // always HIDE the toggler when 'sliding'
-					return;
-				}
-				else
-					$T.show(); // in case was previously hidden
-
-				if (!(togLen > 0) || togLen === "100%" || togLen > paneLen) {
-					togLen = paneLen;
-					offset = 0;
-				}
-				else { // calculate 'offset' based on options.PANE.togglerAlign_open/closed
-					if (isStr(togAlign)) {
-						switch (togAlign) {
-							case "top":
-							case "left":	offset = 0;
-											break;
-							case "bottom":
-							case "right":	offset = paneLen - togLen;
-											break;
-							case "middle":
-							case "center":
-							default:		offset = round((paneLen - togLen) / 2); // 'default' catches typos
-						}
-					}
-					else { // togAlign = number
-						var x = parseInt(togAlign, 10); //
-						if (togAlign >= 0) offset = x;
-						else offset = paneLen - togLen + x; // NOTE: x is negative!
-					}
-				}
-
-				if (dir === "horz") { // north/south
-					var width = cssW($T, togLen);
-					$T.css({
-						width:	width  // account for borders & padding
-					,	height:	cssH($T, spacing) // ditto
-					,	left:	offset // TODO: VERIFY that toggler  positions correctly for ALL values
-					,	top:	0
-					});
-					// CENTER the toggler content SPAN
-					$T.children(".content").each(function(){
-						$TC = $(this);
-						$TC.css("marginLeft", round((width-$TC.outerWidth())/2)); // could be negative
-					});
-				}
-				else { // east/west
-					var height = cssH($T, togLen);
-					$T.css({
-						height:	height // account for borders & padding
-					,	width:	cssW($T, spacing) // ditto
-					,	top:	offset // POSITION the toggler
-					,	left:	0
-					});
-					// CENTER the toggler content SPAN
-					$T.children(".content").each(function(){
-						$TC = $(this);
-						$TC.css("marginTop", round((height-$TC.outerHeight())/2)); // could be negative
-					});
-				}
-
-				// remove ALL hover classes
-				removeHover( 0, $T );
-			}
-
-			// DONE measuring and sizing this resizer/toggler, so can be 'hidden' now
-			if (!state.initialized && (o.initHidden || s.noRoom)) {
-				$R.hide();
-				if ($T) $T.hide();
-			}
-		});
-	}
-
-
-	/**
-	* @param {string|Object}	evt_or_pane
-	*/
-,	enableClosable = function (evt_or_pane) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	$T	= $Ts[pane]
-		,	o	= options[pane]
-		;
-		if (!$T) return;
-		o.closable = true;
-		$T	.bind("click."+ sID, function(evt){ evt.stopPropagation(); toggle(pane); })
-			.css("visibility", "visible")
-			.css("cursor", "pointer")
-			.attr("title", state[pane].isClosed ? o.tips.Open : o.tips.Close) // may be blank
-			.show();
-	}
-	/**
-	* @param {string|Object}	evt_or_pane
-	* @param {boolean=}			[hide=false]
-	*/
-,	disableClosable = function (evt_or_pane, hide) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	$T	= $Ts[pane]
-		;
-		if (!$T) return;
-		options[pane].closable = false;
-		// is closable is disable, then pane MUST be open!
-		if (state[pane].isClosed) open(pane, false, true);
-		$T	.unbind("."+ sID)
-			.css("visibility", hide ? "hidden" : "visible") // instead of hide(), which creates logic issues
-			.css("cursor", "default")
-			.attr("title", "");
-	}
-
-
-	/**
-	* @param {string|Object}	evt_or_pane
-	*/
-,	enableSlidable = function (evt_or_pane) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	$R	= $Rs[pane]
-		;
-		if (!$R || !$R.data('draggable')) return;
-		options[pane].slidable = true; 
-		if (state[pane].isClosed)
-			bindStartSlidingEvent(pane, true);
-	}
-	/**
-	* @param {string|Object}	evt_or_pane
-	*/
-,	disableSlidable = function (evt_or_pane) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	$R	= $Rs[pane]
-		;
-		if (!$R) return;
-		options[pane].slidable = false; 
-		if (state[pane].isSliding)
-			close(pane, false, true);
-		else {
-			bindStartSlidingEvent(pane, false);
-			$R	.css("cursor", "default")
-				.attr("title", "");
-			removeHover(null, $R[0]); // in case currently hovered
-		}
-	}
-
-
-	/**
-	* @param {string|Object}	evt_or_pane
-	*/
-,	enableResizable = function (evt_or_pane) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	$R	= $Rs[pane]
-		,	o	= options[pane]
-		;
-		if (!$R || !$R.data('draggable')) return;
-		o.resizable = true; 
-		$R.draggable("enable");
-		if (!state[pane].isClosed)
-			$R	.css("cursor", o.resizerCursor)
-			 	.attr("title", o.tips.Resize);
-	}
-	/**
-	* @param {string|Object}	evt_or_pane
-	*/
-,	disableResizable = function (evt_or_pane) {
-		if (!isInitialized()) return;
-		var	pane = evtPane.call(this, evt_or_pane)
-		,	$R	= $Rs[pane]
-		;
-		if (!$R || !$R.data('draggable')) return;
-		options[pane].resizable = false; 
-		$R	.draggable("disable")
-			.css("cursor", "default")
-			.attr("title", "");
-		removeHover(null, $R[0]); // in case currently hovered
-	}
-
-
-	/**
-	* Move a pane from source-side (eg, west) to target-side (eg, east)
-	* If pane exists on target-side, move that to source-side, ie, 'swap' the panes
-	*
-	* @param {string|Object}	evt_or_pane1	The pane/edge being swapped
-	* @param {string}			pane2			ditto
-	*/
-,	swapPanes = function (evt_or_pane1, pane2) {
-		if (!isInitialized()) return;
-		var pane1 = evtPane.call(this, evt_or_pane1);
-		// change state.edge NOW so callbacks can know where pane is headed...
-		state[pane1].edge = pane2;
-		state[pane2].edge = pane1;
-		// run these even if NOT state.initialized
-		if (false === _runCallbacks("onswap_start", pane1)
-		 ||	false === _runCallbacks("onswap_start", pane2)
-		) {
-			state[pane1].edge = pane1; // reset
-			state[pane2].edge = pane2;
-			return;
-		}
-
-		var
-			oPane1	= copy( pane1 )
-		,	oPane2	= copy( pane2 )
-		,	sizes	= {}
-		;
-		sizes[pane1] = oPane1 ? oPane1.state.size : 0;
-		sizes[pane2] = oPane2 ? oPane2.state.size : 0;
-
-		// clear pointers & state
-		$Ps[pane1] = false; 
-		$Ps[pane2] = false;
-		state[pane1] = {};
-		state[pane2] = {};
-		
-		// ALWAYS remove the resizer & toggler elements
-		if ($Ts[pane1]) $Ts[pane1].remove();
-		if ($Ts[pane2]) $Ts[pane2].remove();
-		if ($Rs[pane1]) $Rs[pane1].remove();
-		if ($Rs[pane2]) $Rs[pane2].remove();
-		$Rs[pane1] = $Rs[pane2] = $Ts[pane1] = $Ts[pane2] = false;
-
-		// transfer element pointers and data to NEW Layout keys
-		move( oPane1, pane2 );
-		move( oPane2, pane1 );
-
-		// cleanup objects
-		oPane1 = oPane2 = sizes = null;
-
-		// make panes 'visible' again
-		if ($Ps[pane1]) $Ps[pane1].css(_c.visible);
-		if ($Ps[pane2]) $Ps[pane2].css(_c.visible);
-
-		// fix any size discrepancies caused by swap
-		resizeAll();
-
-		// run these even if NOT state.initialized
-		_runCallbacks("onswap_end", pane1);
-		_runCallbacks("onswap_end", pane2);
-
-		return;
-
-		function copy (n) { // n = pane
-			var
-				$P	= $Ps[n]
-			,	$C	= $Cs[n]
-			;
-			return !$P ? false : {
-				pane:		n
-			,	P:			$P ? $P[0] : false
-			,	C:			$C ? $C[0] : false
-			,	state:		$.extend(true, {}, state[n])
-			,	options:	$.extend(true, {}, options[n])
-			}
-		};
-
-		function move (oPane, pane) {
-			if (!oPane) return;
-			var
-				P		= oPane.P
-			,	C		= oPane.C
-			,	oldPane = oPane.pane
-			,	c		= _c[pane]
-			,	side	= c.side.toLowerCase()
-			,	inset	= "inset"+ c.side
-			//	save pane-options that should be retained
-			,	s		= $.extend(true, {}, state[pane])
-			,	o		= options[pane]
-			//	RETAIN side-specific FX Settings - more below
-			,	fx		= { resizerCursor: o.resizerCursor }
-			,	re, size, pos
-			;
-			$.each("fxName,fxSpeed,fxSettings".split(","), function (i, k) {
-				fx[k +"_open"]  = o[k +"_open"];
-				fx[k +"_close"] = o[k +"_close"];
-				fx[k +"_size"]  = o[k +"_size"];
-			});
-
-			// update object pointers and attributes
-			$Ps[pane] = $(P)
-				.data({
-					layoutPane:		Instance[pane]	// NEW pointer to pane-alias-object
-				,	layoutEdge:		pane
-				})
-				.css(_c.hidden)
-				.css(c.cssReq)
-			;
-			$Cs[pane] = C ? $(C) : false;
-
-			// set options and state
-			options[pane]	= $.extend(true, {}, oPane.options, fx);
-			state[pane]		= $.extend(true, {}, oPane.state);
-
-			// change classNames on the pane, eg: ui-layout-pane-east ==> ui-layout-pane-west
-			re = new RegExp(o.paneClass +"-"+ oldPane, "g");
-			P.className = P.className.replace(re, o.paneClass +"-"+ pane);
-
-			// ALWAYS regenerate the resizer & toggler elements
-			initHandles(pane); // create the required resizer & toggler
-
-			// if moving to different orientation, then keep 'target' pane size
-			if (c.dir != _c[oldPane].dir) {
-				size = sizes[pane] || 0;
-				setSizeLimits(pane); // update pane-state
-				size = max(size, state[pane].minSize);
-				// use manualSizePane to disable autoResize - not useful after panes are swapped
-				manualSizePane(pane, size, true, true); // true/true = skipCallback/noAnimation
-			}
-			else // move the resizer here
-				$Rs[pane].css(side, sC[inset] + (state[pane].isVisible ? getPaneSize(pane) : 0));
-
-
-			// ADD CLASSNAMES & SLIDE-BINDINGS
-			if (oPane.state.isVisible && !s.isVisible)
-				setAsOpen(pane, true); // true = skipCallback
-			else {
-				setAsClosed(pane);
-				bindStartSlidingEvent(pane, true); // will enable events IF option is set
-			}
-
-			// DESTROY the object
-			oPane = null;
-		};
-	}
-
-
-	/**
-	* INTERNAL method to sync pin-buttons when pane is opened or closed
-	* Unpinned means the pane is 'sliding' - ie, over-top of the adjacent panes
-	*
-	* @see  open(), setAsOpen(), setAsClosed()
-	* @param {string}	pane   These are the params returned to callbacks by layout()
-	* @param {boolean}	doPin  True means set the pin 'down', False means 'up'
-	*/
-,	syncPinBtns = function (pane, doPin) {
-		if ($.layout.plugins.buttons)
-			$.each(state[pane].pins, function (i, selector) {
-				$.layout.buttons.setPinState(Instance, $(selector), pane, doPin);
-			});
-	}
-
-;	// END var DECLARATIONS
-
-	/**
-	* Capture keys when enableCursorHotkey - toggle pane if hotkey pressed
-	*
-	* @see  document.keydown()
-	*/
-	function keyDown (evt) {
-		if (!evt) return true;
-		var code = evt.keyCode;
-		if (code < 33) return true; // ignore special keys: ENTER, TAB, etc
-
-		var
-			PANE = {
-				38: "north" // Up Cursor	- $.ui.keyCode.UP
-			,	40: "south" // Down Cursor	- $.ui.keyCode.DOWN
-			,	37: "west"  // Left Cursor	- $.ui.keyCode.LEFT
-			,	39: "east"  // Right Cursor	- $.ui.keyCode.RIGHT
-			}
-		,	ALT		= evt.altKey // no worky!
-		,	SHIFT	= evt.shiftKey
-		,	CTRL	= evt.ctrlKey
-		,	CURSOR	= (CTRL && code >= 37 && code <= 40)
-		,	o, k, m, pane
-		;
-
-		if (CURSOR && options[PANE[code]].enableCursorHotkey) // valid cursor-hotkey
-			pane = PANE[code];
-		else if (CTRL || SHIFT) // check to see if this matches a custom-hotkey
-			$.each(_c.borderPanes, function (i, p) { // loop each pane to check its hotkey
-				o = options[p];
-				k = o.customHotkey;
-				m = o.customHotkeyModifier; // if missing or invalid, treated as "CTRL+SHIFT"
-				if ((SHIFT && m=="SHIFT") || (CTRL && m=="CTRL") || (CTRL && SHIFT)) { // Modifier matches
-					if (k && code === (isNaN(k) || k <= 9 ? k.toUpperCase().charCodeAt(0) : k)) { // Key matches
-						pane = p;
-						return false; // BREAK
-					}
-				}
-			});
-
-		// validate pane
-		if (!pane || !$Ps[pane] || !options[pane].closable || state[pane].isHidden)
-			return true;
-
-		toggle(pane);
-
-		evt.stopPropagation();
-		evt.returnValue = false; // CANCEL key
-		return false;
-	};
-
-
-/*
- * ######################################
- *	UTILITY METHODS
- *	called externally or by initButtons
- * ######################################
- */
-
-	/**
-	* Change/reset a pane overflow setting & zIndex to allow popups/drop-downs to work
-	*
-	* @param {Object=}   [el]	(optional) Can also be 'bound' to a click, mouseOver, or other event
-	*/
-	function allowOverflow (el) {
-		if (!isInitialized()) return;
-		if (this && this.tagName) el = this; // BOUND to element
-		var $P;
-		if (isStr(el))
-			$P = $Ps[el];
-		else if ($(el).data("layoutRole"))
-			$P = $(el);
-		else
-			$(el).parents().each(function(){
-				if ($(this).data("layoutRole")) {
-					$P = $(this);
-					return false; // BREAK
-				}
-			});
-		if (!$P || !$P.length) return; // INVALID
-
-		var
-			pane	= $P.data("layoutEdge")
-		,	s		= state[pane]
-		;
-
-		// if pane is already raised, then reset it before doing it again!
-		// this would happen if allowOverflow is attached to BOTH the pane and an element 
-		if (s.cssSaved)
-			resetOverflow(pane); // reset previous CSS before continuing
-
-		// if pane is raised by sliding or resizing, or its closed, then abort
-		if (s.isSliding || s.isResizing || s.isClosed) {
-			s.cssSaved = false;
-			return;
-		}
-
-		var
-			newCSS	= { zIndex: (options.zIndexes.resizer_normal + 1) }
-		,	curCSS	= {}
-		,	of		= $P.css("overflow")
-		,	ofX		= $P.css("overflowX")
-		,	ofY		= $P.css("overflowY")
-		;
-		// determine which, if any, overflow settings need to be changed
-		if (of != "visible") {
-			curCSS.overflow = of;
-			newCSS.overflow = "visible";
-		}
-		if (ofX && !ofX.match(/(visible|auto)/)) {
-			curCSS.overflowX = ofX;
-			newCSS.overflowX = "visible";
-		}
-		if (ofY && !ofY.match(/(visible|auto)/)) {
-			curCSS.overflowY = ofX;
-			newCSS.overflowY = "visible";
-		}
-
-		// save the current overflow settings - even if blank!
-		s.cssSaved = curCSS;
-
-		// apply new CSS to raise zIndex and, if necessary, make overflow 'visible'
-		$P.css( newCSS );
-
-		// make sure the zIndex of all other panes is normal
-		$.each(_c.allPanes, function(i, p) {
-			if (p != pane) resetOverflow(p);
-		});
-
-	};
-	/**
-	* @param {Object=}   [el]	(optional) Can also be 'bound' to a click, mouseOver, or other event
-	*/
-	function resetOverflow (el) {
-		if (!isInitialized()) return;
-		if (this && this.tagName) el = this; // BOUND to element
-		var $P;
-		if (isStr(el))
-			$P = $Ps[el];
-		else if ($(el).data("layoutRole"))
-			$P = $(el);
-		else
-			$(el).parents().each(function(){
-				if ($(this).data("layoutRole")) {
-					$P = $(this);
-					return false; // BREAK
-				}
-			});
-		if (!$P || !$P.length) return; // INVALID
-
-		var
-			pane	= $P.data("layoutEdge")
-		,	s		= state[pane]
-		,	CSS		= s.cssSaved || {}
-		;
-		// reset the zIndex
-		if (!s.isSliding && !s.isResizing)
-			$P.css("zIndex", options.zIndexes.pane_normal);
-
-		// reset Overflow - if necessary
-		$P.css( CSS );
-
-		// clear var
-		s.cssSaved = false;
-	};
-
-/*
- * #####################
- * CREATE/RETURN LAYOUT
- * #####################
- */
-
-	// validate that container exists
-	var $N = $(this).eq(0); // FIRST matching Container element
-	if (!$N.length) {
-		return _log( options.errors.containerMissing );
-	};
-
-	// Users retrieve Instance of a layout with: $N.layout() OR $N.data("layout")
-	// return the Instance-pointer if layout has already been initialized
-	if ($N.data("layoutContainer") && $N.data("layout"))
-		return $N.data("layout"); // cached pointer
-
-	// init global vars
-	var 
-		$Ps	= {}	// Panes x5		- set in initPanes()
-	,	$Cs	= {}	// Content x5	- set in initPanes()
-	,	$Rs	= {}	// Resizers x4	- set in initHandles()
-	,	$Ts	= {}	// Togglers x4	- set in initHandles()
-	,	$Ms	= $([])	// Masks - up to 2 masks per pane (IFRAME + DIV)
-	//	aliases for code brevity
-	,	sC	= state.container // alias for easy access to 'container dimensions'
-	,	sID	= state.id // alias for unique layout ID/namespace - eg: "layout435"
-	;
-
-	// create Instance object to expose data & option Properties, and primary action Methods
-	var Instance = {
-	//	layout data
-		options:			options			// property - options hash
-	,	state:				state			// property - dimensions hash
-	//	object pointers
-	,	container:			$N				// property - object pointers for layout container
-	,	panes:				$Ps				// property - object pointers for ALL Panes: panes.north, panes.center
-	,	contents:			$Cs				// property - object pointers for ALL Content: contents.north, contents.center
-	,	resizers:			$Rs				// property - object pointers for ALL Resizers, eg: resizers.north
-	,	togglers:			$Ts				// property - object pointers for ALL Togglers, eg: togglers.north
-	//	border-pane open/close
-	,	hide:				hide			// method - ditto
-	,	show:				show			// method - ditto
-	,	toggle:				toggle			// method - pass a 'pane' ("north", "west", etc)
-	,	open:				open			// method - ditto
-	,	close:				close			// method - ditto
-	,	slideOpen:			slideOpen		// method - ditto
-	,	slideClose:			slideClose		// method - ditto
-	,	slideToggle:		slideToggle		// method - ditto
-	//	pane actions
-	,	setSizeLimits:		setSizeLimits	// method - pass a 'pane' - update state min/max data
-	,	_sizePane:			sizePane		// method -intended for user by plugins only!
-	,	sizePane:			manualSizePane	// method - pass a 'pane' AND an 'outer-size' in pixels or percent, or 'auto'
-	,	sizeContent:		sizeContent		// method - pass a 'pane'
-	,	swapPanes:			swapPanes		// method - pass TWO 'panes' - will swap them
-	,	showMasks:			showMasks		// method - pass a 'pane' OR list of panes - default = all panes with mask option set
-	,	hideMasks:			hideMasks		// method - ditto'
-	//	pane element methods
-	,	initContent:		initContent		// method - ditto
-	,	addPane:			addPane			// method - pass a 'pane'
-	,	removePane:			removePane		// method - pass a 'pane' to remove from layout, add 'true' to delete the pane-elem
-	,	createChildLayout:	createChildLayout// method - pass a 'pane' and (optional) layout-options (OVERRIDES options[pane].childOptions
-	//	special pane option setting
-	,	enableClosable:		enableClosable	// method - pass a 'pane'
-	,	disableClosable:	disableClosable	// method - ditto
-	,	enableSlidable:		enableSlidable	// method - ditto
-	,	disableSlidable:	disableSlidable	// method - ditto
-	,	enableResizable:	enableResizable	// method - ditto
-	,	disableResizable:	disableResizable// method - ditto
-	//	utility methods for panes
-	,	allowOverflow:		allowOverflow	// utility - pass calling element (this)
-	,	resetOverflow:		resetOverflow	// utility - ditto
-	//	layout control
-	,	destroy:			destroy			// method - no parameters
-	,	initPanes:			isInitialized	// method - no parameters
-	,	resizeAll:			resizeAll		// method - no parameters
-	//	callback triggering
-	,	runCallbacks:		_runCallbacks	// method - pass evtName & pane (if a pane-event), eg: trigger("onopen", "west")
-	//	alias collections of options, state and children - created in addPane and extended elsewhere
-	,	hasParentLayout:	false			// set by initContainer()
-	,	children:			children		// pointers to child-layouts, eg: Instance.children["west"]
-	,	north:				false			// alias group: { name: pane, pane: $Ps[pane], options: options[pane], state: state[pane], child: children[pane] }
-	,	south:				false			// ditto
-	,	west:				false			// ditto
-	,	east:				false			// ditto
-	,	center:				false			// ditto
-	};
-
-	// create the border layout NOW
-	if (_create() === 'cancel') // onload_start callback returned false to CANCEL layout creation
-		return null;
-	else // true OR false -- if layout-elements did NOT init (hidden or do not exist), can auto-init later
-		return Instance; // return the Instance object
-
-}
-
-
-/*	OLD versions of jQuery only set $.support.boxModel after page is loaded
- *	so if this is IE, use support.boxModel to test for quirks-mode (ONLY IE changes boxModel).
- */
-$(function(){
-	var b = $.layout.browser;
-	if (b.msie) b.boxModel = $.support.boxModel;
-});
-
-
-/**
- * jquery.layout.state 1.0
- * $Date: 2011-07-16 08:00:00 (Sat, 16 July 2011) $
- *
- * Copyright (c) 2010 
- *   Kevin Dalman (http://allpro.net)
- *
- * Dual licensed under the GPL (http://www.gnu.org/licenses/gpl.html)
- * and MIT (http://www.opensource.org/licenses/mit-license.php) licenses.
- *
- * @dependancies: UI Layout 1.3.0.rc30.1 or higher
- * @dependancies: $.ui.cookie (above)
- *
- * @support: http://groups.google.com/group/jquery-ui-layout
- */
-/*
- *	State-management options stored in options.stateManagement, which includes a .cookie hash
- *	Default options saves ALL KEYS for ALL PANES, ie: pane.size, pane.isClosed, pane.isHidden
- *
- *	// STATE/COOKIE OPTIONS
- *	@example $(el).layout({
-				stateManagement: {
-					enabled:	true
-				,	stateKeys:	"east.size,west.size,east.isClosed,west.isClosed"
-				,	cookie:		{ name: "appLayout", path: "/" }
-				}
-			})
- *	@example $(el).layout({ stateManagement__enabled: true }) // enable auto-state-management using cookies
- *	@example $(el).layout({ stateManagement__cookie: { name: "appLayout", path: "/" } })
- *	@example $(el).layout({ stateManagement__cookie__name: "appLayout", stateManagement__cookie__path: "/" })
- *
- *	// STATE/COOKIE METHODS
- *	@example myLayout.saveCookie( "west.isClosed,north.size,south.isHidden", {expires: 7} );
- *	@example myLayout.loadCookie();
- *	@example myLayout.deleteCookie();
- *	@example var JSON = myLayout.readState();	// CURRENT Layout State
- *	@example var JSON = myLayout.readCookie();	// SAVED Layout State (from cookie)
- *	@example var JSON = myLayout.state.stateData;	// LAST LOADED Layout State (cookie saved in layout.state hash)
- *
- *	CUSTOM STATE-MANAGEMENT (eg, saved in a database)
- *	@example var JSON = myLayout.readState( "west.isClosed,north.size,south.isHidden" );
- *	@example myLayout.loadState( JSON );
- */
-
-/**
- *	UI COOKIE UTILITY
- *
- *	A $.cookie OR $.ui.cookie namespace *should be standard*, but until then...
- *	This creates $.ui.cookie so Layout does not need the cookie.jquery.js plugin
- *	NOTE: This utility is REQUIRED by the layout.state plugin
- *
- *	Cookie methods in Layout are created as part of State Management 
- */
-if (!$.ui) $.ui = {};
-$.ui.cookie = {
-
-	// cookieEnabled is not in DOM specs, but DOES works in all browsers,including IE6
-	acceptsCookies: !!navigator.cookieEnabled
-
-,	read: function (name) {
-		var
-			c		= document.cookie
-		,	cs		= c ? c.split(';') : []
-		,	pair	// loop var
-		;
-		for (var i=0, n=cs.length; i < n; i++) {
-			pair = $.trim(cs[i]).split('='); // name=value pair
-			if (pair[0] == name) // found the layout cookie
-				return decodeURIComponent(pair[1]);
-
-		}
-		return null;
-	}
-
-,	write: function (name, val, cookieOpts) {
-		var
-			params	= ''
-		,	date	= ''
-		,	clear	= false
-		,	o		= cookieOpts || {}
-		,	x		= o.expires
-		;
-		if (x && x.toUTCString)
-			date = x;
-		else if (x === null || typeof x === 'number') {
-			date = new Date();
-			if (x > 0)
-				date.setDate(date.getDate() + x);
-			else {
-				date.setFullYear(1970);
-				clear = true;
-			}
-		}
-		if (date)		params += ';expires='+ date.toUTCString();
-		if (o.path)		params += ';path='+ o.path;
-		if (o.domain)	params += ';domain='+ o.domain;
-		if (o.secure)	params += ';secure';
-		document.cookie = name +'='+ (clear ? "" : encodeURIComponent( val )) + params; // write or clear cookie
-	}
-
-,	clear: function (name) {
-		$.ui.cookie.write(name, '', {expires: -1});
-	}
-
-};
-// if cookie.jquery.js is not loaded, create an alias to replicate it
-// this may be useful to other plugins or code dependent on that plugin
-if (!$.cookie) $.cookie = function (k, v, o) {
-	var C = $.ui.cookie;
-	if (v === null)
-		C.clear(k);
-	else if (v === undefined)
-		return C.read(k);
-	else
-		C.write(k, v, o);
-};
-
-
-// tell Layout that the state plugin is available
-$.layout.plugins.stateManagement = true;
-
-//	Add State-Management options to layout.defaults
-$.layout.config.optionRootKeys.push("stateManagement");
-$.layout.defaults.stateManagement = {
-	enabled:	false	// true = enable state-management, even if not using cookies
-,	autoSave:	true	// Save a state-cookie when page exits?
-,	autoLoad:	true	// Load the state-cookie when Layout inits?
-	// List state-data to save - must be pane-specific
-,	stateKeys:	"north.size,south.size,east.size,west.size,"+
-				"north.isClosed,south.isClosed,east.isClosed,west.isClosed,"+
-				"north.isHidden,south.isHidden,east.isHidden,west.isHidden"
-,	cookie: {
-		name:	""	// If not specified, will use Layout.name, else just "Layout"
-	,	domain:	""	// blank = current domain
-	,	path:	""	// blank = current page, '/' = entire website
-	,	expires: ""	// 'days' to keep cookie - leave blank for 'session cookie'
-	,	secure:	false
-	}
-};
-// Set stateManagement as a layout-option, NOT a pane-option
-$.layout.optionsMap.layout.push("stateManagement");
-
-/*
- *	State Management methods
- */
-$.layout.state = {
-
-	/**
-	 * Get the current layout state and save it to a cookie
-	 *
-	 * myLayout.saveCookie( keys, cookieOpts )
-	 *
-	 * @param {Object}			inst
-	 * @param {(string|Array)=}	keys
-	 * @param {Object=}			cookieOpts
-	 */
-	saveCookie: function (inst, keys, cookieOpts) {
-		var o	= inst.options
-		,	oS	= o.stateManagement
-		,	oC	= $.extend(true, {}, oS.cookie, cookieOpts || null)
-		,	data = inst.state.stateData = inst.readState( keys || oS.stateKeys ) // read current panes-state
-		;
-		$.ui.cookie.write( oC.name || o.name || "Layout", $.layout.state.encodeJSON(data), oC );
-		return $.extend(true, {}, data); // return COPY of state.stateData data
-	}
-
-	/**
-	 * Remove the state cookie
-	 *
-	 * @param {Object}	inst
-	 */
-,	deleteCookie: function (inst) {
-		var o = inst.options;
-		$.ui.cookie.clear( o.stateManagement.cookie.name || o.name || "Layout" );
-	}
-
-	/**
-	 * Read & return data from the cookie - as JSON
-	 *
-	 * @param {Object}	inst
-	 */
-,	readCookie: function (inst) {
-		var o = inst.options;
-		var c = $.ui.cookie.read( o.stateManagement.cookie.name || o.name || "Layout" );
-		// convert cookie string back to a hash and return it
-		return c ? $.layout.state.decodeJSON(c) : {};
-	}
-
-	/**
-	 * Get data from the cookie and USE IT to loadState
-	 *
-	 * @param {Object}	inst
-	 */
-,	loadCookie: function (inst) {
-		var c = $.layout.state.readCookie(inst); // READ the cookie
-		if (c) {
-			inst.state.stateData = $.extend(true, {}, c); // SET state.stateData
-			inst.loadState(c); // LOAD the retrieved state
-		}
-		return c;
-	}
-	
-	/**
-	 * Update layout options from the cookie, if one exists
-	 *
-	 * @param {Object}		inst
-	 * @param {Object=}		stateData
-	 * @param {boolean=}	animate
-	 */
-,	loadState: function (inst, stateData, animate) {
-		stateData = $.layout.transformData( stateData ); // panes = default subkey
-		if ($.isEmptyObject( stateData )) return;
-		$.extend(true, inst.options, stateData); // update layout options
-		// if layout has already been initialized, then UPDATE layout state
-		if (inst.state.initialized) {
-			var pane, vis, o, s, h, c
-			,	noAnimate = (animate===false)
-			;
-			$.each($.layout.config.borderPanes, function (idx, pane) {
-				state = inst.state[pane];
-				o = stateData[ pane ];
-				if (typeof o != 'object') return; // no key, continue
-				s	= o.size;
-				c	= o.initClosed;
-				h	= o.initHidden;
-				vis	= state.isVisible;
-				// resize BEFORE opening
-				if (!vis)
-					inst.sizePane(pane, s, false, false);
-				if (h === true)			inst.hide(pane, noAnimate);
-				else if (c === false)	inst.open (pane, false, noAnimate);
-				else if (c === true)	inst.close(pane, false, noAnimate);
-				else if (h === false)	inst.show (pane, false, noAnimate);
-				// resize AFTER any other actions
-				if (vis)
-					inst.sizePane(pane, s, false, noAnimate); // animate resize if option passed
-			});
-		};
-	}
-
-	/**
-	 * Get the *current layout state* and return it as a hash
-	 *
-	 * @param {Object=}			inst
-	 * @param {(string|Array)=}	keys
-	 */
-,	readState: function (inst, keys) {
-		var
-			data	= {}
-		,	alt		= { isClosed: 'initClosed', isHidden: 'initHidden' }
-		,	state	= inst.state
-		,	panes	= $.layout.config.allPanes
-		,	pair, pane, key, val
-		;
-		if (!keys) keys = inst.options.stateManagement.stateKeys; // if called by user
-		if ($.isArray(keys)) keys = keys.join(",");
-		// convert keys to an array and change delimiters from '__' to '.'
-		keys = keys.replace(/__/g, ".").split(',');
-		// loop keys and create a data hash
-		for (var i=0, n=keys.length; i < n; i++) {
-			pair = keys[i].split(".");
-			pane = pair[0];
-			key  = pair[1];
-			if ($.inArray(pane, panes) < 0) continue; // bad pane!
-			val = state[ pane ][ key ];
-			if (val == undefined) continue;
-			if (key=="isClosed" && state[pane]["isSliding"])
-				val = true; // if sliding, then *really* isClosed
-			( data[pane] || (data[pane]={}) )[ alt[key] ? alt[key] : key ] = val;
-		}
-		return data;
-	}
-
-	/**
-	 *	Stringify a JSON hash so can save in a cookie or db-field
-	 */
-,	encodeJSON: function (JSON) {
-		return parse(JSON);
-		function parse (h) {
-			var D=[], i=0, k, v, t; // k = key, v = value
-			for (k in h) {
-				v = h[k];
-				t = typeof v;
-				if (t == 'string')		// STRING - add quotes
-					v = '"'+ v +'"';
-				else if (t == 'object')	// SUB-KEY - recurse into it
-					v = parse(v);
-				D[i++] = '"'+ k +'":'+ v;
-			}
-			return '{'+ D.join(',') +'}';
-		};
-	}
-
-	/**
-	 *	Convert stringified JSON back to a hash object
-	 *	@see		$.parseJSON(), adding in jQuery 1.4.1
-	 */
-,	decodeJSON: function (str) {
-		try { return $.parseJSON ? $.parseJSON(str) : window["eval"]("("+ str +")") || {}; }
-		catch (e) { return {}; }
-	}
-
-
-,	_create: function (inst) {
-		var _	= $.layout.state;
-		//	ADD State-Management plugin methods to inst
-		 $.extend( inst, {
-		//	readCookie - update options from cookie - returns hash of cookie data
-			readCookie:		function () { return _.readCookie(inst); }
-		//	deleteCookie
-		,	deleteCookie:	function () { _.deleteCookie(inst); }
-		//	saveCookie - optionally pass keys-list and cookie-options (hash)
-		,	saveCookie:		function (keys, cookieOpts) { return _.saveCookie(inst, keys, cookieOpts); }
-		//	loadCookie - readCookie and use to loadState() - returns hash of cookie data
-		,	loadCookie:		function () { return _.loadCookie(inst); }
-		//	loadState - pass a hash of state to use to update options
-		,	loadState:		function (stateData, animate) { _.loadState(inst, stateData, animate); }
-		//	readState - returns hash of current layout-state
-		,	readState:		function (keys) { return _.readState(inst, keys); }
-		//	add JSON utility methods too...
-		,	encodeJSON:		_.encodeJSON
-		,	decodeJSON:		_.decodeJSON
-		});
-
-		// init state.stateData key, even if plugin is initially disabled
-		inst.state.stateData = {};
-
-		// read and load cookie-data per options
-		var oS = inst.options.stateManagement;
-		if (oS.enabled) {
-			if (oS.autoLoad) // update the options from the cookie
-				inst.loadCookie();
-			else // don't modify options - just store cookie data in state.stateData
-				inst.state.stateData = inst.readCookie();
-		}
-	}
-
-,	_unload: function (inst) {
-		var oS = inst.options.stateManagement;
-		if (oS.enabled) {
-			if (oS.autoSave) // save a state-cookie automatically
-				inst.saveCookie();
-			else // don't save a cookie, but do store state-data in state.stateData key
-				inst.state.stateData = inst.readState();
-		}
-	}
-
-};
-
-// add state initialization method to Layout's onCreate array of functions
-$.layout.onCreate.push( $.layout.state._create );
-$.layout.onUnload.push( $.layout.state._unload );
-
-
-
-
-/**
- * jquery.layout.buttons 1.0
- * $Date: 2011-07-16 08:00:00 (Sat, 16 July 2011) $
- *
- * Copyright (c) 2010 
- *   Kevin Dalman (http://allpro.net)
- *
- * Dual licensed under the GPL (http://www.gnu.org/licenses/gpl.html)
- * and MIT (http://www.opensource.org/licenses/mit-license.php) licenses.
- *
- * @dependancies: UI Layout 1.3.0.rc30.1 or higher
- *
- * @support: http://groups.google.com/group/jquery-ui-layout
- *
- * Docs: [ to come ]
- * Tips: [ to come ]
- */
-
-// tell Layout that the state plugin is available
-$.layout.plugins.buttons = true;
-
-//	Add buttons options to layout.defaults
-$.layout.defaults.autoBindCustomButtons = false;
-// Specify autoBindCustomButtons as a layout-option, NOT a pane-option
-$.layout.optionsMap.layout.push("autoBindCustomButtons");
-
-/*
- *	Button methods
- */
-$.layout.buttons = {
-
-	/**
-	* Searches for .ui-layout-button-xxx elements and auto-binds them as layout-buttons
-	*
-	* @see  _create()
-	*
-	* @param  {Object}		inst	Layout Instance object
-	*/
-	init: function (inst) {
-		var pre		= "ui-layout-button-"
-		,	layout	= inst.options.name || ""
-		,	name;
-		$.each("toggle,open,close,pin,toggle-slide,open-slide".split(","), function (i, action) {
-			$.each($.layout.config.borderPanes, function (ii, pane) {
-				$("."+pre+action+"-"+pane).each(function(){
-					// if button was previously 'bound', data.layoutName was set, but is blank if layout has no 'name'
-					name = $(this).data("layoutName") || $(this).attr("layoutName");
-					if (name == undefined || name === layout)
-						inst.bindButton(this, action, pane);
-				});
-			});
-		});
-	}
-
-	/**
-	* Helper function to validate params received by addButton utilities
-	*
-	* Two classes are added to the element, based on the buttonClass...
-	* The type of button is appended to create the 2nd className:
-	*  - ui-layout-button-pin		// action btnClass
-	*  - ui-layout-button-pin-west	// action btnClass + pane
-	*  - ui-layout-button-toggle
-	*  - ui-layout-button-open
-	*  - ui-layout-button-close
-	*
-	* @param {Object}			inst		Layout Instance object
-	* @param {(string|!Object)}	selector	jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
-	* @param {string}   		pane 		Name of the pane the button is for: 'north', 'south', etc.
-	*
-	* @return {Array.<Object>}	If both params valid, the element matching 'selector' in a jQuery wrapper - otherwise returns null
-	*/
-,	get: function (inst, selector, pane, action) {
-		var $E	= $(selector)
-		,	o	= inst.options
-		,	err	= o.errors.addButtonError
-		;
-		if (!$E.length) { // element not found
-			$.layout.msg(err +" "+ o.errors.selector +": "+ selector, true);
-		}
-		else if ($.inArray(pane, $.layout.config.borderPanes) < 0) { // invalid 'pane' sepecified
-			$.layout.msg(err +" "+ o.errors.pane +": "+ pane, true);
-			$E = $("");  // NO BUTTON
-		}
-		else { // VALID
-			var btn = o[pane].buttonClass +"-"+ action;
-			$E	.addClass( btn +" "+ btn +"-"+ pane )
-				.data("layoutName", o.name); // add layout identifier - even if blank!
-		}
-		return $E;
-	}
-
-
-	/**
-	* NEW syntax for binding layout-buttons - will eventually replace addToggle, addOpen, etc.
-	*
-	* @param {Object}			inst		Layout Instance object
-	* @param {(string|!Object)}	selector	jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
-	* @param {string}			action
-	* @param {string}			pane
-	*/
-,	bind: function (inst, selector, action, pane) {
-		var _ = $.layout.buttons;
-		switch (action.toLowerCase()) {
-			case "toggle":			_.addToggle	(inst, selector, pane); break;	
-			case "open":			_.addOpen	(inst, selector, pane); break;
-			case "close":			_.addClose	(inst, selector, pane); break;
-			case "pin":				_.addPin	(inst, selector, pane); break;
-			case "toggle-slide":	_.addToggle	(inst, selector, pane, true); break;	
-			case "open-slide":		_.addOpen	(inst, selector, pane, true); break;
-		}
-		return inst;
-	}
-
-	/**
-	* Add a custom Toggler button for a pane
-	*
-	* @param {Object}			inst		Layout Instance object
-	* @param {(string|!Object)}	selector	jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
-	* @param {string}  			pane 		Name of the pane the button is for: 'north', 'south', etc.
-	* @param {boolean=}			slide 		true = slide-open, false = pin-open
-	*/
-,	addToggle: function (inst, selector, pane, slide) {
-		$.layout.buttons.get(inst, selector, pane, "toggle")
-			.click(function(evt){
-				inst.toggle(pane, !!slide);
-				evt.stopPropagation();
-			});
-		return inst;
-	}
-
-	/**
-	* Add a custom Open button for a pane
-	*
-	* @param {Object}			inst		Layout Instance object
-	* @param {(string|!Object)}	selector	jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
-	* @param {string}			pane 		Name of the pane the button is for: 'north', 'south', etc.
-	* @param {boolean=}			slide 		true = slide-open, false = pin-open
-	*/
-,	addOpen: function (inst, selector, pane, slide) {
-		$.layout.buttons.get(inst, selector, pane, "open")
-			.attr("title", inst.options[pane].tips.Open)
-			.click(function (evt) {
-				inst.open(pane, !!slide);
-				evt.stopPropagation();
-			});
-		return inst;
-	}
-
-	/**
-	* Add a custom Close button for a pane
-	*
-	* @param {Object}			inst		Layout Instance object
-	* @param {(string|!Object)}	selector	jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
-	* @param {string}   		pane 		Name of the pane the button is for: 'north', 'south', etc.
-	*/
-,	addClose: function (inst, selector, pane) {
-		$.layout.buttons.get(inst, selector, pane, "close")
-			.attr("title", inst.options[pane].tips.Close)
-			.click(function (evt) {
-				inst.close(pane);
-				evt.stopPropagation();
-			});
-		return inst;
-	}
-
-	/**
-	* Add a custom Pin button for a pane
-	*
-	* Four classes are added to the element, based on the paneClass for the associated pane...
-	* Assuming the default paneClass and the pin is 'up', these classes are added for a west-pane pin:
-	*  - ui-layout-pane-pin
-	*  - ui-layout-pane-west-pin
-	*  - ui-layout-pane-pin-up
-	*  - ui-layout-pane-west-pin-up
-	*
-	* @param {Object}			inst		Layout Instance object
-	* @param {(string|!Object)}	selector	jQuery selector (or element) for button, eg: ".ui-layout-north .toggle-button"
-	* @param {string}   		pane 		Name of the pane the pin is for: 'north', 'south', etc.
-	*/
-,	addPin: function (inst, selector, pane) {
-		var	_	= $.layout.buttons
-		,	$E	= _.get(inst, selector, pane, "pin");
-		if ($E.length) {
-			var s = inst.state[pane];
-			$E.click(function (evt) {
-				_.setPinState(inst, $(this), pane, (s.isSliding || s.isClosed));
-				if (s.isSliding || s.isClosed) inst.open( pane ); // change from sliding to open
-				else inst.close( pane ); // slide-closed
-				evt.stopPropagation();
-			});
-			// add up/down pin attributes and classes
-			_.setPinState(inst, $E, pane, (!s.isClosed && !s.isSliding));
-			// add this pin to the pane data so we can 'sync it' automatically
-			// PANE.pins key is an array so we can store multiple pins for each pane
-			s.pins.push( selector ); // just save the selector string
-		}
-		return inst;
-	}
-
-	/**
-	* Change the class of the pin button to make it look 'up' or 'down'
-	*
-	* @see  addPin(), syncPins()
-	*
-	* @param {Object}			inst	Layout Instance object
-	* @param {Array.<Object>}	$Pin	The pin-span element in a jQuery wrapper
-	* @param {string}			pane	These are the params returned to callbacks by layout()
-	* @param {boolean}			doPin	true = set the pin 'down', false = set it 'up'
-	*/
-,	setPinState: function (inst, $Pin, pane, doPin) {
-		var updown = $Pin.attr("pin");
-		if (updown && doPin === (updown=="down")) return; // already in correct state
-		var
-			o		= inst.options[pane]
-		,	pin		= o.buttonClass +"-pin"
-		,	side	= pin +"-"+ pane
-		,	UP		= pin +"-up "+	side +"-up"
-		,	DN		= pin +"-down "+side +"-down"
-		;
-		$Pin
-			.attr("pin", doPin ? "down" : "up") // logic
-			.attr("title", doPin ? o.tips.Unpin : o.tips.Pin)
-			.removeClass( doPin ? UP : DN ) 
-			.addClass( doPin ? DN : UP ) 
-		;
-	}
-
-	/**
-	* INTERNAL function to sync 'pin buttons' when pane is opened or closed
-	* Unpinned means the pane is 'sliding' - ie, over-top of the adjacent panes
-	*
-	* @see  open(), close()
-	*
-	* @param {Object}			inst	Layout Instance object
-	* @param {string}	pane	These are the params returned to callbacks by layout()
-	* @param {boolean}	doPin	True means set the pin 'down', False means 'up'
-	*/
-,	syncPinBtns: function (inst, pane, doPin) {
-		// REAL METHOD IS _INSIDE_ LAYOUT - THIS IS HERE JUST FOR REFERENCE
-		$.each(inst.state[pane].pins, function (i, selector) {
-			$.layout.buttons.setPinState(inst, $(selector), pane, doPin);
-		});
-	}
-
-
-,	_load: function (inst) {
-		var	_	= $.layout.buttons;
-		// ADD Button methods to Layout Instance
-		// Note: sel = jQuery Selector string
-		$.extend( inst, {
-			bindButton:		function (sel, action, pane) { return _.bind(inst, sel, action, pane); }
-		//	DEPRECATED METHODS
-		,	addToggleBtn:	function (sel, pane, slide) { return _.addToggle(inst, sel, pane, slide); }
-		,	addOpenBtn:		function (sel, pane, slide) { return _.addOpen(inst, sel, pane, slide); }
-		,	addCloseBtn:	function (sel, pane) { return _.addClose(inst, sel, pane); }
-		,	addPinBtn:		function (sel, pane) { return _.addPin(inst, sel, pane); }
-		});
-
-		// init state array to hold pin-buttons
-		for (var i=0; i<4; i++) {
-			var pane = $.layout.config.borderPanes[i];
-			inst.state[pane].pins = [];
-		}
-
-		// auto-init buttons onLoad if option is enabled
-		if ( inst.options.autoBindCustomButtons )
-			_.init(inst);
-	}
-
-,	_unload: function (inst) {
-		// TODO: unbind all buttons???
-	}
-
-};
-
-// add initialization method to Layout's onLoad array of functions
-$.layout.onLoad.push(  $.layout.buttons._load );
-//$.layout.onUnload.push( $.layout.buttons._unload );
-
-
-
-/**
- * jquery.layout.browserZoom 1.0
- * $Date: 2011-12-29 08:00:00 (Thu, 29 Dec 2011) $
- *
- * Copyright (c) 2012 
- *   Kevin Dalman (http://allpro.net)
- *
- * Dual licensed under the GPL (http://www.gnu.org/licenses/gpl.html)
- * and MIT (http://www.opensource.org/licenses/mit-license.php) licenses.
- *
- * @dependancies: UI Layout 1.3.0.rc30.1 or higher
- *
- * @support: http://groups.google.com/group/jquery-ui-layout
- *
- * @todo: Extend logic to handle other problematic zooming in browsers
- * @todo: Add hotkey/mousewheel bindings to _instantly_ respond to these zoom event
- */
-
-// tell Layout that the plugin is available
-$.layout.plugins.browserZoom = true;
-
-$.layout.defaults.browserZoomCheckInterval = 1000;
-$.layout.optionsMap.layout.push("browserZoomCheckInterval");
-
-/*
- *	browserZoom methods
- */
-$.layout.browserZoom = {
-
-	_init: function (inst) {
-		// abort if browser does not need this check
-		if ($.layout.browserZoom.ratio() !== false)
-			$.layout.browserZoom._setTimer(inst);
-	}
-
-,	_setTimer: function (inst) {
-		// abort if layout destroyed or browser does not need this check
-		if (inst.destroyed) return;
-		var o	= inst.options
-		,	s	= inst.state
-		//	don't need check if inst has parentLayout, but check occassionally in case parent destroyed!
-		//	MINIMUM 100ms interval, for performance
-		,	ms	= inst.hasParentLayout ?  5000 : Math.max( o.browserZoomCheckInterval, 100 )
-		;
-		// set the timer
-		setTimeout(function(){
-			if (inst.destroyed || !o.resizeWithWindow) return;
-			var d = $.layout.browserZoom.ratio();
-			if (d !== s.browserZoom) {
-				s.browserZoom = d;
-				inst.resizeAll();
-			}
-			// set a NEW timeout
-			$.layout.browserZoom._setTimer(inst);
-		}
-		,	ms );
-	}
-
-,	ratio: function () {
-		var w	= window
-		,	s	= screen
-		,	d	= document
-		,	dE	= d.documentElement || d.body
-		,	b	= $.layout.browser
-		,	v	= b.version
-		,	r, sW, cW
-		;
-		// we can ignore all browsers that fire window.resize event onZoom
-		if ((b.msie && v > 8)
-		||	!b.msie
-		) return false; // don't need to track zoom
-
-		if (s.deviceXDPI)
-			return calc(s.deviceXDPI, s.systemXDPI);
-		// everything below is just for future reference!
-		if (b.webkit && (r = d.body.getBoundingClientRect))
-			return calc((r.left - r.right), d.body.offsetWidth);
-		if (b.webkit && (sW = w.outerWidth))
-			return calc(sW, w.innerWidth);
-		if ((sW = s.width) && (cW = dE.clientWidth))
-			return calc(sW, cW);
-		return false; // no match, so cannot - or don't need to - track zoom
-
-		function calc (x,y) { return (parseInt(x,10) / parseInt(y,10) * 100).toFixed(); }
-	}
-
-};
-// add initialization method to Layout's onLoad array of functions
-$.layout.onReady.push( $.layout.browserZoom._init );
-
-
-
-})( jQuery );
\ No newline at end of file
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/lato-v11-latin-regular.eot b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/lato-v11-latin-regular.eot
new file mode 100644
index 0000000000..28343da023
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/lato-v11-latin-regular.eot
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/lato-v11-latin-regular.ttf b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/lato-v11-latin-regular.ttf
new file mode 100644
index 0000000000..7608bc3e0f
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/lato-v11-latin-regular.ttf
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/lato-v11-latin-regular.woff b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/lato-v11-latin-regular.woff
new file mode 100644
index 0000000000..49e604471f
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/lato-v11-latin-regular.woff
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/navigation-li-a.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/navigation-li-a.png
deleted file mode 100644
index 9b32288e04..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/navigation-li-a.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/navigation-li.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/navigation-li.png
deleted file mode 100644
index fd0ad06e81..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/navigation-li.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object.png
deleted file mode 100644
index ad312793ea..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object.svg b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object.svg
new file mode 100644
index 0000000000..6665d73c57
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object.svg
@@ -0,0 +1,54 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="72px" height="72px" viewBox="0 0 72 72" version="1.1">
+  <defs>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-1">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+    <circle id="path-2" cx="32" cy="32" r="32"/>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-4">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feOffset dx="0" dy="1" in="SourceAlpha" result="shadowOffsetInner1"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner1" result="shadowBlurInner1"/>
+      <feComposite in="shadowBlurInner1" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner1"/>
+      <feColorMatrix values="0 0 0 0 1   0 0 0 0 1   0 0 0 0 1  0 0 0 0.14 0" in="shadowInnerInner1" type="matrix" result="shadowMatrixInner1"/>
+      <feOffset dx="0" dy="-1" in="SourceAlpha" result="shadowOffsetInner2"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner2" result="shadowBlurInner2"/>
+      <feComposite in="shadowBlurInner2" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner2"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowInnerInner2" type="matrix" result="shadowMatrixInner2"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+        <feMergeNode in="shadowMatrixInner1"/>
+        <feMergeNode in="shadowMatrixInner2"/>
+      </feMerge>
+    </filter>
+    <path id="path-5" d="M32 61C49.673112 61 64 48.0162577 64 32 64 15.9837423 49.673112 3 32 3 14.326888 3 0 15.9837423 0 32 0 48.0162577 14.326888 61 32 61Z"/>
+  </defs>
+  <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+    <g id="Artboard-1" transform="translate(-298.000000, -91.000000)">
+      <g id="BG" transform="translate(302.000000, 91.000000)">
+        <g id="Icon">
+          <mask id="mask-3" fill="white">
+            <use xlink:href="#path-2"/>
+          </mask>
+          <use id="Mask" fill="#2C6C8D" filter="url(#filter-1)" xlink:href="#path-2"/>
+          <mask id="mask-6" fill="white">
+            <use xlink:href="#path-5"/>
+          </mask>
+          <text id="O" mask="url(#mask-6)" font-family="Open Sans, Helvetica Neueu, Sans-serif" font-size="40" font-weight="normal" fill="#FFFFFF">
+            <tspan x="17" y="47">
+              O
+            </tspan>
+          </text>
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_big.png
deleted file mode 100644
index 67ffca79de..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_comp.svg b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_comp.svg
new file mode 100644
index 0000000000..0434243fbd
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_comp.svg
@@ -0,0 +1,57 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="72px" height="72px" viewBox="0 0 72 72" version="1.1">
+  <defs>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-1">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+    <circle id="path-2" cx="32" cy="32" r="32"/>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-4">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feOffset dx="0" dy="1" in="SourceAlpha" result="shadowOffsetInner1"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner1" result="shadowBlurInner1"/>
+      <feComposite in="shadowBlurInner1" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner1"/>
+      <feColorMatrix values="0 0 0 0 1   0 0 0 0 1   0 0 0 0 1  0 0 0 0.14 0" in="shadowInnerInner1" type="matrix" result="shadowMatrixInner1"/>
+      <feOffset dx="0" dy="-1" in="SourceAlpha" result="shadowOffsetInner2"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner2" result="shadowBlurInner2"/>
+      <feComposite in="shadowBlurInner2" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner2"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowInnerInner2" type="matrix" result="shadowMatrixInner2"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+        <feMergeNode in="shadowMatrixInner1"/>
+        <feMergeNode in="shadowMatrixInner2"/>
+      </feMerge>
+    </filter>
+    <path id="path-5" d="M32 61C49.673112 61 64 48.0162577 64 32 64 15.9837423 49.673112 3 32 3 14.326888 3 0 15.9837423 0 32 0 48.0162577 14.326888 61 32 61Z"/>
+  </defs>
+  <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+    <g id="Artboard-1" transform="translate(-298.000000, -91.000000)">
+      <g id="BG" transform="translate(302.000000, 91.000000)">
+        <g id="Icon">
+          <mask id="mask-3" fill="white">
+            <use xlink:href="#path-2"/>
+          </mask>
+          <use id="Mask" fill="#44AD7D" filter="url(#filter-1)" xlink:href="#path-2"/>
+          <rect id="Rectangle-2" opacity="0.3" fill="#000000" mask="url(#mask-3)" x="-8" y="33" width="80" height="31"/>
+          <mask id="mask-6" fill="white">
+            <use xlink:href="#path-5"/>
+          </mask>
+          <use id="Mask" fill="#2C6C8D" filter="url(#filter-4)" xlink:href="#path-5"/>
+          <text id="O" mask="url(#mask-6)" font-family="Open Sans, Helvetica Neueu, Sans-serif" font-size="40" font-weight="normal" fill="#FFFFFF">
+            <tspan x="17" y="47">
+              O
+            </tspan>
+          </text>
+          <rect id="Rectangle-2" opacity="0.190065299" fill="#000000" mask="url(#mask-6)" x="-8" y="2" width="80" height="31"/>
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_to_class_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_to_class_big.png
deleted file mode 100644
index 7502942eb6..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_to_class_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_to_trait_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_to_trait_big.png
deleted file mode 100644
index c777bfce8d..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_to_trait_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_to_type_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_to_type_big.png
deleted file mode 100644
index 7502942eb6..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/object_to_type_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/open-sans-v13-latin-regular.eot b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/open-sans-v13-latin-regular.eot
new file mode 100644
index 0000000000..1d98e6eab0
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/open-sans-v13-latin-regular.eot
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/open-sans-v13-latin-regular.ttf b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/open-sans-v13-latin-regular.ttf
new file mode 100644
index 0000000000..0dae9c3bbc
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/open-sans-v13-latin-regular.ttf
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/open-sans-v13-latin-regular.woff b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/open-sans-v13-latin-regular.woff
new file mode 100644
index 0000000000..e096d04f82
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/open-sans-v13-latin-regular.woff
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/package.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/package.png
deleted file mode 100644
index 6ea17ac320..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/package.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/package.svg b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/package.svg
new file mode 100644
index 0000000000..63f581b3b1
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/package.svg
@@ -0,0 +1,54 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="72px" height="72px" viewBox="0 0 72 72" version="1.1">
+  <defs>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-1">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+    <circle id="path-2" cx="32" cy="32" r="32"/>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-4">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feOffset dx="0" dy="1" in="SourceAlpha" result="shadowOffsetInner1"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner1" result="shadowBlurInner1"/>
+      <feComposite in="shadowBlurInner1" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner1"/>
+      <feColorMatrix values="0 0 0 0 1   0 0 0 0 1   0 0 0 0 1  0 0 0 0.14 0" in="shadowInnerInner1" type="matrix" result="shadowMatrixInner1"/>
+      <feOffset dx="0" dy="-1" in="SourceAlpha" result="shadowOffsetInner2"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner2" result="shadowBlurInner2"/>
+      <feComposite in="shadowBlurInner2" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner2"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowInnerInner2" type="matrix" result="shadowMatrixInner2"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+        <feMergeNode in="shadowMatrixInner1"/>
+        <feMergeNode in="shadowMatrixInner2"/>
+      </feMerge>
+    </filter>
+    <path id="path-5" d="M32 61C49.673112 61 64 48.0162577 64 32 64 15.9837423 49.673112 3 32 3 14.326888 3 0 15.9837423 0 32 0 48.0162577 14.326888 61 32 61Z"/>
+  </defs>
+  <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+    <g id="Artboard-1" transform="translate(-298.000000, -91.000000)">
+      <g id="BG" transform="translate(302.000000, 91.000000)">
+        <g id="Icon">
+          <mask id="mask-3" fill="white">
+            <use xlink:href="#path-2"/>
+          </mask>
+          <use id="Mask" fill="#2C6C8D" filter="url(#filter-1)" xlink:href="#path-2"/>
+          <mask id="mask-6" fill="white">
+            <use xlink:href="#path-5"/>
+          </mask>
+          <text id="p" mask="url(#mask-6)" font-family="Open Sans, Helvetica Neueu, Sans-serif" font-size="40" font-weight="normal" fill="#FFFFFF">
+            <tspan x="22" y="40">
+              p
+            </tspan>
+          </text>
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/package_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/package_big.png
deleted file mode 100644
index 529aa93188..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/package_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/packagesbg.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/packagesbg.gif
deleted file mode 100644
index 00c3378a2a..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/packagesbg.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/permalink.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/permalink.png
deleted file mode 100644
index d54bc93f6a..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/permalink.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/permalink.svg b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/permalink.svg
new file mode 100644
index 0000000000..a11d568d94
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/permalink.svg
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="24" fill="#ffffff" height="24" viewBox="0 0 24 24"><path d="M10.59,13.41C11,13.8 11,14.44 10.59,14.83C10.2,15.22 9.56,15.22 9.17,14.83C7.22,12.88 7.22,9.71 9.17,7.76V7.76L12.71,4.22C14.66,2.27 17.83,2.27 19.78,4.22C21.73,6.17 21.73,9.34 19.78,11.29L18.29,12.78C18.3,11.96 18.17,11.14 17.89,10.36L18.36,9.88C19.54,8.71 19.54,6.81 18.36,5.64C17.19,4.46 15.29,4.46 14.12,5.64L10.59,9.17C9.41,10.34 9.41,12.24 10.59,13.41M13.41,9.17C13.8,8.78 14.44,8.78 14.83,9.17C16.78,11.12 16.78,14.29 14.83,16.24V16.24L11.29,19.78C9.34,21.73 6.17,21.73 4.22,19.78C2.27,17.83 2.27,14.66 4.22,12.71L5.71,11.22C5.7,12.04 5.83,12.86 6.11,13.65L5.64,14.12C4.46,15.29 4.46,17.19 5.64,18.36C6.81,19.54 8.71,19.54 9.88,18.36L13.41,14.83C14.59,13.66 14.59,11.76 13.41,10.59C13,10.2 13,9.56 13.41,9.17Z" /></svg>
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/raphael-min.js b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/raphael-min.js
deleted file mode 100644
index d30dbad858..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/raphael-min.js
+++ /dev/null
@@ -1,10 +0,0 @@
-// ┌────────────────────────────────────────────────────────────────────┐ \\
-// │ Raphaël 2.1.0 - JavaScript Vector Library                          │ \\
-// ├────────────────────────────────────────────────────────────────────┤ \\
-// │ Copyright © 2008-2012 Dmitry Baranovskiy (http://raphaeljs.com)    │ \\
-// │ Copyright © 2008-2012 Sencha Labs (http://sencha.com)              │ \\
-// ├────────────────────────────────────────────────────────────────────┤ \\
-// │ Licensed under the MIT (http://raphaeljs.com/license.html) license.│ \\
-// └────────────────────────────────────────────────────────────────────┘ \\
-
-(function(a){var b="0.3.4",c="hasOwnProperty",d=/[\.\/]/,e="*",f=function(){},g=function(a,b){return a-b},h,i,j={n:{}},k=function(a,b){var c=j,d=i,e=Array.prototype.slice.call(arguments,2),f=k.listeners(a),l=0,m=!1,n,o=[],p={},q=[],r=h,s=[];h=a,i=0;for(var t=0,u=f.length;t<u;t++)"zIndex"in f[t]&&(o.push(f[t].zIndex),f[t].zIndex<0&&(p[f[t].zIndex]=f[t]));o.sort(g);while(o[l]<0){n=p[o[l++]],q.push(n.apply(b,e));if(i){i=d;return q}}for(t=0;t<u;t++){n=f[t];if("zIndex"in n)if(n.zIndex==o[l]){q.push(n.apply(b,e));if(i)break;do{l++,n=p[o[l]],n&&q.push(n.apply(b,e));if(i)break}while(n)}else p[n.zIndex]=n;else{q.push(n.apply(b,e));if(i)break}}i=d,h=r;return q.length?q:null};k.listeners=function(a){var b=a.split(d),c=j,f,g,h,i,k,l,m,n,o=[c],p=[];for(i=0,k=b.length;i<k;i++){n=[];for(l=0,m=o.length;l<m;l++){c=o[l].n,g=[c[b[i]],c[e]],h=2;while(h--)f=g[h],f&&(n.push(f),p=p.concat(f.f||[]))}o=n}return p},k.on=function(a,b){var c=a.split(d),e=j;for(var g=0,h=c.length;g<h;g++)e=e.n,!e[c[g]]&&(e[c[g]]={n:{}}),e=e[c[g]];e.f=e.f||[];for(g=0,h=e.f.length;g<h;g++)if(e.f[g]==b)return f;e.f.push(b);return function(a){+a==+a&&(b.zIndex=+a)}},k.stop=function(){i=1},k.nt=function(a){if(a)return(new RegExp("(?:\\.|\\/|^)"+a+"(?:\\.|\\/|$)")).test(h);return h},k.off=k.unbind=function(a,b){var f=a.split(d),g,h,i,k,l,m,n,o=[j];for(k=0,l=f.length;k<l;k++)for(m=0;m<o.length;m+=i.length-2){i=[m,1],g=o[m].n;if(f[k]!=e)g[f[k]]&&i.push(g[f[k]]);else for(h in g)g[c](h)&&i.push(g[h]);o.splice.apply(o,i)}for(k=0,l=o.length;k<l;k++){g=o[k];while(g.n){if(b){if(g.f){for(m=0,n=g.f.length;m<n;m++)if(g.f[m]==b){g.f.splice(m,1);break}!g.f.length&&delete g.f}for(h in g.n)if(g.n[c](h)&&g.n[h].f){var p=g.n[h].f;for(m=0,n=p.length;m<n;m++)if(p[m]==b){p.splice(m,1);break}!p.length&&delete g.n[h].f}}else{delete g.f;for(h in g.n)g.n[c](h)&&g.n[h].f&&delete g.n[h].f}g=g.n}}},k.once=function(a,b){var c=function(){var d=b.apply(this,arguments);k.unbind(a,c);return d};return k.on(a,c)},k.version=b,k.toString=function(){return"You are running Eve "+b},typeof module!="undefined"&&module.exports?module.exports=k:typeof define!="undefined"?define("eve",[],function(){return k}):a.eve=k})(this),function(){function cF(a){for(var b=0;b<cy.length;b++)cy[b].el.paper==a&&cy.splice(b--,1)}function cE(b,d,e,f,h,i){e=Q(e);var j,k,l,m=[],o,p,q,t=b.ms,u={},v={},w={};if(f)for(y=0,z=cy.length;y<z;y++){var x=cy[y];if(x.el.id==d.id&&x.anim==b){x.percent!=e?(cy.splice(y,1),l=1):k=x,d.attr(x.totalOrigin);break}}else f=+v;for(var y=0,z=b.percents.length;y<z;y++){if(b.percents[y]==e||b.percents[y]>f*b.top){e=b.percents[y],p=b.percents[y-1]||0,t=t/b.top*(e-p),o=b.percents[y+1],j=b.anim[e];break}f&&d.attr(b.anim[b.percents[y]])}if(!!j){if(!k){for(var A in j)if(j[g](A))if(U[g](A)||d.paper.customAttributes[g](A)){u[A]=d.attr(A),u[A]==null&&(u[A]=T[A]),v[A]=j[A];switch(U[A]){case C:w[A]=(v[A]-u[A])/t;break;case"colour":u[A]=a.getRGB(u[A]);var B=a.getRGB(v[A]);w[A]={r:(B.r-u[A].r)/t,g:(B.g-u[A].g)/t,b:(B.b-u[A].b)/t};break;case"path":var D=bR(u[A],v[A]),E=D[1];u[A]=D[0],w[A]=[];for(y=0,z=u[A].length;y<z;y++){w[A][y]=[0];for(var F=1,G=u[A][y].length;F<G;F++)w[A][y][F]=(E[y][F]-u[A][y][F])/t}break;case"transform":var H=d._,I=ca(H[A],v[A]);if(I){u[A]=I.from,v[A]=I.to,w[A]=[],w[A].real=!0;for(y=0,z=u[A].length;y<z;y++){w[A][y]=[u[A][y][0]];for(F=1,G=u[A][y].length;F<G;F++)w[A][y][F]=(v[A][y][F]-u[A][y][F])/t}}else{var J=d.matrix||new cb,K={_:{transform:H.transform},getBBox:function(){return d.getBBox(1)}};u[A]=[J.a,J.b,J.c,J.d,J.e,J.f],b$(K,v[A]),v[A]=K._.transform,w[A]=[(K.matrix.a-J.a)/t,(K.matrix.b-J.b)/t,(K.matrix.c-J.c)/t,(K.matrix.d-J.d)/t,(K.matrix.e-J.e)/t,(K.matrix.f-J.f)/t]}break;case"csv":var L=r(j[A])[s](c),M=r(u[A])[s](c);if(A=="clip-rect"){u[A]=M,w[A]=[],y=M.length;while(y--)w[A][y]=(L[y]-u[A][y])/t}v[A]=L;break;default:L=[][n](j[A]),M=[][n](u[A]),w[A]=[],y=d.paper.customAttributes[A].length;while(y--)w[A][y]=((L[y]||0)-(M[y]||0))/t}}var O=j.easing,P=a.easing_formulas[O];if(!P){P=r(O).match(N);if(P&&P.length==5){var R=P;P=function(a){return cC(a,+R[1],+R[2],+R[3],+R[4],t)}}else P=bf}q=j.start||b.start||+(new Date),x={anim:b,percent:e,timestamp:q,start:q+(b.del||0),status:0,initstatus:f||0,stop:!1,ms:t,easing:P,from:u,diff:w,to:v,el:d,callback:j.callback,prev:p,next:o,repeat:i||b.times,origin:d.attr(),totalOrigin:h},cy.push(x);if(f&&!k&&!l){x.stop=!0,x.start=new Date-t*f;if(cy.length==1)return cA()}l&&(x.start=new Date-x.ms*f),cy.length==1&&cz(cA)}else k.initstatus=f,k.start=new Date-k.ms*f;eve("raphael.anim.start."+d.id,d,b)}}function cD(a,b){var c=[],d={};this.ms=b,this.times=1;if(a){for(var e in a)a[g](e)&&(d[Q(e)]=a[e],c.push(Q(e)));c.sort(bd)}this.anim=d,this.top=c[c.length-1],this.percents=c}function cC(a,b,c,d,e,f){function o(a,b){var c,d,e,f,j,k;for(e=a,k=0;k<8;k++){f=m(e)-a;if(z(f)<b)return e;j=(3*i*e+2*h)*e+g;if(z(j)<1e-6)break;e=e-f/j}c=0,d=1,e=a;if(e<c)return c;if(e>d)return d;while(c<d){f=m(e);if(z(f-a)<b)return e;a>f?c=e:d=e,e=(d-c)/2+c}return e}function n(a,b){var c=o(a,b);return((l*c+k)*c+j)*c}function m(a){return((i*a+h)*a+g)*a}var g=3*b,h=3*(d-b)-g,i=1-g-h,j=3*c,k=3*(e-c)-j,l=1-j-k;return n(a,1/(200*f))}function cq(){return this.x+q+this.y+q+this.width+" × "+this.height}function cp(){return this.x+q+this.y}function cb(a,b,c,d,e,f){a!=null?(this.a=+a,this.b=+b,this.c=+c,this.d=+d,this.e=+e,this.f=+f):(this.a=1,this.b=0,this.c=0,this.d=1,this.e=0,this.f=0)}function bH(b,c,d){b=a._path2curve(b),c=a._path2curve(c);var e,f,g,h,i,j,k,l,m,n,o=d?0:[];for(var p=0,q=b.length;p<q;p++){var r=b[p];if(r[0]=="M")e=i=r[1],f=j=r[2];else{r[0]=="C"?(m=[e,f].concat(r.slice(1)),e=m[6],f=m[7]):(m=[e,f,e,f,i,j,i,j],e=i,f=j);for(var s=0,t=c.length;s<t;s++){var u=c[s];if(u[0]=="M")g=k=u[1],h=l=u[2];else{u[0]=="C"?(n=[g,h].concat(u.slice(1)),g=n[6],h=n[7]):(n=[g,h,g,h,k,l,k,l],g=k,h=l);var v=bG(m,n,d);if(d)o+=v;else{for(var w=0,x=v.length;w<x;w++)v[w].segment1=p,v[w].segment2=s,v[w].bez1=m,v[w].bez2=n;o=o.concat(v)}}}}}return o}function bG(b,c,d){var e=a.bezierBBox(b),f=a.bezierBBox(c);if(!a.isBBoxIntersect(e,f))return d?0:[];var g=bB.apply(0,b),h=bB.apply(0,c),i=~~(g/5),j=~~(h/5),k=[],l=[],m={},n=d?0:[];for(var o=0;o<i+1;o++){var p=a.findDotsAtSegment.apply(a,b.concat(o/i));k.push({x:p.x,y:p.y,t:o/i})}for(o=0;o<j+1;o++)p=a.findDotsAtSegment.apply(a,c.concat(o/j)),l.push({x:p.x,y:p.y,t:o/j});for(o=0;o<i;o++)for(var q=0;q<j;q++){var r=k[o],s=k[o+1],t=l[q],u=l[q+1],v=z(s.x-r.x)<.001?"y":"x",w=z(u.x-t.x)<.001?"y":"x",x=bD(r.x,r.y,s.x,s.y,t.x,t.y,u.x,u.y);if(x){if(m[x.x.toFixed(4)]==x.y.toFixed(4))continue;m[x.x.toFixed(4)]=x.y.toFixed(4);var y=r.t+z((x[v]-r[v])/(s[v]-r[v]))*(s.t-r.t),A=t.t+z((x[w]-t[w])/(u[w]-t[w]))*(u.t-t.t);y>=0&&y<=1&&A>=0&&A<=1&&(d?n++:n.push({x:x.x,y:x.y,t1:y,t2:A}))}}return n}function bF(a,b){return bG(a,b,1)}function bE(a,b){return bG(a,b)}function bD(a,b,c,d,e,f,g,h){if(!(x(a,c)<y(e,g)||y(a,c)>x(e,g)||x(b,d)<y(f,h)||y(b,d)>x(f,h))){var i=(a*d-b*c)*(e-g)-(a-c)*(e*h-f*g),j=(a*d-b*c)*(f-h)-(b-d)*(e*h-f*g),k=(a-c)*(f-h)-(b-d)*(e-g);if(!k)return;var l=i/k,m=j/k,n=+l.toFixed(2),o=+m.toFixed(2);if(n<+y(a,c).toFixed(2)||n>+x(a,c).toFixed(2)||n<+y(e,g).toFixed(2)||n>+x(e,g).toFixed(2)||o<+y(b,d).toFixed(2)||o>+x(b,d).toFixed(2)||o<+y(f,h).toFixed(2)||o>+x(f,h).toFixed(2))return;return{x:l,y:m}}}function bC(a,b,c,d,e,f,g,h,i){if(!(i<0||bB(a,b,c,d,e,f,g,h)<i)){var j=1,k=j/2,l=j-k,m,n=.01;m=bB(a,b,c,d,e,f,g,h,l);while(z(m-i)>n)k/=2,l+=(m<i?1:-1)*k,m=bB(a,b,c,d,e,f,g,h,l);return l}}function bB(a,b,c,d,e,f,g,h,i){i==null&&(i=1),i=i>1?1:i<0?0:i;var j=i/2,k=12,l=[-0.1252,.1252,-0.3678,.3678,-0.5873,.5873,-0.7699,.7699,-0.9041,.9041,-0.9816,.9816],m=[.2491,.2491,.2335,.2335,.2032,.2032,.1601,.1601,.1069,.1069,.0472,.0472],n=0;for(var o=0;o<k;o++){var p=j*l[o]+j,q=bA(p,a,c,e,g),r=bA(p,b,d,f,h),s=q*q+r*r;n+=m[o]*w.sqrt(s)}return j*n}function bA(a,b,c,d,e){var f=-3*b+9*c-9*d+3*e,g=a*f+6*b-12*c+6*d;return a*g-3*b+3*c}function by(a,b){var c=[];for(var d=0,e=a.length;e-2*!b>d;d+=2){var f=[{x:+a[d-2],y:+a[d-1]},{x:+a[d],y:+a[d+1]},{x:+a[d+2],y:+a[d+3]},{x:+a[d+4],y:+a[d+5]}];b?d?e-4==d?f[3]={x:+a[0],y:+a[1]}:e-2==d&&(f[2]={x:+a[0],y:+a[1]},f[3]={x:+a[2],y:+a[3]}):f[0]={x:+a[e-2],y:+a[e-1]}:e-4==d?f[3]=f[2]:d||(f[0]={x:+a[d],y:+a[d+1]}),c.push(["C",(-f[0].x+6*f[1].x+f[2].x)/6,(-f[0].y+6*f[1].y+f[2].y)/6,(f[1].x+6*f[2].x-f[3].x)/6,(f[1].y+6*f[2].y-f[3].y)/6,f[2].x,f[2].y])}return c}function bx(){return this.hex}function bv(a,b,c){function d(){var e=Array.prototype.slice.call(arguments,0),f=e.join("␀"),h=d.cache=d.cache||{},i=d.count=d.count||[];if(h[g](f)){bu(i,f);return c?c(h[f]):h[f]}i.length>=1e3&&delete h[i.shift()],i.push(f),h[f]=a[m](b,e);return c?c(h[f]):h[f]}return d}function bu(a,b){for(var c=0,d=a.length;c<d;c++)if(a[c]===b)return a.push(a.splice(c,1)[0])}function bm(a){if(Object(a)!==a)return a;var b=new a.constructor;for(var c in a)a[g](c)&&(b[c]=bm(a[c]));return b}function a(c){if(a.is(c,"function"))return b?c():eve.on("raphael.DOMload",c);if(a.is(c,E))return a._engine.create[m](a,c.splice(0,3+a.is(c[0],C))).add(c);var d=Array.prototype.slice.call(arguments,0);if(a.is(d[d.length-1],"function")){var e=d.pop();return b?e.call(a._engine.create[m](a,d)):eve.on("raphael.DOMload",function(){e.call(a._engine.create[m](a,d))})}return a._engine.create[m](a,arguments)}a.version="2.1.0",a.eve=eve;var b,c=/[, ]+/,d={circle:1,rect:1,path:1,ellipse:1,text:1,image:1},e=/\{(\d+)\}/g,f="prototype",g="hasOwnProperty",h={doc:document,win:window},i={was:Object.prototype[g].call(h.win,"Raphael"),is:h.win.Raphael},j=function(){this.ca=this.customAttributes={}},k,l="appendChild",m="apply",n="concat",o="createTouch"in h.doc,p="",q=" ",r=String,s="split",t="click dblclick mousedown mousemove mouseout mouseover mouseup touchstart touchmove touchend touchcancel"[s](q),u={mousedown:"touchstart",mousemove:"touchmove",mouseup:"touchend"},v=r.prototype.toLowerCase,w=Math,x=w.max,y=w.min,z=w.abs,A=w.pow,B=w.PI,C="number",D="string",E="array",F="toString",G="fill",H=Object.prototype.toString,I={},J="push",K=a._ISURL=/^url\(['"]?([^\)]+?)['"]?\)$/i,L=/^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+%?)?)\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\))\s*$/i,M={NaN:1,Infinity:1,"-Infinity":1},N=/^(?:cubic-)?bezier\(([^,]+),([^,]+),([^,]+),([^\)]+)\)/,O=w.round,P="setAttribute",Q=parseFloat,R=parseInt,S=r.prototype.toUpperCase,T=a._availableAttrs={"arrow-end":"none","arrow-start":"none",blur:0,"clip-rect":"0 0 1e9 1e9",cursor:"default",cx:0,cy:0,fill:"#fff","fill-opacity":1,font:'10px "Arial"',"font-family":'"Arial"',"font-size":"10","font-style":"normal","font-weight":400,gradient:0,height:0,href:"http://raphaeljs.com/","letter-spacing":0,opacity:1,path:"M0,0",r:0,rx:0,ry:0,src:"",stroke:"#000","stroke-dasharray":"","stroke-linecap":"butt","stroke-linejoin":"butt","stroke-miterlimit":0,"stroke-opacity":1,"stroke-width":1,target:"_blank","text-anchor":"middle",title:"Raphael",transform:"",width:0,x:0,y:0},U=a._availableAnimAttrs={blur:C,"clip-rect":"csv",cx:C,cy:C,fill:"colour","fill-opacity":C,"font-size":C,height:C,opacity:C,path:"path",r:C,rx:C,ry:C,stroke:"colour","stroke-opacity":C,"stroke-width":C,transform:"transform",width:C,x:C,y:C},V=/[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]/g,W=/[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*/,X={hs:1,rg:1},Y=/,?([achlmqrstvxz]),?/gi,Z=/([achlmrqstvz])[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*)+)/ig,$=/([rstm])[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029,]*((-?\d*\.?\d*(?:e[\-+]?\d+)?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*)+)/ig,_=/(-?\d*\.?\d*(?:e[\-+]?\d+)?)[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,?[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*/ig,ba=a._radial_gradient=/^r(?:\(([^,]+?)[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*,[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\u2028\u2029]*([^\)]+?)\))?/,bb={},bc=function(a,b){return a.key-b.key},bd=function(a,b){return Q(a)-Q(b)},be=function(){},bf=function(a){return a},bg=a._rectPath=function(a,b,c,d,e){if(e)return[["M",a+e,b],["l",c-e*2,0],["a",e,e,0,0,1,e,e],["l",0,d-e*2],["a",e,e,0,0,1,-e,e],["l",e*2-c,0],["a",e,e,0,0,1,-e,-e],["l",0,e*2-d],["a",e,e,0,0,1,e,-e],["z"]];return[["M",a,b],["l",c,0],["l",0,d],["l",-c,0],["z"]]},bh=function(a,b,c,d){d==null&&(d=c);return[["M",a,b],["m",0,-d],["a",c,d,0,1,1,0,2*d],["a",c,d,0,1,1,0,-2*d],["z"]]},bi=a._getPath={path:function(a){return a.attr("path")},circle:function(a){var b=a.attrs;return bh(b.cx,b.cy,b.r)},ellipse:function(a){var b=a.attrs;return bh(b.cx,b.cy,b.rx,b.ry)},rect:function(a){var b=a.attrs;return bg(b.x,b.y,b.width,b.height,b.r)},image:function(a){var b=a.attrs;return bg(b.x,b.y,b.width,b.height)},text:function(a){var b=a._getBBox();return bg(b.x,b.y,b.width,b.height)}},bj=a.mapPath=function(a,b){if(!b)return a;var c,d,e,f,g,h,i;a=bR(a);for(e=0,g=a.length;e<g;e++){i=a[e];for(f=1,h=i.length;f<h;f+=2)c=b.x(i[f],i[f+1]),d=b.y(i[f],i[f+1]),i[f]=c,i[f+1]=d}return a};a._g=h,a.type=h.win.SVGAngle||h.doc.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure","1.1")?"SVG":"VML";if(a.type=="VML"){var bk=h.doc.createElement("div"),bl;bk.innerHTML='<v:shape adj="1"/>',bl=bk.firstChild,bl.style.behavior="url(#default#VML)";if(!bl||typeof bl.adj!="object")return a.type=p;bk=null}a.svg=!(a.vml=a.type=="VML"),a._Paper=j,a.fn=k=j.prototype=a.prototype,a._id=0,a._oid=0,a.is=function(a,b){b=v.call(b);if(b=="finite")return!M[g](+a);if(b=="array")return a instanceof Array;return b=="null"&&a===null||b==typeof a&&a!==null||b=="object"&&a===Object(a)||b=="array"&&Array.isArray&&Array.isArray(a)||H.call(a).slice(8,-1).toLowerCase()==b},a.angle=function(b,c,d,e,f,g){if(f==null){var h=b-d,i=c-e;if(!h&&!i)return 0;return(180+w.atan2(-i,-h)*180/B+360)%360}return a.angle(b,c,f,g)-a.angle(d,e,f,g)},a.rad=function(a){return a%360*B/180},a.deg=function(a){return a*180/B%360},a.snapTo=function(b,c,d){d=a.is(d,"finite")?d:10;if(a.is(b,E)){var e=b.length;while(e--)if(z(b[e]-c)<=d)return b[e]}else{b=+b;var f=c%b;if(f<d)return c-f;if(f>b-d)return c-f+b}return c};var bn=a.createUUID=function(a,b){return function(){return"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(a,b).toUpperCase()}}(/[xy]/g,function(a){var b=w.random()*16|0,c=a=="x"?b:b&3|8;return c.toString(16)});a.setWindow=function(b){eve("raphael.setWindow",a,h.win,b),h.win=b,h.doc=h.win.document,a._engine.initWin&&a._engine.initWin(h.win)};var bo=function(b){if(a.vml){var c=/^\s+|\s+$/g,d;try{var e=new ActiveXObject("htmlfile");e.write("<body>"),e.close(),d=e.body}catch(f){d=createPopup().document.body}var g=d.createTextRange();bo=bv(function(a){try{d.style.color=r(a).replace(c,p);var b=g.queryCommandValue("ForeColor");b=(b&255)<<16|b&65280|(b&16711680)>>>16;return"#"+("000000"+b.toString(16)).slice(-6)}catch(e){return"none"}})}else{var i=h.doc.createElement("i");i.title="Raphaël Colour Picker",i.style.display="none",h.doc.body.appendChild(i),bo=bv(function(a){i.style.color=a;return h.doc.defaultView.getComputedStyle(i,p).getPropertyValue("color")})}return bo(b)},bp=function(){return"hsb("+[this.h,this.s,this.b]+")"},bq=function(){return"hsl("+[this.h,this.s,this.l]+")"},br=function(){return this.hex},bs=function(b,c,d){c==null&&a.is(b,"object")&&"r"in b&&"g"in b&&"b"in b&&(d=b.b,c=b.g,b=b.r);if(c==null&&a.is(b,D)){var e=a.getRGB(b);b=e.r,c=e.g,d=e.b}if(b>1||c>1||d>1)b/=255,c/=255,d/=255;return[b,c,d]},bt=function(b,c,d,e){b*=255,c*=255,d*=255;var f={r:b,g:c,b:d,hex:a.rgb(b,c,d),toString:br};a.is(e,"finite")&&(f.opacity=e);return f};a.color=function(b){var c;a.is(b,"object")&&"h"in b&&"s"in b&&"b"in b?(c=a.hsb2rgb(b),b.r=c.r,b.g=c.g,b.b=c.b,b.hex=c.hex):a.is(b,"object")&&"h"in b&&"s"in b&&"l"in b?(c=a.hsl2rgb(b),b.r=c.r,b.g=c.g,b.b=c.b,b.hex=c.hex):(a.is(b,"string")&&(b=a.getRGB(b)),a.is(b,"object")&&"r"in b&&"g"in b&&"b"in b?(c=a.rgb2hsl(b),b.h=c.h,b.s=c.s,b.l=c.l,c=a.rgb2hsb(b),b.v=c.b):(b={hex:"none"},b.r=b.g=b.b=b.h=b.s=b.v=b.l=-1)),b.toString=br;return b},a.hsb2rgb=function(a,b,c,d){this.is(a,"object")&&"h"in a&&"s"in a&&"b"in a&&(c=a.b,b=a.s,a=a.h,d=a.o),a*=360;var e,f,g,h,i;a=a%360/60,i=c*b,h=i*(1-z(a%2-1)),e=f=g=c-i,a=~~a,e+=[i,h,0,0,h,i][a],f+=[h,i,i,h,0,0][a],g+=[0,0,h,i,i,h][a];return bt(e,f,g,d)},a.hsl2rgb=function(a,b,c,d){this.is(a,"object")&&"h"in a&&"s"in a&&"l"in a&&(c=a.l,b=a.s,a=a.h);if(a>1||b>1||c>1)a/=360,b/=100,c/=100;a*=360;var e,f,g,h,i;a=a%360/60,i=2*b*(c<.5?c:1-c),h=i*(1-z(a%2-1)),e=f=g=c-i/2,a=~~a,e+=[i,h,0,0,h,i][a],f+=[h,i,i,h,0,0][a],g+=[0,0,h,i,i,h][a];return bt(e,f,g,d)},a.rgb2hsb=function(a,b,c){c=bs(a,b,c),a=c[0],b=c[1],c=c[2];var d,e,f,g;f=x(a,b,c),g=f-y(a,b,c),d=g==0?null:f==a?(b-c)/g:f==b?(c-a)/g+2:(a-b)/g+4,d=(d+360)%6*60/360,e=g==0?0:g/f;return{h:d,s:e,b:f,toString:bp}},a.rgb2hsl=function(a,b,c){c=bs(a,b,c),a=c[0],b=c[1],c=c[2];var d,e,f,g,h,i;g=x(a,b,c),h=y(a,b,c),i=g-h,d=i==0?null:g==a?(b-c)/i:g==b?(c-a)/i+2:(a-b)/i+4,d=(d+360)%6*60/360,f=(g+h)/2,e=i==0?0:f<.5?i/(2*f):i/(2-2*f);return{h:d,s:e,l:f,toString:bq}},a._path2string=function(){return this.join(",").replace(Y,"$1")};var bw=a._preload=function(a,b){var c=h.doc.createElement("img");c.style.cssText="position:absolute;left:-9999em;top:-9999em",c.onload=function(){b.call(this),this.onload=null,h.doc.body.removeChild(this)},c.onerror=function(){h.doc.body.removeChild(this)},h.doc.body.appendChild(c),c.src=a};a.getRGB=bv(function(b){if(!b||!!((b=r(b)).indexOf("-")+1))return{r:-1,g:-1,b:-1,hex:"none",error:1,toString:bx};if(b=="none")return{r:-1,g:-1,b:-1,hex:"none",toString:bx};!X[g](b.toLowerCase().substring(0,2))&&b.charAt()!="#"&&(b=bo(b));var c,d,e,f,h,i,j,k=b.match(L);if(k){k[2]&&(f=R(k[2].substring(5),16),e=R(k[2].substring(3,5),16),d=R(k[2].substring(1,3),16)),k[3]&&(f=R((i=k[3].charAt(3))+i,16),e=R((i=k[3].charAt(2))+i,16),d=R((i=k[3].charAt(1))+i,16)),k[4]&&(j=k[4][s](W),d=Q(j[0]),j[0].slice(-1)=="%"&&(d*=2.55),e=Q(j[1]),j[1].slice(-1)=="%"&&(e*=2.55),f=Q(j[2]),j[2].slice(-1)=="%"&&(f*=2.55),k[1].toLowerCase().slice(0,4)=="rgba"&&(h=Q(j[3])),j[3]&&j[3].slice(-1)=="%"&&(h/=100));if(k[5]){j=k[5][s](W),d=Q(j[0]),j[0].slice(-1)=="%"&&(d*=2.55),e=Q(j[1]),j[1].slice(-1)=="%"&&(e*=2.55),f=Q(j[2]),j[2].slice(-1)=="%"&&(f*=2.55),(j[0].slice(-3)=="deg"||j[0].slice(-1)=="°")&&(d/=360),k[1].toLowerCase().slice(0,4)=="hsba"&&(h=Q(j[3])),j[3]&&j[3].slice(-1)=="%"&&(h/=100);return a.hsb2rgb(d,e,f,h)}if(k[6]){j=k[6][s](W),d=Q(j[0]),j[0].slice(-1)=="%"&&(d*=2.55),e=Q(j[1]),j[1].slice(-1)=="%"&&(e*=2.55),f=Q(j[2]),j[2].slice(-1)=="%"&&(f*=2.55),(j[0].slice(-3)=="deg"||j[0].slice(-1)=="°")&&(d/=360),k[1].toLowerCase().slice(0,4)=="hsla"&&(h=Q(j[3])),j[3]&&j[3].slice(-1)=="%"&&(h/=100);return a.hsl2rgb(d,e,f,h)}k={r:d,g:e,b:f,toString:bx},k.hex="#"+(16777216|f|e<<8|d<<16).toString(16).slice(1),a.is(h,"finite")&&(k.opacity=h);return k}return{r:-1,g:-1,b:-1,hex:"none",error:1,toString:bx}},a),a.hsb=bv(function(b,c,d){return a.hsb2rgb(b,c,d).hex}),a.hsl=bv(function(b,c,d){return a.hsl2rgb(b,c,d).hex}),a.rgb=bv(function(a,b,c){return"#"+(16777216|c|b<<8|a<<16).toString(16).slice(1)}),a.getColor=function(a){var b=this.getColor.start=this.getColor.start||{h:0,s:1,b:a||.75},c=this.hsb2rgb(b.h,b.s,b.b);b.h+=.075,b.h>1&&(b.h=0,b.s-=.2,b.s<=0&&(this.getColor.start={h:0,s:1,b:b.b}));return c.hex},a.getColor.reset=function(){delete this.start},a.parsePathString=function(b){if(!b)return null;var c=bz(b);if(c.arr)return bJ(c.arr);var d={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},e=[];a.is(b,E)&&a.is(b[0],E)&&(e=bJ(b)),e.length||r(b).replace(Z,function(a,b,c){var f=[],g=b.toLowerCase();c.replace(_,function(a,b){b&&f.push(+b)}),g=="m"&&f.length>2&&(e.push([b][n](f.splice(0,2))),g="l",b=b=="m"?"l":"L");if(g=="r")e.push([b][n](f));else while(f.length>=d[g]){e.push([b][n](f.splice(0,d[g])));if(!d[g])break}}),e.toString=a._path2string,c.arr=bJ(e);return e},a.parseTransformString=bv(function(b){if(!b)return null;var c={r:3,s:4,t:2,m:6},d=[];a.is(b,E)&&a.is(b[0],E)&&(d=bJ(b)),d.length||r(b).replace($,function(a,b,c){var e=[],f=v.call(b);c.replace(_,function(a,b){b&&e.push(+b)}),d.push([b][n](e))}),d.toString=a._path2string;return d});var bz=function(a){var b=bz.ps=bz.ps||{};b[a]?b[a].sleep=100:b[a]={sleep:100},setTimeout(function(){for(var c in b)b[g](c)&&c!=a&&(b[c].sleep--,!b[c].sleep&&delete b[c])});return b[a]};a.findDotsAtSegment=function(a,b,c,d,e,f,g,h,i){var j=1-i,k=A(j,3),l=A(j,2),m=i*i,n=m*i,o=k*a+l*3*i*c+j*3*i*i*e+n*g,p=k*b+l*3*i*d+j*3*i*i*f+n*h,q=a+2*i*(c-a)+m*(e-2*c+a),r=b+2*i*(d-b)+m*(f-2*d+b),s=c+2*i*(e-c)+m*(g-2*e+c),t=d+2*i*(f-d)+m*(h-2*f+d),u=j*a+i*c,v=j*b+i*d,x=j*e+i*g,y=j*f+i*h,z=90-w.atan2(q-s,r-t)*180/B;(q>s||r<t)&&(z+=180);return{x:o,y:p,m:{x:q,y:r},n:{x:s,y:t},start:{x:u,y:v},end:{x:x,y:y},alpha:z}},a.bezierBBox=function(b,c,d,e,f,g,h,i){a.is(b,"array")||(b=[b,c,d,e,f,g,h,i]);var j=bQ.apply(null,b);return{x:j.min.x,y:j.min.y,x2:j.max.x,y2:j.max.y,width:j.max.x-j.min.x,height:j.max.y-j.min.y}},a.isPointInsideBBox=function(a,b,c){return b>=a.x&&b<=a.x2&&c>=a.y&&c<=a.y2},a.isBBoxIntersect=function(b,c){var d=a.isPointInsideBBox;return d(c,b.x,b.y)||d(c,b.x2,b.y)||d(c,b.x,b.y2)||d(c,b.x2,b.y2)||d(b,c.x,c.y)||d(b,c.x2,c.y)||d(b,c.x,c.y2)||d(b,c.x2,c.y2)||(b.x<c.x2&&b.x>c.x||c.x<b.x2&&c.x>b.x)&&(b.y<c.y2&&b.y>c.y||c.y<b.y2&&c.y>b.y)},a.pathIntersection=function(a,b){return bH(a,b)},a.pathIntersectionNumber=function(a,b){return bH(a,b,1)},a.isPointInsidePath=function(b,c,d){var e=a.pathBBox(b);return a.isPointInsideBBox(e,c,d)&&bH(b,[["M",c,d],["H",e.x2+10]],1)%2==1},a._removedFactory=function(a){return function(){eve("raphael.log",null,"Raphaël: you are calling to method “"+a+"” of removed object",a)}};var bI=a.pathBBox=function(a){var b=bz(a);if(b.bbox)return b.bbox;if(!a)return{x:0,y:0,width:0,height:0,x2:0,y2:0};a=bR(a);var c=0,d=0,e=[],f=[],g;for(var h=0,i=a.length;h<i;h++){g=a[h];if(g[0]=="M")c=g[1],d=g[2],e.push(c),f.push(d);else{var j=bQ(c,d,g[1],g[2],g[3],g[4],g[5],g[6]);e=e[n](j.min.x,j.max.x),f=f[n](j.min.y,j.max.y),c=g[5],d=g[6]}}var k=y[m](0,e),l=y[m](0,f),o=x[m](0,e),p=x[m](0,f),q={x:k,y:l,x2:o,y2:p,width:o-k,height:p-l};b.bbox=bm(q);return q},bJ=function(b){var c=bm(b);c.toString=a._path2string;return c},bK=a._pathToRelative=function(b){var c=bz(b);if(c.rel)return bJ(c.rel);if(!a.is(b,E)||!a.is(b&&b[0],E))b=a.parsePathString(b);var d=[],e=0,f=0,g=0,h=0,i=0;b[0][0]=="M"&&(e=b[0][1],f=b[0][2],g=e,h=f,i++,d.push(["M",e,f]));for(var j=i,k=b.length;j<k;j++){var l=d[j]=[],m=b[j];if(m[0]!=v.call(m[0])){l[0]=v.call(m[0]);switch(l[0]){case"a":l[1]=m[1],l[2]=m[2],l[3]=m[3],l[4]=m[4],l[5]=m[5],l[6]=+(m[6]-e).toFixed(3),l[7]=+(m[7]-f).toFixed(3);break;case"v":l[1]=+(m[1]-f).toFixed(3);break;case"m":g=m[1],h=m[2];default:for(var n=1,o=m.length;n<o;n++)l[n]=+(m[n]-(n%2?e:f)).toFixed(3)}}else{l=d[j]=[],m[0]=="m"&&(g=m[1]+e,h=m[2]+f);for(var p=0,q=m.length;p<q;p++)d[j][p]=m[p]}var r=d[j].length;switch(d[j][0]){case"z":e=g,f=h;break;case"h":e+=+d[j][r-1];break;case"v":f+=+d[j][r-1];break;default:e+=+d[j][r-2],f+=+d[j][r-1]}}d.toString=a._path2string,c.rel=bJ(d);return d},bL=a._pathToAbsolute=function(b){var c=bz(b);if(c.abs)return bJ(c.abs);if(!a.is(b,E)||!a.is(b&&b[0],E))b=a.parsePathString(b);if(!b||!b.length)return[["M",0,0]];var d=[],e=0,f=0,g=0,h=0,i=0;b[0][0]=="M"&&(e=+b[0][1],f=+b[0][2],g=e,h=f,i++,d[0]=["M",e,f]);var j=b.length==3&&b[0][0]=="M"&&b[1][0].toUpperCase()=="R"&&b[2][0].toUpperCase()=="Z";for(var k,l,m=i,o=b.length;m<o;m++){d.push(k=[]),l=b[m];if(l[0]!=S.call(l[0])){k[0]=S.call(l[0]);switch(k[0]){case"A":k[1]=l[1],k[2]=l[2],k[3]=l[3],k[4]=l[4],k[5]=l[5],k[6]=+(l[6]+e),k[7]=+(l[7]+f);break;case"V":k[1]=+l[1]+f;break;case"H":k[1]=+l[1]+e;break;case"R":var p=[e,f][n](l.slice(1));for(var q=2,r=p.length;q<r;q++)p[q]=+p[q]+e,p[++q]=+p[q]+f;d.pop(),d=d[n](by(p,j));break;case"M":g=+l[1]+e,h=+l[2]+f;default:for(q=1,r=l.length;q<r;q++)k[q]=+l[q]+(q%2?e:f)}}else if(l[0]=="R")p=[e,f][n](l.slice(1)),d.pop(),d=d[n](by(p,j)),k=["R"][n](l.slice(-2));else for(var s=0,t=l.length;s<t;s++)k[s]=l[s];switch(k[0]){case"Z":e=g,f=h;break;case"H":e=k[1];break;case"V":f=k[1];break;case"M":g=k[k.length-2],h=k[k.length-1];default:e=k[k.length-2],f=k[k.length-1]}}d.toString=a._path2string,c.abs=bJ(d);return d},bM=function(a,b,c,d){return[a,b,c,d,c,d]},bN=function(a,b,c,d,e,f){var g=1/3,h=2/3;return[g*a+h*c,g*b+h*d,g*e+h*c,g*f+h*d,e,f]},bO=function(a,b,c,d,e,f,g,h,i,j){var k=B*120/180,l=B/180*(+e||0),m=[],o,p=bv(function(a,b,c){var d=a*w.cos(c)-b*w.sin(c),e=a*w.sin(c)+b*w.cos(c);return{x:d,y:e}});if(!j){o=p(a,b,-l),a=o.x,b=o.y,o=p(h,i,-l),h=o.x,i=o.y;var q=w.cos(B/180*e),r=w.sin(B/180*e),t=(a-h)/2,u=(b-i)/2,v=t*t/(c*c)+u*u/(d*d);v>1&&(v=w.sqrt(v),c=v*c,d=v*d);var x=c*c,y=d*d,A=(f==g?-1:1)*w.sqrt(z((x*y-x*u*u-y*t*t)/(x*u*u+y*t*t))),C=A*c*u/d+(a+h)/2,D=A*-d*t/c+(b+i)/2,E=w.asin(((b-D)/d).toFixed(9)),F=w.asin(((i-D)/d).toFixed(9));E=a<C?B-E:E,F=h<C?B-F:F,E<0&&(E=B*2+E),F<0&&(F=B*2+F),g&&E>F&&(E=E-B*2),!g&&F>E&&(F=F-B*2)}else E=j[0],F=j[1],C=j[2],D=j[3];var G=F-E;if(z(G)>k){var H=F,I=h,J=i;F=E+k*(g&&F>E?1:-1),h=C+c*w.cos(F),i=D+d*w.sin(F),m=bO(h,i,c,d,e,0,g,I,J,[F,H,C,D])}G=F-E;var K=w.cos(E),L=w.sin(E),M=w.cos(F),N=w.sin(F),O=w.tan(G/4),P=4/3*c*O,Q=4/3*d*O,R=[a,b],S=[a+P*L,b-Q*K],T=[h+P*N,i-Q*M],U=[h,i];S[0]=2*R[0]-S[0],S[1]=2*R[1]-S[1];if(j)return[S,T,U][n](m);m=[S,T,U][n](m).join()[s](",");var V=[];for(var W=0,X=m.length;W<X;W++)V[W]=W%2?p(m[W-1],m[W],l).y:p(m[W],m[W+1],l).x;return V},bP=function(a,b,c,d,e,f,g,h,i){var j=1-i;return{x:A(j,3)*a+A(j,2)*3*i*c+j*3*i*i*e+A(i,3)*g,y:A(j,3)*b+A(j,2)*3*i*d+j*3*i*i*f+A(i,3)*h}},bQ=bv(function(a,b,c,d,e,f,g,h){var i=e-2*c+a-(g-2*e+c),j=2*(c-a)-2*(e-c),k=a-c,l=(-j+w.sqrt(j*j-4*i*k))/2/i,n=(-j-w.sqrt(j*j-4*i*k))/2/i,o=[b,h],p=[a,g],q;z(l)>"1e12"&&(l=.5),z(n)>"1e12"&&(n=.5),l>0&&l<1&&(q=bP(a,b,c,d,e,f,g,h,l),p.push(q.x),o.push(q.y)),n>0&&n<1&&(q=bP(a,b,c,d,e,f,g,h,n),p.push(q.x),o.push(q.y)),i=f-2*d+b-(h-2*f+d),j=2*(d-b)-2*(f-d),k=b-d,l=(-j+w.sqrt(j*j-4*i*k))/2/i,n=(-j-w.sqrt(j*j-4*i*k))/2/i,z(l)>"1e12"&&(l=.5),z(n)>"1e12"&&(n=.5),l>0&&l<1&&(q=bP(a,b,c,d,e,f,g,h,l),p.push(q.x),o.push(q.y)),n>0&&n<1&&(q=bP(a,b,c,d,e,f,g,h,n),p.push(q.x),o.push(q.y));return{min:{x:y[m](0,p),y:y[m](0,o)},max:{x:x[m](0,p),y:x[m](0,o)}}}),bR=a._path2curve=bv(function(a,b){var c=!b&&bz(a);if(!b&&c.curve)return bJ(c.curve);var d=bL(a),e=b&&bL(b),f={x:0,y:0,bx:0,by:0,X:0,Y:0,qx:null,qy:null},g={x:0,y:0,bx:0,by:0,X:0,Y:0,qx:null,qy:null},h=function(a,b){var c,d;if(!a)return["C",b.x,b.y,b.x,b.y,b.x,b.y];!(a[0]in{T:1,Q:1})&&(b.qx=b.qy=null);switch(a[0]){case"M":b.X=a[1],b.Y=a[2];break;case"A":a=["C"][n](bO[m](0,[b.x,b.y][n](a.slice(1))));break;case"S":c=b.x+(b.x-(b.bx||b.x)),d=b.y+(b.y-(b.by||b.y)),a=["C",c,d][n](a.slice(1));break;case"T":b.qx=b.x+(b.x-(b.qx||b.x)),b.qy=b.y+(b.y-(b.qy||b.y)),a=["C"][n](bN(b.x,b.y,b.qx,b.qy,a[1],a[2]));break;case"Q":b.qx=a[1],b.qy=a[2],a=["C"][n](bN(b.x,b.y,a[1],a[2],a[3],a[4]));break;case"L":a=["C"][n](bM(b.x,b.y,a[1],a[2]));break;case"H":a=["C"][n](bM(b.x,b.y,a[1],b.y));break;case"V":a=["C"][n](bM(b.x,b.y,b.x,a[1]));break;case"Z":a=["C"][n](bM(b.x,b.y,b.X,b.Y))}return a},i=function(a,b){if(a[b].length>7){a[b].shift();var c=a[b];while(c.length)a.splice(b++,0,["C"][n](c.splice(0,6)));a.splice(b,1),l=x(d.length,e&&e.length||0)}},j=function(a,b,c,f,g){a&&b&&a[g][0]=="M"&&b[g][0]!="M"&&(b.splice(g,0,["M",f.x,f.y]),c.bx=0,c.by=0,c.x=a[g][1],c.y=a[g][2],l=x(d.length,e&&e.length||0))};for(var k=0,l=x(d.length,e&&e.length||0);k<l;k++){d[k]=h(d[k],f),i(d,k),e&&(e[k]=h(e[k],g)),e&&i(e,k),j(d,e,f,g,k),j(e,d,g,f,k);var o=d[k],p=e&&e[k],q=o.length,r=e&&p.length;f.x=o[q-2],f.y=o[q-1],f.bx=Q(o[q-4])||f.x,f.by=Q(o[q-3])||f.y,g.bx=e&&(Q(p[r-4])||g.x),g.by=e&&(Q(p[r-3])||g.y),g.x=e&&p[r-2],g.y=e&&p[r-1]}e||(c.curve=bJ(d));return e?[d,e]:d},null,bJ),bS=a._parseDots=bv(function(b){var c=[];for(var d=0,e=b.length;d<e;d++){var f={},g=b[d].match(/^([^:]*):?([\d\.]*)/);f.color=a.getRGB(g[1]);if(f.color.error)return null;f.color=f.color.hex,g[2]&&(f.offset=g[2]+"%"),c.push(f)}for(d=1,e=c.length-1;d<e;d++)if(!c[d].offset){var h=Q(c[d-1].offset||0),i=0;for(var j=d+1;j<e;j++)if(c[j].offset){i=c[j].offset;break}i||(i=100,j=e),i=Q(i);var k=(i-h)/(j-d+1);for(;d<j;d++)h+=k,c[d].offset=h+"%"}return c}),bT=a._tear=function(a,b){a==b.top&&(b.top=a.prev),a==b.bottom&&(b.bottom=a.next),a.next&&(a.next.prev=a.prev),a.prev&&(a.prev.next=a.next)},bU=a._tofront=function(a,b){b.top!==a&&(bT(a,b),a.next=null,a.prev=b.top,b.top.next=a,b.top=a)},bV=a._toback=function(a,b){b.bottom!==a&&(bT(a,b),a.next=b.bottom,a.prev=null,b.bottom.prev=a,b.bottom=a)},bW=a._insertafter=function(a,b,c){bT(a,c),b==c.top&&(c.top=a),b.next&&(b.next.prev=a),a.next=b.next,a.prev=b,b.next=a},bX=a._insertbefore=function(a,b,c){bT(a,c),b==c.bottom&&(c.bottom=a),b.prev&&(b.prev.next=a),a.prev=b.prev,b.prev=a,a.next=b},bY=a.toMatrix=function(a,b){var c=bI(a),d={_:{transform:p},getBBox:function(){return c}};b$(d,b);return d.matrix},bZ=a.transformPath=function(a,b){return bj(a,bY(a,b))},b$=a._extractTransform=function(b,c){if(c==null)return b._.transform;c=r(c).replace(/\.{3}|\u2026/g,b._.transform||p);var d=a.parseTransformString(c),e=0,f=0,g=0,h=1,i=1,j=b._,k=new cb;j.transform=d||[];if(d)for(var l=0,m=d.length;l<m;l++){var n=d[l],o=n.length,q=r(n[0]).toLowerCase(),s=n[0]!=q,t=s?k.invert():0,u,v,w,x,y;q=="t"&&o==3?s?(u=t.x(0,0),v=t.y(0,0),w=t.x(n[1],n[2]),x=t.y(n[1],n[2]),k.translate(w-u,x-v)):k.translate(n[1],n[2]):q=="r"?o==2?(y=y||b.getBBox(1),k.rotate(n[1],y.x+y.width/2,y.y+y.height/2),e+=n[1]):o==4&&(s?(w=t.x(n[2],n[3]),x=t.y(n[2],n[3]),k.rotate(n[1],w,x)):k.rotate(n[1],n[2],n[3]),e+=n[1]):q=="s"?o==2||o==3?(y=y||b.getBBox(1),k.scale(n[1],n[o-1],y.x+y.width/2,y.y+y.height/2),h*=n[1],i*=n[o-1]):o==5&&(s?(w=t.x(n[3],n[4]),x=t.y(n[3],n[4]),k.scale(n[1],n[2],w,x)):k.scale(n[1],n[2],n[3],n[4]),h*=n[1],i*=n[2]):q=="m"&&o==7&&k.add(n[1],n[2],n[3],n[4],n[5],n[6]),j.dirtyT=1,b.matrix=k}b.matrix=k,j.sx=h,j.sy=i,j.deg=e,j.dx=f=k.e,j.dy=g=k.f,h==1&&i==1&&!e&&j.bbox?(j.bbox.x+=+f,j.bbox.y+=+g):j.dirtyT=1},b_=function(a){var b=a[0];switch(b.toLowerCase()){case"t":return[b,0,0];case"m":return[b,1,0,0,1,0,0];case"r":return a.length==4?[b,0,a[2],a[3]]:[b,0];case"s":return a.length==5?[b,1,1,a[3],a[4]]:a.length==3?[b,1,1]:[b,1]}},ca=a._equaliseTransform=function(b,c){c=r(c).replace(/\.{3}|\u2026/g,b),b=a.parseTransformString(b)||[],c=a.parseTransformString(c)||[];var d=x(b.length,c.length),e=[],f=[],g=0,h,i,j,k;for(;g<d;g++){j=b[g]||b_(c[g]),k=c[g]||b_(j);if(j[0]!=k[0]||j[0].toLowerCase()=="r"&&(j[2]!=k[2]||j[3]!=k[3])||j[0].toLowerCase()=="s"&&(j[3]!=k[3]||j[4]!=k[4]))return;e[g]=[],f[g]=[];for(h=0,i=x(j.length,k.length);h<i;h++)h in j&&(e[g][h]=j[h]),h in k&&(f[g][h]=k[h])}return{from:e,to:f}};a._getContainer=function(b,c,d,e){var f;f=e==null&&!a.is(b,"object")?h.doc.getElementById(b):b;if(f!=null){if(f.tagName)return c==null?{container:f,width:f.style.pixelWidth||f.offsetWidth,height:f.style.pixelHeight||f.offsetHeight}:{container:f,width:c,height:d};return{container:1,x:b,y:c,width:d,height:e}}},a.pathToRelative=bK,a._engine={},a.path2curve=bR,a.matrix=function(a,b,c,d,e,f){return new cb(a,b,c,d,e,f)},function(b){function d(a){var b=w.sqrt(c(a));a[0]&&(a[0]/=b),a[1]&&(a[1]/=b)}function c(a){return a[0]*a[0]+a[1]*a[1]}b.add=function(a,b,c,d,e,f){var g=[[],[],[]],h=[[this.a,this.c,this.e],[this.b,this.d,this.f],[0,0,1]],i=[[a,c,e],[b,d,f],[0,0,1]],j,k,l,m;a&&a instanceof cb&&(i=[[a.a,a.c,a.e],[a.b,a.d,a.f],[0,0,1]]);for(j=0;j<3;j++)for(k=0;k<3;k++){m=0;for(l=0;l<3;l++)m+=h[j][l]*i[l][k];g[j][k]=m}this.a=g[0][0],this.b=g[1][0],this.c=g[0][1],this.d=g[1][1],this.e=g[0][2],this.f=g[1][2]},b.invert=function(){var a=this,b=a.a*a.d-a.b*a.c;return new cb(a.d/b,-a.b/b,-a.c/b,a.a/b,(a.c*a.f-a.d*a.e)/b,(a.b*a.e-a.a*a.f)/b)},b.clone=function(){return new cb(this.a,this.b,this.c,this.d,this.e,this.f)},b.translate=function(a,b){this.add(1,0,0,1,a,b)},b.scale=function(a,b,c,d){b==null&&(b=a),(c||d)&&this.add(1,0,0,1,c,d),this.add(a,0,0,b,0,0),(c||d)&&this.add(1,0,0,1,-c,-d)},b.rotate=function(b,c,d){b=a.rad(b),c=c||0,d=d||0;var e=+w.cos(b).toFixed(9),f=+w.sin(b).toFixed(9);this.add(e,f,-f,e,c,d),this.add(1,0,0,1,-c,-d)},b.x=function(a,b){return a*this.a+b*this.c+this.e},b.y=function(a,b){return a*this.b+b*this.d+this.f},b.get=function(a){return+this[r.fromCharCode(97+a)].toFixed(4)},b.toString=function(){return a.svg?"matrix("+[this.get(0),this.get(1),this.get(2),this.get(3),this.get(4),this.get(5)].join()+")":[this.get(0),this.get(2),this.get(1),this.get(3),0,0].join()},b.toFilter=function(){return"progid:DXImageTransform.Microsoft.Matrix(M11="+this.get(0)+", M12="+this.get(2)+", M21="+this.get(1)+", M22="+this.get(3)+", Dx="+this.get(4)+", Dy="+this.get(5)+", sizingmethod='auto expand')"},b.offset=function(){return[this.e.toFixed(4),this.f.toFixed(4)]},b.split=function(){var b={};b.dx=this.e,b.dy=this.f;var e=[[this.a,this.c],[this.b,this.d]];b.scalex=w.sqrt(c(e[0])),d(e[0]),b.shear=e[0][0]*e[1][0]+e[0][1]*e[1][1],e[1]=[e[1][0]-e[0][0]*b.shear,e[1][1]-e[0][1]*b.shear],b.scaley=w.sqrt(c(e[1])),d(e[1]),b.shear/=b.scaley;var f=-e[0][1],g=e[1][1];g<0?(b.rotate=a.deg(w.acos(g)),f<0&&(b.rotate=360-b.rotate)):b.rotate=a.deg(w.asin(f)),b.isSimple=!+b.shear.toFixed(9)&&(b.scalex.toFixed(9)==b.scaley.toFixed(9)||!b.rotate),b.isSuperSimple=!+b.shear.toFixed(9)&&b.scalex.toFixed(9)==b.scaley.toFixed(9)&&!b.rotate,b.noRotation=!+b.shear.toFixed(9)&&!b.rotate;return b},b.toTransformString=function(a){var b=a||this[s]();if(b.isSimple){b.scalex=+b.scalex.toFixed(4),b.scaley=+b.scaley.toFixed(4),b.rotate=+b.rotate.toFixed(4);return(b.dx||b.dy?"t"+[b.dx,b.dy]:p)+(b.scalex!=1||b.scaley!=1?"s"+[b.scalex,b.scaley,0,0]:p)+(b.rotate?"r"+[b.rotate,0,0]:p)}return"m"+[this.get(0),this.get(1),this.get(2),this.get(3),this.get(4),this.get(5)]}}(cb.prototype);var cc=navigator.userAgent.match(/Version\/(.*?)\s/)||navigator.userAgent.match(/Chrome\/(\d+)/);navigator.vendor=="Apple Computer, Inc."&&(cc&&cc[1]<4||navigator.platform.slice(0,2)=="iP")||navigator.vendor=="Google Inc."&&cc&&cc[1]<8?k.safari=function(){var a=this.rect(-99,-99,this.width+99,this.height+99).attr({stroke:"none"});setTimeout(function(){a.remove()})}:k.safari=be;var cd=function(){this.returnValue=!1},ce=function(){return this.originalEvent.preventDefault()},cf=function(){this.cancelBubble=!0},cg=function(){return this.originalEvent.stopPropagation()},ch=function(){if(h.doc.addEventListener)return function(a,b,c,d){var e=o&&u[b]?u[b]:b,f=function(e){var f=h.doc.documentElement.scrollTop||h.doc.body.scrollTop,i=h.doc.documentElement.scrollLeft||h.doc.body.scrollLeft,j=e.clientX+i,k=e.clientY+f;if(o&&u[g](b))for(var l=0,m=e.targetTouches&&e.targetTouches.length;l<m;l++)if(e.targetTouches[l].target==a){var n=e;e=e.targetTouches[l],e.originalEvent=n,e.preventDefault=ce,e.stopPropagation=cg;break}return c.call(d,e,j,k)};a.addEventListener(e,f,!1);return function(){a.removeEventListener(e,f,!1);return!0}};if(h.doc.attachEvent)return function(a,b,c,d){var e=function(a){a=a||h.win.event;var b=h.doc.documentElement.scrollTop||h.doc.body.scrollTop,e=h.doc.documentElement.scrollLeft||h.doc.body.scrollLeft,f=a.clientX+e,g=a.clientY+b;a.preventDefault=a.preventDefault||cd,a.stopPropagation=a.stopPropagation||cf;return c.call(d,a,f,g)};a.attachEvent("on"+b,e);var f=function(){a.detachEvent("on"+b,e);return!0};return f}}(),ci=[],cj=function(a){var b=a.clientX,c=a.clientY,d=h.doc.documentElement.scrollTop||h.doc.body.scrollTop,e=h.doc.documentElement.scrollLeft||h.doc.body.scrollLeft,f,g=ci.length;while(g--){f=ci[g];if(o){var i=a.touches.length,j;while(i--){j=a.touches[i];if(j.identifier==f.el._drag.id){b=j.clientX,c=j.clientY,(a.originalEvent?a.originalEvent:a).preventDefault();break}}}else a.preventDefault();var k=f.el.node,l,m=k.nextSibling,n=k.parentNode,p=k.style.display;h.win.opera&&n.removeChild(k),k.style.display="none",l=f.el.paper.getElementByPoint(b,c),k.style.display=p,h.win.opera&&(m?n.insertBefore(k,m):n.appendChild(k)),l&&eve("raphael.drag.over."+f.el.id,f.el,l),b+=e,c+=d,eve("raphael.drag.move."+f.el.id,f.move_scope||f.el,b-f.el._drag.x,c-f.el._drag.y,b,c,a)}},ck=function(b){a.unmousemove(cj).unmouseup(ck);var c=ci.length,d;while(c--)d=ci[c],d.el._drag={},eve("raphael.drag.end."+d.el.id,d.end_scope||d.start_scope||d.move_scope||d.el,b);ci=[]},cl=a.el={};for(var cm=t.length;cm--;)(function(b){a[b]=cl[b]=function(c,d){a.is(c,"function")&&(this.events=this.events||[],this.events.push({name:b,f:c,unbind:ch(this.shape||this.node||h.doc,b,c,d||this)}));return this},a["un"+b]=cl["un"+b]=function(a){var c=this.events||[],d=c.length;while(d--)if(c[d].name==b&&c[d].f==a){c[d].unbind(),c.splice(d,1),!c.length&&delete this.events;return this}return this}})(t[cm]);cl.data=function(b,c){var d=bb[this.id]=bb[this.id]||{};if(arguments.length==1){if(a.is(b,"object")){for(var e in b)b[g](e)&&this.data(e,b[e]);return this}eve("raphael.data.get."+this.id,this,d[b],b);return d[b]}d[b]=c,eve("raphael.data.set."+this.id,this,c,b);return this},cl.removeData=function(a){a==null?bb[this.id]={}:bb[this.id]&&delete bb[this.id][a];return this},cl.hover=function(a,b,c,d){return this.mouseover(a,c).mouseout(b,d||c)},cl.unhover=function(a,b){return this.unmouseover(a).unmouseout(b)};var cn=[];cl.drag=function(b,c,d,e,f,g){function i(i){(i.originalEvent||i).preventDefault();var j=h.doc.documentElement.scrollTop||h.doc.body.scrollTop,k=h.doc.documentElement.scrollLeft||h.doc.body.scrollLeft;this._drag.x=i.clientX+k,this._drag.y=i.clientY+j,this._drag.id=i.identifier,!ci.length&&a.mousemove(cj).mouseup(ck),ci.push({el:this,move_scope:e,start_scope:f,end_scope:g}),c&&eve.on("raphael.drag.start."+this.id,c),b&&eve.on("raphael.drag.move."+this.id,b),d&&eve.on("raphael.drag.end."+this.id,d),eve("raphael.drag.start."+this.id,f||e||this,i.clientX+k,i.clientY+j,i)}this._drag={},cn.push({el:this,start:i}),this.mousedown(i);return this},cl.onDragOver=function(a){a?eve.on("raphael.drag.over."+this.id,a):eve.unbind("raphael.drag.over."+this.id)},cl.undrag=function(){var b=cn.length;while(b--)cn[b].el==this&&(this.unmousedown(cn[b].start),cn.splice(b,1),eve.unbind("raphael.drag.*."+this.id));!cn.length&&a.unmousemove(cj).unmouseup(ck)},k.circle=function(b,c,d){var e=a._engine.circle(this,b||0,c||0,d||0);this.__set__&&this.__set__.push(e);return e},k.rect=function(b,c,d,e,f){var g=a._engine.rect(this,b||0,c||0,d||0,e||0,f||0);this.__set__&&this.__set__.push(g);return g},k.ellipse=function(b,c,d,e){var f=a._engine.ellipse(this,b||0,c||0,d||0,e||0);this.__set__&&this.__set__.push(f);return f},k.path=function(b){b&&!a.is(b,D)&&!a.is(b[0],E)&&(b+=p);var c=a._engine.path(a.format[m](a,arguments),this);this.__set__&&this.__set__.push(c);return c},k.image=function(b,c,d,e,f){var g=a._engine.image(this,b||"about:blank",c||0,d||0,e||0,f||0);this.__set__&&this.__set__.push(g);return g},k.text=function(b,c,d){var e=a._engine.text(this,b||0,c||0,r(d));this.__set__&&this.__set__.push(e);return e},k.set=function(b){!a.is(b,"array")&&(b=Array.prototype.splice.call(arguments,0,arguments.length));var c=new cG(b);this.__set__&&this.__set__.push(c);return c},k.setStart=function(a){this.__set__=a||this.set()},k.setFinish=function(a){var b=this.__set__;delete this.__set__;return b},k.setSize=function(b,c){return a._engine.setSize.call(this,b,c)},k.setViewBox=function(b,c,d,e,f){return a._engine.setViewBox.call(this,b,c,d,e,f)},k.top=k.bottom=null,k.raphael=a;var co=function(a){var b=a.getBoundingClientRect(),c=a.ownerDocument,d=c.body,e=c.documentElement,f=e.clientTop||d.clientTop||0,g=e.clientLeft||d.clientLeft||0,i=b.top+(h.win.pageYOffset||e.scrollTop||d.scrollTop)-f,j=b.left+(h.win.pageXOffset||e.scrollLeft||d.scrollLeft)-g;return{y:i,x:j}};k.getElementByPoint=function(a,b){var c=this,d=c.canvas,e=h.doc.elementFromPoint(a,b);if(h.win.opera&&e.tagName=="svg"){var f=co(d),g=d.createSVGRect();g.x=a-f.x,g.y=b-f.y,g.width=g.height=1;var i=d.getIntersectionList(g,null);i.length&&(e=i[i.length-1])}if(!e)return null;while(e.parentNode&&e!=d.parentNode&&!e.raphael)e=e.parentNode;e==c.canvas.parentNode&&(e=d),e=e&&e.raphael?c.getById(e.raphaelid):null;return e},k.getById=function(a){var b=this.bottom;while(b){if(b.id==a)return b;b=b.next}return null},k.forEach=function(a,b){var c=this.bottom;while(c){if(a.call(b,c)===!1)return this;c=c.next}return this},k.getElementsByPoint=function(a,b){var c=this.set();this.forEach(function(d){d.isPointInside(a,b)&&c.push(d)});return c},cl.isPointInside=function(b,c){var d=this.realPath=this.realPath||bi[this.type](this);return a.isPointInsidePath(d,b,c)},cl.getBBox=function(a){if(this.removed)return{};var b=this._;if(a){if(b.dirty||!b.bboxwt)this.realPath=bi[this.type](this),b.bboxwt=bI(this.realPath),b.bboxwt.toString=cq,b.dirty=0;return b.bboxwt}if(b.dirty||b.dirtyT||!b.bbox){if(b.dirty||!this.realPath)b.bboxwt=0,this.realPath=bi[this.type](this);b.bbox=bI(bj(this.realPath,this.matrix)),b.bbox.toString=cq,b.dirty=b.dirtyT=0}return b.bbox},cl.clone=function(){if(this.removed)return null;var a=this.paper[this.type]().attr(this.attr());this.__set__&&this.__set__.push(a);return a},cl.glow=function(a){if(this.type=="text")return null;a=a||{};var b={width:(a.width||10)+(+this.attr("stroke-width")||1),fill:a.fill||!1,opacity:a.opacity||.5,offsetx:a.offsetx||0,offsety:a.offsety||0,color:a.color||"#000"},c=b.width/2,d=this.paper,e=d.set(),f=this.realPath||bi[this.type](this);f=this.matrix?bj(f,this.matrix):f;for(var g=1;g<c+1;g++)e.push(d.path(f).attr({stroke:b.color,fill:b.fill?b.color:"none","stroke-linejoin":"round","stroke-linecap":"round","stroke-width":+(b.width/c*g).toFixed(3),opacity:+(b.opacity/c).toFixed(3)}));return e.insertBefore(this).translate(b.offsetx,b.offsety)};var cr={},cs=function(b,c,d,e,f,g,h,i,j){return j==null?bB(b,c,d,e,f,g,h,i):a.findDotsAtSegment(b,c,d,e,f,g,h,i,bC(b,c,d,e,f,g,h,i,j))},ct=function(b,c){return function(d,e,f){d=bR(d);var g,h,i,j,k="",l={},m,n=0;for(var o=0,p=d.length;o<p;o++){i=d[o];if(i[0]=="M")g=+i[1],h=+i[2];else{j=cs(g,h,i[1],i[2],i[3],i[4],i[5],i[6]);if(n+j>e){if(c&&!l.start){m=cs(g,h,i[1],i[2],i[3],i[4],i[5],i[6],e-n),k+=["C"+m.start.x,m.start.y,m.m.x,m.m.y,m.x,m.y];if(f)return k;l.start=k,k=["M"+m.x,m.y+"C"+m.n.x,m.n.y,m.end.x,m.end.y,i[5],i[6]].join(),n+=j,g=+i[5],h=+i[6];continue}if(!b&&!c){m=cs(g,h,i[1],i[2],i[3],i[4],i[5],i[6],e-n);return{x:m.x,y:m.y,alpha:m.alpha}}}n+=j,g=+i[5],h=+i[6]}k+=i.shift()+i}l.end=k,m=b?n:c?l:a.findDotsAtSegment(g,h,i[0],i[1],i[2],i[3],i[4],i[5],1),m.alpha&&(m={x:m.x,y:m.y,alpha:m.alpha});return m}},cu=ct(1),cv=ct(),cw=ct(0,1);a.getTotalLength=cu,a.getPointAtLength=cv,a.getSubpath=function(a,b,c){if(this.getTotalLength(a)-c<1e-6)return cw(a,b).end;var d=cw(a,c,1);return b?cw(d,b).end:d},cl.getTotalLength=function(){if(this.type=="path"){if(this.node.getTotalLength)return this.node.getTotalLength();return cu(this.attrs.path)}},cl.getPointAtLength=function(a){if(this.type=="path")return cv(this.attrs.path,a)},cl.getSubpath=function(b,c){if(this.type=="path")return a.getSubpath(this.attrs.path,b,c)};var cx=a.easing_formulas={linear:function(a){return a},"<":function(a){return A(a,1.7)},">":function(a){return A(a,.48)},"<>":function(a){var b=.48-a/1.04,c=w.sqrt(.1734+b*b),d=c-b,e=A(z(d),1/3)*(d<0?-1:1),f=-c-b,g=A(z(f),1/3)*(f<0?-1:1),h=e+g+.5;return(1-h)*3*h*h+h*h*h},backIn:function(a){var b=1.70158;return a*a*((b+1)*a-b)},backOut:function(a){a=a-1;var b=1.70158;return a*a*((b+1)*a+b)+1},elastic:function(a){if(a==!!a)return a;return A(2,-10*a)*w.sin((a-.075)*2*B/.3)+1},bounce:function(a){var b=7.5625,c=2.75,d;a<1/c?d=b*a*a:a<2/c?(a-=1.5/c,d=b*a*a+.75):a<2.5/c?(a-=2.25/c,d=b*a*a+.9375):(a-=2.625/c,d=b*a*a+.984375);return d}};cx.easeIn=cx["ease-in"]=cx["<"],cx.easeOut=cx["ease-out"]=cx[">"],cx.easeInOut=cx["ease-in-out"]=cx["<>"],cx["back-in"]=cx.backIn,cx["back-out"]=cx.backOut;var cy=[],cz=window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.oRequestAnimationFrame||window.msRequestAnimationFrame||function(a){setTimeout(a,16)},cA=function(){var b=+(new Date),c=0;for(;c<cy.length;c++){var d=cy[c];if(d.el.removed||d.paused)continue;var e=b-d.start,f=d.ms,h=d.easing,i=d.from,j=d.diff,k=d.to,l=d.t,m=d.el,o={},p,r={},s;d.initstatus?(e=(d.initstatus*d.anim.top-d.prev)/(d.percent-d.prev)*f,d.status=d.initstatus,delete d.initstatus,d.stop&&cy.splice(c--,1)):d.status=(d.prev+(d.percent-d.prev)*(e/f))/d.anim.top;if(e<0)continue;if(e<f){var t=h(e/f);for(var u in i)if(i[g](u)){switch(U[u]){case C:p=+i[u]+t*f*j[u];break;case"colour":p="rgb("+[cB(O(i[u].r+t*f*j[u].r)),cB(O(i[u].g+t*f*j[u].g)),cB(O(i[u].b+t*f*j[u].b))].join(",")+")";break;case"path":p=[];for(var v=0,w=i[u].length;v<w;v++){p[v]=[i[u][v][0]];for(var x=1,y=i[u][v].length;x<y;x++)p[v][x]=+i[u][v][x]+t*f*j[u][v][x];p[v]=p[v].join(q)}p=p.join(q);break;case"transform":if(j[u].real){p=[];for(v=0,w=i[u].length;v<w;v++){p[v]=[i[u][v][0]];for(x=1,y=i[u][v].length;x<y;x++)p[v][x]=i[u][v][x]+t*f*j[u][v][x]}}else{var z=function(a){return+i[u][a]+t*f*j[u][a]};p=[["m",z(0),z(1),z(2),z(3),z(4),z(5)]]}break;case"csv":if(u=="clip-rect"){p=[],v=4;while(v--)p[v]=+i[u][v]+t*f*j[u][v]}break;default:var A=[][n](i[u]);p=[],v=m.paper.customAttributes[u].length;while(v--)p[v]=+A[v]+t*f*j[u][v]}o[u]=p}m.attr(o),function(a,b,c){setTimeout(function(){eve("raphael.anim.frame."+a,b,c)})}(m.id,m,d.anim)}else{(function(b,c,d){setTimeout(function(){eve("raphael.anim.frame."+c.id,c,d),eve("raphael.anim.finish."+c.id,c,d),a.is(b,"function")&&b.call(c)})})(d.callback,m,d.anim),m.attr(k),cy.splice(c--,1);if(d.repeat>1&&!d.next){for(s in k)k[g](s)&&(r[s]=d.totalOrigin[s]);d.el.attr(r),cE(d.anim,d.el,d.anim.percents[0],null,d.totalOrigin,d.repeat-1)}d.next&&!d.stop&&cE(d.anim,d.el,d.next,null,d.totalOrigin,d.repeat)}}a.svg&&m&&m.paper&&m.paper.safari(),cy.length&&cz(cA)},cB=function(a){return a>255?255:a<0?0:a};cl.animateWith=function(b,c,d,e,f,g){var h=this;if(h.removed){g&&g.call(h);return h}var i=d instanceof cD?d:a.animation(d,e,f,g),j,k;cE(i,h,i.percents[0],null,h.attr());for(var l=0,m=cy.length;l<m;l++)if(cy[l].anim==c&&cy[l].el==b){cy[m-1].start=cy[l].start;break}return h},cl.onAnimation=function(a){a?eve.on("raphael.anim.frame."+this.id,a):eve.unbind("raphael.anim.frame."+this.id);return this},cD.prototype.delay=function(a){var b=new cD(this.anim,this.ms);b.times=this.times,b.del=+a||0;return b},cD.prototype.repeat=function(a){var b=new cD(this.anim,this.ms);b.del=this.del,b.times=w.floor(x(a,0))||1;return b},a.animation=function(b,c,d,e){if(b instanceof cD)return b;if(a.is(d,"function")||!d)e=e||d||null,d=null;b=Object(b),c=+c||0;var f={},h,i;for(i in b)b[g](i)&&Q(i)!=i&&Q(i)+"%"!=i&&(h=!0,f[i]=b[i]);if(!h)return new cD(b,c);d&&(f.easing=d),e&&(f.callback=e);return new cD({100:f},c)},cl.animate=function(b,c,d,e){var f=this;if(f.removed){e&&e.call(f);return f}var g=b instanceof cD?b:a.animation(b,c,d,e);cE(g,f,g.percents[0],null,f.attr());return f},cl.setTime=function(a,b){a&&b!=null&&this.status(a,y(b,a.ms)/a.ms);return this},cl.status=function(a,b){var c=[],d=0,e,f;if(b!=null){cE(a,this,-1,y(b,1));return this}e=cy.length;for(;d<e;d++){f=cy[d];if(f.el.id==this.id&&(!a||f.anim==a)){if(a)return f.status;c.push({anim:f.anim,status:f.status})}}if(a)return 0;return c},cl.pause=function(a){for(var b=0;b<cy.length;b++)cy[b].el.id==this.id&&(!a||cy[b].anim==a)&&eve("raphael.anim.pause."+this.id,this,cy[b].anim)!==!1&&(cy[b].paused=!0);return this},cl.resume=function(a){for(var b=0;b<cy.length;b++)if(cy[b].el.id==this.id&&(!a||cy[b].anim==a)){var c=cy[b];eve("raphael.anim.resume."+this.id,this,c.anim)!==!1&&(delete c.paused,this.status(c.anim,c.status))}return this},cl.stop=function(a){for(var b=0;b<cy.length;b++)cy[b].el.id==this.id&&(!a||cy[b].anim==a)&&eve("raphael.anim.stop."+this.id,this,cy[b].anim)!==!1&&cy.splice(b--,1);return this},eve.on("raphael.remove",cF),eve.on("raphael.clear",cF),cl.toString=function(){return"Raphaël’s object"};var cG=function(a){this.items=[],this.length=0,this.type="set";if(a)for(var b=0,c=a.length;b<c;b++)a[b]&&(a[b].constructor==cl.constructor||a[b].constructor==cG)&&(this[this.items.length]=this.items[this.items.length]=a[b],this.length++)},cH=cG.prototype;cH.push=function(){var a,b;for(var c=0,d=arguments.length;c<d;c++)a=arguments[c],a&&(a.constructor==cl.constructor||a.constructor==cG)&&(b=this.items.length,this[b]=this.items[b]=a,this.length++);return this},cH.pop=function(){this.length&&delete this[this.length--];return this.items.pop()},cH.forEach=function(a,b){for(var c=0,d=this.items.length;c<d;c++)if(a.call(b,this.items[c],c)===!1)return this;return this};for(var cI in cl)cl[g](cI)&&(cH[cI]=function(a){return function(){var b=arguments;return this.forEach(function(c){c[a][m](c,b)})}}(cI));cH.attr=function(b,c){if(b&&a.is(b,E)&&a.is(b[0],"object"))for(var d=0,e=b.length;d<e;d++)this.items[d].attr(b[d]);else for(var f=0,g=this.items.length;f<g;f++)this.items[f].attr(b,c);return this},cH.clear=function(){while(this.length)this.pop()},cH.splice=function(a,b,c){a=a<0?x(this.length+a,0):a,b=x(0,y(this.length-a,b));var d=[],e=[],f=[],g;for(g=2;g<arguments.length;g++)f.push(arguments[g]);for(g=0;g<b;g++)e.push(this[a+g]);for(;g<this.length-a;g++)d.push(this[a+g]);var h=f.length;for(g=0;g<h+d.length;g++)this.items[a+g]=this[a+g]=g<h?f[g]:d[g-h];g=this.items.length=this.length-=b-h;while(this[g])delete this[g++];return new cG(e)},cH.exclude=function(a){for(var b=0,c=this.length;b<c;b++)if(this[b]==a){this.splice(b,1);return!0}},cH.animate=function(b,c,d,e){(a.is(d,"function")||!d)&&(e=d||null);var f=this.items.length,g=f,h,i=this,j;if(!f)return this;e&&(j=function(){!--f&&e.call(i)}),d=a.is(d,D)?d:j;var k=a.animation(b,c,d,j);h=this.items[--g].animate(k);while(g--)this.items[g]&&!this.items[g].removed&&this.items[g].animateWith(h,k,k);return this},cH.insertAfter=function(a){var b=this.items.length;while(b--)this.items[b].insertAfter(a);return this},cH.getBBox=function(){var a=[],b=[],c=[],d=[];for(var e=this.items.length;e--;)if(!this.items[e].removed){var f=this.items[e].getBBox();a.push(f.x),b.push(f.y),c.push(f.x+f.width),d.push(f.y+f.height)}a=y[m](0,a),b=y[m](0,b),c=x[m](0,c),d=x[m](0,d);return{x:a,y:b,x2:c,y2:d,width:c-a,height:d-b}},cH.clone=function(a){a=new cG;for(var b=0,c=this.items.length;b<c;b++)a.push(this.items[b].clone());return a},cH.toString=function(){return"Raphaël‘s set"},a.registerFont=function(a){if(!a.face)return a;this.fonts=this.fonts||{};var b={w:a.w,face:{},glyphs:{}},c=a.face["font-family"];for(var d in a.face)a.face[g](d)&&(b.face[d]=a.face[d]);this.fonts[c]?this.fonts[c].push(b):this.fonts[c]=[b];if(!a.svg){b.face["units-per-em"]=R(a.face["units-per-em"],10);for(var e in a.glyphs)if(a.glyphs[g](e)){var f=a.glyphs[e];b.glyphs[e]={w:f.w,k:{},d:f.d&&"M"+f.d.replace(/[mlcxtrv]/g,function(a){return{l:"L",c:"C",x:"z",t:"m",r:"l",v:"c"}[a]||"M"})+"z"};if(f.k)for(var h in f.k)f[g](h)&&(b.glyphs[e].k[h]=f.k[h])}}return a},k.getFont=function(b,c,d,e){e=e||"normal",d=d||"normal",c=+c||{normal:400,bold:700,lighter:300,bolder:800}[c]||400;if(!!a.fonts){var f=a.fonts[b];if(!f){var h=new RegExp("(^|\\s)"+b.replace(/[^\w\d\s+!~.:_-]/g,p)+"(\\s|$)","i");for(var i in a.fonts)if(a.fonts[g](i)&&h.test(i)){f=a.fonts[i];break}}var j;if(f)for(var k=0,l=f.length;k<l;k++){j=f[k];if(j.face["font-weight"]==c&&(j.face["font-style"]==d||!j.face["font-style"])&&j.face["font-stretch"]==e)break}return j}},k.print=function(b,d,e,f,g,h,i){h=h||"middle",i=x(y(i||0,1),-1);var j=r(e)[s](p),k=0,l=0,m=p,n;a.is(f,e)&&(f=this.getFont(f));if(f){n=(g||16)/f.face["units-per-em"];var o=f.face.bbox[s](c),q=+o[0],t=o[3]-o[1],u=0,v=+o[1]+(h=="baseline"?t+ +f.face.descent:t/2);for(var w=0,z=j.length;w<z;w++){if(j[w]=="\n")k=0,B=0,l=0,u+=t;else{var A=l&&f.glyphs[j[w-1]]||{},B=f.glyphs[j[w]];k+=l?(A.w||f.w)+(A.k&&A.k[j[w]]||0)+f.w*i:0,l=1}B&&B.d&&(m+=a.transformPath(B.d,["t",k*n,u*n,"s",n,n,q,v,"t",(b-q)/n,(d-v)/n]))}}return this.path(m).attr({fill:"#000",stroke:"none"})},k.add=function(b){if(a.is(b,"array")){var c=this.set(),e=0,f=b.length,h;for(;e<f;e++)h=b[e]||{},d[g](h.type)&&c.push(this[h.type]().attr(h))}return c},a.format=function(b,c){var d=a.is(c,E)?[0][n](c):arguments;b&&a.is(b,D)&&d.length-1&&(b=b.replace(e,function(a,b){return d[++b]==null?p:d[b]}));return b||p},a.fullfill=function(){var a=/\{([^\}]+)\}/g,b=/(?:(?:^|\.)(.+?)(?=\[|\.|$|\()|\[('|")(.+?)\2\])(\(\))?/g,c=function(a,c,d){var e=d;c.replace(b,function(a,b,c,d,f){b=b||d,e&&(b in e&&(e=e[b]),typeof e=="function"&&f&&(e=e()))}),e=(e==null||e==d?a:e)+"";return e};return function(b,d){return String(b).replace(a,function(a,b){return c(a,b,d)})}}(),a.ninja=function(){i.was?h.win.Raphael=i.is:delete Raphael;return a},a.st=cH,function(b,c,d){function e(){/in/.test(b.readyState)?setTimeout(e,9):a.eve("raphael.DOMload")}b.readyState==null&&b.addEventListener&&(b.addEventListener(c,d=function(){b.removeEventListener(c,d,!1),b.readyState="complete"},!1),b.readyState="loading"),e()}(document,"DOMContentLoaded"),i.was?h.win.Raphael=a:Raphael=a,eve.on("raphael.DOMload",function(){b=!0})}(),window.Raphael.svg&&function(a){var b="hasOwnProperty",c=String,d=parseFloat,e=parseInt,f=Math,g=f.max,h=f.abs,i=f.pow,j=/[, ]+/,k=a.eve,l="",m=" ",n="http://www.w3.org/1999/xlink",o={block:"M5,0 0,2.5 5,5z",classic:"M5,0 0,2.5 5,5 3.5,3 3.5,2z",diamond:"M2.5,0 5,2.5 2.5,5 0,2.5z",open:"M6,1 1,3.5 6,6",oval:"M2.5,0A2.5,2.5,0,0,1,2.5,5 2.5,2.5,0,0,1,2.5,0z"},p={};a.toString=function(){return"Your browser supports SVG.\nYou are running Raphaël "+this.version};var q=function(d,e){if(e){typeof d=="string"&&(d=q(d));for(var f in e)e[b](f)&&(f.substring(0,6)=="xlink:"?d.setAttributeNS(n,f.substring(6),c(e[f])):d.setAttribute(f,c(e[f])))}else d=a._g.doc.createElementNS("http://www.w3.org/2000/svg",d),d.style&&(d.style.webkitTapHighlightColor="rgba(0,0,0,0)");return d},r=function(b,e){var j="linear",k=b.id+e,m=.5,n=.5,o=b.node,p=b.paper,r=o.style,s=a._g.doc.getElementById(k);if(!s){e=c(e).replace(a._radial_gradient,function(a,b,c){j="radial";if(b&&c){m=d(b),n=d(c);var e=(n>.5)*2-1;i(m-.5,2)+i(n-.5,2)>.25&&(n=f.sqrt(.25-i(m-.5,2))*e+.5)&&n!=.5&&(n=n.toFixed(5)-1e-5*e)}return l}),e=e.split(/\s*\-\s*/);if(j=="linear"){var t=e.shift();t=-d(t);if(isNaN(t))return null;var u=[0,0,f.cos(a.rad(t)),f.sin(a.rad(t))],v=1/(g(h(u[2]),h(u[3]))||1);u[2]*=v,u[3]*=v,u[2]<0&&(u[0]=-u[2],u[2]=0),u[3]<0&&(u[1]=-u[3],u[3]=0)}var w=a._parseDots(e);if(!w)return null;k=k.replace(/[\(\)\s,\xb0#]/g,"_"),b.gradient&&k!=b.gradient.id&&(p.defs.removeChild(b.gradient),delete b.gradient);if(!b.gradient){s=q(j+"Gradient",{id:k}),b.gradient=s,q(s,j=="radial"?{fx:m,fy:n}:{x1:u[0],y1:u[1],x2:u[2],y2:u[3],gradientTransform:b.matrix.invert()}),p.defs.appendChild(s);for(var x=0,y=w.length;x<y;x++)s.appendChild(q("stop",{offset:w[x].offset?w[x].offset:x?"100%":"0%","stop-color":w[x].color||"#fff"}))}}q(o,{fill:"url(#"+k+")",opacity:1,"fill-opacity":1}),r.fill=l,r.opacity=1,r.fillOpacity=1;return 1},s=function(a){var b=a.getBBox(1);q(a.pattern,{patternTransform:a.matrix.invert()+" translate("+b.x+","+b.y+")"})},t=function(d,e,f){if(d.type=="path"){var g=c(e).toLowerCase().split("-"),h=d.paper,i=f?"end":"start",j=d.node,k=d.attrs,m=k["stroke-width"],n=g.length,r="classic",s,t,u,v,w,x=3,y=3,z=5;while(n--)switch(g[n]){case"block":case"classic":case"oval":case"diamond":case"open":case"none":r=g[n];break;case"wide":y=5;break;case"narrow":y=2;break;case"long":x=5;break;case"short":x=2}r=="open"?(x+=2,y+=2,z+=2,u=1,v=f?4:1,w={fill:"none",stroke:k.stroke}):(v=u=x/2,w={fill:k.stroke,stroke:"none"}),d._.arrows?f?(d._.arrows.endPath&&p[d._.arrows.endPath]--,d._.arrows.endMarker&&p[d._.arrows.endMarker]--):(d._.arrows.startPath&&p[d._.arrows.startPath]--,d._.arrows.startMarker&&p[d._.arrows.startMarker]--):d._.arrows={};if(r!="none"){var A="raphael-marker-"+r,B="raphael-marker-"+i+r+x+y;a._g.doc.getElementById(A)?p[A]++:(h.defs.appendChild(q(q("path"),{"stroke-linecap":"round",d:o[r],id:A})),p[A]=1);var C=a._g.doc.getElementById(B),D;C?(p[B]++,D=C.getElementsByTagName("use")[0]):(C=q(q("marker"),{id:B,markerHeight:y,markerWidth:x,orient:"auto",refX:v,refY:y/2}),D=q(q("use"),{"xlink:href":"#"+A,transform:(f?"rotate(180 "+x/2+" "+y/2+") ":l)+"scale("+x/z+","+y/z+")","stroke-width":(1/((x/z+y/z)/2)).toFixed(4)}),C.appendChild(D),h.defs.appendChild(C),p[B]=1),q(D,w);var F=u*(r!="diamond"&&r!="oval");f?(s=d._.arrows.startdx*m||0,t=a.getTotalLength(k.path)-F*m):(s=F*m,t=a.getTotalLength(k.path)-(d._.arrows.enddx*m||0)),w={},w["marker-"+i]="url(#"+B+")";if(t||s)w.d=Raphael.getSubpath(k.path,s,t);q(j,w),d._.arrows[i+"Path"]=A,d._.arrows[i+"Marker"]=B,d._.arrows[i+"dx"]=F,d._.arrows[i+"Type"]=r,d._.arrows[i+"String"]=e}else f?(s=d._.arrows.startdx*m||0,t=a.getTotalLength(k.path)-s):(s=0,t=a.getTotalLength(k.path)-(d._.arrows.enddx*m||0)),d._.arrows[i+"Path"]&&q(j,{d:Raphael.getSubpath(k.path,s,t)}),delete d._.arrows[i+"Path"],delete d._.arrows[i+"Marker"],delete d._.arrows[i+"dx"],delete d._.arrows[i+"Type"],delete d._.arrows[i+"String"];for(w in p)if(p[b](w)&&!p[w]){var G=a._g.doc.getElementById(w);G&&G.parentNode.removeChild(G)}}},u={"":[0],none:[0],"-":[3,1],".":[1,1],"-.":[3,1,1,1],"-..":[3,1,1,1,1,1],". ":[1,3],"- ":[4,3],"--":[8,3],"- .":[4,3,1,3],"--.":[8,3,1,3],"--..":[8,3,1,3,1,3]},v=function(a,b,d){b=u[c(b).toLowerCase()];if(b){var e=a.attrs["stroke-width"]||"1",f={round:e,square:e,butt:0}[a.attrs["stroke-linecap"]||d["stroke-linecap"]]||0,g=[],h=b.length;while(h--)g[h]=b[h]*e+(h%2?1:-1)*f;q(a.node,{"stroke-dasharray":g.join(",")})}},w=function(d,f){var i=d.node,k=d.attrs,m=i.style.visibility;i.style.visibility="hidden";for(var o in f)if(f[b](o)){if(!a._availableAttrs[b](o))continue;var p=f[o];k[o]=p;switch(o){case"blur":d.blur(p);break;case"href":case"title":case"target":var u=i.parentNode;if(u.tagName.toLowerCase()!="a"){var w=q("a");u.insertBefore(w,i),w.appendChild(i),u=w}o=="target"?u.setAttributeNS(n,"show",p=="blank"?"new":p):u.setAttributeNS(n,o,p);break;case"cursor":i.style.cursor=p;break;case"transform":d.transform(p);break;case"arrow-start":t(d,p);break;case"arrow-end":t(d,p,1);break;case"clip-rect":var x=c(p).split(j);if(x.length==4){d.clip&&d.clip.parentNode.parentNode.removeChild(d.clip.parentNode);var z=q("clipPath"),A=q("rect");z.id=a.createUUID(),q(A,{x:x[0],y:x[1],width:x[2],height:x[3]}),z.appendChild(A),d.paper.defs.appendChild(z),q(i,{"clip-path":"url(#"+z.id+")"}),d.clip=A}if(!p){var B=i.getAttribute("clip-path");if(B){var C=a._g.doc.getElementById(B.replace(/(^url\(#|\)$)/g,l));C&&C.parentNode.removeChild(C),q(i,{"clip-path":l}),delete d.clip}}break;case"path":d.type=="path"&&(q(i,{d:p?k.path=a._pathToAbsolute(p):"M0,0"}),d._.dirty=1,d._.arrows&&("startString"in d._.arrows&&t(d,d._.arrows.startString),"endString"in d._.arrows&&t(d,d._.arrows.endString,1)));break;case"width":i.setAttribute(o,p),d._.dirty=1;if(k.fx)o="x",p=k.x;else break;case"x":k.fx&&(p=-k.x-(k.width||0));case"rx":if(o=="rx"&&d.type=="rect")break;case"cx":i.setAttribute(o,p),d.pattern&&s(d),d._.dirty=1;break;case"height":i.setAttribute(o,p),d._.dirty=1;if(k.fy)o="y",p=k.y;else break;case"y":k.fy&&(p=-k.y-(k.height||0));case"ry":if(o=="ry"&&d.type=="rect")break;case"cy":i.setAttribute(o,p),d.pattern&&s(d),d._.dirty=1;break;case"r":d.type=="rect"?q(i,{rx:p,ry:p}):i.setAttribute(o,p),d._.dirty=1;break;case"src":d.type=="image"&&i.setAttributeNS(n,"href",p);break;case"stroke-width":if(d._.sx!=1||d._.sy!=1)p/=g(h(d._.sx),h(d._.sy))||1;d.paper._vbSize&&(p*=d.paper._vbSize),i.setAttribute(o,p),k["stroke-dasharray"]&&v(d,k["stroke-dasharray"],f),d._.arrows&&("startString"in d._.arrows&&t(d,d._.arrows.startString),"endString"in d._.arrows&&t(d,d._.arrows.endString,1));break;case"stroke-dasharray":v(d,p,f);break;case"fill":var D=c(p).match(a._ISURL);if(D){z=q("pattern");var F=q("image");z.id=a.createUUID(),q(z,{x:0,y:0,patternUnits:"userSpaceOnUse",height:1,width:1}),q(F,{x:0,y:0,"xlink:href":D[1]}),z.appendChild(F),function(b){a._preload(D[1],function(){var a=this.offsetWidth,c=this.offsetHeight;q(b,{width:a,height:c}),q(F,{width:a,height:c}),d.paper.safari()})}(z),d.paper.defs.appendChild(z),q(i,{fill:"url(#"+z.id+")"}),d.pattern=z,d.pattern&&s(d);break}var G=a.getRGB(p);if(!G.error)delete f.gradient,delete k.gradient,!a.is(k.opacity,"undefined")&&a.is(f.opacity,"undefined")&&q(i,{opacity:k.opacity}),!a.is(k["fill-opacity"],"undefined")&&a.is(f["fill-opacity"],"undefined")&&q(i,{"fill-opacity":k["fill-opacity"]});else if((d.type=="circle"||d.type=="ellipse"||c(p).charAt()!="r")&&r(d,p)){if("opacity"in k||"fill-opacity"in k){var H=a._g.doc.getElementById(i.getAttribute("fill").replace(/^url\(#|\)$/g,l));if(H){var I=H.getElementsByTagName("stop");q(I[I.length-1],{"stop-opacity":("opacity"in k?k.opacity:1)*("fill-opacity"in k?k["fill-opacity"]:1)})}}k.gradient=p,k.fill="none";break}G[b]("opacity")&&q(i,{"fill-opacity":G.opacity>1?G.opacity/100:G.opacity});case"stroke":G=a.getRGB(p),i.setAttribute(o,G.hex),o=="stroke"&&G[b]("opacity")&&q(i,{"stroke-opacity":G.opacity>1?G.opacity/100:G.opacity}),o=="stroke"&&d._.arrows&&("startString"in d._.arrows&&t(d,d._.arrows.startString),"endString"in d._.arrows&&t(d,d._.arrows.endString,1));break;case"gradient":(d.type=="circle"||d.type=="ellipse"||c(p).charAt()!="r")&&r(d,p);break;case"opacity":k.gradient&&!k[b]("stroke-opacity")&&q(i,{"stroke-opacity":p>1?p/100:p});case"fill-opacity":if(k.gradient){H=a._g.doc.getElementById(i.getAttribute("fill").replace(/^url\(#|\)$/g,l)),H&&(I=H.getElementsByTagName("stop"),q(I[I.length-1],{"stop-opacity":p}));break};default:o=="font-size"&&(p=e(p,10)+"px");var J=o.replace(/(\-.)/g,function(a){return a.substring(1).toUpperCase()});i.style[J]=p,d._.dirty=1,i.setAttribute(o,p)}}y(d,f),i.style.visibility=m},x=1.2,y=function(d,f){if(d.type=="text"&&!!(f[b]("text")||f[b]("font")||f[b]("font-size")||f[b]("x")||f[b]("y"))){var g=d.attrs,h=d.node,i=h.firstChild?e(a._g.doc.defaultView.getComputedStyle(h.firstChild,l).getPropertyValue("font-size"),10):10;if(f[b]("text")){g.text=f.text;while(h.firstChild)h.removeChild(h.firstChild);var j=c(f.text).split("\n"),k=[],m;for(var n=0,o=j.length;n<o;n++)m=q("tspan"),n&&q(m,{dy:i*x,x:g.x}),m.appendChild(a._g.doc.createTextNode(j[n])),h.appendChild(m),k[n]=m}else{k=h.getElementsByTagName("tspan");for(n=0,o=k.length;n<o;n++)n?q(k[n],{dy:i*x,x:g.x}):q(k[0],{dy:0})}q(h,{x:g.x,y:g.y}),d._.dirty=1;var p=d._getBBox(),r=g.y-(p.y+p.height/2);r&&a.is(r,"finite")&&q(k[0],{dy:r})}},z=function(b,c){var d=0,e=0;this[0]=this.node=b,b.raphael=!0,this.id=a._oid++,b.raphaelid=this.id,this.matrix=a.matrix(),this.realPath=null,this.paper=c,this.attrs=this.attrs||{},this._={transform:[],sx:1,sy:1,deg:0,dx:0,dy:0,dirty:1},!c.bottom&&(c.bottom=this),this.prev=c.top,c.top&&(c.top.next=this),c.top=this,this.next=null},A=a.el;z.prototype=A,A.constructor=z,a._engine.path=function(a,b){var c=q("path");b.canvas&&b.canvas.appendChild(c);var d=new z(c,b);d.type="path",w(d,{fill:"none",stroke:"#000",path:a});return d},A.rotate=function(a,b,e){if(this.removed)return this;a=c(a).split(j),a.length-1&&(b=d(a[1]),e=d(a[2])),a=d(a[0]),e==null&&(b=e);if(b==null||e==null){var f=this.getBBox(1);b=f.x+f.width/2,e=f.y+f.height/2}this.transform(this._.transform.concat([["r",a,b,e]]));return this},A.scale=function(a,b,e,f){if(this.removed)return this;a=c(a).split(j),a.length-1&&(b=d(a[1]),e=d(a[2]),f=d(a[3])),a=d(a[0]),b==null&&(b=a),f==null&&(e=f);if(e==null||f==null)var g=this.getBBox(1);e=e==null?g.x+g.width/2:e,f=f==null?g.y+g.height/2:f,this.transform(this._.transform.concat([["s",a,b,e,f]]));return this},A.translate=function(a,b){if(this.removed)return this;a=c(a).split(j),a.length-1&&(b=d(a[1])),a=d(a[0])||0,b=+b||0,this.transform(this._.transform.concat([["t",a,b]]));return this},A.transform=function(c){var d=this._;if(c==null)return d.transform;a._extractTransform(this,c),this.clip&&q(this.clip,{transform:this.matrix.invert()}),this.pattern&&s(this),this.node&&q(this.node,{transform:this.matrix});if(d.sx!=1||d.sy!=1){var e=this.attrs[b]("stroke-width")?this.attrs["stroke-width"]:1;this.attr({"stroke-width":e})}return this},A.hide=function(){!this.removed&&this.paper.safari(this.node.style.display="none");return this},A.show=function(){!this.removed&&this.paper.safari(this.node.style.display="");return this},A.remove=function(){if(!this.removed&&!!this.node.parentNode){var b=this.paper;b.__set__&&b.__set__.exclude(this),k.unbind("raphael.*.*."+this.id),this.gradient&&b.defs.removeChild(this.gradient),a._tear(this,b),this.node.parentNode.tagName.toLowerCase()=="a"?this.node.parentNode.parentNode.removeChild(this.node.parentNode):this.node.parentNode.removeChild(this.node);for(var c in this)this[c]=typeof this[c]=="function"?a._removedFactory(c):null;this.removed=!0}},A._getBBox=function(){if(this.node.style.display=="none"){this.show();var a=!0}var b={};try{b=this.node.getBBox()}catch(c){}finally{b=b||{}}a&&this.hide();return b},A.attr=function(c,d){if(this.removed)return this;if(c==null){var e={};for(var f in this.attrs)this.attrs[b](f)&&(e[f]=this.attrs[f]);e.gradient&&e.fill=="none"&&(e.fill=e.gradient)&&delete e.gradient,e.transform=this._.transform;return e}if(d==null&&a.is(c,"string")){if(c=="fill"&&this.attrs.fill=="none"&&this.attrs.gradient)return this.attrs.gradient;if(c=="transform")return this._.transform;var g=c.split(j),h={};for(var i=0,l=g.length;i<l;i++)c=g[i],c in this.attrs?h[c]=this.attrs[c]:a.is(this.paper.customAttributes[c],"function")?h[c]=this.paper.customAttributes[c].def:h[c]=a._availableAttrs[c];return l-1?h:h[g[0]]}if(d==null&&a.is(c,"array")){h={};for(i=0,l=c.length;i<l;i++)h[c[i]]=this.attr(c[i]);return h}if(d!=null){var m={};m[c]=d}else c!=null&&a.is(c,"object")&&(m=c);for(var n in m)k("raphael.attr."+n+"."+this.id,this,m[n]);for(n in this.paper.customAttributes)if(this.paper.customAttributes[b](n)&&m[b](n)&&a.is(this.paper.customAttributes[n],"function")){var o=this.paper.customAttributes[n].apply(this,[].concat(m[n]));this.attrs[n]=m[n];for(var p in o)o[b](p)&&(m[p]=o[p])}w(this,m);return this},A.toFront=function(){if(this.removed)return this;this.node.parentNode.tagName.toLowerCase()=="a"?this.node.parentNode.parentNode.appendChild(this.node.parentNode):this.node.parentNode.appendChild(this.node);var b=this.paper;b.top!=this&&a._tofront(this,b);return this},A.toBack=function(){if(this.removed)return this;var b=this.node.parentNode;b.tagName.toLowerCase()=="a"?b.parentNode.insertBefore(this.node.parentNode,this.node.parentNode.parentNode.firstChild):b.firstChild!=this.node&&b.insertBefore(this.node,this.node.parentNode.firstChild),a._toback(this,this.paper);var c=this.paper;return this},A.insertAfter=function(b){if(this.removed)return this;var c=b.node||b[b.length-1].node;c.nextSibling?c.parentNode.insertBefore(this.node,c.nextSibling):c.parentNode.appendChild(this.node),a._insertafter(this,b,this.paper);return this},A.insertBefore=function(b){if(this.removed)return this;var c=b.node||b[0].node;c.parentNode.insertBefore(this.node,c),a._insertbefore(this,b,this.paper);return this},A.blur=function(b){var c=this;if(+b!==0){var d=q("filter"),e=q("feGaussianBlur");c.attrs.blur=b,d.id=a.createUUID(),q(e,{stdDeviation:+b||1.5}),d.appendChild(e),c.paper.defs.appendChild(d),c._blur=d,q(c.node,{filter:"url(#"+d.id+")"})}else c._blur&&(c._blur.parentNode.removeChild(c._blur),delete c._blur,delete c.attrs.blur),c.node.removeAttribute("filter")},a._engine.circle=function(a,b,c,d){var e=q("circle");a.canvas&&a.canvas.appendChild(e);var f=new z(e,a);f.attrs={cx:b,cy:c,r:d,fill:"none",stroke:"#000"},f.type="circle",q(e,f.attrs);return f},a._engine.rect=function(a,b,c,d,e,f){var g=q("rect");a.canvas&&a.canvas.appendChild(g);var h=new z(g,a);h.attrs={x:b,y:c,width:d,height:e,r:f||0,rx:f||0,ry:f||0,fill:"none",stroke:"#000"},h.type="rect",q(g,h.attrs);return h},a._engine.ellipse=function(a,b,c,d,e){var f=q("ellipse");a.canvas&&a.canvas.appendChild(f);var g=new z(f,a);g.attrs={cx:b,cy:c,rx:d,ry:e,fill:"none",stroke:"#000"},g.type="ellipse",q(f,g.attrs);return g},a._engine.image=function(a,b,c,d,e,f){var g=q("image");q(g,{x:c,y:d,width:e,height:f,preserveAspectRatio:"none"}),g.setAttributeNS(n,"href",b),a.canvas&&a.canvas.appendChild(g);var h=new z(g,a);h.attrs={x:c,y:d,width:e,height:f,src:b},h.type="image";return h},a._engine.text=function(b,c,d,e){var f=q("text");b.canvas&&b.canvas.appendChild(f);var g=new z(f,b);g.attrs={x:c,y:d,"text-anchor":"middle",text:e,font:a._availableAttrs.font,stroke:"none",fill:"#000"},g.type="text",w(g,g.attrs);return g},a._engine.setSize=function(a,b){this.width=a||this.width,this.height=b||this.height,this.canvas.setAttribute("width",this.width),this.canvas.setAttribute("height",this.height),this._viewBox&&this.setViewBox.apply(this,this._viewBox);return this},a._engine.create=function(){var b=a._getContainer.apply(0,arguments),c=b&&b.container,d=b.x,e=b.y,f=b.width,g=b.height;if(!c)throw new Error("SVG container not found.");var h=q("svg"),i="overflow:hidden;",j;d=d||0,e=e||0,f=f||512,g=g||342,q(h,{height:g,version:1.1,width:f,xmlns:"http://www.w3.org/2000/svg"}),c==1?(h.style.cssText=i+"position:absolute;left:"+d+"px;top:"+e+"px",a._g.doc.body.appendChild(h),j=1):(h.style.cssText=i+"position:relative",c.firstChild?c.insertBefore(h,c.firstChild):c.appendChild(h)),c=new a._Paper,c.width=f,c.height=g,c.canvas=h,c.clear(),c._left=c._top=0,j&&(c.renderfix=function(){}),c.renderfix();return c},a._engine.setViewBox=function(a,b,c,d,e){k("raphael.setViewBox",this,this._viewBox,[a,b,c,d,e]);var f=g(c/this.width,d/this.height),h=this.top,i=e?"meet":"xMinYMin",j,l;a==null?(this._vbSize&&(f=1),delete this._vbSize,j="0 0 "+this.width+m+this.height):(this._vbSize=f,j=a+m+b+m+c+m+d),q(this.canvas,{viewBox:j,preserveAspectRatio:i});while(f&&h)l="stroke-width"in h.attrs?h.attrs["stroke-width"]:1,h.attr({"stroke-width":l}),h._.dirty=1,h._.dirtyT=1,h=h.prev;this._viewBox=[a,b,c,d,!!e];return this},a.prototype.renderfix=function(){var a=this.canvas,b=a.style,c;try{c=a.getScreenCTM()||a.createSVGMatrix()}catch(d){c=a.createSVGMatrix()}var e=-c.e%1,f=-c.f%1;if(e||f)e&&(this._left=(this._left+e)%1,b.left=this._left+"px"),f&&(this._top=(this._top+f)%1,b.top=this._top+"px")},a.prototype.clear=function(){a.eve("raphael.clear",this);var b=this.canvas;while(b.firstChild)b.removeChild(b.firstChild);this.bottom=this.top=null,(this.desc=q("desc")).appendChild(a._g.doc.createTextNode("Created with Raphaël "+a.version)),b.appendChild(this.desc),b.appendChild(this.defs=q("defs"))},a.prototype.remove=function(){k("raphael.remove",this),this.canvas.parentNode&&this.canvas.parentNode.removeChild(this.canvas);for(var b in this)this[b]=typeof this[b]=="function"?a._removedFactory(b):null};var B=a.st;for(var C in A)A[b](C)&&!B[b](C)&&(B[C]=function(a){return function(){var b=arguments;return this.forEach(function(c){c[a].apply(c,b)})}}(C))}(window.Raphael),window.Raphael.vml&&function(a){var b="hasOwnProperty",c=String,d=parseFloat,e=Math,f=e.round,g=e.max,h=e.min,i=e.abs,j="fill",k=/[, ]+/,l=a.eve,m=" progid:DXImageTransform.Microsoft",n=" ",o="",p={M:"m",L:"l",C:"c",Z:"x",m:"t",l:"r",c:"v",z:"x"},q=/([clmz]),?([^clmz]*)/gi,r=/ progid:\S+Blur\([^\)]+\)/g,s=/-?[^,\s-]+/g,t="position:absolute;left:0;top:0;width:1px;height:1px",u=21600,v={path:1,rect:1,image:1},w={circle:1,ellipse:1},x=function(b){var d=/[ahqstv]/ig,e=a._pathToAbsolute;c(b).match(d)&&(e=a._path2curve),d=/[clmz]/g;if(e==a._pathToAbsolute&&!c(b).match(d)){var g=c(b).replace(q,function(a,b,c){var d=[],e=b.toLowerCase()=="m",g=p[b];c.replace(s,function(a){e&&d.length==2&&(g+=d+p[b=="m"?"l":"L"],d=[]),d.push(f(a*u))});return g+d});return g}var h=e(b),i,j;g=[];for(var k=0,l=h.length;k<l;k++){i=h[k],j=h[k][0].toLowerCase(),j=="z"&&(j="x");for(var m=1,r=i.length;m<r;m++)j+=f(i[m]*u)+(m!=r-1?",":o);g.push(j)}return g.join(n)},y=function(b,c,d){var e=a.matrix();e.rotate(-b,.5,.5);return{dx:e.x(c,d),dy:e.y(c,d)}},z=function(a,b,c,d,e,f){var g=a._,h=a.matrix,k=g.fillpos,l=a.node,m=l.style,o=1,p="",q,r=u/b,s=u/c;m.visibility="hidden";if(!!b&&!!c){l.coordsize=i(r)+n+i(s),m.rotation=f*(b*c<0?-1:1);if(f){var t=y(f,d,e);d=t.dx,e=t.dy}b<0&&(p+="x"),c<0&&(p+=" y")&&(o=-1),m.flip=p,l.coordorigin=d*-r+n+e*-s;if(k||g.fillsize){var v=l.getElementsByTagName(j);v=v&&v[0],l.removeChild(v),k&&(t=y(f,h.x(k[0],k[1]),h.y(k[0],k[1])),v.position=t.dx*o+n+t.dy*o),g.fillsize&&(v.size=g.fillsize[0]*i(b)+n+g.fillsize[1]*i(c)),l.appendChild(v)}m.visibility="visible"}};a.toString=function(){return"Your browser doesn’t support SVG. Falling down to VML.\nYou are running Raphaël "+this.version};var A=function(a,b,d){var e=c(b).toLowerCase().split("-"),f=d?"end":"start",g=e.length,h="classic",i="medium",j="medium";while(g--)switch(e[g]){case"block":case"classic":case"oval":case"diamond":case"open":case"none":h=e[g];break;case"wide":case"narrow":j=e[g];break;case"long":case"short":i=e[g]}var k=a.node.getElementsByTagName("stroke")[0];k[f+"arrow"]=h,k[f+"arrowlength"]=i,k[f+"arrowwidth"]=j},B=function(e,i){e.attrs=e.attrs||{};var l=e.node,m=e.attrs,p=l.style,q,r=v[e.type]&&(i.x!=m.x||i.y!=m.y||i.width!=m.width||i.height!=m.height||i.cx!=m.cx||i.cy!=m.cy||i.rx!=m.rx||i.ry!=m.ry||i.r!=m.r),s=w[e.type]&&(m.cx!=i.cx||m.cy!=i.cy||m.r!=i.r||m.rx!=i.rx||m.ry!=i.ry),t=e;for(var y in i)i[b](y)&&(m[y]=i[y]);r&&(m.path=a._getPath[e.type](e),e._.dirty=1),i.href&&(l.href=i.href),i.title&&(l.title=i.title),i.target&&(l.target=i.target),i.cursor&&(p.cursor=i.cursor),"blur"in i&&e.blur(i.blur);if(i.path&&e.type=="path"||r)l.path=x(~c(m.path).toLowerCase().indexOf("r")?a._pathToAbsolute(m.path):m.path),e.type=="image"&&(e._.fillpos=[m.x,m.y],e._.fillsize=[m.width,m.height],z(e,1,1,0,0,0));"transform"in i&&e.transform(i.transform);if(s){var B=+m.cx,D=+m.cy,E=+m.rx||+m.r||0,G=+m.ry||+m.r||0;l.path=a.format("ar{0},{1},{2},{3},{4},{1},{4},{1}x",f((B-E)*u),f((D-G)*u),f((B+E)*u),f((D+G)*u),f(B*u))}if("clip-rect"in i){var H=c(i["clip-rect"]).split(k);if(H.length==4){H[2]=+H[2]+ +H[0],H[3]=+H[3]+ +H[1];var I=l.clipRect||a._g.doc.createElement("div"),J=I.style;J.clip=a.format("rect({1}px {2}px {3}px {0}px)",H),l.clipRect||(J.position="absolute",J.top=0,J.left=0,J.width=e.paper.width+"px",J.height=e.paper.height+"px",l.parentNode.insertBefore(I,l),I.appendChild(l),l.clipRect=I)}i["clip-rect"]||l.clipRect&&(l.clipRect.style.clip="auto")}if(e.textpath){var K=e.textpath.style;i.font&&(K.font=i.font),i["font-family"]&&(K.fontFamily='"'+i["font-family"].split(",")[0].replace(/^['"]+|['"]+$/g,o)+'"'),i["font-size"]&&(K.fontSize=i["font-size"]),i["font-weight"]&&(K.fontWeight=i["font-weight"]),i["font-style"]&&(K.fontStyle=i["font-style"])}"arrow-start"in i&&A(t,i["arrow-start"]),"arrow-end"in i&&A(t,i["arrow-end"],1);if(i.opacity!=null||i["stroke-width"]!=null||i.fill!=null||i.src!=null||i.stroke!=null||i["stroke-width"]!=null||i["stroke-opacity"]!=null||i["fill-opacity"]!=null||i["stroke-dasharray"]!=null||i["stroke-miterlimit"]!=null||i["stroke-linejoin"]!=null||i["stroke-linecap"]!=null){var L=l.getElementsByTagName(j),M=!1;L=L&&L[0],!L&&(M=L=F(j)),e.type=="image"&&i.src&&(L.src=i.src),i.fill&&(L.on=!0);if(L.on==null||i.fill=="none"||i.fill===null)L.on=!1;if(L.on&&i.fill){var N=c(i.fill).match(a._ISURL);if(N){L.parentNode==l&&l.removeChild(L),L.rotate=!0,L.src=N[1],L.type="tile";var O=e.getBBox(1);L.position=O.x+n+O.y,e._.fillpos=[O.x,O.y],a._preload(N[1],function(){e._.fillsize=[this.offsetWidth,this.offsetHeight]})}else L.color=a.getRGB(i.fill).hex,L.src=o,L.type="solid",a.getRGB(i.fill).error&&(t.type in{circle:1,ellipse:1}||c(i.fill).charAt()!="r")&&C(t,i.fill,L)&&(m.fill="none",m.gradient=i.fill,L.rotate=!1)}if("fill-opacity"in i||"opacity"in i){var P=((+m["fill-opacity"]+1||2)-1)*((+m.opacity+1||2)-1)*((+a.getRGB(i.fill).o+1||2)-1);P=h(g(P,0),1),L.opacity=P,L.src&&(L.color="none")}l.appendChild(L);var Q=l.getElementsByTagName("stroke")&&l.getElementsByTagName("stroke")[0],T=!1;!Q&&(T=Q=F("stroke"));if(i.stroke&&i.stroke!="none"||i["stroke-width"]||i["stroke-opacity"]!=null||i["stroke-dasharray"]||i["stroke-miterlimit"]||i["stroke-linejoin"]||i["stroke-linecap"])Q.on=!0;(i.stroke=="none"||i.stroke===null||Q.on==null||i.stroke==0||i["stroke-width"]==0)&&(Q.on=!1);var U=a.getRGB(i.stroke);Q.on&&i.stroke&&(Q.color=U.hex),P=((+m["stroke-opacity"]+1||2)-1)*((+m.opacity+1||2)-1)*((+U.o+1||2)-1);var V=(d(i["stroke-width"])||1)*.75;P=h(g(P,0),1),i["stroke-width"]==null&&(V=m["stroke-width"]),i["stroke-width"]&&(Q.weight=V),V&&V<1&&(P*=V)&&(Q.weight=1),Q.opacity=P,i["stroke-linejoin"]&&(Q.joinstyle=i["stroke-linejoin"]||"miter"),Q.miterlimit=i["stroke-miterlimit"]||8,i["stroke-linecap"]&&(Q.endcap=i["stroke-linecap"]=="butt"?"flat":i["stroke-linecap"]=="square"?"square":"round");if(i["stroke-dasharray"]){var W={"-":"shortdash",".":"shortdot","-.":"shortdashdot","-..":"shortdashdotdot",". ":"dot","- ":"dash","--":"longdash","- .":"dashdot","--.":"longdashdot","--..":"longdashdotdot"};Q.dashstyle=W[b](i["stroke-dasharray"])?W[i["stroke-dasharray"]]:o}T&&l.appendChild(Q)}if(t.type=="text"){t.paper.canvas.style.display=o;var X=t.paper.span,Y=100,Z=m.font&&m.font.match(/\d+(?:\.\d*)?(?=px)/);p=X.style,m.font&&(p.font=m.font),m["font-family"]&&(p.fontFamily=m["font-family"]),m["font-weight"]&&(p.fontWeight=m["font-weight"]),m["font-style"]&&(p.fontStyle=m["font-style"]),Z=d(m["font-size"]||Z&&Z[0])||10,p.fontSize=Z*Y+"px",t.textpath.string&&(X.innerHTML=c(t.textpath.string).replace(/</g,"&#60;").replace(/&/g,"&#38;").replace(/\n/g,"<br>"));var $=X.getBoundingClientRect();t.W=m.w=($.right-$.left)/Y,t.H=m.h=($.bottom-$.top)/Y,t.X=m.x,t.Y=m.y+t.H/2,("x"in i||"y"in i)&&(t.path.v=a.format("m{0},{1}l{2},{1}",f(m.x*u),f(m.y*u),f(m.x*u)+1));var _=["x","y","text","font","font-family","font-weight","font-style","font-size"];for(var ba=0,bb=_.length;ba<bb;ba++)if(_[ba]in i){t._.dirty=1;break}switch(m["text-anchor"]){case"start":t.textpath.style["v-text-align"]="left",t.bbx=t.W/2;break;case"end":t.textpath.style["v-text-align"]="right",t.bbx=-t.W/2;break;default:t.textpath.style["v-text-align"]="center",t.bbx=0}t.textpath.style["v-text-kern"]=!0}},C=function(b,f,g){b.attrs=b.attrs||{};var h=b.attrs,i=Math.pow,j,k,l="linear",m=".5 .5";b.attrs.gradient=f,f=c(f).replace(a._radial_gradient,function(a,b,c){l="radial",b&&c&&(b=d(b),c=d(c),i(b-.5,2)+i(c-.5,2)>.25&&(c=e.sqrt(.25-i(b-.5,2))*((c>.5)*2-1)+.5),m=b+n+c);return o}),f=f.split(/\s*\-\s*/);if(l=="linear"){var p=f.shift();p=-d(p);if(isNaN(p))return null}var q=a._parseDots(f);if(!q)return null;b=b.shape||b.node;if(q.length){b.removeChild(g),g.on=!0,g.method="none",g.color=q[0].color,g.color2=q[q.length-1].color;var r=[];for(var s=0,t=q.length;s<t;s++)q[s].offset&&r.push(q[s].offset+n+q[s].color);g.colors=r.length?r.join():"0% "+g.color,l=="radial"?(g.type="gradientTitle",g.focus="100%",g.focussize="0 0",g.focusposition=m,g.angle=0):(g.type="gradient",g.angle=(270-p)%360),b.appendChild(g)}return 1},D=function(b,c){this[0]=this.node=b,b.raphael=!0,this.id=a._oid++,b.raphaelid=this.id,this.X=0,this.Y=0,this.attrs={},this.paper=c,this.matrix=a.matrix(),this._={transform:[],sx:1,sy:1,dx:0,dy:0,deg:0,dirty:1,dirtyT:1},!c.bottom&&(c.bottom=this),this.prev=c.top,c.top&&(c.top.next=this),c.top=this,this.next=null},E=a.el;D.prototype=E,E.constructor=D,E.transform=function(b){if(b==null)return this._.transform;var d=this.paper._viewBoxShift,e=d?"s"+[d.scale,d.scale]+"-1-1t"+[d.dx,d.dy]:o,f;d&&(f=b=c(b).replace(/\.{3}|\u2026/g,this._.transform||o)),a._extractTransform(this,e+b);var g=this.matrix.clone(),h=this.skew,i=this.node,j,k=~c(this.attrs.fill).indexOf("-"),l=!c(this.attrs.fill).indexOf("url(");g.translate(-0.5,-0.5);if(l||k||this.type=="image"){h.matrix="1 0 0 1",h.offset="0 0",j=g.split();if(k&&j.noRotation||!j.isSimple){i.style.filter=g.toFilter();var m=this.getBBox(),p=this.getBBox(1),q=m.x-p.x,r=m.y-p.y;i.coordorigin=q*-u+n+r*-u,z(this,1,1,q,r,0)}else i.style.filter=o,z(this,j.scalex,j.scaley,j.dx,j.dy,j.rotate)}else i.style.filter=o,h.matrix=c(g),h.offset=g.offset();f&&(this._.transform=f);return this},E.rotate=function(a,b,e){if(this.removed)return this;if(a!=null){a=c(a).split(k),a.length-1&&(b=d(a[1]),e=d(a[2])),a=d(a[0]),e==null&&(b=e);if(b==null||e==null){var f=this.getBBox(1);b=f.x+f.width/2,e=f.y+f.height/2}this._.dirtyT=1,this.transform(this._.transform.concat([["r",a,b,e]]));return this}},E.translate=function(a,b){if(this.removed)return this;a=c(a).split(k),a.length-1&&(b=d(a[1])),a=d(a[0])||0,b=+b||0,this._.bbox&&(this._.bbox.x+=a,this._.bbox.y+=b),this.transform(this._.transform.concat([["t",a,b]]));return this},E.scale=function(a,b,e,f){if(this.removed)return this;a=c(a).split(k),a.length-1&&(b=d(a[1]),e=d(a[2]),f=d(a[3]),isNaN(e)&&(e=null),isNaN(f)&&(f=null)),a=d(a[0]),b==null&&(b=a),f==null&&(e=f);if(e==null||f==null)var g=this.getBBox(1);e=e==null?g.x+g.width/2:e,f=f==null?g.y+g.height/2:f,this.transform(this._.transform.concat([["s",a,b,e,f]])),this._.dirtyT=1;return this},E.hide=function(){!this.removed&&(this.node.style.display="none");return this},E.show=function(){!this.removed&&(this.node.style.display=o);return this},E._getBBox=function(){if(this.removed)return{};return{x:this.X+(this.bbx||0)-this.W/2,y:this.Y-this.H,width:this.W,height:this.H}},E.remove=function(){if(!this.removed&&!!this.node.parentNode){this.paper.__set__&&this.paper.__set__.exclude(this),a.eve.unbind("raphael.*.*."+this.id),a._tear(this,this.paper),this.node.parentNode.removeChild(this.node),this.shape&&this.shape.parentNode.removeChild(this.shape);for(var b in this)this[b]=typeof this[b]=="function"?a._removedFactory(b):null;this.removed=!0}},E.attr=function(c,d){if(this.removed)return this;if(c==null){var e={};for(var f in this.attrs)this.attrs[b](f)&&(e[f]=this.attrs[f]);e.gradient&&e.fill=="none"&&(e.fill=e.gradient)&&delete e.gradient,e.transform=this._.transform;return e}if(d==null&&a.is(c,"string")){if(c==j&&this.attrs.fill=="none"&&this.attrs.gradient)return this.attrs.gradient;var g=c.split(k),h={};for(var i=0,m=g.length;i<m;i++)c=g[i],c in this.attrs?h[c]=this.attrs[c]:a.is(this.paper.customAttributes[c],"function")?h[c]=this.paper.customAttributes[c].def:h[c]=a._availableAttrs[c];return m-1?h:h[g[0]]}if(this.attrs&&d==null&&a.is(c,"array")){h={};for(i=0,m=c.length;i<m;i++)h[c[i]]=this.attr(c[i]);return h}var n;d!=null&&(n={},n[c]=d),d==null&&a.is(c,"object")&&(n=c);for(var o in n)l("raphael.attr."+o+"."+this.id,this,n[o]);if(n){for(o in this.paper.customAttributes)if(this.paper.customAttributes[b](o)&&n[b](o)&&a.is(this.paper.customAttributes[o],"function")){var p=this.paper.customAttributes[o].apply(this,[].concat(n[o]));this.attrs[o]=n[o];for(var q in p)p[b](q)&&(n[q]=p[q])}n.text&&this.type=="text"&&(this.textpath.string=n.text),B(this,n)}return this},E.toFront=function(){!this.removed&&this.node.parentNode.appendChild(this.node),this.paper&&this.paper.top!=this&&a._tofront(this,this.paper);return this},E.toBack=function(){if(this.removed)return this;this.node.parentNode.firstChild!=this.node&&(this.node.parentNode.insertBefore(this.node,this.node.parentNode.firstChild),a._toback(this,this.paper));return this},E.insertAfter=function(b){if(this.removed)return this;b.constructor==a.st.constructor&&(b=b[b.length-1]),b.node.nextSibling?b.node.parentNode.insertBefore(this.node,b.node.nextSibling):b.node.parentNode.appendChild(this.node),a._insertafter(this,b,this.paper);return this},E.insertBefore=function(b){if(this.removed)return this;b.constructor==a.st.constructor&&(b=b[0]),b.node.parentNode.insertBefore(this.node,b.node),a._insertbefore(this,b,this.paper);return this},E.blur=function(b){var c=this.node.runtimeStyle,d=c.filter;d=d.replace(r,o),+b!==0?(this.attrs.blur=b,c.filter=d+n+m+".Blur(pixelradius="+(+b||1.5)+")",c.margin=a.format("-{0}px 0 0 -{0}px",f(+b||1.5))):(c.filter=d,c.margin=0,delete this.attrs.blur)},a._engine.path=function(a,b){var c=F("shape");c.style.cssText=t,c.coordsize=u+n+u,c.coordorigin=b.coordorigin;var d=new D(c,b),e={fill:"none",stroke:"#000"};a&&(e.path=a),d.type="path",d.path=[],d.Path=o,B(d,e),b.canvas.appendChild(c);var f=F("skew");f.on=!0,c.appendChild(f),d.skew=f,d.transform(o);return d},a._engine.rect=function(b,c,d,e,f,g){var h=a._rectPath(c,d,e,f,g),i=b.path(h),j=i.attrs;i.X=j.x=c,i.Y=j.y=d,i.W=j.width=e,i.H=j.height=f,j.r=g,j.path=h,i.type="rect";return i},a._engine.ellipse=function(a,b,c,d,e){var f=a.path(),g=f.attrs;f.X=b-d,f.Y=c-e,f.W=d*2,f.H=e*2,f.type="ellipse",B(f,{cx:b,cy:c,rx:d,ry:e});return f},a._engine.circle=function(a,b,c,d){var e=a.path(),f=e.attrs;e.X=b-d,e.Y=c-d,e.W=e.H=d*2,e.type="circle",B(e,{cx:b,cy:c,r:d});return e},a._engine.image=function(b,c,d,e,f,g){var h=a._rectPath(d,e,f,g),i=b.path(h).attr({stroke:"none"}),k=i.attrs,l=i.node,m=l.getElementsByTagName(j)[0];k.src=c,i.X=k.x=d,i.Y=k.y=e,i.W=k.width=f,i.H=k.height=g,k.path=h,i.type="image",m.parentNode==l&&l.removeChild(m),m.rotate=!0,m.src=c,m.type="tile",i._.fillpos=[d,e],i._.fillsize=[f,g],l.appendChild(m),z(i,1,1,0,0,0);return i},a._engine.text=function(b,d,e,g){var h=F("shape"),i=F("path"),j=F("textpath");d=d||0,e=e||0,g=g||"",i.v=a.format("m{0},{1}l{2},{1}",f(d*u),f(e*u),f(d*u)+1),i.textpathok=!0,j.string=c(g),j.on=!0,h.style.cssText=t,h.coordsize=u+n+u,h.coordorigin="0 0";var k=new D(h,b),l={fill:"#000",stroke:"none",font:a._availableAttrs.font,text:g};k.shape=h,k.path=i,k.textpath=j,k.type="text",k.attrs.text=c(g),k.attrs.x=d,k.attrs.y=e,k.attrs.w=1,k.attrs.h=1,B(k,l),h.appendChild(j),h.appendChild(i),b.canvas.appendChild(h);var m=F("skew");m.on=!0,h.appendChild(m),k.skew=m,k.transform(o);return k},a._engine.setSize=function(b,c){var d=this.canvas.style;this.width=b,this.height=c,b==+b&&(b+="px"),c==+c&&(c+="px"),d.width=b,d.height=c,d.clip="rect(0 "+b+" "+c+" 0)",this._viewBox&&a._engine.setViewBox.apply(this,this._viewBox);return this},a._engine.setViewBox=function(b,c,d,e,f){a.eve("raphael.setViewBox",this,this._viewBox,[b,c,d,e,f]);var h=this.width,i=this.height,j=1/g(d/h,e/i),k,l;f&&(k=i/e,l=h/d,d*k<h&&(b-=(h-d*k)/2/k),e*l<i&&(c-=(i-e*l)/2/l)),this._viewBox=[b,c,d,e,!!f],this._viewBoxShift={dx:-b,dy:-c,scale:j},this.forEach(function(a){a.transform("...")});return this};var F;a._engine.initWin=function(a){var b=a.document;b.createStyleSheet().addRule(".rvml","behavior:url(#default#VML)");try{!b.namespaces.rvml&&b.namespaces.add("rvml","urn:schemas-microsoft-com:vml"),F=function(a){return b.createElement("<rvml:"+a+' class="rvml">')}}catch(c){F=function(a){return b.createElement("<"+a+' xmlns="urn:schemas-microsoft.com:vml" class="rvml">')}}},a._engine.initWin(a._g.win),a._engine.create=function(){var b=a._getContainer.apply(0,arguments),c=b.container,d=b.height,e,f=b.width,g=b.x,h=b.y;if(!c)throw new Error("VML container not found.");var i=new a._Paper,j=i.canvas=a._g.doc.createElement("div"),k=j.style;g=g||0,h=h||0,f=f||512,d=d||342,i.width=f,i.height=d,f==+f&&(f+="px"),d==+d&&(d+="px"),i.coordsize=u*1e3+n+u*1e3,i.coordorigin="0 0",i.span=a._g.doc.createElement("span"),i.span.style.cssText="position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;",j.appendChild(i.span),k.cssText=a.format("top:0;left:0;width:{0};height:{1};display:inline-block;position:relative;clip:rect(0 {0} {1} 0);overflow:hidden",f,d),c==1?(a._g.doc.body.appendChild(j),k.left=g+"px",k.top=h+"px",k.position="absolute"):c.firstChild?c.insertBefore(j,c.firstChild):c.appendChild(j),i.renderfix=function(){};return i},a.prototype.clear=function(){a.eve("raphael.clear",this),this.canvas.innerHTML=o,this.span=a._g.doc.createElement("span"),this.span.style.cssText="position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;display:inline;",this.canvas.appendChild(this.span),this.bottom=this.top=null},a.prototype.remove=function(){a.eve("raphael.remove",this),this.canvas.parentNode.removeChild(this.canvas);for(var b in this)this[b]=typeof this[b]=="function"?a._removedFactory(b):null;return!0};var G=a.st;for(var H in E)E[b](H)&&!G[b](H)&&(G[H]=function(a){return function(){var b=arguments;return this.forEach(function(c){c[a].apply(c,b)})}}(H))}(window.Raphael)
\ No newline at end of file
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/ref-index.css b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/ref-index.css
index 7d64b9c5c5..7cdcd9de21 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/ref-index.css
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/ref-index.css
@@ -1,10 +1,32 @@
+/* fonts */
+@font-face {
+  font-family: 'Source Code Pro';
+  font-style: normal;
+  font-weight: 400;
+  src: url('source-code-pro-v6-latin-regular.eot');
+  src: local('Source Code Pro'), local('SourceCodePro-Regular'),
+  url('source-code-pro-v6-latin-regular.eot?#iefix') format('embedded-opentype'),
+  url('source-code-pro-v6-latin-regular.woff') format('woff'),
+  url('source-code-pro-v6-latin-regular.ttf') format('truetype');
+}
+@font-face {
+  font-family: 'Source Code Pro';
+  font-style: normal;
+  font-weight: 700;
+  src: url('source-code-pro-v6-latin-700.eot');
+  src: local('Source Code Pro Bold'), local('SourceCodePro-Bold'),
+  url('source-code-pro-v6-latin-700.eot?#iefix') format('embedded-opentype'),
+  url('source-code-pro-v6-latin-700.woff') format('woff'),
+  url('source-code-pro-v6-latin-700.ttf') format('truetype');
+}
+
 body {
-	font-size: 10pt;
-	font-family: Arial, sans-serif;
+    font-size: 10pt;
+    font-family: Arial, sans-serif;
 }
 
 a {
-	color:#315479;
+    color:#315479;
 }
 
 .letters {
@@ -15,16 +37,20 @@ a {
   border-bottom:1px solid gray;
 }
 
-.entry {
-  border-bottom: 1px solid lightgray;
-  padding: 5px 0 8px;
+div.entry {
+  padding: 0.5em;
+  background-color: #e1e7ed;
+  border-radius: 0.2em;
+  color: #103a51;
+  margin: 0.5em 0;
 }
 
 .name {
-	/* background-color:#E5E5E5; */
+  font-family: "Source Code Pro";
+  font-size: 1.1em;
 }
 
 .occurrences {
   margin-left: 1em;
-  margin-top: 5px;	
-}
\ No newline at end of file
+  margin-top: 5px;
+}
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/remove.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/remove.png
deleted file mode 100644
index 4625f9df74..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/remove.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/remove.psd b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/remove.psd
deleted file mode 100644
index 3764f82ccb..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/remove.psd
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected-implicits.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected-implicits.png
deleted file mode 100644
index bc29efb3e6..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected-implicits.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected-right-implicits.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected-right-implicits.png
deleted file mode 100644
index 8313f4975b..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected-right-implicits.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected-right.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected-right.png
deleted file mode 100644
index 04eda2f307..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected-right.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected.png
deleted file mode 100644
index c89765239e..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected2-right.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected2-right.png
deleted file mode 100644
index bf984ef0ba..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected2-right.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected2.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected2.png
deleted file mode 100644
index a790bb1169..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/selected2.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/signaturebg.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/signaturebg.gif
deleted file mode 100644
index b6ac4415e4..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/signaturebg.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/signaturebg2.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/signaturebg2.gif
deleted file mode 100644
index 9aae5ba0aa..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/signaturebg2.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-700.eot b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-700.eot
new file mode 100644
index 0000000000..094e578e59
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-700.eot
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-700.ttf b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-700.ttf
new file mode 100644
index 0000000000..04159884d6
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-700.ttf
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-700.woff b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-700.woff
new file mode 100644
index 0000000000..6ac8a3b295
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-700.woff
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-regular.eot b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-regular.eot
new file mode 100644
index 0000000000..60bd73b583
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-regular.eot
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-regular.ttf b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-regular.ttf
new file mode 100644
index 0000000000..268a2e4322
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-regular.ttf
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-regular.woff b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-regular.woff
new file mode 100644
index 0000000000..7daeecc8a6
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/source-code-pro-v6-latin-regular.woff
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.css b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.css
index f158aa7309..662ae48944 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.css
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.css
@@ -20,6 +20,8 @@ table { border-collapse: separate; border-spacing: 0; }
 caption, th, td { text-align: left; font-weight: normal; }
 table, td, th { vertical-align: middle; }
 
+textarea, input { outline: none; }
+
 blockquote:before, blockquote:after, q:before, q:after { content: ""; }
 blockquote, q { quotes: none; }
 
@@ -27,15 +29,55 @@ a img { border: none; }
 
 input { border-width: 0px; }
 
-/* Page */
+/* Fonts */
+@font-face {
+  font-family: 'Source Code Pro';
+  font-style: normal;
+  font-weight: 400;
+  src: url('source-code-pro-v6-latin-regular.eot');
+  src: local('Source Code Pro'), local('SourceCodePro-Regular'),
+  url('source-code-pro-v6-latin-regular.eot?#iefix') format('embedded-opentype'),
+  url('source-code-pro-v6-latin-regular.woff') format('woff'),
+  url('source-code-pro-v6-latin-regular.ttf') format('truetype');
+}
+@font-face {
+  font-family: 'Source Code Pro';
+  font-style: normal;
+  font-weight: 700;
+  src: url('source-code-pro-v6-latin-700.eot');
+  src: local('Source Code Pro Bold'), local('SourceCodePro-Bold'),
+  url('source-code-pro-v6-latin-700.eot?#iefix') format('embedded-opentype'),
+  url('source-code-pro-v6-latin-700.woff') format('woff'),
+  url('source-code-pro-v6-latin-700.ttf') format('truetype');
+}
+
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: 400;
+  src: url('open-sans-v13-latin-regular.eot');
+  src: local('Open Sans'), local('OpenSans'),
+  url('open-sans-v13-latin-regular.eot?#iefix') format('embedded-opentype'),
+  url('open-sans-v13-latin-regular.woff') format('woff'),
+  url('open-sans-v13-latin-regular.ttf') format('truetype');
+}
 
+/* Page */
 body {
+  overflow-x: hidden;
   font-family: Arial, sans-serif;
-  font-size: 10pt;
+  background-color: #f0f3f6;
+}
+
+html {
+    box-sizing: border-box;
+}
+
+*, *:before, *:after {
+    box-sizing: inherit;
 }
 
 #footer {
-  font-size: 9pt;
   text-align: center;
   color: #858484;
   bottom: 0;
@@ -52,6 +94,10 @@ a[href]:hover {
   text-decoration: none;
 }
 
+body.trait > div#definition {
+  background-color: #2e6d82;
+}
+
 #types ol li > p {
   margin-top: 5px;
 }
@@ -60,24 +106,11 @@ a[href]:hover {
   margin-bottom: 5px;
 }
 
-/*
 #definition {
-  padding: 6px 0 6px 6px;
-  min-height: 59px;
-  color: white;
-}
-*/
-
-#definition {
-  display: block-inline;
+  display: block;
   padding: 5px 0px;
-  height: 61px;
-}
-
-#definition > img {
-  float: left;
-  padding-right: 6px;
-  padding-left: 5px;
+  height: 5.5em;
+  padding: 0;
 }
 
 #definition > a > img {
@@ -91,28 +124,22 @@ a[href]:hover {
 }
 
 #definition > h1 {
-/*  padding: 12px 0 12px 6px;*/
   color: white;
-  text-shadow: 3px black;
-  text-shadow: black 0px 2px 0px;
-  font-size: 24pt;
   display: inline-block;
   overflow: hidden;
   margin-top: 10px;
+  font-size: 2.0em;
 }
 
 #definition h1 > a {
-  color: #ffffff;
-  font-size: 24pt;
-  text-shadow: black 0px 2px 0px;
-/*  text-shadow: black 0px 0px 0px;*/
-text-decoration: none;
+  color: #fff;
+  text-decoration: none;
 }
 
 #definition #owner {
   color: #ffffff;
-  margin-top: 4px;
-  font-size: 10pt;
+  padding-top: 1.3em;
+  font-size: 0.8em;
   overflow: hidden;
 }
 
@@ -125,13 +152,17 @@ text-decoration: none;
 }
 
 #signature {
-  background-image:url('signaturebg2.gif');
-  background-color: #d7d7d7;
+  background-color:#c2d2dc;
   min-height: 18px;
-  background-repeat:repeat-x;
-  font-size: 11.5pt;
-/*  margin-bottom: 10px;*/
+  font-size: 0.9em;
   padding: 8px;
+  box-shadow: 0 0 0.35em 0.05em rgba(0,0,0,0.5);
+  position: fixed;
+  top: 6.1em;
+  left: 0;
+  width: 100%;
+  z-index: 9998;
+  color: #103a51;
 }
 
 #signature > span.modifier_kind {
@@ -140,16 +171,12 @@ text-decoration: none;
   text-align: left;
   width: auto;
   position: static;
-  text-shadow: 2px white;
-  text-shadow: white 0px 1px 0px;
 }
 
 #signature > span.symbol {
   text-align: left;
   display: inline;
   padding-left: 0.7em;
-  text-shadow: 2px white;
-  text-shadow: white 0px 1px 0px;
 }
 
 /* Linear super types and known subclasses */
@@ -158,47 +185,130 @@ text-decoration: none;
 }
 
 .toggleContainer .toggle {
+  position: relative;
+  color: #103a51;
+  margin-left: 2.3em;
+  cursor: pointer;
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -khtml-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+
+.toggleContainer .toggle:before {
   cursor: pointer;
   padding-left: 15px;
-  background: url("arrow-right.png") no-repeat 0 3px transparent;
+  content: "▶";
+  position: absolute;
+  left: -2.7em;
+  top: 0em;
 }
 
-.toggleContainer .toggle.open {
-  background: url("arrow-down.png") no-repeat 0 3px transparent;
+.toggleContainer .toggle.open:before {
+  content: "▼";
+  position: absolute;
+  left: -2.7em;
+  top: 0em;
 }
 
 .toggleContainer .hiddenContent {
-  margin-top: 5px;
+  margin-top: 1.5em;
 }
 
 .value #definition {
-  background-color: #2C475C; /* blue */
-  background-image:url('defbg-blue.gif');
-  background-repeat:repeat-x;
+  background-color: #103A51; /* blue */
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  z-index: 9999;
 }
 
 .type #definition {
-  background-color: #316555; /* green */
-  background-image:url('defbg-green.gif');
-  background-repeat:repeat-x;
+  background-color: rgba(49, 101, 85, 1); /* green */
+  position: fixed;
+  top: 0;
+  left: 0;
+  min-height: 5.5em;
+  width: 100%;
+  z-index: 9999;
+}
+
+.abstract.type #definition {
+  background-color: #447A90;
+}
+
+.big-circle {
+  box-sizing: content-box;
+  height: 5.7em;
+  width: 5.7em;
+  float: left;
+  color: transparent;
+}
+
+.big-circle:hover {
+  background-size: 5.7em;
+}
+
+.big-circle.class {
+  background: url("class.svg") no-repeat center;
+}
+
+.big-circle.cl.companion {
+  background: url("class_comp.svg") no-repeat center;
+}
+
+.big-circle.ob.companion {
+  background: url("object_comp.svg") no-repeat center;
+}
+
+.big-circle.tr.companion {
+  background: url("trait_comp.svg") no-repeat center;
+}
+
+.big-circle.object {
+  background: url("object.svg") no-repeat center;
+}
+
+.big-circle.trait {
+  background: url("trait.svg") no-repeat center;
+}
+
+.big-circle.package {
+  background: url("package.svg") no-repeat center;
+}
+
+body.abstract.type div.big-circle {
+  background: url("abstract_type.svg") no-repeat center;
 }
 
 #template {
-  margin-bottom: 50px;
+  margin: 0.9em 0.75em 2em 0.75em;
+  border-radius: 0.2em;
+  background-color: #fff;
+  -webkit-box-shadow: 0 0 10px rgba(0,0,0,0.1);
+  box-shadow: 0 0 10px rgba(0,0,0,0.1);
+  padding-bottom: 0.5em;
+}
+
+#order {
+  margin-top: 1.5em;
 }
 
 h3 {
   color: white;
   padding: 5px 10px;
-  font-size: 12pt;
+  font-size: 1em;
   font-weight: bold;
-  text-shadow: black 1px 1px 0px;
 }
 
 dl.attributes > dt {
   display: block;
   float: left;
   font-style: italic;
+  font-weight: bold;
 }
 
 dl.attributes > dt.implicit {
@@ -214,8 +324,10 @@ dl.attributes > dd {
 }
 
 #template .values > h3 {
-  background: #2C475C url("valuemembersbg.gif") repeat-x bottom left;  /* grayish blue */
-  height: 18px;
+  color: #2C475C;
+  height: 2em;
+  padding: 1em 1em 2em;
+  font-size: 1.2em;
 }
 
 .values ol li:last-child {
@@ -223,20 +335,18 @@ dl.attributes > dd {
 }
 
 #template .types > h3 {
-  background: #316555 url("typebg.gif") repeat-x bottom left;  /* green */
   height: 18px;
 }
 
 #constructors > h3 {
-  background: #4f504f url("constructorsbg.gif") repeat-x bottom left; /* gray */
-  height: 18px;
+  height: 2em;
+  padding: 1em 1em 2em;
+  color: #2C475C;
 }
 
 #inheritedMembers > div.parent > h3 {
-  background: #dadada url("constructorsbg.gif") repeat-x bottom left; /* gray */
   height: 17px;
   font-style: italic;
-  font-size: 12pt;
 }
 
 #inheritedMembers > div.parent > h3 * {
@@ -244,29 +354,19 @@ dl.attributes > dd {
 }
 
 #inheritedMembers > div.conversion > h3 {
-  background: #dadada url("conversionbg.gif") repeat-x bottom left; /* gray */
-  height: 17px;
+  height: 2em;
+  padding: 1em;
   font-style: italic;
-  font-size: 12pt;
-}
-
-#inheritedMembers > div.conversion > h3 * {
-  color: white;
+  color: #2C475C;
 }
 
 #groupedMembers > div.group > h3 {
-  background: #dadada url("typebg.gif") repeat-x bottom left; /* green */
-  height: 17px;
-  font-size: 12pt;
-}
-
-#groupedMembers > div.group > h3 * {
-  color: white;
+  color: #2C475C;
+  height: 2em;
+  padding: 1em 1em 2em;
 }
 
-
 /* Member cells */
-
 div.members > ol {
   background-color: white;
   list-style: none
@@ -274,10 +374,19 @@ div.members > ol {
 
 div.members > ol > li {
   display: block;
-  border-bottom: 1px solid gray;
   padding: 5px 0 6px;
   margin: 0 10px;
   position: relative;
+  background-color: #e1e7ed;
+  border-radius: 0.2em;
+  color: #103a51;
+  padding: 5px 0 5px;
+  margin-bottom: 0.4em;
+}
+
+div.members > ol >li.selected,
+div.members > ol > li:hover {
+  background-color: #c2d2dc;
 }
 
 div.members > ol > li:last-child {
@@ -297,13 +406,11 @@ div.members > ol > li:last-child {
 }
 
 .signature {
-  font-family: monospace;
-  font-size: 10pt;
+  font-family: "Source Code Pro";
+  font-size: 0.8rem;
   line-height: 18px;
   clear: both;
   display: block;
-  text-shadow: 2px white;
-  text-shadow: white 0px 1px 0px;
 }
 
 .signature .modifier_kind {
@@ -358,15 +465,28 @@ div.members > ol > li:last-child {
 }
 
 #template .signature.closed {
-  background: url("arrow-right.png") no-repeat 0 5px transparent;
   cursor: pointer;
 }
 
+#template .signature.closed:before {
+    content: "▶";
+    position: absolute;
+    left: 1em;
+    top: 0.5em;
+}
+
 #template .signature.opened {
-  background: url("arrow-down.png") no-repeat 0 5px transparent;
   cursor: pointer;
 }
 
+#template .signature.opened:before {
+  content: "▼";
+  position: absolute;
+  left: 1em;
+  top: 0.5em;
+  color: #2C475C;
+}
+
 #template .values .signature .name {
   color: darkblue;
 }
@@ -376,11 +496,21 @@ div.members > ol > li:last-child {
 }
 
 .full-signature-usecase h4 span {
-  font-size: 10pt;
+  font-size: 0.9em;
 }
 
 .full-signature-usecase > #signature {
   padding-top: 0px;
+  position: relative;
+  top: 0;
+}
+
+.full-signature-usecase > .signature.closed:before {
+  content: "" !important;
+}
+
+.full-signature-usecase > .signature.opened:before {
+  content: "" !important;
 }
 
 #template .full-signature-usecase > .signature.closed {
@@ -404,6 +534,7 @@ div.members > ol > li:last-child {
   top: 40px;
   right: 10px;
   width: 450px;
+  font-family: 'Source Sans Pro', 'Helvetica Neue', Arial, sans-serif;
 }
 
 #definition .morelinks a {
@@ -444,7 +575,9 @@ div.members > ol > li:last-child {
 
 /* Comments text formating */
 
-.cmt {}
+.cmt {
+  color: #103a51;
+}
 
 .cmt p {
   margin: 0.7em 0;
@@ -469,29 +602,15 @@ div.members > ol > li:last-child {
   font-weight: bold;
 }
 
-.cmt h3 {
-  font-size: 14pt;
-}
-
-.cmt h4 {
-  font-size: 13pt;
-}
-
-.cmt h5 {
-  font-size: 12pt;
-}
-
-.cmt h6 {
-  font-size: 11pt;
-}
-
 .cmt pre {
-  padding: 5px;
-  border: 1px solid #ddd;
-  background-color: #eee;
+  padding: 0.5em;
+  border: 0px solid #ddd;
+  background-color: #fff;
   margin: 5px 0;
   display: block;
-  font-family: monospace;
+  font-family: "Source Code Pro";
+  border-radius: 0.2em;
+  overflow-x: auto;
 }
 
 .cmt pre span.ano {
@@ -554,7 +673,7 @@ div.members > ol > li:last-child {
 }
 
 .cmt code {
-  font-family: monospace;
+  font-weight: bold;
 }
 
 .cmt a {
@@ -572,17 +691,9 @@ div.members > ol > li:last-child {
 /* Comments structured layout */
 
 .group > div.comment {
-  padding-top: 5px;
-  padding-bottom: 5px;
-  padding-right: 5px;
-  padding-left: 5px;
-  border: 1px solid #ddd;
-  background-color: #eeeee;
-  margin-top:5px;
-  margin-bottom:5px;
-  margin-right:5px;
-  margin-left:5px;
   display: block;
+  padding: 0 1.2em 1em;
+  font-family: "Open Sans";
 }
 
 p.comment {
@@ -596,10 +707,15 @@ p.comment {
   margin: 5px 10px;
 }
 
+.shortcomment > span.badge {
+  display: block;
+  position: absolute;
+  right: 0;
+  top: 0.7em;
+}
+
 div.fullcommenttop {
-  padding: 10px 10px;
-  background-image:url('fullcommenttopbg.gif');
-  background-repeat:repeat-x;
+  padding: 1em 0.8em;
 }
 
 div.fullcomment {
@@ -615,20 +731,42 @@ div.fullcomment {
 #template .shortcomment {
   margin: 5px 0 0 14.7em;
   padding: 0;
+  font-family: "Open Sans";
 }
 
 div.fullcomment .block {
   padding: 5px 0 0;
-  border-top: 1px solid #EBEBEB;
+  border-top: 2px solid #fff;
   margin-top: 5px;
   overflow: hidden;
+  margin-right: 0.5em;
+  font-family: "Open Sans";
 }
 
 div.fullcommenttop .block {
-  padding: 5px 0 0;
-  border-top: 1px solid #EBEBEB;
-  margin-top: 5px;
-  margin-bottom: 5px
+  padding: 1em;
+  margin: 0.5em 0;
+  border-radius: 0.2em;
+  background-color: #fff;
+  -webkit-box-shadow: 0 0 10px rgba(0,0,0,0.1);
+  box-shadow: 0 0 10px rgba(0,0,0,0.1);
+}
+
+div#comment,
+div#mbrsel,
+div#template,
+div#footer {
+  font-size: 0.8em;
+}
+
+#comment {
+  font-family: "Open Sans";
+}
+
+#comment > dl {
+  background: transparent;
+  -webkit-box-shadow: none;
+  box-shadow: none;
 }
 
 div.fullcomment div.block ol li p,
@@ -643,6 +781,7 @@ div.fullcomment .block > h5 {
 }
 
 div.fullcomment .comment {
+  font-family: "Open Sans";
   margin: 5px 0 10px;
 }
 
@@ -678,216 +817,372 @@ div.fullcomment dl.paramcmts > dd {
 #textfilter {
   position: relative;
   display: block;
-    height: 20px;
+  height: 2.7em;
   margin-bottom: 5px;
-}
-
-#textfilter > .pre {
-    display: block;
-    position: absolute;
-    top: 0;
-    left: 0;
-    height: 23px;
-    width: 21px;
-    background: url("filter_box_left.png");
+  margin-left: 1.5em;
 }
 
 #textfilter > .input {
   display: block;
-    position: absolute;
-    top: 0;
-    right: 20px;
-    left: 20px;
+  position: absolute;
+  top: 0;
+  left: -1.65em;
+  right: -0.2em;
+  transition: 0.2s;
 }
 
 #textfilter > .input > input {
-  height: 20px;
-  padding: 1px;
-  font-weight: bold;
-  color: #000000;
-        background: #ffffff url("filterboxbarbg.png") repeat-x top left;
-        width: 100%;
+  color: #fff;
+  width: 100%;
+  border-radius: 0.2em;
+  padding: 0.5em;
+  background: rgba(255, 255, 255, 0.2);
+  font-family: "Open Sans";
 }
 
-#textfilter > .post {
-    display: block;
-    position: absolute;
-    top: 0;
-    right: 0;
-    height: 23px;
-    width: 21px;
-    background: url("filter_box_right.png");
+#textfilter > .clear {
+  display: none;
+  position: absolute;
+  top: 0.6em;
+  right: -0.65em;
+  height: 23px;
+  width: 21px;
+  color: rgba(255, 255, 255, 0.4);
+}
+
+#textfilter > .clear:hover {
+  color: #fff;
+  cursor: pointer;
 }
 
 #mbrsel {
-  padding: 5px 10px;
-  background-color: #ededee; /* light gray */
-  background-image:url('filterboxbg.gif');
-  background-repeat:repeat-x;
-  font-size: 9.5pt;
   display: block;
-  margin-top: 1em;
-/*  margin-bottom: 1em; */
+  padding: 1em 1em 0.5em;
+  margin: 0.8em;
+  border-radius: 0.2em;
+  background-color: #364550;
+  -webkit-box-shadow: 0 0 10px rgba(0,0,0,0.1);
+  box-shadow: 0 0 10px rgba(0,0,0,0.1);
+  position: relative;
+  margin-bottom: -1em;
+  border-bottom-left-radius: 0;
+  border-bottom-right-radius: 0;
+}
+
+#mbrsel > div.toggle {
+  opacity: 0;
+  position: absolute;
+  left: 1.85em;
+  top: 1.75em;
+  width: 1em;
+  height: 1em;
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -khtml-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+  transition: 0.2s;
 }
 
-#mbrsel > div {
+#mbrsel:hover > div.toggle {
+  opacity: 1;
+}
+
+#mbrsel:hover #textfilter > .input {
+  left: 0.7em;
+}
+
+#mbrsel > div.toggle:before {
+  cursor: pointer;
+  content: "▶";
+  position: absolute;
+  left: 0;
+  top: 0;
+  color: #fff;
+}
+
+#mbrsel > div.toggle.open:before {
+  content: "▼";
+}
+
+#mbrsel > div#filterby {
+  display: none;
+}
+
+#mbrsel > div#filterby > div {
   margin-bottom: 5px;
 }
 
-#mbrsel > div:last-child {
+#mbrsel > div#filterby > div:last-child {
   margin-bottom: 0;
 }
 
-#mbrsel > div > span.filtertype {
+#mbrsel > div#filterby > div > span.filtertype {
+  color: #fff;
   padding: 4px;
-  margin-right: 5px;
+  margin-right: 1em;
   float: left;
   display: inline-block;
-  color: #000000;
   font-weight: bold;
-  text-shadow: white 0px 1px 0px;
   width: 4.5em;
 }
 
-#mbrsel > div > ol {
+#mbrsel > div#filterby > div > ol {
   display: inline-block;
 }
 
-#mbrsel > div > a {
+#mbrsel > div#filterby > div > a {
   position:relative;
   top: -8px;
   font-size: 11px;
-  text-shadow: #ffffff 0 1px 0;
 }
 
-#mbrsel > div > ol#linearization {
+#mbrsel > div#filterby > div > ol#linearization {
   display: table;
   margin-left: 70px;
 }
 
-#mbrsel > div > ol#linearization > li.in {
+#mbrsel > div#filterby > div > ol#linearization > li.in {
   text-decoration: none;
   float: left;
-  padding-right: 10px;
   margin-right: 5px;
-  background: url(selected-right.png) no-repeat;
   background-position: right 0px;
 }
 
-#mbrsel > div > ol#linearization > li.in > span{
-  color: #404040;
+#mbrsel > div#filterby > div > ol#linearization > li.in > span{
   float: left;
-  padding: 1px 0 1px 10px;
-  background: url(selected.png) no-repeat;
-  background-position: 0px 0px;
-  text-shadow: #ffffff 0 1px 0;
 }
 
-#mbrsel > div > ol#implicits {
+#mbrsel > div#filterby > div > ol#implicits {
   display: table;
   margin-left: 70px;
 }
 
-#mbrsel > div > ol#implicits > li.in {
+#mbrsel > div#filterby > div > ol#implicits > li {
+  text-decoration: none;
+  float: left;
+  margin: 0.4em 0.4em 0.4em 0;
+}
+
+#mbrsel > div#filterby > div > ol#implicits > li.in {
   text-decoration: none;
   float: left;
-  padding-right: 10px;
-  margin-right: 5px;
-  background: url(selected-right-implicits.png) no-repeat;
-  background-position: right 0px;
 }
 
-#mbrsel > div > ol#implicits > li.in > span{
-  color: #404040;
+#mbrsel > div#filterby > div > ol#implicits > li.in > span{
   float: left;
-  padding: 1px 0 1px 10px;
-  background: url(selected-implicits.png) no-repeat;
-  background-position: 0px 0px;
-  text-shadow: #ffffff 0 1px 0;
 }
 
-#mbrsel > div > ol > li {
-/*  padding: 3px 10px;*/
-  line-height: 16pt;
+#mbrsel > div#filterby > div > ol > li {
+  line-height: 1.5em;
   display: inline-block;
   cursor: pointer;
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -khtml-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
 }
 
-#mbrsel > div > ol > li.in {
+#mbrsel > div#filterby > div > ol > li.in {
   text-decoration: none;
   float: left;
-  padding-right: 10px;
   margin-right: 5px;
-  background: url(selected-right.png) no-repeat;
-  background-position: right 0px;
+
+  font-size: 0.8em;
+  -webkit-border-radius: 0.2em;
+  border-radius: 0.2em;
+  padding: 5px 15px;
+  cursor: pointer;
+  background: #f16665;
+  border-bottom: 2px solid #d64546;
+  color: #fff;
+  font-weight: 700;
 }
 
-#mbrsel > div > ol > li.in > span{
-  color: #404040;
+#mbrsel > div#filterby > div > ol > li.in > span{
   float: left;
-  padding: 1px 0 1px 10px;
-  background: url(selected.png) no-repeat;
-  background-position: 0px 0px;
-  text-shadow: #ffffff 0 1px 0;
 }
 
-#mbrsel > div > ol > li.out {
+#mbrsel > div#filterby > div > ol > li.out {
   text-decoration: none;
   float: left;
   padding-right: 10px;
   margin-right: 5px;
+  font-size: 0.8em;
+  -webkit-border-radius: 0.2em;
+  border-radius: 0.2em;
+  padding: 5px 15px;
+  cursor: pointer;
+  background: #c2d2dc;
+  border-bottom: 2px solid rgba(0, 0, 0, 0.1);
+  color: #103a51;
+  font-weight: 700;
 }
 
-#mbrsel > div > ol > li.out > span{
-  color: #747474;
-/*  background-color: #999; */
+#mbrsel > div#filterby > div > ol > li.out > span{
   float: left;
-  padding: 1px 0 1px 10px;
-/*  background: url(unselected.png) no-repeat;*/
-  background-position: 0px -1px;
-  text-shadow: #ffffff 0 1px 0;
-}
-/*
-#mbrsel .hideall {
-  color: #4C4C4C;
-  line-height: 16px;
-  font-weight: bold;
-}
-
-#mbrsel .hideall span {
-  color: #4C4C4C;
-  font-weight: bold;
-}
-
-#mbrsel .showall {
-  color: #4C4C4C;
-  line-height: 16px;
-  font-weight: bold;
 }
 
-#mbrsel .showall span {
-  color: #4C4C4C;
-  font-weight: bold;
-}*/
-
 .badge {
   display: inline-block;
-  padding: 2px 4px;
-  font-size: 11.844px;
+  padding: 0.3em 1em;
+  font-size: 0.8em;
   font-weight: bold;
-  line-height: 14px;
   color: #ffffff;
-  text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
   white-space: nowrap;
-  vertical-align: baseline;
+  vertical-align: middle;
   background-color: #999999;
-  padding-right: 9px;
-  padding-left: 9px;
   -webkit-border-radius: 9px;
-     -moz-border-radius: 9px;
-          border-radius: 9px;
+  -moz-border-radius: 9px;
+  border-radius: 1em;
+  font-family: "Open Sans";
 }
 
 .badge-red {
   background-color: #b94a48;
+  margin-right: 0.8em !important;
+}
+
+/* Media query rules for smaller viewport */
+@media only screen /* Large screen with a small window */
+and (max-width: 560px)
+,
+screen /* HiDPI device like Nexus 5 */
+and (max-device-width: 360px)
+and (max-device-height: 640px)
+and (-webkit-device-pixel-ratio: 3)
+,
+screen /* Most mobile devices  */
+and (max-device-width: 480px)
+and (orientation: portrait)
+,
+only screen /* iPhone 6 */
+and (max-device-width: 667px)
+and (-webkit-device-pixel-ratio: 2)
+{
+  body,
+  body > h4#signature {
+    min-width: 300px;
+  }
+
+  .signature .modifier_kind {
+    width: 10em;
+  }
+
+  .signature > .symbol {
+    padding-left: 10.7em;
+  }
+
+  #template .shortcomment {
+    margin-left: 10.7em;
+  }
+
+  #template div.fullcommenttop, #template div.fullcomment {
+    margin-left: 10.7em;
+  }
+
+  #definition {
+    min-width: 300px;
+    height: 6em;
+  }
+
+  #definition .morelinks {
+    text-align: left;
+    left: 7.2em;
+    font-size: 0.8em;
+    top: auto;
+    bottom: 0.5em;
+  }
+
+  #signature {
+    top: 6.7em;
+  }
+
+  .big-circle {
+    margin-top: 0.6em;
+  }
+}
+
+/* Media query rules specifically for mobile devices */
+@media
+screen /* HiDPI device like Nexus 5 */
+and (max-device-width: 360px)
+and (max-device-height: 640px)
+and (-webkit-device-pixel-ratio: 3)
+,
+screen /* Most mobile devices  */
+and (max-device-width: 480px)
+and (orientation: portrait)
+,
+only screen /* iPhone 6 */
+and (max-device-width: 667px)
+and (-webkit-device-pixel-ratio: 2)
+{
+  #definition {
+    position: absolute !important;
+    min-height: 0 !important;
+    height: 4em !important;
+  }
+
+  #signature {
+    position: absolute !important;
+    font-size: 0.7em;
+    top: 5.7em;
+  }
+
+  #definition > h1 {
+    font-size: 1.3em;
+  }
+
+  #definition .morelinks {
+    display: none;
+  }
+
+  #definition #owner {
+    padding-top: 0.7em;
+  }
+
+  div.fullcommenttop {
+    margin-top: 11.6em;
+  }
+
+  #template .shortcomment {
+    margin-left: 1em;
+  }
+
+  div.fullcomment dl.attributes > dt {
+    margin: 0.5em 0;
+    clear: both;
+  }
+
+  div.fullcomment dl.attributes > dd {
+    padding-left: 0;
+    clear: both;
+  }
+
+  #template div.fullcommenttop, #template div.fullcomment {
+    margin-left: 1em;
+  }
+
+  .big-circle {
+    width: 3em;
+    height: 3em;
+    background-size: 3em !important;
+    margin: 0.5em;
+  }
+
+  div#template {
+    margin-bottom: 0.5em;
+  }
+
+  div#footer {
+    font-size: 0.5em;
+  }
+
+  .shortcomment > span.badge {
+    display: none;
+  }
 }
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.js b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.js
index c1e3010834..9d9d7bdfff 100644
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.js
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.js
@@ -1,7 +1,40 @@
 // © 2009–2010 EPFL/LAMP
-// code by Gilles Dubochet with contributions by Pedro Furlanetto and Marcin Kubala
+// code by Gilles Dubochet with contributions by Pedro Furlanetto, Marcin Kubala and Felix Mulder
+
+$(document).ready(function() {
+
+    $("#template > div > div > ol > li > span > a").click(function(e) {
+        $("#template > div > div > ol > li").removeClass("selected");
+        $(this).parent().parent().addClass("selected");
+        var defHeight = $("#definition").height() + $("#signature").height() + 50;
+        $('html,body').animate({scrollTop: $(this).offset().top - defHeight}, 500);
+    });
+
+    /* Handle dynamic size of signature and offset the fullcommenttop div
+     * appropriately
+     *
+     * Some mobile devices render quite slowly, delay the margin-top
+     * calculation if mobile
+     */
+    if(/Android|webOS|Mobi|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)) {
+        setTimeout(function() {
+            $("div.fullcommenttop").css({
+                "margin-top": $("#definition").height() + $("#signature").height() + 15
+            });
+        }, 1000);
+    } else {
+        $("div.fullcommenttop").css({
+            "margin-top": $("#definition").height() + $("#signature").height() + 15
+        });
+    }
+
+    /* When the window is resized, adjust the fullcommenttop div's offset */
+    $(window).resize(function() {
+        $("div.fullcommenttop").css({
+            "margin-top": $("#definition").height() + $("#signature").height() + 15
+        });
+    });
 
-$(document).ready(function(){
 
     var controls = {
         visibility: {
@@ -48,8 +81,9 @@ $(document).ready(function(){
 
         filter();
         window.scrollTo(0, 0);
-        jqElemParent.effect("highlight", {color: "#FFCC85"}, 3000);
-        $('html,body').animate({scrollTop: jqElemParent.offset().top}, 1000);
+        var defHeight = $("#definition").height() + $("#signature").height() + 50;
+        jqElemParent.addClass("selected");
+        $('html,body').animate({scrollTop: jqElemParent.offset().top - defHeight}, 1000);
     }
 
     var isHiddenClass = function (name) {
@@ -69,6 +103,10 @@ $(document).ready(function(){
         return isHidden(this);
     }).removeClass("in").addClass("out");
 
+    $("#mbrsel > div.toggle").click(function() {
+        $("#filterby").toggle();
+    });
+
     // Pre-filter members
     filter();
 
@@ -101,7 +139,7 @@ $(document).ready(function(){
             break;
 
         default:
-            window.scrollTo(0, $("#mbrsel").offset().top);
+            window.scrollTo(0, $("#mbrsel").offset().top - 130);
             filter(true);
             break;
 
@@ -110,7 +148,7 @@ $(document).ready(function(){
     input.focus(function(event) {
         input.select();
     });
-    $("#textfilter > .post").click(function() {
+    $("#textfilter > .clear").click(function() {
         $("#textfilter input").attr("value", "");
         filter();
     });
@@ -147,19 +185,19 @@ $(document).ready(function(){
         filter();
     });
 
-    $("#mbrsel > div.ancestors > ol > li.hideall").click(function() {
+    $("#mbrsel > div > div.ancestors > ol > li.hideall").click(function() {
         $("#linearization li.in").removeClass("in").addClass("out");
         $("#linearization li:first").removeClass("out").addClass("in");
         $("#implicits li.in").removeClass("in").addClass("out");
 
-        if ($(this).hasClass("out") && $("#mbrsel > div.ancestors > ol > li.showall").hasClass("in")) {
+        if ($(this).hasClass("out") && $("#mbrsel > div > div.ancestors > ol > li.showall").hasClass("in")) {
             $(this).removeClass("out").addClass("in");
-            $("#mbrsel > div.ancestors > ol > li.showall").removeClass("in").addClass("out");
+            $("#mbrsel > div > div.ancestors > ol > li.showall").removeClass("in").addClass("out");
         }
 
         filter();
     })
-    $("#mbrsel > div.ancestors > ol > li.showall").click(function() {
+    $("#mbrsel > div > div.ancestors > ol > li.showall").click(function() {
         var filteredLinearization =
             $("#linearization li.out").filter(function() {
                 return ! isHiddenClass($(this).attr("name"));
@@ -167,14 +205,14 @@ $(document).ready(function(){
         filteredLinearization.removeClass("out").addClass("in");
 
         var filteredImplicits =
-        $("#implicits li.out").filter(function() {
-            return ! isHidden(this);
-        });
+            $("#implicits li.out").filter(function() {
+                return ! isHidden(this);
+            });
         filteredImplicits.removeClass("out").addClass("in");
 
-        if ($(this).hasClass("out") && $("#mbrsel > div.ancestors > ol > li.hideall").hasClass("in")) {
+        if ($(this).hasClass("out") && $("#mbrsel > div > div.ancestors > ol > li.hideall").hasClass("in")) {
             $(this).removeClass("out").addClass("in");
-            $("#mbrsel > div.ancestors > ol > li.hideall").removeClass("in").addClass("out");
+            $("#mbrsel > div > div.ancestors > ol > li.hideall").removeClass("in").addClass("out");
         }
 
         filter();
@@ -267,6 +305,14 @@ $(document).ready(function(){
             exposeMember(jqElem);
         }
     }
+
+    $("#mbrsel-input").on("focus", function() {
+        $("#textfilter > .clear").show();
+    });
+
+    $("#mbrsel-input").on("blur", function() {
+        $("#textfilter > .clear").hide();
+    });
 });
 
 function orderAlpha() {
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait.png
deleted file mode 100644
index fb961a2eda..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait.svg b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait.svg
new file mode 100644
index 0000000000..207a89f37f
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait.svg
@@ -0,0 +1,54 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="72px" height="72px" viewBox="0 0 72 72" version="1.1">
+  <defs>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-1">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+    <circle id="path-2" cx="32" cy="32" r="32"/>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-4">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feOffset dx="0" dy="1" in="SourceAlpha" result="shadowOffsetInner1"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner1" result="shadowBlurInner1"/>
+      <feComposite in="shadowBlurInner1" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner1"/>
+      <feColorMatrix values="0 0 0 0 1   0 0 0 0 1   0 0 0 0 1  0 0 0 0.14 0" in="shadowInnerInner1" type="matrix" result="shadowMatrixInner1"/>
+      <feOffset dx="0" dy="-1" in="SourceAlpha" result="shadowOffsetInner2"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner2" result="shadowBlurInner2"/>
+      <feComposite in="shadowBlurInner2" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner2"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowInnerInner2" type="matrix" result="shadowMatrixInner2"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+        <feMergeNode in="shadowMatrixInner1"/>
+        <feMergeNode in="shadowMatrixInner2"/>
+      </feMerge>
+    </filter>
+    <path id="path-5" d="M32 61C49.673112 61 64 48.0162577 64 32 64 15.9837423 49.673112 3 32 3 14.326888 3 0 15.9837423 0 32 0 48.0162577 14.326888 61 32 61Z"/>
+  </defs>
+  <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+    <g id="Artboard-1" transform="translate(-298.000000, -91.000000)">
+      <g id="BG" transform="translate(302.000000, 91.000000)">
+        <g id="Icon">
+          <mask id="mask-3" fill="white">
+            <use xlink:href="#path-2"/>
+          </mask>
+          <use id="Mask" fill="#19AACF" filter="url(#filter-1)" xlink:href="#path-2"/>
+          <mask id="mask-6" fill="white">
+            <use xlink:href="#path-5"/>
+          </mask>
+          <text id="t" mask="url(#mask-6)" font-family="Open Sans, Helvetica Neueu, Sans-serif" font-size="40" font-weight="normal" fill="#FFFFFF">
+            <tspan x="27" y="46">
+              t
+            </tspan>
+          </text>
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait_big.png
deleted file mode 100644
index 625d9251cb..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait_comp.svg b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait_comp.svg
new file mode 100644
index 0000000000..8c83dec1f1
--- /dev/null
+++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait_comp.svg
@@ -0,0 +1,57 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="72px" height="72px" viewBox="0 0 72 72" version="1.1">
+  <defs>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-1">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>
+    <circle id="path-2" cx="32" cy="32" r="32"/>
+    <filter x="-50%" y="-50%" width="200%" height="200%" filterUnits="objectBoundingBox" id="filter-4">
+      <feOffset dx="0" dy="4" in="SourceAlpha" result="shadowOffsetOuter1"/>
+      <feGaussianBlur stdDeviation="2" in="shadowOffsetOuter1" result="shadowBlurOuter1"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowBlurOuter1" type="matrix" result="shadowMatrixOuter1"/>
+      <feOffset dx="0" dy="1" in="SourceAlpha" result="shadowOffsetInner1"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner1" result="shadowBlurInner1"/>
+      <feComposite in="shadowBlurInner1" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner1"/>
+      <feColorMatrix values="0 0 0 0 1   0 0 0 0 1   0 0 0 0 1  0 0 0 0.14 0" in="shadowInnerInner1" type="matrix" result="shadowMatrixInner1"/>
+      <feOffset dx="0" dy="-1" in="SourceAlpha" result="shadowOffsetInner2"/>
+      <feGaussianBlur stdDeviation="0" in="shadowOffsetInner2" result="shadowBlurInner2"/>
+      <feComposite in="shadowBlurInner2" in2="SourceAlpha" operator="arithmetic" k2="-1" k3="1" result="shadowInnerInner2"/>
+      <feColorMatrix values="0 0 0 0 0   0 0 0 0 0   0 0 0 0 0  0 0 0 0.14 0" in="shadowInnerInner2" type="matrix" result="shadowMatrixInner2"/>
+      <feMerge>
+        <feMergeNode in="shadowMatrixOuter1"/>
+        <feMergeNode in="SourceGraphic"/>
+        <feMergeNode in="shadowMatrixInner1"/>
+        <feMergeNode in="shadowMatrixInner2"/>
+      </feMerge>
+    </filter>
+    <path id="path-5" d="M32 61C49.673112 61 64 48.0162577 64 32 64 15.9837423 49.673112 3 32 3 14.326888 3 0 15.9837423 0 32 0 48.0162577 14.326888 61 32 61Z"/>
+  </defs>
+  <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+    <g id="Artboard-1" transform="translate(-298.000000, -91.000000)">
+      <g id="BG" transform="translate(302.000000, 91.000000)">
+        <g id="Icon">
+          <mask id="mask-3" fill="white">
+            <use xlink:href="#path-2"/>
+          </mask>
+          <use id="Mask" fill="#2C6C8D" filter="url(#filter-1)" xlink:href="#path-2"/>
+          <rect id="Rectangle-2" opacity="0.3" fill="#000000" mask="url(#mask-3)" x="-8" y="33" width="80" height="31"/>
+          <mask id="mask-6" fill="white">
+            <use xlink:href="#path-5"/>
+          </mask>
+          <use id="Mask" fill="#19AACF" filter="url(#filter-4)" xlink:href="#path-5"/>
+          <text id="t" mask="url(#mask-6)" font-family="Open Sans, Helvetica Neueu, Sans-serif" font-size="40" font-weight="normal" fill="#FFFFFF">
+            <tspan x="27" y="46">
+              t
+            </tspan>
+          </text>
+          <rect id="Rectangle-2" opacity="0.190065299" fill="#000000" mask="url(#mask-6)" x="-8" y="2" width="80" height="31"/>
+        </g>
+      </g>
+    </g>
+  </g>
+</svg>
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait_to_object_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait_to_object_big.png
deleted file mode 100644
index d0cd7fd512..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/trait_to_object_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/type.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/type.png
deleted file mode 100644
index 6c6e1fe2f5..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/type.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/type_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/type_big.png
deleted file mode 100644
index 04c8794e92..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/type_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/type_to_object_big.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/type_to_object_big.png
deleted file mode 100644
index ef2615bacc..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/type_to_object_big.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/typebg.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/typebg.gif
deleted file mode 100644
index 2fcc77b2e8..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/typebg.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/unselected.png b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/unselected.png
deleted file mode 100644
index d5ac639405..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/unselected.png
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/valuemembersbg.gif b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/valuemembersbg.gif
deleted file mode 100644
index 2a949311d7..0000000000
--- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/valuemembersbg.gif
+++ /dev/null
diff --git a/src/scaladoc/scala/tools/nsc/doc/model/Entity.scala b/src/scaladoc/scala/tools/nsc/doc/model/Entity.scala
index d55c51b19c..524f94443d 100644
--- a/src/scaladoc/scala/tools/nsc/doc/model/Entity.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/model/Entity.scala
@@ -62,9 +62,15 @@ object Entity {
     case x: MemberEntity  => x.deprecation.isDefined
     case _                => false
   }
+
+  private def isObject(x: Entity) = x match {
+    case x: TemplateEntity  => x.isObject
+    case _                  => false
+  }
+
   /** Ordering deprecated things last. */
   implicit lazy val EntityOrdering: Ordering[Entity] =
-    Ordering[(Boolean, String)] on (x => (isDeprecated(x), x.name))
+    Ordering[(Boolean, String, Boolean)] on (x => (isDeprecated(x), x.qualifiedName, isObject(x)))
 }
 
 /** A template, which is either a class, trait, object or package. Depending on whether documentation is available
diff --git a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala
index 3432e5e150..bccb65aa5f 100644
--- a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala
@@ -9,11 +9,9 @@ import base.comment._
 import diagram._
 
 import scala.collection._
-import scala.tools.nsc.doc.html.HtmlPage
 import scala.tools.nsc.doc.html.page.diagram.{DotRunner}
 import scala.util.matching.Regex
 import scala.reflect.macros.internal.macroImpl
-import scala.xml.NodeSeq
 import symtab.Flags
 
 import io._
@@ -30,8 +28,8 @@ class ModelFactory(val global: Global, val settings: doc.Settings) {
                with MemberLookup =>
 
   import global._
-  import definitions.{ ObjectClass, NothingClass, AnyClass, AnyValClass, AnyRefClass, ListClass }
-  import rootMirror.{ RootPackage, RootClass, EmptyPackage }
+  import definitions.{ ObjectClass, NothingClass, AnyClass, AnyValClass, AnyRefClass }
+  import rootMirror.{ RootPackage, EmptyPackage }
 
   // Defaults for member grouping, that may be overridden by the template
   val defaultGroup = "Ungrouped"
diff --git a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala
index db39d059d7..0264f2f99f 100644
--- a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala
@@ -11,7 +11,6 @@ package doc
 package model
 
 import scala.collection._
-import symtab.Flags
 
 /**
  * This trait finds implicit conversions for a class in the default scope and creates scaladoc entries for each of them.
diff --git a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala
index 45745b5f55..9b04125cc5 100644
--- a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala
@@ -20,7 +20,7 @@ trait ModelFactoryTypeSupport {
                with MemberLookup =>
 
   import global._
-  import definitions.{ ObjectClass, NothingClass, AnyClass, AnyValClass, AnyRefClass }
+  import definitions.{ ObjectClass, AnyClass, AnyRefClass }
 
   protected val typeCache = new mutable.LinkedHashMap[Type, TypeEntity]
 
diff --git a/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala b/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala
index c1228e8735..27668a6040 100644
--- a/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala
@@ -3,7 +3,7 @@ package doc
 package model
 
 import scala.collection._
-import scala.reflect.internal.util.{RangePosition, OffsetPosition, SourceFile}
+import scala.reflect.internal.util.{RangePosition, SourceFile}
 
 /** The goal of this trait is , using makeTree,
   * to browse a tree to
diff --git a/src/scaladoc/scala/tools/nsc/doc/model/diagram/DiagramDirectiveParser.scala b/src/scaladoc/scala/tools/nsc/doc/model/diagram/DiagramDirectiveParser.scala
index b300752a34..3b7eb4e947 100644
--- a/src/scaladoc/scala/tools/nsc/doc/model/diagram/DiagramDirectiveParser.scala
+++ b/src/scaladoc/scala/tools/nsc/doc/model/diagram/DiagramDirectiveParser.scala
@@ -3,7 +3,7 @@ package model
 package diagram
 
 import model._
-import java.util.regex.{Pattern, Matcher}
+import java.util.regex.Pattern
 import scala.util.matching.Regex
 
 /**
diff --git a/src/scaladoc/scala/tools/partest/ScaladocModelTest.scala b/src/scaladoc/scala/tools/partest/ScaladocModelTest.scala
index fa3e8ff5cb..1ad3b3ff2b 100644
--- a/src/scaladoc/scala/tools/partest/ScaladocModelTest.scala
+++ b/src/scaladoc/scala/tools/partest/ScaladocModelTest.scala
@@ -5,7 +5,6 @@
 
 package scala.tools.partest
 
-import scala.tools.nsc
 import scala.tools.nsc._
 import scala.tools.cmd.CommandLineParser
 import scala.tools.nsc.doc.{ DocFactory, Universe }
diff --git a/src/scalap/scala/tools/scalap/CodeWriter.scala b/src/scalap/scala/tools/scalap/CodeWriter.scala
index 168050096d..07aba0b632 100644
--- a/src/scalap/scala/tools/scalap/CodeWriter.scala
+++ b/src/scalap/scala/tools/scalap/CodeWriter.scala
@@ -35,7 +35,7 @@ class CodeWriter(writer: Writer) {
   def setIndentWidth(width: Int): CodeWriter =
     setIndentString(List.fill(width)(' ').mkString)
 
-  def getIndentString = step;
+  def getIndentString = step
 
   def setIndentString(step: String): CodeWriter = {
     this.step = step
diff --git a/src/scalap/scala/tools/scalap/Decode.scala b/src/scalap/scala/tools/scalap/Decode.scala
index 76ce3f4173..8e63c7f47f 100644
--- a/src/scalap/scala/tools/scalap/Decode.scala
+++ b/src/scalap/scala/tools/scalap/Decode.scala
@@ -10,12 +10,12 @@
 package scala.tools.scalap
 
 import scala.tools.scalap.scalax.rules.scalasig._
-import scala.tools.nsc.util.ScalaClassLoader
-import scala.tools.nsc.util.ScalaClassLoader.appLoader
+import scala.reflect.internal.util.ScalaClassLoader
+import scala.reflect.internal.util.ScalaClassLoader.appLoader
 import scala.reflect.internal.pickling.ByteCodecs
 
 import ClassFileParser.{ ConstValueIndex, Annotation }
-import Main.{ SCALA_SIG, SCALA_SIG_ANNOTATION, BYTES_VALUE }
+import Main.{ SCALA_SIG_ANNOTATION, BYTES_VALUE }
 
 /** Temporary decoder.  This would be better off in the scala.tools.nsc
  *  but right now the compiler won't acknowledge scala.tools.scalap
@@ -49,7 +49,7 @@ object Decode {
     import classFile._
 
     classFile annotation SCALA_SIG_ANNOTATION map { case Annotation(_, els) =>
-      val bytesElem = els find (x => constant(x.elementNameIndex) == BYTES_VALUE) getOrElse null
+      val bytesElem = els find (x => constant(x.elementNameIndex) == BYTES_VALUE) orNull
       val _bytes    = bytesElem.elementValue match { case ConstValueIndex(x) => constantWrapped(x) }
       val bytes     = _bytes.asInstanceOf[StringBytesPair].bytes
       val length    = ByteCodecs.decode(bytes)
diff --git a/src/scalap/scala/tools/scalap/JavaWriter.scala b/src/scalap/scala/tools/scalap/JavaWriter.scala
index 772cf6eacd..75e2637d56 100644
--- a/src/scalap/scala/tools/scalap/JavaWriter.scala
+++ b/src/scalap/scala/tools/scalap/JavaWriter.scala
@@ -164,7 +164,7 @@ class JavaWriter(classfile: Classfile, writer: Writer) extends CodeWriter(writer
   }
 
   def printClass() {
-    val pck = getPackage(cf.classname);
+    val pck = getPackage(cf.classname)
     if (pck.length() > 0)
       println("package " + pck + ";")
     print(flagsToStr(true, cf.flags))
@@ -175,14 +175,14 @@ class JavaWriter(classfile: Classfile, writer: Writer) extends CodeWriter(writer
         printClassHeader;
       case Some(cf.Attribute(_, data)) =>
         val mp = new MetaParser(getName(
-          ((data(0) & 0xff) << 8) + (data(1) & 0xff)).trim());
+          ((data(0) & 0xff) << 8) + (data(1) & 0xff)).trim())
         mp.parse match {
           case None => printClassHeader;
           case Some(str) =>
             if (isInterface(cf.flags))
-              print("trait " + getSimpleClassName(cf.classname) + str);
+              print("trait " + getSimpleClassName(cf.classname) + str)
             else
-              print("class " + getSimpleClassName(cf.classname) + str);
+              print("class " + getSimpleClassName(cf.classname) + str)
         }
     }
     var statics: List[cf.Member] = Nil
diff --git a/src/scalap/scala/tools/scalap/MetaParser.scala b/src/scalap/scala/tools/scalap/MetaParser.scala
index 1ebf86268a..b9dab0ad01 100644
--- a/src/scalap/scala/tools/scalap/MetaParser.scala
+++ b/src/scalap/scala/tools/scalap/MetaParser.scala
@@ -64,7 +64,7 @@ class MetaParser(meta: String) {
         case _: Exception => None
       }
     } else
-      None;
+      None
 
   protected def parseMetaClass: String = {
     nextToken
@@ -100,7 +100,7 @@ class MetaParser(meta: String) {
         parseType
       } while (token == "with")
     }
-    res.toString();
+    res.toString()
   }
 
   protected def parseMetaMethod: String = {
@@ -113,10 +113,10 @@ class MetaParser(meta: String) {
         var loop = true
         res.append("[")
         while (loop) {
-          res.append(token.substring(1));
-          nextToken;
+          res.append(token.substring(1))
+          nextToken
           if (token == "<") {
-            nextToken;
+            nextToken
             res.append(" <: ")
             parseType
           }
@@ -133,16 +133,16 @@ class MetaParser(meta: String) {
     if (token == "(") {
       do {
         if (token == ",") {
-          nextToken;
+          nextToken
           if (token != ")")
             res.append(", ")
         } else {
-          nextToken;
+          nextToken
           res.append("(")
         }
         if (token != ")") {
           if (token == "def") {
-            nextToken;
+            nextToken
             res.append("def ")
           }
           parseType
diff --git a/src/scalap/scala/tools/scalap/scalax/rules/Result.scala b/src/scalap/scala/tools/scalap/scalax/rules/Result.scala
index f37340e7b7..b6f650b899 100644
--- a/src/scalap/scala/tools/scalap/scalax/rules/Result.scala
+++ b/src/scalap/scala/tools/scalap/scalax/rules/Result.scala
@@ -12,7 +12,7 @@
 
 package scala.tools.scalap
 package scalax
-package rules;
+package rules
 
 /** Represents the combined value of two rules applied in sequence.
  *
diff --git a/src/scalap/scala/tools/scalap/scalax/rules/scalasig/ScalaSigPrinter.scala b/src/scalap/scala/tools/scalap/scalax/rules/scalasig/ScalaSigPrinter.scala
index dd17c39d84..3bfb82a639 100644
--- a/src/scalap/scala/tools/scalap/scalax/rules/scalasig/ScalaSigPrinter.scala
+++ b/src/scalap/scala/tools/scalap/scalax/rules/scalasig/ScalaSigPrinter.scala
@@ -91,7 +91,7 @@ class ScalaSigPrinter(stream: PrintStream, printPrivates: Boolean) {
 
   def printWithIndent(level: Int, s: String) {
     def indent() {for (i <- 1 to level) print("  ")}
-    indent;
+    indent
     print(s)
   }
 
@@ -208,7 +208,7 @@ class ScalaSigPrinter(stream: PrintStream, printPrivates: Boolean) {
       mt.resultType match {
         case mt: MethodType => printMethodType(mt, printResult)({})
         case x => if (printResult) {
-          print(": ");
+          print(": ")
           printType(x)
         }
       }
@@ -374,7 +374,7 @@ class ScalaSigPrinter(stream: PrintStream, printPrivates: Boolean) {
       }
       case AnnotatedWithSelfType(typeRef, symbol, attribTreeRefs) => toString(typeRef, sep)
       case ExistentialType(typeRef, symbols) => {
-        val refs = symbols.map(toString _).filter(!_.startsWith("_")).map("type " + _)
+        val refs = symbols.map(toString).filter(!_.startsWith("_")).map("type " + _)
         toString(typeRef, sep) + (if (refs.size > 0) refs.mkString(" forSome {", "; ", "}") else "")
       }
       case _ => sep + t.toString
diff --git a/test/disabled/presentation/akka/src/akka/actor/Supervisor.scala b/test/disabled/presentation/akka/src/akka/actor/Supervisor.scala
index 4a1309faef..bec3c83f1a 100644
--- a/test/disabled/presentation/akka/src/akka/actor/Supervisor.scala
+++ b/test/disabled/presentation/akka/src/akka/actor/Supervisor.scala
@@ -95,7 +95,7 @@ case class SupervisorFactory(val config: SupervisorConfig) {
  * wire the children together using 'link', 'spawnLink' etc. and set the 'trapExit' flag in the
  * children that should trap error signals and trigger restart.
  * <p/>
- * See the ScalaDoc for the SupervisorFactory for an example on how to declaratively wire up children.
+ * See the Scaladoc for the SupervisorFactory for an example on how to declaratively wire up children.
  *
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
diff --git a/test/files/instrumented/inline-in-constructors.flags b/test/files/instrumented/inline-in-constructors.flags
index d1ebc4c940..65caa3736e 100644
--- a/test/files/instrumented/inline-in-constructors.flags
+++ b/test/files/instrumented/inline-in-constructors.flags
@@ -1 +1 @@
--optimise -Ydelambdafy:inline -Ybackend:GenASM
+-Yopt:l:classpath
diff --git a/test/files/jvm/bytecode-test-example/Foo_1.flags b/test/files/jvm/bytecode-test-example/Foo_1.flags
deleted file mode 100644
index 49f2d2c4c8..0000000000
--- a/test/files/jvm/bytecode-test-example/Foo_1.flags
+++ /dev/null
@@ -1 +0,0 @@
--Ybackend:GenASM
diff --git a/test/files/jvm/constant-optimization/Foo_1.flags b/test/files/jvm/constant-optimization/Foo_1.flags
deleted file mode 100644
index 67a1dbe8da..0000000000
--- a/test/files/jvm/constant-optimization/Foo_1.flags
+++ /dev/null
@@ -1 +0,0 @@
--Ynooptimise -Yconst-opt -Ybackend:GenASM
\ No newline at end of file
diff --git a/test/files/jvm/nooptimise/Foo_1.flags b/test/files/jvm/nooptimise/Foo_1.flags
deleted file mode 100644
index f493cf9f3f..0000000000
--- a/test/files/jvm/nooptimise/Foo_1.flags
+++ /dev/null
@@ -1 +0,0 @@
--Ybackend:GenASM -optimise -Ynooptimise
\ No newline at end of file
diff --git a/test/files/jvm/nooptimise/Foo_1.scala b/test/files/jvm/nooptimise/Foo_1.scala
deleted file mode 100644
index 896d5695de..0000000000
--- a/test/files/jvm/nooptimise/Foo_1.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-class Foo_1 {
-  def foo() {
-    // optimization will remove this magic 3 from appearing in the source
-    // so -Ynooptimize should prevent that
-    val x = 3
-
-  }
-}
diff --git a/test/files/jvm/nooptimise/Test.scala b/test/files/jvm/nooptimise/Test.scala
deleted file mode 100644
index 7b7ecd6dbd..0000000000
--- a/test/files/jvm/nooptimise/Test.scala
+++ /dev/null
@@ -1,23 +0,0 @@
-import scala.tools.partest.BytecodeTest
-import scala.tools.asm
-import asm.tree.InsnList
-import scala.collection.JavaConverters._
-
-object Test extends BytecodeTest {
-  def show: Unit = {
-    val classNode = loadClassNode("Foo_1")
-    val methodNode = getMethod(classNode, "foo")
-    // if optimization didn't run then
-    // there should be some useless instructions
-    // with the magic constant 3
-    val expected = 1
-    val got = countMagicThrees(methodNode.instructions)
-    assert(got == expected, s"expected $expected but got $got magic threes")
-  }
-
-  def countMagicThrees(insnList: InsnList): Int = {
-    def isMagicThree(node: asm.tree.AbstractInsnNode): Boolean =
-      (node.getOpcode == asm.Opcodes.ICONST_3)
-    insnList.iterator.asScala.count(isMagicThree)
-  }
-}
diff --git a/test/files/jvm/patmat_opt_ignore_underscore.flags b/test/files/jvm/patmat_opt_ignore_underscore.flags
deleted file mode 100644
index 2cd4b38726..0000000000
--- a/test/files/jvm/patmat_opt_ignore_underscore.flags
+++ /dev/null
@@ -1 +0,0 @@
--optimize -Ybackend:GenASM
\ No newline at end of file
diff --git a/test/files/jvm/patmat_opt_no_nullcheck.flags b/test/files/jvm/patmat_opt_no_nullcheck.flags
deleted file mode 100644
index 2cd4b38726..0000000000
--- a/test/files/jvm/patmat_opt_no_nullcheck.flags
+++ /dev/null
@@ -1 +0,0 @@
--optimize -Ybackend:GenASM
\ No newline at end of file
diff --git a/test/files/jvm/patmat_opt_no_nullcheck/test.scala b/test/files/jvm/patmat_opt_no_nullcheck/test.scala
deleted file mode 100644
index d02c929e01..0000000000
--- a/test/files/jvm/patmat_opt_no_nullcheck/test.scala
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * filter: inliner warning; re-run with
- */
-import scala.tools.partest.BytecodeTest
-
-object Test extends BytecodeTest {
-  def show: Unit = {
-    val classNode = loadClassNode("SameBytecode")
-    sameBytecode(getMethod(classNode, "a"), getMethod(classNode, "b"))
-  }
-}
diff --git a/test/files/jvm/patmat_opt_primitive_typetest.flags b/test/files/jvm/patmat_opt_primitive_typetest.flags
deleted file mode 100644
index b9bb09167e..0000000000
--- a/test/files/jvm/patmat_opt_primitive_typetest.flags
+++ /dev/null
@@ -1 +0,0 @@
--optimize -Ybackend:GenASM
diff --git a/test/files/jvm/t7006/Foo_1.flags b/test/files/jvm/t7006/Foo_1.flags
deleted file mode 100644
index 29a9d424f0..0000000000
--- a/test/files/jvm/t7006/Foo_1.flags
+++ /dev/null
@@ -1 +0,0 @@
--optimise -Ydebug -Xfatal-warnings -Ybackend:GenASM
diff --git a/test/files/neg/case-collision.check b/test/files/neg/case-collision.check
index 22cf105a4f..7360833a7d 100644
--- a/test/files/neg/case-collision.check
+++ b/test/files/neg/case-collision.check
@@ -1,12 +1,12 @@
 case-collision.scala:5: warning: Class foo.BIPPY differs only in case from foo.Bippy. Such classes will overwrite one another on case-insensitive filesystems.
 class BIPPY
       ^
-case-collision.scala:11: warning: Class foo.HyRaX$ differs only in case from foo.Hyrax$. Such classes will overwrite one another on case-insensitive filesystems.
-object HyRaX
-       ^
 case-collision.scala:8: warning: Class foo.DINGO$ differs only in case from foo.Dingo$. Such classes will overwrite one another on case-insensitive filesystems.
 object DINGO
        ^
+case-collision.scala:11: warning: Class foo.HyRaX$ differs only in case from foo.Hyrax$. Such classes will overwrite one another on case-insensitive filesystems.
+object HyRaX
+       ^
 error: No warnings can be incurred under -Xfatal-warnings.
 three warnings found
 one error found
diff --git a/test/files/neg/case-collision.flags b/test/files/neg/case-collision.flags
index 14c1069dee..85d8eb2ba2 100644
--- a/test/files/neg/case-collision.flags
+++ b/test/files/neg/case-collision.flags
@@ -1 +1 @@
--Ybackend:GenASM -Xfatal-warnings
+-Xfatal-warnings
diff --git a/test/files/neg/depmet_1.check b/test/files/neg/depmet_1.check
index 7a4f845fd5..15498568c5 100644
--- a/test/files/neg/depmet_1.check
+++ b/test/files/neg/depmet_1.check
@@ -1,7 +1,7 @@
-depmet_1.scala:2: error: illegal dependent method type: parameter appears in the type of another parameter in the same section or an earlier one
+depmet_1.scala:2: error: illegal dependent method type: parameter may only be referenced in a subsequent parameter section
   def precise0(y: x.type)(x: String): Unit = {}
                           ^
-depmet_1.scala:3: error: illegal dependent method type: parameter appears in the type of another parameter in the same section or an earlier one
+depmet_1.scala:3: error: illegal dependent method type: parameter may only be referenced in a subsequent parameter section
   def precise1(x: String, y: x.type): Unit = {}
                ^
 depmet_1.scala:4: error: not found: value y
diff --git a/test/files/neg/macro-without-xmacros-a.check b/test/files/neg/macro-without-xmacros-a.check
index ec194be3a9..65445d80dd 100644
--- a/test/files/neg/macro-without-xmacros-a.check
+++ b/test/files/neg/macro-without-xmacros-a.check
@@ -2,7 +2,7 @@ Macros_2.scala:5: error: macro definition needs to be enabled
 by making the implicit value scala.language.experimental.macros visible.
 This can be achieved by adding the import clause 'import scala.language.experimental.macros'
 or by setting the compiler option -language:experimental.macros.
-See the Scala docs for value scala.language.experimental.macros for a discussion
+See the Scaladoc for value scala.language.experimental.macros for a discussion
 why the feature needs to be explicitly enabled.
     def foo(x: Int): Int = macro foo_impl
         ^
diff --git a/test/files/neg/macro-without-xmacros-b.check b/test/files/neg/macro-without-xmacros-b.check
index c97850f0a9..e3c1010d50 100644
--- a/test/files/neg/macro-without-xmacros-b.check
+++ b/test/files/neg/macro-without-xmacros-b.check
@@ -2,7 +2,7 @@ Macros_2.scala:3: error: macro definition needs to be enabled
 by making the implicit value scala.language.experimental.macros visible.
 This can be achieved by adding the import clause 'import scala.language.experimental.macros'
 or by setting the compiler option -language:experimental.macros.
-See the Scala docs for value scala.language.experimental.macros for a discussion
+See the Scaladoc for value scala.language.experimental.macros for a discussion
 why the feature needs to be explicitly enabled.
     def foo(x: Int): Int = macro Impls.foo_impl
         ^
diff --git a/test/files/neg/sealed-final-neg.check b/test/files/neg/sealed-final-neg.check
index 500d23f49a..e135f38f8b 100644
--- a/test/files/neg/sealed-final-neg.check
+++ b/test/files/neg/sealed-final-neg.check
@@ -1,4 +1,9 @@
-sealed-final-neg.scala:41: error: expected class or object definition
-"Due to SI-6142 this emits no warnings, so we'll just break it until that's fixed."
-^
+sealed-final-neg.scala:17: warning: neg1/Foo::bar(I)I is annotated @inline but cannot be inlined: the method is not final and may be overridden.
+    def f = Foo.mkFoo() bar 10
+                        ^
+sealed-final-neg.scala:37: warning: neg2/Foo::bar(I)I is annotated @inline but cannot be inlined: the method is not final and may be overridden.
+    def f = Foo.mkFoo() bar 10
+                        ^
+error: No warnings can be incurred under -Xfatal-warnings.
+two warnings found
 one error found
diff --git a/test/files/neg/sealed-final-neg.flags b/test/files/neg/sealed-final-neg.flags
index 3f0fcd2201..01bd79154a 100644
--- a/test/files/neg/sealed-final-neg.flags
+++ b/test/files/neg/sealed-final-neg.flags
@@ -1 +1 @@
--Xfatal-warnings -Ybackend:GenASM -Yinline-warnings -optimise
\ No newline at end of file
+-Xfatal-warnings -Yopt:l:project -Yinline-warnings
\ No newline at end of file
diff --git a/test/files/neg/sealed-final-neg.scala b/test/files/neg/sealed-final-neg.scala
index bc25330e13..ec3b199819 100644
--- a/test/files/neg/sealed-final-neg.scala
+++ b/test/files/neg/sealed-final-neg.scala
@@ -37,5 +37,3 @@ package neg2 {
     def f = Foo.mkFoo() bar 10
   }
 }
-
-"Due to SI-6142 this emits no warnings, so we'll just break it until that's fixed."
diff --git a/test/files/neg/t3234.check b/test/files/neg/t3234.check
deleted file mode 100644
index 8f0d624ed9..0000000000
--- a/test/files/neg/t3234.check
+++ /dev/null
@@ -1,6 +0,0 @@
-t3234.scala:17: warning: At the end of the day, could not inline @inline-marked method foo3
-    println(foo(42) + foo2(11) + foo3(2))
-                                     ^
-error: No warnings can be incurred under -Xfatal-warnings.
-one warning found
-one error found
diff --git a/test/files/neg/t3234.flags b/test/files/neg/t3234.flags
deleted file mode 100644
index 406231bd96..0000000000
--- a/test/files/neg/t3234.flags
+++ /dev/null
@@ -1 +0,0 @@
--Yinline -Yinline-warnings -Xfatal-warnings -Ybackend:GenASM
diff --git a/test/files/neg/t6040.check b/test/files/neg/t6040.check
index 16c90ede7e..350f796d18 100644
--- a/test/files/neg/t6040.check
+++ b/test/files/neg/t6040.check
@@ -2,7 +2,7 @@ t6040.scala:1: error: extension of type scala.Dynamic needs to be enabled
 by making the implicit value scala.language.dynamics visible.
 This can be achieved by adding the import clause 'import scala.language.dynamics'
 or by setting the compiler option -language:dynamics.
-See the Scala docs for value scala.language.dynamics for a discussion
+See the Scaladoc for value scala.language.dynamics for a discussion
 why the feature needs to be explicitly enabled.
 class X extends Dynamic
                 ^
diff --git a/test/files/neg/t6120.check b/test/files/neg/t6120.check
index a7d17e29cf..f432fde32f 100644
--- a/test/files/neg/t6120.check
+++ b/test/files/neg/t6120.check
@@ -2,7 +2,7 @@ t6120.scala:5: warning: postfix operator bippy should be enabled
 by making the implicit value scala.language.postfixOps visible.
 This can be achieved by adding the import clause 'import scala.language.postfixOps'
 or by setting the compiler option -language:postfixOps.
-See the Scala docs for value scala.language.postfixOps for a discussion
+See the Scaladoc for value scala.language.postfixOps for a discussion
 why the feature should be explicitly enabled.
   def f = null == null bippy
                        ^
diff --git a/test/files/neg/t6446-additional.check b/test/files/neg/t6446-additional.check
index a87af2f1e5..e56a67b28b 100644
--- a/test/files/neg/t6446-additional.check
+++ b/test/files/neg/t6446-additional.check
@@ -22,18 +22,6 @@ superaccessors   6  add super accessors in traits and nested classes
          mixin  20  mixin composition
        cleanup  21  platform-specific cleanups, generate reflective calls
     delambdafy  22  remove lambdas
-         icode  23  generate portable intermediate code
-#partest -optimise
-       inliner  24  optimization: do inlining
-inlinehandlers  25  optimization: inline exception handlers
-      closelim  26  optimization: eliminate uncalled closures
-      constopt  27  optimization: optimize null and other constants
-           dce  28  optimization: eliminate dead code
-           jvm  29  generate JVM bytecode
-       ploogin  30  A sample phase that does so many things it's kind of hard...
-      terminal  31  the last phase during a compilation run
-#partest !-optimise
-           jvm  24  generate JVM bytecode
-       ploogin  25  A sample phase that does so many things it's kind of hard...
-      terminal  26  the last phase during a compilation run
-#partest
+           jvm  23  generate JVM bytecode
+       ploogin  24  A sample phase that does so many things it's kind of hard...
+      terminal  25  the last phase during a compilation run
diff --git a/test/files/neg/t6446-missing.check b/test/files/neg/t6446-missing.check
index 029c8057c3..15f0ceb6e3 100644
--- a/test/files/neg/t6446-missing.check
+++ b/test/files/neg/t6446-missing.check
@@ -23,16 +23,5 @@ superaccessors   6  add super accessors in traits and nested classes
          mixin  20  mixin composition
        cleanup  21  platform-specific cleanups, generate reflective calls
     delambdafy  22  remove lambdas
-         icode  23  generate portable intermediate code
-#partest !-optimise
-           jvm  24  generate JVM bytecode
-      terminal  25  the last phase during a compilation run
-#partest -optimise
-       inliner  24  optimization: do inlining
-inlinehandlers  25  optimization: inline exception handlers
-      closelim  26  optimization: eliminate uncalled closures
-      constopt  27  optimization: optimize null and other constants
-           dce  28  optimization: eliminate dead code
-           jvm  29  generate JVM bytecode
-      terminal  30  the last phase during a compilation run
-#partest
+           jvm  23  generate JVM bytecode
+      terminal  24  the last phase during a compilation run
diff --git a/test/files/neg/t6446-show-phases.check b/test/files/neg/t6446-show-phases.check
index 3ae3f96ef2..280a4f43d5 100644
--- a/test/files/neg/t6446-show-phases.check
+++ b/test/files/neg/t6446-show-phases.check
@@ -22,16 +22,5 @@ superaccessors   6  add super accessors in traits and nested classes
          mixin  20  mixin composition
        cleanup  21  platform-specific cleanups, generate reflective calls
     delambdafy  22  remove lambdas
-         icode  23  generate portable intermediate code
-#partest !-optimise
-           jvm  24  generate JVM bytecode
-      terminal  25  the last phase during a compilation run
-#partest -optimise
-       inliner  24  optimization: do inlining
-inlinehandlers  25  optimization: inline exception handlers
-      closelim  26  optimization: eliminate uncalled closures
-      constopt  27  optimization: optimize null and other constants
-           dce  28  optimization: eliminate dead code
-           jvm  29  generate JVM bytecode
-      terminal  30  the last phase during a compilation run
-#partest
+           jvm  23  generate JVM bytecode
+      terminal  24  the last phase during a compilation run
diff --git a/test/files/neg/t6952.check b/test/files/neg/t6952.check
index 1a591d02c6..acee0e7d60 100644
--- a/test/files/neg/t6952.check
+++ b/test/files/neg/t6952.check
@@ -2,7 +2,7 @@ t6952.scala:2: error: extension of type scala.Dynamic needs to be enabled
 by making the implicit value scala.language.dynamics visible.
 This can be achieved by adding the import clause 'import scala.language.dynamics'
 or by setting the compiler option -language:dynamics.
-See the Scala docs for value scala.language.dynamics for a discussion
+See the Scaladoc for value scala.language.dynamics for a discussion
 why the feature needs to be explicitly enabled.
 trait B extends Dynamic
                 ^
diff --git a/test/files/neg/t7494-no-options.check b/test/files/neg/t7494-no-options.check
index e3316f590a..a4c4a1ad5b 100644
--- a/test/files/neg/t7494-no-options.check
+++ b/test/files/neg/t7494-no-options.check
@@ -23,18 +23,6 @@ superaccessors   6  add super accessors in traits and nested classes
          mixin  20  mixin composition
        cleanup  21  platform-specific cleanups, generate reflective calls
     delambdafy  22  remove lambdas
-         icode  23  generate portable intermediate code
-#partest !-optimise
-           jvm  24  generate JVM bytecode
-       ploogin  25  A sample phase that does so many things it's kind of hard...
-      terminal  26  the last phase during a compilation run
-#partest -optimise
-       inliner  24  optimization: do inlining
-inlinehandlers  25  optimization: inline exception handlers
-      closelim  26  optimization: eliminate uncalled closures
-      constopt  27  optimization: optimize null and other constants
-           dce  28  optimization: eliminate dead code
-           jvm  29  generate JVM bytecode
-       ploogin  30  A sample phase that does so many things it's kind of hard...
-      terminal  31  the last phase during a compilation run
-#partest
+           jvm  23  generate JVM bytecode
+       ploogin  24  A sample phase that does so many things it's kind of hard...
+      terminal  25  the last phase during a compilation run
diff --git a/test/files/neg/t7622-cyclic-dependency/ThePlugin.scala b/test/files/neg/t7622-cyclic-dependency/ThePlugin.scala
index 35c0ff8f53..0734863e64 100644
--- a/test/files/neg/t7622-cyclic-dependency/ThePlugin.scala
+++ b/test/files/neg/t7622-cyclic-dependency/ThePlugin.scala
@@ -26,7 +26,7 @@ class ThePlugin(val global: Global) extends Plugin {
   private object thePhase2 extends PluginComponent {
     val global = ThePlugin.this.global
 
-    val runsAfter = List[String]("dce","cyclicdependency1")
+    val runsAfter = List[String]("jvm","cyclicdependency1")
 
     val phaseName = ThePlugin.this.name + "2"
 
diff --git a/test/files/neg/t8700a.check b/test/files/neg/t8700a.check
new file mode 100644
index 0000000000..ce7945a3fc
--- /dev/null
+++ b/test/files/neg/t8700a.check
@@ -0,0 +1,11 @@
+Bar.scala:2: warning: match may not be exhaustive.
+It would fail on the following input: B
+  def bar1(foo: Foo) = foo match {
+                       ^
+Bar.scala:6: warning: match may not be exhaustive.
+It would fail on the following input: B
+  def bar2(foo: Baz) = foo match {
+                       ^
+error: No warnings can be incurred under -Xfatal-warnings.
+two warnings found
+one error found
diff --git a/test/files/neg/t8700a.flags b/test/files/neg/t8700a.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/neg/t8700a.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/neg/t8700a/Bar.scala b/test/files/neg/t8700a/Bar.scala
new file mode 100644
index 0000000000..33ad8e9877
--- /dev/null
+++ b/test/files/neg/t8700a/Bar.scala
@@ -0,0 +1,9 @@
+object Bar {
+  def bar1(foo: Foo) = foo match {
+    case Foo.A => 1
+  }
+
+  def bar2(foo: Baz) = foo match {
+    case Baz.A => 1
+    }
+}
diff --git a/test/files/neg/t8700a/Baz.java b/test/files/neg/t8700a/Baz.java
new file mode 100644
index 0000000000..f85ad40802
--- /dev/null
+++ b/test/files/neg/t8700a/Baz.java
@@ -0,0 +1,11 @@
+public enum Baz {
+    A {
+    	public void baz1() {}
+    },
+    B {
+        public void baz1() {}
+    };
+
+    public abstract void baz1();
+    public void baz2() {}
+}
diff --git a/test/files/neg/t8700a/Foo.java b/test/files/neg/t8700a/Foo.java
new file mode 100644
index 0000000000..cc8e9daf1f
--- /dev/null
+++ b/test/files/neg/t8700a/Foo.java
@@ -0,0 +1,4 @@
+public enum Foo {
+    A,
+    B
+}
diff --git a/test/files/neg/t8700b.check b/test/files/neg/t8700b.check
new file mode 100644
index 0000000000..3bff78dd29
--- /dev/null
+++ b/test/files/neg/t8700b.check
@@ -0,0 +1,11 @@
+Bar_2.scala:2: warning: match may not be exhaustive.
+It would fail on the following input: B
+  def bar1(foo: Foo_1) = foo match {
+                         ^
+Bar_2.scala:6: warning: match may not be exhaustive.
+It would fail on the following input: B
+  def bar2(foo: Baz_1) = foo match {
+                         ^
+error: No warnings can be incurred under -Xfatal-warnings.
+two warnings found
+one error found
diff --git a/test/files/neg/t8700b.flags b/test/files/neg/t8700b.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/neg/t8700b.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/neg/t8700b/Bar_2.scala b/test/files/neg/t8700b/Bar_2.scala
new file mode 100644
index 0000000000..97ba16df27
--- /dev/null
+++ b/test/files/neg/t8700b/Bar_2.scala
@@ -0,0 +1,9 @@
+object Bar {
+  def bar1(foo: Foo_1) = foo match {
+    case Foo_1.A => 1
+  }
+
+  def bar2(foo: Baz_1) = foo match {
+    case Baz_1.A => 1
+    }
+}
diff --git a/test/files/neg/t8700b/Baz_1.java b/test/files/neg/t8700b/Baz_1.java
new file mode 100644
index 0000000000..6a057c2c9c
--- /dev/null
+++ b/test/files/neg/t8700b/Baz_1.java
@@ -0,0 +1,11 @@
+public enum Baz_1 {
+    A {
+    	public void baz1() {}
+    },
+    B {
+        public void baz1() {}
+    };
+
+    public abstract void baz1();
+    public void baz2() {}
+}
diff --git a/test/files/neg/t8700b/Foo_1.java b/test/files/neg/t8700b/Foo_1.java
new file mode 100644
index 0000000000..22656bdedd
--- /dev/null
+++ b/test/files/neg/t8700b/Foo_1.java
@@ -0,0 +1,4 @@
+public enum Foo_1 {
+    A,
+    B
+}
diff --git a/test/files/neg/t8736-c.check b/test/files/neg/t8736-c.check
index 06b2228543..7debb6d515 100644
--- a/test/files/neg/t8736-c.check
+++ b/test/files/neg/t8736-c.check
@@ -2,7 +2,7 @@ t8736-c.scala:4: warning: higher-kinded type should be enabled
 by making the implicit value scala.language.higherKinds visible.
 This can be achieved by adding the import clause 'import scala.language.higherKinds'
 or by setting the compiler option -language:higherKinds.
-See the Scala docs for value scala.language.higherKinds for a discussion
+See the Scaladoc for value scala.language.higherKinds for a discussion
 why the feature should be explicitly enabled.
   def hk[M[_]] = ???
          ^
diff --git a/test/files/pos/existental-slow-compile2.scala b/test/files/pos/existental-slow-compile2.scala
new file mode 100644
index 0000000000..907344982c
--- /dev/null
+++ b/test/files/pos/existental-slow-compile2.scala
@@ -0,0 +1,7 @@
+class C {
+  class L[+A]
+  def test = {
+    val foo:
+      L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: _ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: _ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_]]]]]]]]]]]]]]]]]]]]]]]]
+          = ??? } }
+
diff --git a/test/files/pos/existential-slow-compile1.flags b/test/files/pos/existential-slow-compile1.flags
new file mode 100644
index 0000000000..7f7581974d
--- /dev/null
+++ b/test/files/pos/existential-slow-compile1.flags
@@ -0,0 +1 @@
+-Ystop-after:refchecks
diff --git a/test/files/pos/existential-slow-compile1.scala b/test/files/pos/existential-slow-compile1.scala
new file mode 100644
index 0000000000..8602afd9db
--- /dev/null
+++ b/test/files/pos/existential-slow-compile1.scala
@@ -0,0 +1,7 @@
+class C {
+  type L[+A] = scala.collection.immutable.List[A]
+  def test = {
+    val foo:
+      L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: _ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: _ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_ <: L[_]]]]]]]]]]]]]]]]]]]]]]]]
+          = ??? } }
+
diff --git a/test/files/pos/inline-access-levels.flags b/test/files/pos/inline-access-levels.flags
index 9bda07eb6c..d34387c651 100644
--- a/test/files/pos/inline-access-levels.flags
+++ b/test/files/pos/inline-access-levels.flags
@@ -1 +1 @@
--optimise -Ybackend:GenASM -Xfatal-warnings -Yinline-warnings
+-Yopt:l:classpath -Xfatal-warnings -Yinline-warnings
diff --git a/test/files/pos/inliner2.flags b/test/files/pos/inliner2.flags
deleted file mode 100644
index bff4bb8afa..0000000000
--- a/test/files/pos/inliner2.flags
+++ /dev/null
@@ -1 +0,0 @@
--optimise -Ybackend:GenASM -Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/pos/native-warning.scala b/test/files/pos/native-warning.scala
index f721a57e8f..a2918c11b5 100644
--- a/test/files/pos/native-warning.scala
+++ b/test/files/pos/native-warning.scala
@@ -1,3 +1,7 @@
 class A {
   @native def setup(): Unit
+
+  // also kosher
+  @native private def f(): Unit
+  @native final def g(): Unit
 }
diff --git a/test/files/pos/sealed-final.flags b/test/files/pos/sealed-final.flags
deleted file mode 100644
index 63f5e65527..0000000000
--- a/test/files/pos/sealed-final.flags
+++ /dev/null
@@ -1 +0,0 @@
--Xfatal-warnings -Yinline-warnings -Ybackend:GenASM -optimise
\ No newline at end of file
diff --git a/test/files/pos/t3234.flags b/test/files/pos/t3234.flags
new file mode 100644
index 0000000000..78726f64f7
--- /dev/null
+++ b/test/files/pos/t3234.flags
@@ -0,0 +1 @@
+-Yopt:l:project -Yinline-warnings -Xfatal-warnings
diff --git a/test/files/neg/t3234.scala b/test/files/pos/t3234.scala
index 1553f1fa05..c3b7366db8 100644
--- a/test/files/neg/t3234.scala
+++ b/test/files/pos/t3234.scala
@@ -1,7 +1,5 @@
 trait Trait1 {
-  // need more work before this one works
-  // @inline
-  def foo2(n: Int) = n*n
+  @inline def foo2(n: Int) = n*n
 }
 
 trait Trait2 {
diff --git a/test/files/pos/t3420.flags b/test/files/pos/t3420.flags
index bff4bb8afa..4fbafb7e80 100644
--- a/test/files/pos/t3420.flags
+++ b/test/files/pos/t3420.flags
@@ -1 +1 @@
--optimise -Ybackend:GenASM -Xfatal-warnings
\ No newline at end of file
+-Yopt-warnings Yopt:l:project -Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/pos/t8410.flags b/test/files/pos/t8410.flags
index 2f32e3b26a..01fc9cd3ac 100644
--- a/test/files/pos/t8410.flags
+++ b/test/files/pos/t8410.flags
@@ -1 +1 @@
--optimise -Ybackend:GenASM -Xfatal-warnings -deprecation:false -Yinline-warnings:false
+-Yopt:l:project -Xfatal-warnings -deprecation:false -Yinline-warnings:false
diff --git a/test/files/pos/t9178.flags b/test/files/pos/t9178.flags
new file mode 100644
index 0000000000..7de3c0f3ee
--- /dev/null
+++ b/test/files/pos/t9178.flags
@@ -0,0 +1 @@
+-Xfatal-warnings -deprecation
diff --git a/test/files/pos/t9178.scala b/test/files/pos/t9178.scala
new file mode 100644
index 0000000000..f2cf20a778
--- /dev/null
+++ b/test/files/pos/t9178.scala
@@ -0,0 +1,13 @@
+// eta expansion to Function0 is problematic (as shown here).
+// Perhaps we should we deprecate it? See discussion in the comments of
+// on SI-9178.
+//
+// This test encodes the status quo: no deprecation.
+object Test {
+  def foo(): () => String = () => ""
+  val f: () => Any = foo
+
+  def main(args: Array[String]): Unit = {
+    println(f()) // <function0>
+  }
+}
diff --git a/test/files/pos/t9178b.flags b/test/files/pos/t9178b.flags
new file mode 100644
index 0000000000..48fd867160
--- /dev/null
+++ b/test/files/pos/t9178b.flags
@@ -0,0 +1 @@
+-Xexperimental
diff --git a/test/files/pos/t9178b.scala b/test/files/pos/t9178b.scala
new file mode 100644
index 0000000000..cbeaed4f17
--- /dev/null
+++ b/test/files/pos/t9178b.scala
@@ -0,0 +1,7 @@
+abstract class Test{
+  val writeInput: java.io.OutputStream => Unit
+  def getOutputStream(): java.io.OutputStream
+
+  writeInput(getOutputStream)
+}
+
diff --git a/test/files/run/constant-optimization.flags b/test/files/run/constant-optimization.flags
deleted file mode 100644
index 6c9965e749..0000000000
--- a/test/files/run/constant-optimization.flags
+++ /dev/null
@@ -1 +0,0 @@
--optimise -Ybackend:GenASM
diff --git a/test/files/run/dead-code-elimination.flags b/test/files/run/dead-code-elimination.flags
deleted file mode 100644
index b9bb09167e..0000000000
--- a/test/files/run/dead-code-elimination.flags
+++ /dev/null
@@ -1 +0,0 @@
--optimize -Ybackend:GenASM
diff --git a/test/files/run/delambdafy-specialized.check b/test/files/run/delambdafy-specialized.check
deleted file mode 100644
index c6903b9e29..0000000000
--- a/test/files/run/delambdafy-specialized.check
+++ /dev/null
@@ -1 +0,0 @@
-scala.runtime.AbstractFunction1$mcII$sp
diff --git a/test/files/run/delambdafy-specialized.flags b/test/files/run/delambdafy-specialized.flags
deleted file mode 100644
index d6278aa940..0000000000
--- a/test/files/run/delambdafy-specialized.flags
+++ /dev/null
@@ -1 +0,0 @@
--Ydelambdafy:method -Ybackend:GenASM
diff --git a/test/files/run/delambdafy-specialized.scala b/test/files/run/delambdafy-specialized.scala
deleted file mode 100644
index 634d4e490b..0000000000
--- a/test/files/run/delambdafy-specialized.scala
+++ /dev/null
@@ -1,6 +0,0 @@
-object Test {
-  def main(args: Array[String]): Unit = {
-    val f = (x: Int) => -x
-    println(f.getClass.getSuperclass.getName)
-  }
-}
diff --git a/test/files/run/delambdafy_t6028.check b/test/files/run/delambdafy_t6028.check
index 885fc3c9f3..c8c4b1cb4c 100644
--- a/test/files/run/delambdafy_t6028.check
+++ b/test/files/run/delambdafy_t6028.check
@@ -38,10 +38,18 @@ package <empty> {
       <synthetic> <stable> <artifact> def $outer(): T = MethodLocalObject$2.this.$outer;
       <synthetic> <stable> <artifact> def $outer(): T = MethodLocalObject$2.this.$outer
     };
-    final <stable> private[this] def MethodLocalObject$1(barParam$1: String, MethodLocalObject$module$1: runtime.VolatileObjectRef): T#MethodLocalObject$2.type = {
-      MethodLocalObject$module$1.elem = new T#MethodLocalObject$2.type(T.this, barParam$1);
+    final <stable> private[this] def MethodLocalObject$lzycompute$1(barParam$1: String, MethodLocalObject$module$1: runtime.VolatileObjectRef): T#MethodLocalObject$2.type = {
+      T.this.synchronized({
+        if (MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]().eq(null))
+          MethodLocalObject$module$1.elem = new T#MethodLocalObject$2.type(T.this, barParam$1);
+        scala.runtime.BoxedUnit.UNIT
+      });
       MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]()
     };
+    final <stable> private[this] def MethodLocalObject$1(barParam$1: String, MethodLocalObject$module$1: runtime.VolatileObjectRef): T#MethodLocalObject$2.type = if (MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]().eq(null))
+      T.this.MethodLocalObject$lzycompute$1(barParam$1, MethodLocalObject$module$1)
+    else
+      MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]();
     abstract trait MethodLocalTrait$1$class extends Object with T#MethodLocalTrait$1 {
       def /*MethodLocalTrait$1$class*/$init$(barParam$1: String): Unit = {
         ()
diff --git a/test/files/run/elidable-opt.flags b/test/files/run/elidable-opt.flags
index 6537d2f57a..93fd3d5317 100644
--- a/test/files/run/elidable-opt.flags
+++ b/test/files/run/elidable-opt.flags
@@ -1 +1 @@
--optimise -Ybackend:GenASM -Xelide-below 900
+-Xelide-below 900
diff --git a/test/files/run/finalvar.flags b/test/files/run/finalvar.flags
index 8d9be3d62e..a8c7600a03 100644
--- a/test/files/run/finalvar.flags
+++ b/test/files/run/finalvar.flags
@@ -1 +1 @@
--Yoverride-vars -Yinline -Ybackend:GenASM
\ No newline at end of file
+-Yoverride-vars -Yopt:l:project
\ No newline at end of file
diff --git a/test/files/run/icode-reader-dead-code.scala b/test/files/run/icode-reader-dead-code.scala
index 535ef2a2e2..df31219dd5 100644
--- a/test/files/run/icode-reader-dead-code.scala
+++ b/test/files/run/icode-reader-dead-code.scala
@@ -36,7 +36,7 @@ object Test extends DirectTest {
 
     // If inlining fails, the compiler will issue an inliner warning that is not present in the
     // check file
-    compileString(newCompiler("-usejavacp", "-optimise", "-Ybackend:GenASM"))(bCode)
+    compileString(newCompiler("-usejavacp", "-Yopt:l:classpath"))(bCode)
   }
 
   def readClass(file: String) = {
diff --git a/test/files/run/optimizer-array-load.flags b/test/files/run/optimizer-array-load.flags
deleted file mode 100644
index 99bd6c895d..0000000000
--- a/test/files/run/optimizer-array-load.flags
+++ /dev/null
@@ -1 +0,0 @@
--optimise -Ybackend:GenASM
\ No newline at end of file
diff --git a/test/files/run/programmatic-main.check b/test/files/run/programmatic-main.check
index 1cd94ccb45..280a4f43d5 100644
--- a/test/files/run/programmatic-main.check
+++ b/test/files/run/programmatic-main.check
@@ -22,6 +22,5 @@ superaccessors   6  add super accessors in traits and nested classes
          mixin  20  mixin composition
        cleanup  21  platform-specific cleanups, generate reflective calls
     delambdafy  22  remove lambdas
-         icode  23  generate portable intermediate code
-           jvm  24  generate JVM bytecode
-      terminal  25  the last phase during a compilation run
+           jvm  23  generate JVM bytecode
+      terminal  24  the last phase during a compilation run
diff --git a/test/files/run/sbt-icode-interface.scala b/test/files/run/sbt-icode-interface.scala
index 84d38cc65a..7cd2de5c00 100644
--- a/test/files/run/sbt-icode-interface.scala
+++ b/test/files/run/sbt-icode-interface.scala
@@ -9,34 +9,32 @@ object Test extends DirectTest {
   """.trim
 
   def show() {
-    for (b <- List("GenASM", "GenBCode")) {
-      val global = newCompiler("-usejavacp", s"-Ybackend:$b")
-      import global._
-      val r = new Run
-      r.compileSources(newSourceFile(code) :: Nil)
-      
-      val results = collection.mutable.Buffer[(Boolean, String)]()
+    val global = newCompiler("-usejavacp")
+    import global._
+    val r = new Run
+    r.compileSources(newSourceFile(code) :: Nil)
 
-      // Nailing down defacto compiler API from SBT's usage
-      // https://github.com/sbt/sbt/blob/adb41611cf73260938274915d8462d924df200c8/compile/interface/src/main/scala/xsbt/Analyzer.scala#L29-L41
-      def isTopLevelModule(sym: Symbol) = sym.isTopLevel && sym.isModule
-      for (unit <- currentRun.units if !unit.isJava) {
-        val sourceFile = unit.source.file.file
-        for (iclass <- unit.icode) {
-          val sym = iclass.symbol
-          def addGenerated(separatorRequired: Boolean) {
-            results += (separatorRequired -> sym.fullName)
-          }
-          if (sym.isModuleClass && !sym.isImplClass) {
-            if (isTopLevelModule(sym) && sym.companionClass == NoSymbol)
-              addGenerated(false)
-            addGenerated(true)
-          } else
-            addGenerated(false)
+    val results = collection.mutable.Buffer[(Boolean, String)]()
+
+    // Nailing down defacto compiler API from SBT's usage
+    // https://github.com/sbt/sbt/blob/adb41611cf73260938274915d8462d924df200c8/compile/interface/src/main/scala/xsbt/Analyzer.scala#L29-L41
+    def isTopLevelModule(sym: Symbol) = sym.isTopLevel && sym.isModule
+    for (unit <- currentRun.units if !unit.isJava) {
+      val sourceFile = unit.source.file.file
+      for (iclass <- unit.icode) {
+        val sym = iclass.symbol
+        def addGenerated(separatorRequired: Boolean) {
+          results += (separatorRequired -> sym.fullName)
         }
+        if (sym.isModuleClass && !sym.isImplClass) {
+          if (isTopLevelModule(sym) && sym.companionClass == NoSymbol)
+            addGenerated(false)
+          addGenerated(true)
+        } else
+          addGenerated(false)
       }
-      val expected = List((false, "C"), (true, "O"), (false, "C$D"))
-      assert(results.toList == expected, b + ": " + results.toList)
     }
+    val expected = List((false, "C"), (true, "O"), (false, "C$D"))
+    assert(results.toList == expected, s"expected: $expected, actual: ${results.toList}")
   }
 }
diff --git a/test/files/run/showraw_tree_types_ids.check b/test/files/run/showraw_tree_types_ids.check
index 75347463cb..e122148040 100644
--- a/test/files/run/showraw_tree_types_ids.check
+++ b/test/files/run/showraw_tree_types_ids.check
@@ -4,9 +4,9 @@ Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](sca
 [3] TypeRef(ThisType(scala.collection.immutable#<id>), scala.collection.immutable.HashMap#<id>, List())
 [4] TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List())
 [5] SingleType(ThisType(scala#<id>), scala.Predef#<id>)
-Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)))))), termNames.CONSTRUCTOR#<id>), List())
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.mutable.HashMap#<id>), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>), TypeName("String")#<id>)))))), termNames.CONSTRUCTOR#<id>), List())
+[1] TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List(TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List())))
+[2] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List(TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()))))
+[3] TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List())
 [4] TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List())
 [5] SingleType(ThisType(scala#<id>), scala.Predef#<id>)
-[6] TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List(TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List())))
-[7] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List(TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()), TypeRef(SingleType(ThisType(scala#<id>), scala.Predef#<id>), TypeName("String")#<id>, List()))))
-[8] TypeRef(ThisType(scala.collection.mutable#<id>), scala.collection.mutable.HashMap#<id>, List())
diff --git a/test/files/run/showraw_tree_types_typed.check b/test/files/run/showraw_tree_types_typed.check
index de691e369e..4934ed41dc 100644
--- a/test/files/run/showraw_tree_types_typed.check
+++ b/test/files/run/showraw_tree_types_typed.check
@@ -4,9 +4,9 @@ Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](sca
 [3] TypeRef(ThisType(scala.collection.immutable), scala.collection.immutable.HashMap, List())
 [4] TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List())
 [5] SingleType(ThisType(scala), scala.Predef)
-Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))))))), termNames.CONSTRUCTOR), List())
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.mutable.HashMap), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef), TypeName("String"))))))), termNames.CONSTRUCTOR), List())
+[1] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()), TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List())))
+[2] MethodType(List(), TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()), TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()))))
+[3] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List())
 [4] TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List())
 [5] SingleType(ThisType(scala), scala.Predef)
-[6] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()), TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List())))
-[7] MethodType(List(), TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List(TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()), TypeRef(SingleType(ThisType(scala), scala.Predef), TypeName("String"), List()))))
-[8] TypeRef(ThisType(scala.collection.mutable), scala.collection.mutable.HashMap, List())
diff --git a/test/files/run/showraw_tree_ultimate.check b/test/files/run/showraw_tree_ultimate.check
index 81efcc05ab..b94d568a75 100644
--- a/test/files/run/showraw_tree_ultimate.check
+++ b/test/files/run/showraw_tree_ultimate.check
@@ -4,9 +4,9 @@ Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](sca
 [3] TypeRef(ThisType(scala.collection.immutable#<id>#PKC), scala.collection.immutable.HashMap#<id>#CLS, List())
 [4] TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())
 [5] SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD)
-Apply[6](Select[7](New[6](TypeTree[6]().setOriginal(AppliedTypeTree(Ident[8](scala.collection.mutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)))))), termNames.CONSTRUCTOR#<id>#CTOR), List())
+Apply[1](Select[2](New[1](TypeTree[1]().setOriginal(AppliedTypeTree(Ident[3](scala.collection.mutable.HashMap#<id>#CLS), List(TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)), TypeTree[4]().setOriginal(Select[4](Ident[5](scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE)))))), termNames.CONSTRUCTOR#<id>#CTOR), List())
+[1] TypeRef(ThisType(scala.collection.mutable#<id>#PKC), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())))
+[2] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#<id>#PKC), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()))))
+[3] TypeRef(ThisType(scala.collection.mutable#<id>#PKC), scala.collection.mutable.HashMap#<id>#CLS, List())
 [4] TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())
 [5] SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD)
-[6] TypeRef(ThisType(scala.collection.mutable#<id>#PKC), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List())))
-[7] MethodType(List(), TypeRef(ThisType(scala.collection.mutable#<id>#PKC), scala.collection.mutable.HashMap#<id>#CLS, List(TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()), TypeRef(SingleType(ThisType(scala#<id>#PKC), scala.Predef#<id>#MOD), TypeName("String")#<id>#TPE, List()))))
-[8] TypeRef(ThisType(scala.collection.mutable#<id>#PKC), scala.collection.mutable.HashMap#<id>#CLS, List())
diff --git a/test/files/run/synchronized.flags b/test/files/run/synchronized.flags
index b9bb09167e..19c578e4ad 100644
--- a/test/files/run/synchronized.flags
+++ b/test/files/run/synchronized.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
+-Yopt:l:project
diff --git a/test/files/run/t3509.flags b/test/files/run/t3509.flags
index 9c59981aa9..422d6be431 100644
--- a/test/files/run/t3509.flags
+++ b/test/files/run/t3509.flags
@@ -1 +1 @@
--Yinline -Ybackend:GenASM
\ No newline at end of file
+-Yopt:l:classpath
\ No newline at end of file
diff --git a/test/files/run/t3569.flags b/test/files/run/t3569.flags
index 9c59981aa9..422d6be431 100644
--- a/test/files/run/t3569.flags
+++ b/test/files/run/t3569.flags
@@ -1 +1 @@
--Yinline -Ybackend:GenASM
\ No newline at end of file
+-Yopt:l:classpath
\ No newline at end of file
diff --git a/test/files/run/t3647.check b/test/files/run/t3647.check
new file mode 100644
index 0000000000..e5c1ee1701
--- /dev/null
+++ b/test/files/run/t3647.check
@@ -0,0 +1 @@
+warning: there were three deprecation warnings; re-run with -deprecation for details
diff --git a/test/files/run/t4285.flags b/test/files/run/t4285.flags
index 99bd6c895d..422d6be431 100644
--- a/test/files/run/t4285.flags
+++ b/test/files/run/t4285.flags
@@ -1 +1 @@
--optimise -Ybackend:GenASM
\ No newline at end of file
+-Yopt:l:classpath
\ No newline at end of file
diff --git a/test/files/run/t4935.flags b/test/files/run/t4935.flags
index b9bb09167e..65caa3736e 100644
--- a/test/files/run/t4935.flags
+++ b/test/files/run/t4935.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
+-Yopt:l:classpath
diff --git a/test/files/run/t4950.check b/test/files/run/t4950.check
deleted file mode 100644
index 8994441163..0000000000
--- a/test/files/run/t4950.check
+++ /dev/null
@@ -1,7 +0,0 @@
-
-scala> val 1 = 2
-scala.MatchError: 2 (of class java.lang.Integer)
-
-scala> val List(1) = List(1)
-
-scala> :quit
diff --git a/test/files/run/t4950.scala b/test/files/run/t4950.scala
index cef06027bf..e34b2cf3f2 100644
--- a/test/files/run/t4950.scala
+++ b/test/files/run/t4950.scala
@@ -1,12 +1,24 @@
-import scala.tools.partest.ReplTest
+import scala.tools.partest.SessionTest
+import scala.PartialFunction.{ cond => when }
+
+object Elision {
+  val elideMsg = """  ... \d+ elided""".r
+}
+
+object Test extends SessionTest {
+  import Elision._
 
-object Test extends ReplTest {
   // Filter out the abbreviated stacktrace "... X elided" 
   // because the number seems to differ between versions/platforms/...
-  override def show = eval() filterNot (_ contains "elided") foreach println
-  def code =
+  def elided(s: String) = when(s) { case elideMsg() => true }
+  override def eval() = super.eval() filterNot elided
+  def session =
 """
-val 1 = 2
-val List(1) = List(1)
+scala> val 1 = 2
+scala.MatchError: 2 (of class java.lang.Integer)
+
+scala> val List(1) = List(1)
+
+scala> :quit
 """
 }
diff --git a/test/files/run/t5789.scala b/test/files/run/t5789.scala
index c8d95f2153..677c9ca229 100644
--- a/test/files/run/t5789.scala
+++ b/test/files/run/t5789.scala
@@ -5,7 +5,7 @@ import scala.tools.partest.ReplTest
 
 
 object Test extends ReplTest {
-  override def extraSettings = "-Yinline -Ybackend:GenASM"
+  override def extraSettings = "-Yopt:l:classpath"
   def code = """
     val n = 2
     () => n
diff --git a/test/files/run/t6028.check b/test/files/run/t6028.check
index a768f32976..b3d20a9902 100644
--- a/test/files/run/t6028.check
+++ b/test/files/run/t6028.check
@@ -50,10 +50,18 @@ package <empty> {
       <synthetic> <stable> <artifact> def $outer(): T = MethodLocalObject$2.this.$outer;
       <synthetic> <stable> <artifact> def $outer(): T = MethodLocalObject$2.this.$outer
     };
-    final <stable> private[this] def MethodLocalObject$1(barParam$1: Int, MethodLocalObject$module$1: runtime.VolatileObjectRef): T#MethodLocalObject$2.type = {
-      MethodLocalObject$module$1.elem = new T#MethodLocalObject$2.type(T.this, barParam$1);
+    final <stable> private[this] def MethodLocalObject$lzycompute$1(barParam$1: Int, MethodLocalObject$module$1: runtime.VolatileObjectRef): T#MethodLocalObject$2.type = {
+      T.this.synchronized({
+        if (MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]().eq(null))
+          MethodLocalObject$module$1.elem = new T#MethodLocalObject$2.type(T.this, barParam$1);
+        scala.runtime.BoxedUnit.UNIT
+      });
       MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]()
     };
+    final <stable> private[this] def MethodLocalObject$1(barParam$1: Int, MethodLocalObject$module$1: runtime.VolatileObjectRef): T#MethodLocalObject$2.type = if (MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]().eq(null))
+      T.this.MethodLocalObject$lzycompute$1(barParam$1, MethodLocalObject$module$1)
+    else
+      MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]();
     abstract trait MethodLocalTrait$1$class extends Object with T#MethodLocalTrait$1 {
       def /*MethodLocalTrait$1$class*/$init$(barParam$1: Int): Unit = {
         ()
diff --git a/test/files/run/t6188.flags b/test/files/run/t6188.flags
index b9bb09167e..422d6be431 100644
--- a/test/files/run/t6188.flags
+++ b/test/files/run/t6188.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
+-Yopt:l:classpath
\ No newline at end of file
diff --git a/test/files/run/t6288.check b/test/files/run/t6288.check
index a032a10de6..67877fd56d 100644
--- a/test/files/run/t6288.check
+++ b/test/files/run/t6288.check
@@ -33,11 +33,8 @@
       [175]case <synthetic> val x1: [175]Any = [175]"";
       [175]case5()[195]{
         [195]<synthetic> val o7: [195]Option[List[Int]] = [195][195]Case4.unapplySeq([195]x1);
-        [195]if ([195]o7.isEmpty.unary_!)
-          [195]if ([195][195][195][195]o7.get.!=([195]null).&&([195][195][195][195]o7.get.lengthCompare([195]1).==([195]0)))
-            [208][208]matchEnd4([208]())
-          else
-            [195][195]case6()
+        [195]if ([195][195]o7.isEmpty.unary_!.&&([195][195][195][195]o7.get.!=([195]null).&&([195][195][195][195]o7.get.lengthCompare([195]1).==([195]0))))
+          [208][208]matchEnd4([208]())
         else
           [195][195]case6()
       };
@@ -59,11 +56,8 @@
       [273]case <synthetic> val x1: [273]Any = [273]"";
       [273]case5()[293]{
         [293]<synthetic> val o7: [293]Option[List[Int]] = [293][293]Case4.unapplySeq([293]x1);
-        [293]if ([293]o7.isEmpty.unary_!)
-          [293]if ([293][293][293][293]o7.get.!=([293]null).&&([293][293][293][293]o7.get.lengthCompare([293]0).==([293]0)))
-            [304][304]matchEnd4([304]())
-          else
-            [293][293]case6()
+        [293]if ([293][293]o7.isEmpty.unary_!.&&([293][293][293][293]o7.get.!=([293]null).&&([293][293][293][293]o7.get.lengthCompare([293]0).==([293]0))))
+          [304][304]matchEnd4([304]())
         else
           [293][293]case6()
       };
diff --git a/test/files/run/t6546.flags b/test/files/run/t6546.flags
deleted file mode 100644
index 6015e7c61f..0000000000
--- a/test/files/run/t6546.flags
+++ /dev/null
@@ -1 +0,0 @@
--Ybackend:GenASM -optimise
\ No newline at end of file
diff --git a/test/files/run/t6546/A_1.scala b/test/files/run/t6546/A_1.scala
deleted file mode 100644
index bd086c08f8..0000000000
--- a/test/files/run/t6546/A_1.scala
+++ /dev/null
@@ -1,6 +0,0 @@
-final class Opt {
-  @inline def getOrElse(x: => String): String = ""
-}
-class A_1 {
-  def f(x: Opt): String = x getOrElse null
-}
diff --git a/test/files/run/t6546/B_2.scala b/test/files/run/t6546/B_2.scala
deleted file mode 100644
index 64ec966f75..0000000000
--- a/test/files/run/t6546/B_2.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-import scala.tools.partest.BytecodeTest
-
-object Test extends BytecodeTest {
-  def show: Unit = {
-    val node = loadClassNode("A_1")
-    assert(node.innerClasses.isEmpty, node.innerClasses)
-  }
-}
diff --git a/test/files/run/t7008-scala-defined.flags b/test/files/run/t7008-scala-defined.flags
index 49f2d2c4c8..e69de29bb2 100644
--- a/test/files/run/t7008-scala-defined.flags
+++ b/test/files/run/t7008-scala-defined.flags
@@ -1 +0,0 @@
--Ybackend:GenASM
diff --git a/test/files/run/t7459b-optimize.flags b/test/files/run/t7459b-optimize.flags
index b9bb09167e..65caa3736e 100644
--- a/test/files/run/t7459b-optimize.flags
+++ b/test/files/run/t7459b-optimize.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
+-Yopt:l:classpath
diff --git a/test/files/run/t7582.flags b/test/files/run/t7582.flags
index 2cd4b38726..422d6be431 100644
--- a/test/files/run/t7582.flags
+++ b/test/files/run/t7582.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
\ No newline at end of file
+-Yopt:l:classpath
\ No newline at end of file
diff --git a/test/files/run/t7582b.flags b/test/files/run/t7582b.flags
index 2cd4b38726..422d6be431 100644
--- a/test/files/run/t7582b.flags
+++ b/test/files/run/t7582b.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
\ No newline at end of file
+-Yopt:l:classpath
\ No newline at end of file
diff --git a/test/files/run/t7634.check b/test/files/run/t7634.check
index 879aea67a2..43128cad95 100644
--- a/test/files/run/t7634.check
+++ b/test/files/run/t7634.check
@@ -1,6 +1,6 @@
 
 
-scala> .lines
-res1: List[String] = List(shello, world.)
+scala> .lines.foreach(println)
+shello, world.
 
 scala> :quit
diff --git a/test/files/run/t7634.scala b/test/files/run/t7634.scala
index aeb6a5e671..9520931941 100644
--- a/test/files/run/t7634.scala
+++ b/test/files/run/t7634.scala
@@ -9,7 +9,7 @@ import scala.util.Properties.propOrElse
 object Test extends ReplTest {
   def java = propOrElse("javacmd", "java")
   def code = s""":sh $java -classpath $testOutput hello.Hello
-                |.lines""".stripMargin
+                |.lines.foreach(println)""".stripMargin
 }
 
 package hello {
diff --git a/test/files/run/t8601-closure-elim.flags b/test/files/run/t8601-closure-elim.flags
index 9158076b71..642187ff4c 100644
--- a/test/files/run/t8601-closure-elim.flags
+++ b/test/files/run/t8601-closure-elim.flags
@@ -1 +1 @@
--optimize -Ydelambdafy:inline -Ybackend:GenASM
+-Ydelambdafy:method -Yopt:l:classpath
diff --git a/test/files/run/t8601-closure-elim.scala b/test/files/run/t8601-closure-elim.scala
index ebeb16e0c7..40fbf1fe0e 100644
--- a/test/files/run/t8601-closure-elim.scala
+++ b/test/files/run/t8601-closure-elim.scala
@@ -1,4 +1,5 @@
 import scala.tools.partest.BytecodeTest
+import scala.tools.partest.ASMConverters.instructionsFromMethod
 import scala.tools.asm
 import scala.tools.asm.util._
 import scala.collection.JavaConverters._
@@ -10,8 +11,9 @@ object Test extends BytecodeTest {
     def test(methodName: String) {
       val classNode = loadClassNode("Foo")
       val methodNode = getMethod(classNode, "b")
+      val instrs = instructionsFromMethod(methodNode)
       val ops = methodNode.instructions.iterator.asScala.map(_.getOpcode).toList
-      assert(!ops.contains(asm.Opcodes.NEW), ops)// should be allocation free if the closure is eliminated
+      assert(!ops.contains(asm.Opcodes.NEW), instrs)// should be allocation free if the closure is eliminated
     }
     test("b")
   }
diff --git a/test/files/run/t8601.flags b/test/files/run/t8601.flags
index 2cd4b38726..65caa3736e 100644
--- a/test/files/run/t8601.flags
+++ b/test/files/run/t8601.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
\ No newline at end of file
+-Yopt:l:classpath
diff --git a/test/files/run/t8601b.flags b/test/files/run/t8601b.flags
index 2cd4b38726..65caa3736e 100644
--- a/test/files/run/t8601b.flags
+++ b/test/files/run/t8601b.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
\ No newline at end of file
+-Yopt:l:classpath
diff --git a/test/files/run/t8601c.flags b/test/files/run/t8601c.flags
index 2cd4b38726..65caa3736e 100644
--- a/test/files/run/t8601c.flags
+++ b/test/files/run/t8601c.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
\ No newline at end of file
+-Yopt:l:classpath
diff --git a/test/files/run/t8601d.flags b/test/files/run/t8601d.flags
index 2cd4b38726..65caa3736e 100644
--- a/test/files/run/t8601d.flags
+++ b/test/files/run/t8601d.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
\ No newline at end of file
+-Yopt:l:classpath
diff --git a/test/files/run/t8601e.flags b/test/files/run/t8601e.flags
index b9bb09167e..65caa3736e 100644
--- a/test/files/run/t8601e.flags
+++ b/test/files/run/t8601e.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
+-Yopt:l:classpath
diff --git a/test/files/run/t9003.flags b/test/files/run/t9003.flags
index b9bb09167e..65caa3736e 100644
--- a/test/files/run/t9003.flags
+++ b/test/files/run/t9003.flags
@@ -1 +1 @@
--optimize -Ybackend:GenASM
+-Yopt:l:classpath
diff --git a/test/files/run/t9110.scala b/test/files/run/t9110.scala
new file mode 100644
index 0000000000..660291a4d1
--- /dev/null
+++ b/test/files/run/t9110.scala
@@ -0,0 +1,27 @@
+trait Event
+
+trait Domain {
+  case class Created(name: String) extends Event
+}
+
+// declare three instances of Domain trait, one here and two
+// in an inner scope
+
+object DomainC extends Domain
+
+object Test {
+ def main(args: Array[String]) {
+   object DomainA extends Domain
+   object DomainB extends Domain
+
+   def lookingForAs(event: Event): Unit = {
+      event match {
+        case DomainB.Created(_) => throw null
+        case DomainC.Created(_) => throw null
+        case DomainA.Created(_) => // okay
+      }
+   }
+
+   lookingForAs(DomainA.Created("I am an A"))
+  }
+}
diff --git a/test/files/run/t9178a.flags b/test/files/run/t9178a.flags
new file mode 100644
index 0000000000..48fd867160
--- /dev/null
+++ b/test/files/run/t9178a.flags
@@ -0,0 +1 @@
+-Xexperimental
diff --git a/test/files/run/t9178a.scala b/test/files/run/t9178a.scala
new file mode 100644
index 0000000000..4788841f8d
--- /dev/null
+++ b/test/files/run/t9178a.scala
@@ -0,0 +1,15 @@
+trait Sam { def apply(): Unit }
+abstract class Test {
+  def foo(): Sam
+  // no parens, instantiateToMethodType would wrap in a `new Sam { def apply = foo }`
+  // rather than applying to an empty param list() */
+  val f: Sam = foo
+}
+
+object Test extends Test {
+  lazy val samIAm = new Sam { def apply() {} }
+  def foo() = samIAm
+  def main(args: Array[String]): Unit = {
+    assert(f eq samIAm, f)
+  }
+}
diff --git a/test/files/run/t9403.flags b/test/files/run/t9403.flags
index 307668060c..65caa3736e 100644
--- a/test/files/run/t9403.flags
+++ b/test/files/run/t9403.flags
@@ -1 +1 @@
--Ybackend:GenASM -optimize
+-Yopt:l:classpath
diff --git a/test/files/run/t9489.flags b/test/files/run/t9489.flags
new file mode 100644
index 0000000000..48fd867160
--- /dev/null
+++ b/test/files/run/t9489.flags
@@ -0,0 +1 @@
+-Xexperimental
diff --git a/test/files/run/t9489/A.java b/test/files/run/t9489/A.java
new file mode 100644
index 0000000000..c3536faa14
--- /dev/null
+++ b/test/files/run/t9489/A.java
@@ -0,0 +1,3 @@
+public class A {
+  public B b() { return null; }
+}
diff --git a/test/files/run/t9489/B.java b/test/files/run/t9489/B.java
new file mode 100644
index 0000000000..e5d1278cd7
--- /dev/null
+++ b/test/files/run/t9489/B.java
@@ -0,0 +1,3 @@
+public abstract class B {
+  public abstract int m();
+}
diff --git a/test/files/run/t9489/test.scala b/test/files/run/t9489/test.scala
new file mode 100644
index 0000000000..1b745af865
--- /dev/null
+++ b/test/files/run/t9489/test.scala
@@ -0,0 +1,10 @@
+class T {
+  def f(a: A) = g(a.b) // was: "found Int, required B"
+  def g(b: => B) = null
+}
+
+object Test extends T {
+  def main(args: Array[String]): Unit = {
+    f(new A)
+  }
+}
diff --git a/test/files/run/trait-defaults-modules.scala b/test/files/run/trait-defaults-modules.scala
new file mode 100644
index 0000000000..93fc74baff
--- /dev/null
+++ b/test/files/run/trait-defaults-modules.scala
@@ -0,0 +1,20 @@
+trait T1 { def a: Any }
+
+trait T2 extends T1 { object a; object b; private object c; def usec: Any = c}
+trait T3 extends T2
+
+class C1 extends T1 { object a; object b }
+class C2 extends C1
+class C3 extends T2
+class C4 extends T3
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val (c1, c2, c3, c4) = (new C1, new C2, new C3, new C4)
+    c1.a; c1.b; (c1: T1).a
+    c2.a; c2.b; (c2: T1).a
+    c3.a; c3.b; (c3: T1).a; c3.usec
+    c4.a; c4.b; (c4: T1).a; c4.usec
+  }
+
+}
diff --git a/test/files/run/trait-defaults-modules2/T_1.scala b/test/files/run/trait-defaults-modules2/T_1.scala
new file mode 100644
index 0000000000..962acdade1
--- /dev/null
+++ b/test/files/run/trait-defaults-modules2/T_1.scala
@@ -0,0 +1,4 @@
+trait T {
+  private object O
+  def useO: Any = O
+}
diff --git a/test/files/run/trait-defaults-modules2/Test_2.scala b/test/files/run/trait-defaults-modules2/Test_2.scala
new file mode 100644
index 0000000000..a1c49f5ddd
--- /dev/null
+++ b/test/files/run/trait-defaults-modules2/Test_2.scala
@@ -0,0 +1,5 @@
+object Test extends T {
+  def main(args: Array[String]): Unit = {
+    useO
+  }
+}
diff --git a/test/files/run/trait-defaults-modules3.scala b/test/files/run/trait-defaults-modules3.scala
new file mode 100644
index 0000000000..8790a95f4c
--- /dev/null
+++ b/test/files/run/trait-defaults-modules3.scala
@@ -0,0 +1,8 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    object O
+    val x = O
+    val y = O
+    assert(x eq y)
+  }
+}
diff --git a/test/files/scalacheck/parallel-collections/ParallelRangeCheck.scala b/test/files/scalacheck/parallel-collections/ParallelRangeCheck.scala
index f490d9490a..a80d1a27a1 100644
--- a/test/files/scalacheck/parallel-collections/ParallelRangeCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelRangeCheck.scala
@@ -27,7 +27,7 @@ class ParallelRangeCheck(val tasksupport: TaskSupport) extends ParallelSeqCheck[
 
   def isCheckingViews = false
 
-  def ofSize(vals: Seq[Gen[Int]], sz: Int) = unsupported
+  def ofSize(vals: Seq[Gen[Int]], sz: Int) = throw new UnsupportedOperationException
 
   override def instances(vals: Seq[Gen[Int]]): Gen[Seq[Int]] = sized { start =>
     sized { end =>
diff --git a/test/junit/scala/PartialFunctionSerializationTest.scala b/test/junit/scala/PartialFunctionSerializationTest.scala
new file mode 100644
index 0000000000..d525b045cd
--- /dev/null
+++ b/test/junit/scala/PartialFunctionSerializationTest.scala
@@ -0,0 +1,36 @@
+package scala
+
+import org.junit.Test
+import org.junit.Assert._
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(classOf[JUnit4])
+class PartialFunctionSerializationTest {
+  val pf1: PartialFunction[Int, Int] = {
+    case n if n > 0 => 1
+  }
+
+  val pf2: PartialFunction[Int, Int] = {
+    case n if n <= 0 => 2
+  }
+
+
+  private def assertSerializable[A,B](fn: A => B) = {
+    import java.io._
+
+    new ObjectOutputStream(new ByteArrayOutputStream()).writeObject(fn)
+  }
+
+  @Test def canSerializeLiteral= assertSerializable(pf1)
+
+  @Test def canSerializeLifted= assertSerializable(pf1.lift)
+
+  @Test def canSerializeOrElse = assertSerializable(pf1 orElse pf2)
+
+  @Test def canSerializeUnlifted = assertSerializable(Function.unlift((x: Int) => Some(x)))
+
+  @Test def canSerializeAndThen = assertSerializable(pf1.andThen((x: Int) => x))
+
+  @Test def canSerializeEmpty = assertSerializable(PartialFunction.empty)
+}
diff --git a/test/junit/scala/StringContextTest.scala b/test/junit/scala/StringContextTest.scala
index 900852fcc6..b5af6de7eb 100644
--- a/test/junit/scala/StringContextTest.scala
+++ b/test/junit/scala/StringContextTest.scala
@@ -1,6 +1,8 @@
 
 package scala
 
+import java.text.DecimalFormat
+
 import language.implicitConversions
 
 import org.junit.Test
@@ -10,10 +12,32 @@ import org.junit.runners.JUnit4
 
 import scala.tools.testing.AssertUtil._
 
+object StringContextTestUtils {
+  private val decimalSeparator: Char = new DecimalFormat().getDecimalFormatSymbols().getDecimalSeparator()
+  private val numberPattern = """(\d+)\.(\d+.*)""".r
+
+  implicit class StringContextOps(val sc: StringContext) extends AnyVal {
+    // Use this String interpolator to avoid problems with a locale-dependent decimal mark.
+    def locally(numbers: String*): String = {
+      val numbersWithCorrectLocale = numbers.map(applyProperLocale)
+      sc.s(numbersWithCorrectLocale: _*)
+    }
+
+    // Handles cases like locally"3.14" - it's prettier than locally"${"3.14"}".
+    def locally(): String = sc.parts.map(applyProperLocale).mkString
+
+    private def applyProperLocale(number: String): String = {
+      val numberPattern(intPart, fractionalPartAndSuffix) = number
+      s"$intPart$decimalSeparator$fractionalPartAndSuffix"
+    }
+  }
+}
+
 @RunWith(classOf[JUnit4])
 class StringContextTest {
 
   import StringContext._
+  import StringContextTestUtils.StringContextOps
 
   @Test def noEscape() = {
     val s = "string"
@@ -67,26 +91,22 @@ class StringContextTest {
 
   @Test def fIf() = {
     val res = f"${if (true) 2.5 else 2.5}%.2f"
-    val expected = formatUsingCurrentLocale(2.50)
+    val expected = locally"2.50"
     assertEquals(expected, res)
   }
 
   @Test def fIfNot() = {
     val res = f"${if (false) 2.5 else 3.5}%.2f"
-    val expected = formatUsingCurrentLocale(3.50)
+    val expected = locally"3.50"
     assertEquals(expected, res)
   }
 
   @Test def fHeteroArgs() = {
     val res = f"${3.14}%.2f rounds to ${3}%d"
-    val expected = formatUsingCurrentLocale(3.14) + " rounds to 3"
+    val expected = locally"${"3.14"} rounds to 3"
     assertEquals(expected, res)
   }
 
-  // Use this method to avoid problems with a locale-dependent decimal mark.
-  // The string interpolation is not used here intentionally as this method is used to test string interpolation.
-  private def formatUsingCurrentLocale(number: Double, decimalPlaces: Int = 2) = ("%." + decimalPlaces + "f").format(number)
-
   @Test def `f interpolator baseline`(): Unit = {
 
     implicit def stringToBoolean(s: String): Boolean = java.lang.Boolean.parseBoolean(s)
@@ -203,17 +223,17 @@ class StringContextTest {
 
       // 'e' | 'E' | 'g' | 'G' | 'f' | 'a' | 'A' (category: floating point)
       // ------------------------------------------------------------------
-      f"${3.4f}%e" -> "3.400000e+00",
-      f"${3.4}%e"  -> "3.400000e+00",
-      f"${3.4f : java.lang.Float}%e" -> "3.400000e+00",
-      f"${3.4 : java.lang.Double}%e" -> "3.400000e+00",
+      f"${3.4f}%e" -> locally"3.400000e+00",
+      f"${3.4}%e"  -> locally"3.400000e+00",
+      f"${3.4f : java.lang.Float}%e" -> locally"3.400000e+00",
+      f"${3.4 : java.lang.Double}%e" -> locally"3.400000e+00",
 
-      f"${BigDecimal(3.4)}%e" -> "3.400000e+00",
+      f"${BigDecimal(3.4)}%e" -> locally"3.400000e+00",
 
-      f"${new java.math.BigDecimal(3.4)}%e" -> "3.400000e+00",
+      f"${new java.math.BigDecimal(3.4)}%e" -> locally"3.400000e+00",
 
-      f"${3}%e"  -> "3.000000e+00",
-      f"${3L}%e" -> "3.000000e+00",
+      f"${3}%e"  -> locally"3.000000e+00",
+      f"${3L}%e" -> locally"3.000000e+00",
 
       // 't' | 'T' (category: date/time)
       // -------------------------------
@@ -224,11 +244,10 @@ class StringContextTest {
 
       // literals and arg indexes
       f"%%" -> "%",
-      f" mind%n------%nmatter%n" ->
+      f" mind%n------%nmatter" ->
        """| mind
           |------
-          |matter
-          |""".stripMargin,
+          |matter""".stripMargin.lines.mkString(compat.Platform.EOL),
       f"${i}%d %<d ${9}%d"   -> "42 42 9",
       f"${7}%d %<d ${9}%d"   -> "7 7 9",
       f"${7}%d %2$$d ${9}%d" -> "7 9 9",
@@ -237,7 +256,7 @@ class StringContextTest {
 
       f"${5: Any}"      -> "5",
       f"${5}%s%<d"      -> "55",
-      f"${3.14}%s,%<f"  -> "3.14,3.140000",
+      f"${3.14}%s,%<f"  -> locally"3.14,${"3.140000"}",
 
       f"z" -> "z"
     )
diff --git a/test/junit/scala/collection/mutable/SetLikeTest.scala b/test/junit/scala/collection/mutable/SetLikeTest.scala
new file mode 100644
index 0000000000..c819024558
--- /dev/null
+++ b/test/junit/scala/collection/mutable/SetLikeTest.scala
@@ -0,0 +1,26 @@
+package scala.collection.mutable
+
+import org.junit.Assert._
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(classOf[JUnit4])
+class SetLikeTest {
+
+  class MySet(self: Set[String]) extends Set[String] with SetLike[String, MySet] {
+    override def -=(elem: String) = { self -= elem; this }
+    override def +=(elem: String) = { self += elem; this }
+
+    override def empty = new MySet(self.empty)
+    override def iterator = self.iterator
+    override def contains(elem: String) = self.contains(elem)
+  }
+
+  @Test
+  def hasCorrectClear() {
+    val s = new MySet(Set("EXPOSEDNODE", "CONNECTABLE"))
+    s.clear()
+    assertEquals(new MySet(Set()), s)
+  }
+}
diff --git a/test/junit/scala/sys/process/t7350.scala b/test/junit/scala/sys/process/t7350.scala
index 7f3e8897f2..3c0e5145e6 100644
--- a/test/junit/scala/sys/process/t7350.scala
+++ b/test/junit/scala/sys/process/t7350.scala
@@ -18,6 +18,7 @@ import scala.util.control.Exception.ignoring
 class PipedProcessTest {
   class ProcessMock(error: Boolean) extends Process {
     var destroyCount = 0
+    def isAlive() = false
     def exitValue(): Int = {
       if (error) {
         throw new InterruptedException()
diff --git a/test/junit/scala/tools/nsc/transform/delambdafy/DelambdafyTest.scala b/test/junit/scala/tools/nsc/transform/delambdafy/DelambdafyTest.scala
new file mode 100644
index 0000000000..010078e28a
--- /dev/null
+++ b/test/junit/scala/tools/nsc/transform/delambdafy/DelambdafyTest.scala
@@ -0,0 +1,73 @@
+package scala.tools.nsc.transform.delambdafy
+
+import scala.reflect.io.Path.jfile2path
+import scala.tools.nsc.backend.jvm.CodeGenTools.getGeneratedClassfiles
+import scala.tools.nsc.backend.jvm.CodeGenTools.makeSourceFile
+import scala.tools.nsc.backend.jvm.CodeGenTools.newCompilerWithoutVirtualOutdir
+import scala.tools.nsc.io.AbstractFile
+import scala.tools.testing.TempDir
+
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(classOf[JUnit4])
+class DelambdafyTest {
+  def compileToMultipleOutputWithDelamdbafyMethod(): List[(String, Array[Byte])] = {
+    val codeForMultiOutput = """
+object Delambdafy {
+  type -->[D, I] = PartialFunction[D, I]
+
+  def main(args: Array[String]): Unit = {
+    val result = List(1, 2, 4).map { a =>
+      val list = List("1", "2", "3").map { _ + "test" }
+      list.find { _ == a.toString + "test" }
+    }
+    println(result)
+    lazy val _foo = foo(result) {
+      case x :: xs if x isDefined => x.get.length
+      case _ => 0
+    }
+    println(_foo)
+    lazy val bar: Int => Int = {
+      case 2 => 23
+      case _ =>
+        val v = List(1).map { _ + 42 }.head
+        v + 31
+    }
+    bar(3)
+    lazy val _baz = baz {
+      case 1 =>
+        val local = List(1).map(_ + 1)
+        local.head
+    }
+  }
+
+  def baz[T](f: Any --> Any): Any => Any = f
+
+  def foo(b: List[Option[String]])(a: List[Option[String]] => Int): Int = a(b)
+}
+"""
+    val srcFile = makeSourceFile(codeForMultiOutput, "delambdafyTest.scala")
+    val outDir = AbstractFile.getDirectory(TempDir.createTempDir())
+    val outDirPath = outDir.canonicalPath
+    val extraArgs = "-Ybackend:GenBCode -Ydelambdafy:method"
+    val argsWithOutDir = extraArgs + s" -d $outDirPath -cp $outDirPath"
+    val compiler = newCompilerWithoutVirtualOutdir(extraArgs = argsWithOutDir)
+    compiler.settings.outputDirs.add(srcFile.file, outDir)
+
+    new compiler.Run().compileSources(List(srcFile))
+
+    val classfiles = getGeneratedClassfiles(outDir)
+    outDir.delete()
+    classfiles
+  }
+  
+  @Test
+  def shouldFindOutputFoldersForAllPromotedLambdasAsMethod(): Unit = {
+    val actual = compileToMultipleOutputWithDelamdbafyMethod()
+
+    assertTrue(actual.length > 0)
+  }
+}
diff --git a/test/junit/scala/util/SystemPropertiesTest.scala b/test/junit/scala/util/SystemPropertiesTest.scala
new file mode 100644
index 0000000000..38e830eb88
--- /dev/null
+++ b/test/junit/scala/util/SystemPropertiesTest.scala
@@ -0,0 +1,27 @@
+package scala.util
+
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Test
+import org.junit.Assert._
+
+@RunWith(classOf[JUnit4])
+class SystemPropertiesTest {
+  @Test
+  def filterAll(): Unit = {
+    val isEmpty = sys.props.filter(_ => false).size == 0
+    assertTrue("A filter matching nothing should produce an empty result", isEmpty)
+  }
+
+  @Test
+  def filterNone(): Unit = {
+    val isUnchanged = sys.props.filter(_ => true) == sys.props
+    assertTrue("A filter matching everything should not change the result", isUnchanged)
+  }
+
+  @Test
+  def empty(): Unit = {
+    val hasSize0 = sys.props.empty.size == 0
+    assertTrue("SystemProperties.empty should have size of 0", hasSize0)
+  }
+}
diff --git a/test/partest b/test/partest
index 6f14dfe1bc..07a5de12af 100755
--- a/test/partest
+++ b/test/partest
@@ -22,6 +22,14 @@ findScalaHome () {
 }
 
 # Use tput to detect color-capable terminal.
+# (note: I have found that on Cygwin, the script sometimes dies here.
+# it doesn't happen from the Cygwin prompt when ssh'ing in to
+# jenkins-worker-windows-publish, only when I make a Jenkins job
+# that runs this script.  I don't know why.  it may have to do with
+# which bash flags are set (-e? -x?) and with bash flags propagating
+# from one script to another? not sure. anyway, normally in a CI
+# context we run partest through ant, not through this script, so I'm
+# not investigating further for now.)
 term_colors=$(tput colors 2>/dev/null)
 if [[ $? == 0 ]] && [[ $term_colors -gt 2 ]]; then
   git_diff_options="--color=always --word-diff"
diff --git a/test/pending/jvm/constant-optimization/Foo_1.flags b/test/pending/jvm/constant-optimization/Foo_1.flags
new file mode 100644
index 0000000000..9691c0985d
--- /dev/null
+++ b/test/pending/jvm/constant-optimization/Foo_1.flags
@@ -0,0 +1 @@
+// constant otimization not there yet, -Yopt:nullness-tracking not enough.
diff --git a/test/files/jvm/constant-optimization/Foo_1.scala b/test/pending/jvm/constant-optimization/Foo_1.scala
index cb67ad4e90..6f408044d7 100644
--- a/test/files/jvm/constant-optimization/Foo_1.scala
+++ b/test/pending/jvm/constant-optimization/Foo_1.scala
@@ -1,6 +1,6 @@
 class Foo_1 {
   def foo() {
-  	// constant optimization should eliminate all branches
+	// constant optimization should eliminate all branches
     val i = 1
     val x = if (i != 1) null else "good"
     val y = if (x == null) "good" else x + ""
diff --git a/test/files/jvm/constant-optimization/Test.scala b/test/pending/jvm/constant-optimization/Test.scala
index dc0f8f6103..dc0f8f6103 100644
--- a/test/files/jvm/constant-optimization/Test.scala
+++ b/test/pending/jvm/constant-optimization/Test.scala
diff --git a/test/files/jvm/patmat_opt_ignore_underscore.check b/test/pending/jvm/patmat_opt_ignore_underscore.check
index 43f53aba12..43f53aba12 100644
--- a/test/files/jvm/patmat_opt_ignore_underscore.check
+++ b/test/pending/jvm/patmat_opt_ignore_underscore.check
diff --git a/test/pending/jvm/patmat_opt_ignore_underscore.flags b/test/pending/jvm/patmat_opt_ignore_underscore.flags
new file mode 100644
index 0000000000..453b6b7895
--- /dev/null
+++ b/test/pending/jvm/patmat_opt_ignore_underscore.flags
@@ -0,0 +1 @@
+-Yopt:l:project
\ No newline at end of file
diff --git a/test/files/jvm/patmat_opt_ignore_underscore/Analyzed_1.scala b/test/pending/jvm/patmat_opt_ignore_underscore/Analyzed_1.scala
index b0506018f6..b0506018f6 100644
--- a/test/files/jvm/patmat_opt_ignore_underscore/Analyzed_1.scala
+++ b/test/pending/jvm/patmat_opt_ignore_underscore/Analyzed_1.scala
diff --git a/test/files/jvm/patmat_opt_ignore_underscore/test.scala b/test/pending/jvm/patmat_opt_ignore_underscore/test.scala
index d6630e80a0..d6630e80a0 100644
--- a/test/files/jvm/patmat_opt_ignore_underscore/test.scala
+++ b/test/pending/jvm/patmat_opt_ignore_underscore/test.scala
diff --git a/test/files/jvm/patmat_opt_no_nullcheck.check b/test/pending/jvm/patmat_opt_no_nullcheck.check
index 43f53aba12..43f53aba12 100644
--- a/test/files/jvm/patmat_opt_no_nullcheck.check
+++ b/test/pending/jvm/patmat_opt_no_nullcheck.check
diff --git a/test/pending/jvm/patmat_opt_no_nullcheck.flags b/test/pending/jvm/patmat_opt_no_nullcheck.flags
new file mode 100644
index 0000000000..453b6b7895
--- /dev/null
+++ b/test/pending/jvm/patmat_opt_no_nullcheck.flags
@@ -0,0 +1 @@
+-Yopt:l:project
\ No newline at end of file
diff --git a/test/files/jvm/patmat_opt_no_nullcheck/Analyzed_1.scala b/test/pending/jvm/patmat_opt_no_nullcheck/Analyzed_1.scala
index 1e4d564cdf..1e4d564cdf 100644
--- a/test/files/jvm/patmat_opt_no_nullcheck/Analyzed_1.scala
+++ b/test/pending/jvm/patmat_opt_no_nullcheck/Analyzed_1.scala
diff --git a/test/pending/jvm/patmat_opt_no_nullcheck/test.scala b/test/pending/jvm/patmat_opt_no_nullcheck/test.scala
new file mode 100644
index 0000000000..5a4a398b67
--- /dev/null
+++ b/test/pending/jvm/patmat_opt_no_nullcheck/test.scala
@@ -0,0 +1,14 @@
+/*
+ * filter: inliner warning; re-run with
+ */
+import scala.tools.partest.{ BytecodeTest, ASMConverters }
+
+object Test extends BytecodeTest {
+  def show: Unit = {
+    val classNode = loadClassNode("SameBytecode")
+    // ASM and GenBCode assign variable slots slightly differently
+    val instrsA = ASMConverters.instructionsFromMethod(getMethod(classNode, "a"))
+    val instrsB = ASMConverters.instructionsFromMethod(getMethod(classNode, "b"))
+    assert(ASMConverters.equivalentBytecode(instrsA, instrsB), diffInstructions(instrsA, instrsB)) // doesn't work
+  }
+}
diff --git a/test/files/jvm/patmat_opt_primitive_typetest.check b/test/pending/jvm/patmat_opt_primitive_typetest.check
index 43f53aba12..43f53aba12 100644
--- a/test/files/jvm/patmat_opt_primitive_typetest.check
+++ b/test/pending/jvm/patmat_opt_primitive_typetest.check
diff --git a/test/pending/jvm/patmat_opt_primitive_typetest.flags b/test/pending/jvm/patmat_opt_primitive_typetest.flags
new file mode 100644
index 0000000000..19c578e4ad
--- /dev/null
+++ b/test/pending/jvm/patmat_opt_primitive_typetest.flags
@@ -0,0 +1 @@
+-Yopt:l:project
diff --git a/test/files/jvm/patmat_opt_primitive_typetest/Analyzed_1.scala b/test/pending/jvm/patmat_opt_primitive_typetest/Analyzed_1.scala
index c961082fa7..c961082fa7 100644
--- a/test/files/jvm/patmat_opt_primitive_typetest/Analyzed_1.scala
+++ b/test/pending/jvm/patmat_opt_primitive_typetest/Analyzed_1.scala
diff --git a/test/files/jvm/patmat_opt_primitive_typetest/test.scala b/test/pending/jvm/patmat_opt_primitive_typetest/test.scala
index 2927e763d5..2927e763d5 100644
--- a/test/files/jvm/patmat_opt_primitive_typetest/test.scala
+++ b/test/pending/jvm/patmat_opt_primitive_typetest/test.scala
diff --git a/test/files/jvm/t7006.check b/test/pending/jvm/t7006.check
index 6294b14d62..6294b14d62 100644
--- a/test/files/jvm/t7006.check
+++ b/test/pending/jvm/t7006.check
diff --git a/test/pending/jvm/t7006/Foo_1.flags b/test/pending/jvm/t7006/Foo_1.flags
new file mode 100644
index 0000000000..5d1b6b2644
--- /dev/null
+++ b/test/pending/jvm/t7006/Foo_1.flags
@@ -0,0 +1 @@
+-Yopt:l:project -Ydebug -Xfatal-warnings
diff --git a/test/files/jvm/t7006/Foo_1.scala b/test/pending/jvm/t7006/Foo_1.scala
index 3985557d9f..3985557d9f 100644
--- a/test/files/jvm/t7006/Foo_1.scala
+++ b/test/pending/jvm/t7006/Foo_1.scala
diff --git a/test/files/jvm/t7006/Test.scala b/test/pending/jvm/t7006/Test.scala
index 065a23510e..7b4a8c45fb 100644
--- a/test/files/jvm/t7006/Test.scala
+++ b/test/pending/jvm/t7006/Test.scala
@@ -7,8 +7,10 @@ object Test extends BytecodeTest {
   def show: Unit = {
     val classNode = loadClassNode("Foo_1")
     val methodNode = getMethod(classNode, "foo")
-    assert(count(methodNode.instructions, asm.Opcodes.NOP) == 0)
-    assert(count(methodNode.instructions, asm.Opcodes.GOTO) == 1)
+    val nopCount  = count(methodNode.instructions, asm.Opcodes.NOP)
+    val gotoCount = count(methodNode.instructions, asm.Opcodes.GOTO)
+    assert(nopCount  == 0, s"NOPs  expected: 0, actual: $nopCount")
+    assert(gotoCount == 1, s"GOTOs expected: 1, actual: $gotoCount")
   }
 
   def count(insnList: InsnList, opcode: Int): Int = {
diff --git a/test/pending/pos/inliner2.flags b/test/pending/pos/inliner2.flags
new file mode 100644
index 0000000000..4bf93a9c2a
--- /dev/null
+++ b/test/pending/pos/inliner2.flags
@@ -0,0 +1,35 @@
+-optimise -Ybackend:GenASM -Xfatal-warnings
+/*
+This is what we get with 2.11.2-M3 and -Yopt:l:project:
+
+  public final int bob1();
+    Code:
+       0: aload_0
+       1: aload_0
+       2: astore        6
+       4: aload         6
+       6: invokedynamic #62,  0             // InvokeDynamic #0:apply$mcZ$sp:(LA;)Lscala/runtime/java8/JFunction0$mcZ$sp;
+      11: checkcast     #29                 // class scala/Function0
+      14: invokedynamic #71,  0             // InvokeDynamic #1:apply$mcI$sp:()Lscala/runtime/java8/JFunction0$mcI$sp;
+      19: checkcast     #29                 // class scala/Function0
+      22: invokedynamic #76,  0             // InvokeDynamic #2:apply$mcI$sp:()Lscala/runtime/java8/JFunction0$mcI$sp;
+      27: checkcast     #29                 // class scala/Function0
+      30: astore        4
+      32: astore_3
+      33: astore_2
+      34: astore_1
+      35: aload_2
+      36: pop
+      37: aload         6
+      39: invokevirtual #53                 // Method A$$$anonfun$1:()Z
+      42: ifeq          54
+      45: aload_3
+      46: invokeinterface #36,  1           // InterfaceMethod scala/Function0.apply:()Ljava/lang/Object;
+      51: goto          61
+      54: aload         4
+      56: invokeinterface #36,  1           // InterfaceMethod scala/Function0.apply:()Ljava/lang/Object;
+      61: astore        5
+      63: aload         5
+      65: invokestatic  #82                 // Method scala/runtime/BoxesRunTime.unboxToInt:(Ljava/lang/Object;)I
+      68: ireturn
+*/
\ No newline at end of file
diff --git a/test/files/pos/inliner2.scala b/test/pending/pos/inliner2.scala
index bc83e04312..bc83e04312 100644
--- a/test/files/pos/inliner2.scala
+++ b/test/pending/pos/inliner2.scala
diff --git a/test/pending/pos/sealed-final.flags b/test/pending/pos/sealed-final.flags
new file mode 100644
index 0000000000..63d024a0ba
--- /dev/null
+++ b/test/pending/pos/sealed-final.flags
@@ -0,0 +1,41 @@
+-Xfatal-warnings -Yinline-warnings -Ybackend:GenASM -optimise
+/*
+The new flag settings could be
+  -Yopt-warnings -Yopt:l:project
+
+The issue here is that things are being inlined, but a lot of
+redundant load/store instructions are left behind:
+
+2.11.7:
+
+  public int f();
+    Code:
+       0: getstatic     #19                 // Field Foo$.MODULE$:LFoo$;
+       3: invokevirtual #23                 // Method Foo$.mkFoo:()LFoo;
+       6: pop
+       7: bipush        10
+       9: iconst_1
+      10: iadd
+      11: ireturn
+
+
+2.12.0-M3:
+
+  public int f();
+    Code:
+       0: getstatic     #19                 // Field Foo$.MODULE$:LFoo$;
+       3: invokevirtual #23                 // Method Foo$.mkFoo:()LFoo;
+       6: bipush        10
+       8: istore_2
+       9: dup
+      10: ifnonnull     15
+      13: aconst_null
+      14: athrow
+      15: astore_1
+      16: iload_2
+      17: iconst_1
+      18: iadd
+      19: istore_3
+      20: iload_3
+      21: ireturn
+*/
\ No newline at end of file
diff --git a/test/files/pos/sealed-final.scala b/test/pending/pos/sealed-final.scala
index bdedb5c1f6..bdedb5c1f6 100644
--- a/test/files/pos/sealed-final.scala
+++ b/test/pending/pos/sealed-final.scala
diff --git a/test/files/run/inline-ex-handlers.check b/test/pending/run/inline-ex-handlers.check
index 36fc2eefa4..fce32771b4 100644
--- a/test/files/run/inline-ex-handlers.check
+++ b/test/pending/run/inline-ex-handlers.check
@@ -7,7 +7,7 @@
    startBlock: 1
 -  blocks: [1,2,3,4]
 +  blocks: [1,3,4]
-   
+
 @@ -186,2 +186,4 @@
      92	LOAD_LOCAL(value x$1)
 +    92	STORE_LOCAL(variable boxed1)
@@ -16,19 +16,19 @@
 @@ -194,5 +196,2 @@
      92	CALL_METHOD MyException.message (dynamic)
 -    92	JUMP 2
--    
--  2: 
+-
+-  2:
      92	RETURN(REF(class Object))
 @@ -246,3 +245,3 @@
    startBlock: 1
 -  blocks: [1,2,3,4,5,6,7,8,11,12,13,14,15,16,17,18]
 +  blocks: [1,2,3,4,5,6,8,11,12,13,14,15,16,17,18]
-   
+
 @@ -257,5 +256,2 @@
      92	SCOPE_ENTER value x1
 -    92	JUMP 7
--    
--  7: 
+-
+-  7:
      92	LOAD_LOCAL(value x1)
 @@ -408,5 +404,5 @@
    def main(args: Array[String] (ARRAY[REF(class String)])): Unit {
@@ -37,27 +37,27 @@
    startBlock: 1
 -  blocks: [1,2,3,4,5,8,10,11,13]
 +  blocks: [1,2,3,5,8,10,11,13,14]
-   
+
 @@ -434,4 +430,13 @@
      103	CALL_METHOD MyException.<init> (static-instance)
 -    103	THROW(MyException)
 +    ?	STORE_LOCAL(value ex6)
 +    ?	JUMP 14
-     
-+  14: 
+
++  14:
 +    101	LOAD_LOCAL(value ex6)
 +    101	STORE_LOCAL(value x4)
 +    101	SCOPE_ENTER value x4
 +    106	LOAD_LOCAL(value x4)
 +    106	IS_INSTANCE REF(class MyException)
 +    106	CZJUMP (BOOL)NE ? 5 : 8
-+    
-   13: 
++
+   13:
 @@ -447,5 +452,2 @@
      101	SCOPE_ENTER value x4
 -    101	JUMP 4
--    
--  4: 
+-
+-  4:
      106	LOAD_LOCAL(value x4)
 @@ -459,8 +461,5 @@
      106	SCOPE_ENTER value x5
@@ -74,43 +74,43 @@
    startBlock: 1
 -  blocks: [1,2,3,4,6,7,9,10]
 +  blocks: [1,3,4,6,7,9,10,11,12,13]
-   
+
 @@ -565,4 +564,9 @@
      306	CALL_METHOD MyException.<init> (static-instance)
 -    306	THROW(MyException)
 +    ?	JUMP 11
-     
-+  11: 
+
++  11:
 +    ?	LOAD_LOCAL(variable monitor4)
 +    305	MONITOR_EXIT
 +    ?	JUMP 12
-+    
-   9: 
++
+   9:
 @@ -571,3 +575,3 @@
      305	MONITOR_EXIT
 -    ?	THROW(Throwable)
 +    ?	JUMP 12
-     
+
 @@ -577,4 +581,11 @@
      304	MONITOR_EXIT
 -    ?	THROW(Throwable)
 +    ?	STORE_LOCAL(value t)
 +    ?	JUMP 13
-     
-+  12: 
+
++  12:
 +    ?	LOAD_LOCAL(variable monitor3)
 +    304	MONITOR_EXIT
 +    ?	STORE_LOCAL(value t)
 +    ?	JUMP 13
-+    
-   3: 
++
+   3:
 @@ -591,5 +602,14 @@
      310	CALL_METHOD scala.Predef.println (dynamic)
 -    310	JUMP 2
 +    300	RETURN(UNIT)
-     
--  2: 
-+  13: 
+
+-  2:
++  13:
 +    310	LOAD_MODULE object Predef
 +    310	CALL_PRIMITIVE(StartConcat)
 +    310	CONSTANT("Caught crash: ")
@@ -134,28 +134,28 @@
    startBlock: 1
 -  blocks: [1,3,4,5,6,8,9]
 +  blocks: [1,3,4,5,6,8,9,10,11]
-   
+
 @@ -660,4 +680,10 @@
      78	CALL_METHOD java.lang.IllegalArgumentException.<init> (static-instance)
 -    78	THROW(IllegalArgumentException)
 +    ?	STORE_LOCAL(value e)
 +    ?	JUMP 10
-     
-+  10: 
+
++  10:
 +    81	LOAD_LOCAL(value e)
 +    ?	STORE_LOCAL(variable exc1)
 +    ?	JUMP 11
-+    
-   8: 
++
+   8:
 @@ -686,3 +712,4 @@
      81	LOAD_LOCAL(value e)
 -    81	THROW(Exception)
 +    ?	STORE_LOCAL(variable exc1)
 +    ?	JUMP 11
-     
+
 @@ -703,2 +730,15 @@
-     
-+  11: 
+
++  11:
 +    83	LOAD_MODULE object Predef
 +    83	CONSTANT("finally")
 +    83	CALL_METHOD scala.Predef.println (dynamic)
@@ -167,7 +167,7 @@
 +    84	STORE_LOCAL(variable result)
 +    84	LOAD_LOCAL(variable exc1)
 +    84	THROW(Throwable)
-+    
++
    }
 @@ -708,3 +748,3 @@
        with finalizer: null
@@ -181,20 +181,20 @@
    startBlock: 1
 -  blocks: [1,3,4,5,6,9,13,14,15,18,20,21,23,24]
 +  blocks: [1,3,4,5,6,9,13,14,15,18,20,21,23,24,25,26,27]
-   
+
 @@ -758,4 +798,11 @@
      172	CALL_METHOD MyException.<init> (static-instance)
 -    172	THROW(MyException)
 +    ?	STORE_LOCAL(value ex6)
 +    ?	JUMP 25
-     
-+  25: 
+
++  25:
 +    170	LOAD_LOCAL(value ex6)
 +    170	STORE_LOCAL(value x4)
 +    170	SCOPE_ENTER value x4
 +    170	JUMP 14
-+    
-   23: 
++
+   23:
 @@ -798,8 +845,5 @@
      175	SCOPE_ENTER value x5
 -    175	LOAD_LOCAL(value x5)
@@ -215,22 +215,22 @@
 -    177	THROW(MyException)
 +    ?	STORE_LOCAL(value ex6)
 +    ?	JUMP 26
-     
+
 @@ -813,3 +859,4 @@
      170	LOAD_LOCAL(value ex6)
 -    170	THROW(Throwable)
 +    ?	STORE_LOCAL(value ex6)
 +    ?	JUMP 26
-     
+
 @@ -823,2 +870,8 @@
-     
-+  26: 
+
++  26:
 +    169	LOAD_LOCAL(value ex6)
 +    169	STORE_LOCAL(value x4)
 +    169	SCOPE_ENTER value x4
 +    169	JUMP 5
-+    
-   5: 
++
+   5:
 @@ -833,8 +886,5 @@
      180	SCOPE_ENTER value x5
 -    180	LOAD_LOCAL(value x5)
@@ -251,16 +251,16 @@
 -    182	THROW(MyException)
 +    ?	STORE_LOCAL(variable exc2)
 +    ?	JUMP 27
-     
+
 @@ -848,3 +900,4 @@
      169	LOAD_LOCAL(value ex6)
 -    169	THROW(Throwable)
 +    ?	STORE_LOCAL(variable exc2)
 +    ?	JUMP 27
-     
+
 @@ -865,2 +918,15 @@
-     
-+  27: 
+
++  27:
 +    184	LOAD_MODULE object Predef
 +    184	CONSTANT("finally")
 +    184	CALL_METHOD scala.Predef.println (dynamic)
@@ -272,7 +272,7 @@
 +    185	STORE_LOCAL(variable result)
 +    185	LOAD_LOCAL(variable exc2)
 +    185	THROW(Throwable)
-+    
++
    }
 @@ -870,6 +936,6 @@
        with finalizer: null
@@ -290,20 +290,20 @@
    startBlock: 1
 -  blocks: [1,2,3,6,7,8,11,13,14,16]
 +  blocks: [1,2,3,6,7,8,11,13,14,16,17]
-   
+
 @@ -923,4 +989,11 @@
      124	CALL_METHOD MyException.<init> (static-instance)
 -    124	THROW(MyException)
 +    ?	STORE_LOCAL(value ex6)
 +    ?	JUMP 17
-     
-+  17: 
+
++  17:
 +    122	LOAD_LOCAL(value ex6)
 +    122	STORE_LOCAL(value x4)
 +    122	SCOPE_ENTER value x4
 +    122	JUMP 7
-+    
-   16: 
++
+   16:
 @@ -948,8 +1021,5 @@
      127	SCOPE_ENTER value x5
 -    127	LOAD_LOCAL(value x5)
@@ -327,27 +327,27 @@
    startBlock: 1
 -  blocks: [1,2,3,4,5,8,12,13,14,16]
 +  blocks: [1,2,3,5,8,12,13,14,16,17]
-   
+
 @@ -1032,4 +1102,13 @@
      148	CALL_METHOD MyException.<init> (static-instance)
 -    148	THROW(MyException)
 +    ?	STORE_LOCAL(value ex6)
 +    ?	JUMP 17
-     
-+  17: 
+
++  17:
 +    145	LOAD_LOCAL(value ex6)
 +    145	STORE_LOCAL(value x4)
 +    145	SCOPE_ENTER value x4
 +    154	LOAD_LOCAL(value x4)
 +    154	IS_INSTANCE REF(class MyException)
 +    154	CZJUMP (BOOL)NE ? 5 : 8
-+    
-   16: 
++
+   16:
 @@ -1053,5 +1132,2 @@
      145	SCOPE_ENTER value x4
 -    145	JUMP 4
--    
--  4: 
+-
+-  4:
      154	LOAD_LOCAL(value x4)
 @@ -1065,8 +1141,5 @@
      154	SCOPE_ENTER value x5
@@ -364,20 +364,20 @@
    startBlock: 1
 -  blocks: [1,2,3,4,5,7]
 +  blocks: [1,2,3,4,5,7,8]
-   
+
 @@ -1311,4 +1384,11 @@
      38	CALL_METHOD java.lang.IllegalArgumentException.<init> (static-instance)
 -    38	THROW(IllegalArgumentException)
 +    ?	STORE_LOCAL(value e)
 +    ?	JUMP 8
-     
-+  8: 
+
++  8:
 +    42	LOAD_MODULE object Predef
 +    42	CONSTANT("IllegalArgumentException")
 +    42	CALL_METHOD scala.Predef.println (dynamic)
 +    42	JUMP 2
-+    
-   7: 
++
+   7:
 @@ -1358,5 +1438,5 @@
    def main(args: Array[String] (ARRAY[REF(class String)])): Unit {
 -  locals: value args, variable result, value ex6, value x4, value x5, value message, value x
@@ -385,33 +385,33 @@
    startBlock: 1
 -  blocks: [1,2,3,4,5,8,10,11,13,14,16]
 +  blocks: [1,2,3,5,8,10,11,13,14,16,17]
-   
+
 @@ -1384,3 +1464,4 @@
      203	CALL_METHOD MyException.<init> (static-instance)
 -    203	THROW(MyException)
 +    ?	STORE_LOCAL(value ex6)
 +    ?	JUMP 17
-     
+
 @@ -1404,4 +1485,13 @@
      209	CALL_METHOD MyException.<init> (static-instance)
 -    209	THROW(MyException)
 +    ?	STORE_LOCAL(value ex6)
 +    ?	JUMP 17
-     
-+  17: 
+
++  17:
 +    200	LOAD_LOCAL(value ex6)
 +    200	STORE_LOCAL(value x4)
 +    200	SCOPE_ENTER value x4
 +    212	LOAD_LOCAL(value x4)
 +    212	IS_INSTANCE REF(class MyException)
 +    212	CZJUMP (BOOL)NE ? 5 : 8
-+    
-   16: 
++
+   16:
 @@ -1417,5 +1507,2 @@
      200	SCOPE_ENTER value x4
 -    200	JUMP 4
--    
--  4: 
+-
+-  4:
      212	LOAD_LOCAL(value x4)
 @@ -1429,8 +1516,5 @@
      212	SCOPE_ENTER value x5
@@ -428,41 +428,41 @@
    startBlock: 1
 -  blocks: [1,2,3,4,5,7]
 +  blocks: [1,2,3,4,5,7,8]
-   
+
 @@ -1502,4 +1586,11 @@
      58	CALL_METHOD java.lang.IllegalArgumentException.<init> (static-instance)
 -    58	THROW(IllegalArgumentException)
 +    ?	STORE_LOCAL(value e)
 +    ?	JUMP 8
-     
-+  8: 
+
++  8:
 +    62	LOAD_MODULE object Predef
 +    62	CONSTANT("RuntimeException")
 +    62	CALL_METHOD scala.Predef.println (dynamic)
 +    62	JUMP 2
-+    
-   7: 
++
+   7:
 @@ -1551,3 +1642,3 @@
    startBlock: 1
 -  blocks: [1,3,4]
 +  blocks: [1,3,4,5]
-   
+
 @@ -1571,4 +1662,9 @@
      229	CALL_METHOD MyException.<init> (static-instance)
 -    229	THROW(MyException)
 +    ?	JUMP 5
-     
-+  5: 
+
++  5:
 +    ?	LOAD_LOCAL(variable monitor1)
 +    228	MONITOR_EXIT
 +    228	THROW(Throwable)
-+    
-   3: 
++
+   3:
 @@ -1577,3 +1673,3 @@
      228	MONITOR_EXIT
 -    ?	THROW(Throwable)
 +    228	THROW(Throwable)
-     
+
 @@ -1605,5 +1701,5 @@
    def main(args: Array[String] (ARRAY[REF(class String)])): Unit {
 -  locals: value args, variable result, variable monitor2, variable monitorResult1
@@ -470,7 +470,7 @@
    startBlock: 1
 -  blocks: [1,3,4]
 +  blocks: [1,3,4,5]
-   
+
 @@ -1630,4 +1726,12 @@
      245	CALL_METHOD MyException.<init> (static-instance)
 -    245	THROW(MyException)
@@ -478,15 +478,14 @@
 +    ?	DROP ConcatClass
 +    ?	LOAD_LOCAL(value exception$1)
 +    ?	JUMP 5
-     
-+  5: 
+
++  5:
 +    ?	LOAD_LOCAL(variable monitor2)
 +    244	MONITOR_EXIT
 +    244	THROW(Throwable)
-+    
-   3: 
++
+   3:
 @@ -1636,3 +1740,3 @@
      244	MONITOR_EXIT
 -    ?	THROW(Throwable)
 +    244	THROW(Throwable)
-     
diff --git a/test/files/run/inline-ex-handlers.scala b/test/pending/run/inline-ex-handlers.scala
index 4095d54e36..964594d258 100644
--- a/test/files/run/inline-ex-handlers.scala
+++ b/test/pending/run/inline-ex-handlers.scala
@@ -1,7 +1,7 @@
 import scala.tools.partest.IcodeComparison
 
 object Test extends IcodeComparison {
-  override def printIcodeAfterPhase = "inlinehandlers"; override def extraSettings: String = super.extraSettings + " -Ybackend:GenASM" // same line to minimize check file changs
+  override def printIcodeAfterPhase = "inlinehandlers"
 }
 
 import scala.util.Random._
diff --git a/test/files/run/t5313.check b/test/pending/run/t5313.check
index 7a48b2b711..7a48b2b711 100644
--- a/test/files/run/t5313.check
+++ b/test/pending/run/t5313.check
diff --git a/test/files/run/t5313.scala b/test/pending/run/t5313.scala
index 24ed334816..4a5b076e6e 100644
--- a/test/files/run/t5313.scala
+++ b/test/pending/run/t5313.scala
@@ -3,7 +3,7 @@ import scala.tools.partest.IcodeComparison
 object Test extends IcodeComparison {
   override def printIcodeAfterPhase = "dce"
 
-  override def extraSettings: String = super.extraSettings + " -optimize -Ybackend:GenASM"
+  override def extraSettings: String = super.extraSettings + " -Yopt:l:classpath"
 
   override def code =
     """class Foo {
diff --git a/test/files/run/t6955.scala b/test/pending/run/t6955.scala
index 9ee3ef6bc5..787617eff1 100644
--- a/test/files/run/t6955.scala
+++ b/test/pending/run/t6955.scala
@@ -21,8 +21,6 @@ class Switches {
 }
 
 object Test extends IcodeComparison {
-  override def extraSettings: String = super.extraSettings + " -Ybackend:GenASM"
-
   // ensure we get two switches out of this -- ignore the rest of the output for robustness
   // exclude the constant we emit for the "SWITCH ..." string below (we get the icode for all the code you see in this file)
   override def show() = {
@@ -30,7 +28,6 @@ object Test extends IcodeComparison {
     val actual = (collectIcode() filter {
       x => x.indexOf("SWITCH ...") >= 0 && x.indexOf("CONSTANT(") == -1
     }).size
-    assert(actual == expected)
+    assert(actual == expected, s"switches expected: $expected, actual: $actual")
   }
 }
-
diff --git a/test/files/run/t6956.scala b/test/pending/run/t6956.scala
index 594f5c9194..57d721807d 100644
--- a/test/files/run/t6956.scala
+++ b/test/pending/run/t6956.scala
@@ -19,8 +19,6 @@ class Switches {
 }
 
 object Test extends IcodeComparison {
-  override def extraSettings: String = super.extraSettings + " -Ybackend:GenASM"
-
   // ensure we get two switches out of this -- ignore the rest of the output for robustness
   // exclude the constant we emit for the "SWITCH ..." string below (we get the icode for all the code you see in this file)
   override def show() = {
@@ -28,6 +26,6 @@ object Test extends IcodeComparison {
     val actual = (collectIcode() filter {
       x => x.indexOf("SWITCH ...") >= 0 && x.indexOf("CONSTANT(") == -1
     }).size
-    assert(actual == expected)
+    assert(actual == expected, s"switches expected: $expected, actual: $actual")
   }
 }
diff --git a/test/files/run/test-cpp.check b/test/pending/run/test-cpp.check
index 40c10e3350..ff4c9bf2bf 100644
--- a/test/files/run/test-cpp.check
+++ b/test/pending/run/test-cpp.check
@@ -6,7 +6,7 @@
 +  locals: value args
    startBlock: 1
 @@ -59,10 +59,6 @@
-   1: 
+   1:
 -    52	CONSTANT(2)
 -    52	STORE_LOCAL(value x)
      52	SCOPE_ENTER value x
@@ -37,7 +37,7 @@
 +  locals: value args
    startBlock: 1
 @@ -157,10 +151,6 @@
-   1: 
+   1:
 -    66	THIS(TestAliasChainDerefThis)
 -    66	STORE_LOCAL(value x)
      66	SCOPE_ENTER value x
@@ -54,7 +54,7 @@
 +  locals: value x
    startBlock: 1
 @@ -198,7 +188,5 @@
-   1: 
+   1:
 -    29	LOAD_LOCAL(value x)
 -    29	STORE_LOCAL(value y)
      29	SCOPE_ENTER value y
diff --git a/test/files/run/test-cpp.scala b/test/pending/run/test-cpp.scala
index 80163deb66..4fca67d51e 100644
--- a/test/files/run/test-cpp.scala
+++ b/test/pending/run/test-cpp.scala
@@ -15,7 +15,7 @@
 import scala.tools.partest.IcodeComparison
 
 object Test extends IcodeComparison {
-  override def printIcodeAfterPhase = "dce"; override def extraSettings: String = super.extraSettings + " -Ybackend:GenASM" // same line to minimize check file changs
+  override def printIcodeAfterPhase = "dce"
 }
 
 import scala.util.Random._
diff --git a/test/scaladoc/javascript/test-index.html b/test/scaladoc/javascript/test-index.html
index 42cbc8cc09..91756b5be1 100644
--- a/test/scaladoc/javascript/test-index.html
+++ b/test/scaladoc/javascript/test-index.html
@@ -6,7 +6,6 @@
             src="http://code.jquery.com/qunit/git/qunit.js"></script>
     <script type="text/javascript"
             src="../../../src/compiler/scala/tools/nsc/doc/html/resource/lib/jquery.js"></script>
-    <script src="../../../src/compiler/scala/tools/nsc/doc/html/resource/lib/jquery.layout.js"></script>
     <script src="../../../src/compiler/scala/tools/nsc/doc/html/resource/lib/scheduler.js"></script>
     <script type="text/javascript"
             src="../../../src/compiler/scala/tools/nsc/doc/html/resource/lib/index.js"></script>
diff --git a/test/scaladoc/resources/links.scala b/test/scaladoc/resources/links.scala
index ecac9c63cf..8e000ab979 100644
--- a/test/scaladoc/resources/links.scala
+++ b/test/scaladoc/resources/links.scala
@@ -1,6 +1,6 @@
 // that would be:
 // SI-5079 "Scaladoc can't link to an object (only a class or trait)"
-// SI-4497 "Links in ScalaDoc - Spec and implementation unsufficient"
+// SI-4497 "Links in Scaladoc - Spec and implementation unsufficient"
 // SI-4224 "Wiki-links should support method targets"
 // SI-3695 "support non-fully-qualified type links in scaladoc comments"
 // SI-6487 "Scaladoc can't link to inner classes"
diff --git a/test/scaladoc/run/links.scala b/test/scaladoc/run/links.scala
index 64441c2d95..01db66aec3 100644
--- a/test/scaladoc/run/links.scala
+++ b/test/scaladoc/run/links.scala
@@ -3,7 +3,7 @@ import scala.tools.nsc.doc.model._
 import scala.tools.partest.ScaladocModelTest
 
 // SI-5079 "Scaladoc can't link to an object (only a class or trait)"
-// SI-4497 "Links in ScalaDoc - Spec and implementation unsufficient"
+// SI-4497 "Links in Scaladoc - Spec and implementation unsufficient"
 // SI-4224 "Wiki-links should support method targets"
 // SI-3695 "support non-fully-qualified type links in scaladoc comments"
 // SI-6487 "Scaladoc can't link to inner classes"
diff --git a/tools/get-scala-commit-date.bat b/tools/get-scala-commit-date.bat
index e169de1b04..735a80b927 100644
--- a/tools/get-scala-commit-date.bat
+++ b/tools/get-scala-commit-date.bat
@@ -1,9 +1,9 @@
 @echo off
 for %%X in (bash.exe) do (set FOUND=%%~$PATH:X)
 if defined FOUND (
-  bash "%~dp0\get-scala-commit-date"
+  bash "%~dp0\get-scala-commit-date" 2>NUL
 ) else (
   rem echo this script does not work with cmd.exe. please, install bash
   echo unknown
   exit 1
-)
\ No newline at end of file
+)
diff --git a/tools/get-scala-commit-sha.bat b/tools/get-scala-commit-sha.bat
index 1eaffc0a15..6559a19120 100644
--- a/tools/get-scala-commit-sha.bat
+++ b/tools/get-scala-commit-sha.bat
@@ -1,9 +1,9 @@
 @echo off
 for %%X in (bash.exe) do (set FOUND=%%~$PATH:X)
 if defined FOUND (
-  bash "%~dp0\get-scala-commit-sha"
+  bash "%~dp0\get-scala-commit-sha" 2>NUL
 ) else (
   rem echo this script does not work with cmd.exe. please, install bash
   echo unknown
   exit 1
-)
\ No newline at end of file
+)