diff --git a/build.gradle b/build.gradle
index ec53231..2671227 100644
--- a/build.gradle
+++ b/build.gradle
@@ -472,9 +472,11 @@
         // Default disable errorprone (enabled and setup below).
         options.errorprone.enabled = false
         options.compilerArgs << '-Xlint:unchecked'
+        // Run all compilation tasks in a forked subprocess.
+        options.fork = true
         // Javac often runs out of stack space when compiling the tests.
         // Increase the stack size for the javac process.
-        options.forkOptions.jvmArgs << "-Xss8m"
+        options.forkOptions.jvmArgs << "-Xss4m"
         // Set the bootclass path so compilation is consistent with 1.8 target compatibility.
         options.forkOptions.jvmArgs << "-Xbootclasspath/a:third_party/openjdk/openjdk-rt-1.8/rt.jar"
     }
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 2d19d9d..4f472c6 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -615,15 +615,17 @@
         new DiscardedChecker(rootSet, application, options).run();
       }
 
-      timing.begin("Minification");
-      // If we did not have keep rules, everything will be marked as keep, so no minification
-      // will happen. Just avoid the overhead.
-      NamingLens namingLens =
-          options.enableMinification
-              ? new Minifier(appView.appInfo().withLiveness(), rootSet, desugaredCallSites, options)
-                  .run(timing)
-              : NamingLens.getIdentityLens();
-      timing.end();
+      // Perform minification.
+      NamingLens namingLens;
+      if (options.enableMinification) {
+        timing.begin("Minification");
+        namingLens =
+            new Minifier(appView.appInfo().withLiveness(), rootSet, desugaredCallSites, options)
+                .run(timing);
+        timing.end();
+      } else {
+        namingLens = NamingLens.getIdentityLens();
+      }
 
       ProguardMapSupplier proguardMapSupplier;
 
diff --git a/src/main/java/com/android/tools/r8/code/InstructionFactory.java b/src/main/java/com/android/tools/r8/code/InstructionFactory.java
index 14d2f4b..83b0570 100644
--- a/src/main/java/com/android/tools/r8/code/InstructionFactory.java
+++ b/src/main/java/com/android/tools/r8/code/InstructionFactory.java
@@ -4,7 +4,6 @@
 package com.android.tools.r8.code;
 
 import com.android.tools.r8.graph.OffsetToObjectMapping;
-import java.nio.ByteBuffer;
 import java.nio.ShortBuffer;
 import java.util.ArrayList;
 import java.util.List;
@@ -18,11 +17,6 @@
     return create(high, opcode, stream, mapping);
   }
 
-  public Instruction[] readSequenceFrom(ByteBuffer buffer, int startIndex, int length,
-      OffsetToObjectMapping mapping) {
-    return readSequenceFrom(buffer.asShortBuffer(), startIndex, length, mapping);
-  }
-
   public Instruction[] readSequenceFrom(ShortBuffer buffer, int startIndex, int length,
       OffsetToObjectMapping mapping) {
     ShortBufferBytecodeStream range =
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
index 825846e..26398d8 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationWriter.java
@@ -281,7 +281,7 @@
                     }
                     // Release use of the backing buffer now that accept has returned.
                     data.invalidate();
-                    byteBufferProvider.releaseByteBuffer(result.buffer);
+                    byteBufferProvider.releaseByteBuffer(result.buffer.asByteBuffer());
                     return true;
                   }));
         }
diff --git a/src/main/java/com/android/tools/r8/dex/BinaryReader.java b/src/main/java/com/android/tools/r8/dex/BinaryReader.java
index 5d51238..dd1cfee 100644
--- a/src/main/java/com/android/tools/r8/dex/BinaryReader.java
+++ b/src/main/java/com/android/tools/r8/dex/BinaryReader.java
@@ -10,14 +10,13 @@
 import com.android.tools.r8.utils.LebUtils;
 import com.android.tools.r8.utils.StreamUtils;
 import java.io.IOException;
-import java.nio.ByteBuffer;
 
 /**
  * Base class for reading binary content.
  */
 public abstract class BinaryReader {
   protected final Origin origin;
-  protected final ByteBuffer buffer;
+  protected final CompatByteBuffer buffer;
 
   protected BinaryReader(ProgramResource resource) throws ResourceException, IOException {
     this(resource.getOrigin(), StreamUtils.StreamToByteArrayClose(resource.getByteStream()));
@@ -26,7 +25,7 @@
   protected BinaryReader(Origin origin, byte[] bytes) {
     assert origin != null;
     this.origin = origin;
-    buffer = ByteBuffer.wrap(bytes);
+    buffer = CompatByteBuffer.wrap(bytes);
   }
 
   public Origin getOrigin() {
diff --git a/src/main/java/com/android/tools/r8/dex/CompatByteBuffer.java b/src/main/java/com/android/tools/r8/dex/CompatByteBuffer.java
new file mode 100644
index 0000000..6e32c6e
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/dex/CompatByteBuffer.java
@@ -0,0 +1,135 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.dex;
+
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+
+/**
+ * In JDK 9 ByteBuffer ByteBuffer.position(int) started overriding Buffer Buffer.position(int) along
+ * with various other methods defined on java.nio.Buffer. To avoid issues with running R8 on JDK 8
+ * we internally wrap any use of ByteBuffer and make sure access to the overridden methods happens
+ * only at the super type Buffer which is known to be in both JDKs.
+ */
+public class CompatByteBuffer {
+
+  private final ByteBuffer buffer;
+
+  public CompatByteBuffer(ByteBuffer buffer) {
+    this.buffer = buffer;
+  }
+
+  public static CompatByteBuffer wrap(byte[] bytes) {
+    return new CompatByteBuffer(ByteBuffer.wrap(bytes));
+  }
+
+  private Buffer asBuffer() {
+    return buffer;
+  }
+
+  public ByteBuffer asByteBuffer() {
+    return buffer;
+  }
+
+  // ----------------------------------------------------------------------------------------------
+  // 1.8 compatible calls to java.nio.Buffer methods.
+  // ----------------------------------------------------------------------------------------------
+
+  // The position(int) became overridden with a ByteBuffer return value.
+  public void position(int newPosition) {
+    asBuffer().position(newPosition);
+  }
+
+  // The rewind() became overridden with a ByteBuffer return value.
+  public void rewind() {
+    asBuffer().rewind();
+  }
+
+  // ----------------------------------------------------------------------------------------------
+  // Methods on java.nio.Buffer that are safely overridden or not non-overridden.
+  // ----------------------------------------------------------------------------------------------
+
+  // Note: array() overrides Buffer.array() in JDK 8 too, so that is safe for JDK 8 and 9.
+  public byte[] array() {
+    return asByteBuffer().array();
+  }
+
+  public int arrayOffset() {
+    return asByteBuffer().arrayOffset();
+  }
+
+  public int capacity() {
+    return asByteBuffer().capacity();
+  }
+
+  public boolean hasArray() {
+    return asByteBuffer().hasArray();
+  }
+
+  public boolean hasRemaining() {
+    return asByteBuffer().hasRemaining();
+  }
+
+  public int position() {
+    return asByteBuffer().position();
+  }
+
+  public int remaining() {
+    return asByteBuffer().remaining();
+  }
+
+  // ----------------------------------------------------------------------------------------------
+  // Methods on java.nio.ByteBuffer.
+  // ----------------------------------------------------------------------------------------------
+
+  public ShortBuffer asShortBuffer() {
+    return asByteBuffer().asShortBuffer();
+  }
+
+  public void order(ByteOrder bo) {
+    asByteBuffer().order(bo);
+  }
+
+  public byte get() {
+    return asByteBuffer().get();
+  }
+
+  public byte get(int index) {
+    return asByteBuffer().get(index);
+  }
+
+  public void get(byte[] dst) {
+    asByteBuffer().get(dst);
+  }
+
+  public int getInt() {
+    return asByteBuffer().getInt();
+  }
+
+  public int getInt(int offset) {
+    return asByteBuffer().getInt(offset);
+  }
+
+  public short getShort() {
+    return asByteBuffer().getShort();
+  }
+
+  public void put(byte aByte) {
+    asByteBuffer().put(aByte);
+  }
+
+  public void putShort(short aShort) {
+    asByteBuffer().putShort(aShort);
+  }
+
+  public void putInt(int anInteger) {
+    asByteBuffer().putInt(anInteger);
+  }
+
+  public void put(byte[] bytes) {
+    asByteBuffer().put(bytes);
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java b/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java
index 000bc0e..2d1da51 100644
--- a/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java
+++ b/src/main/java/com/android/tools/r8/dex/DexOutputBuffer.java
@@ -22,7 +22,7 @@
   private static final int DEFAULT_BUFFER_SIZE = 256 * 1024;
 
   private final ByteBufferProvider byteBufferProvider;
-  private ByteBuffer byteBuffer;
+  private CompatByteBuffer byteBuffer;
 
   @VisibleForTesting
   DexOutputBuffer() {
@@ -37,16 +37,16 @@
   private void ensureSpaceFor(int bytes) {
     if (byteBuffer.remaining() < bytes) {
       int newSize = byteBuffer.capacity() + Math.max(byteBuffer.capacity(), bytes * 2);
-      ByteBuffer newBuffer = allocateByteBuffer(newSize);
-      System.arraycopy(byteBuffer.array(), 0, newBuffer.array(), 0, byteBuffer.position());
+      CompatByteBuffer newBuffer = allocateByteBuffer(newSize);
+      System.arraycopy(byteBuffer.array(), 0, newBuffer.array(), 0, position());
       newBuffer.position(byteBuffer.position());
       freeByteBuffer(byteBuffer);
       byteBuffer = newBuffer;
     }
   }
 
-  private ByteBuffer allocateByteBuffer(int size) {
-    ByteBuffer buffer = byteBufferProvider.acquireByteBuffer(size);
+  private CompatByteBuffer allocateByteBuffer(int size) {
+    CompatByteBuffer buffer = new CompatByteBuffer(byteBufferProvider.acquireByteBuffer(size));
     if (!buffer.hasArray()) {
       throw new CompilationError(
           "Provided byte-buffer is required to have an array backing, but does not.");
@@ -69,9 +69,9 @@
     return buffer;
   }
 
-  private void freeByteBuffer(ByteBuffer buffer) {
+  private void freeByteBuffer(CompatByteBuffer buffer) {
     assert buffer != null;
-    byteBufferProvider.releaseByteBuffer(buffer);
+    byteBufferProvider.releaseByteBuffer(buffer.asByteBuffer());
   }
 
   public void putUleb128(int value) {
@@ -133,7 +133,7 @@
   public int align(int bytes) {
     assert bytes > 0;
     int mask = bytes - 1;
-    int newPosition = (byteBuffer.position() + mask) & ~mask;
+    int newPosition = (position() + mask) & ~mask;
     ensureSpaceFor(newPosition - position());
     byteBuffer.position(newPosition);
     return newPosition;
@@ -165,8 +165,8 @@
     return byteBuffer.array();
   }
 
-  public ByteBuffer stealByteBuffer() {
-    ByteBuffer buffer = byteBuffer;
+  public CompatByteBuffer stealByteBuffer() {
+    CompatByteBuffer buffer = byteBuffer;
     byteBuffer = null;
     return buffer;
   }
diff --git a/src/main/java/com/android/tools/r8/dex/DexReader.java b/src/main/java/com/android/tools/r8/dex/DexReader.java
index d8997f7..45a0696 100644
--- a/src/main/java/com/android/tools/r8/dex/DexReader.java
+++ b/src/main/java/com/android/tools/r8/dex/DexReader.java
@@ -12,7 +12,6 @@
 import com.android.tools.r8.utils.DexVersion;
 import java.io.IOException;
 import java.nio.BufferUnderflowException;
-import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
 /**
@@ -38,7 +37,7 @@
   }
 
   // Parse the magic header and determine the dex file version.
-  private int parseMagic(ByteBuffer buffer) {
+  private int parseMagic(CompatByteBuffer buffer) {
     try {
       buffer.get();
       buffer.rewind();
diff --git a/src/main/java/com/android/tools/r8/dex/FileWriter.java b/src/main/java/com/android/tools/r8/dex/FileWriter.java
index 1af80fa..4197da5 100644
--- a/src/main/java/com/android/tools/r8/dex/FileWriter.java
+++ b/src/main/java/com/android/tools/r8/dex/FileWriter.java
@@ -57,7 +57,6 @@
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntLinkedOpenHashMap;
 import it.unimi.dsi.fastutil.objects.Reference2IntMap;
-import java.nio.ByteBuffer;
 import java.security.MessageDigest;
 import java.util.Arrays;
 import java.util.Collection;
@@ -77,10 +76,10 @@
   /** Simple pair of a byte buffer and its written length. */
   public static class ByteBufferResult {
     // Ownership of the buffer is transferred to the receiver of this result structure.
-    public final ByteBuffer buffer;
+    public final CompatByteBuffer buffer;
     public final int length;
 
-    private ByteBufferResult(ByteBuffer buffer, int length) {
+    private ByteBufferResult(CompatByteBuffer buffer, int length) {
       this.buffer = buffer;
       this.length = length;
     }
diff --git a/src/main/java/com/android/tools/r8/dex/VDexReader.java b/src/main/java/com/android/tools/r8/dex/VDexReader.java
index a3a5a2f..8d6f2d0 100644
--- a/src/main/java/com/android/tools/r8/dex/VDexReader.java
+++ b/src/main/java/com/android/tools/r8/dex/VDexReader.java
@@ -14,7 +14,6 @@
 import com.google.common.io.ByteStreams;
 import java.io.IOException;
 import java.io.InputStream;
-import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
 /**
@@ -37,7 +36,7 @@
   }
 
   // Parse the magic header and determine the dex file version.
-  private int parseMagic(ByteBuffer buffer) {
+  private int parseMagic(CompatByteBuffer buffer) {
     int index = 0;
     for (byte prefixByte : VDEX_FILE_MAGIC_PREFIX) {
       if (buffer.get(index++) != prefixByte) {
diff --git a/src/main/java/com/android/tools/r8/experimental/graphinfo/GraphEdgeInfo.java b/src/main/java/com/android/tools/r8/experimental/graphinfo/GraphEdgeInfo.java
index e3fa01b..88b3b4b 100644
--- a/src/main/java/com/android/tools/r8/experimental/graphinfo/GraphEdgeInfo.java
+++ b/src/main/java/com/android/tools/r8/experimental/graphinfo/GraphEdgeInfo.java
@@ -15,6 +15,7 @@
     TargetedBySuper,
     InvokedFrom,
     InvokedFromLambdaCreatedIn,
+    AnnotatedOn,
     ReferencedFrom,
     ReflectiveUseFrom,
     ReachableFromLiveType,
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index 28aabea..5e65aa3 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -38,22 +38,17 @@
   public DexTypeList interfaces;
   public DexString sourceFile;
 
-  /**
-   * Access has to be synchronized during concurrent collection/writing phase.
-   */
-  protected DexEncodedField[] staticFields;
-  /**
-   * Access has to be synchronized during concurrent collection/writing phase.
-   */
-  protected DexEncodedField[] instanceFields;
-  /**
-   * Access has to be synchronized during concurrent collection/writing phase.
-   */
-  protected DexEncodedMethod[] directMethods;
-  /**
-   * Access has to be synchronized during concurrent collection/writing phase.
-   */
-  protected DexEncodedMethod[] virtualMethods;
+  /** Access has to be synchronized during concurrent collection/writing phase. */
+  protected DexEncodedField[] staticFields = NO_FIELDS;
+
+  /** Access has to be synchronized during concurrent collection/writing phase. */
+  protected DexEncodedField[] instanceFields = NO_FIELDS;
+
+  /** Access has to be synchronized during concurrent collection/writing phase. */
+  protected DexEncodedMethod[] directMethods = NO_METHODS;
+
+  /** Access has to be synchronized during concurrent collection/writing phase. */
+  protected DexEncodedMethod[] virtualMethods = NO_METHODS;
 
   /** Enclosing context of this class if it is an inner class, null otherwise. */
   private EnclosingMethodAttribute enclosingMethod;
@@ -146,7 +141,8 @@
     System.arraycopy(directMethods, 0, newMethods, 0, directMethods.length);
     newMethods[directMethods.length] = method;
     directMethods = newMethods;
-    assert verifyNoDuplicateMethods(directMethods);
+    assert verifyCorrectnessOfMethodHolder(method);
+    assert verifyNoDuplicateMethods();
   }
 
   public void appendDirectMethods(Collection<DexEncodedMethod> methods) {
@@ -158,7 +154,8 @@
       i++;
     }
     directMethods = newMethods;
-    assert verifyNoDuplicateMethods(directMethods);
+    assert verifyCorrectnessOfMethodHolders(methods);
+    assert verifyNoDuplicateMethods();
   }
 
   public void removeDirectMethod(int index) {
@@ -170,12 +167,14 @@
 
   public void setDirectMethod(int index, DexEncodedMethod method) {
     directMethods[index] = method;
-    assert verifyNoDuplicateMethods(directMethods);
+    assert verifyCorrectnessOfMethodHolder(method);
+    assert verifyNoDuplicateMethods();
   }
 
   public void setDirectMethods(DexEncodedMethod[] values) {
     directMethods = MoreObjects.firstNonNull(values, NO_METHODS);
-    assert verifyNoDuplicateMethods(directMethods);
+    assert verifyCorrectnessOfMethodHolders(directMethods());
+    assert verifyNoDuplicateMethods();
   }
 
   public List<DexEncodedMethod> virtualMethods() {
@@ -191,7 +190,8 @@
     System.arraycopy(virtualMethods, 0, newMethods, 0, virtualMethods.length);
     newMethods[virtualMethods.length] = method;
     virtualMethods = newMethods;
-    assert verifyNoDuplicateMethods(virtualMethods);
+    assert verifyCorrectnessOfMethodHolder(method);
+    assert verifyNoDuplicateMethods();
   }
 
   public void appendVirtualMethods(Collection<DexEncodedMethod> methods) {
@@ -203,7 +203,8 @@
       i++;
     }
     virtualMethods = newMethods;
-    assert verifyNoDuplicateMethods(virtualMethods);
+    assert verifyCorrectnessOfMethodHolders(methods);
+    assert verifyNoDuplicateMethods();
   }
 
   public void removeVirtualMethod(int index) {
@@ -216,22 +217,39 @@
 
   public void setVirtualMethod(int index, DexEncodedMethod method) {
     virtualMethods[index] = method;
-    assert verifyNoDuplicateMethods(virtualMethods);
+    assert verifyCorrectnessOfMethodHolder(method);
+    assert verifyNoDuplicateMethods();
   }
 
   public void setVirtualMethods(DexEncodedMethod[] values) {
     virtualMethods = MoreObjects.firstNonNull(values, NO_METHODS);
-    assert verifyNoDuplicateMethods(virtualMethods);
+    assert verifyCorrectnessOfMethodHolders(virtualMethods());
+    assert verifyNoDuplicateMethods();
   }
 
-  private boolean verifyNoDuplicateMethods(DexEncodedMethod[] methods) {
+  private boolean verifyCorrectnessOfMethodHolder(DexEncodedMethod method) {
+    assert method.method.holder == type
+        : "Expected method `"
+            + method.method.toSourceString()
+            + "` to have holder `"
+            + type.toSourceString()
+            + "`";
+    return true;
+  }
+
+  private boolean verifyCorrectnessOfMethodHolders(Iterable<DexEncodedMethod> methods) {
+    for (DexEncodedMethod method : methods) {
+      assert verifyCorrectnessOfMethodHolder(method);
+    }
+    return true;
+  }
+
+  private boolean verifyNoDuplicateMethods() {
     Set<DexMethod> unique = Sets.newIdentityHashSet();
-    Arrays.stream(methods)
-        .forEach(
-            method -> {
-              boolean changed = unique.add(method.method);
-              assert changed : "Duplicate method `" + method.method.toSourceString() + "`";
-            });
+    for (DexEncodedMethod method : methods()) {
+      boolean changed = unique.add(method.method);
+      assert changed : "Duplicate method `" + method.method.toSourceString() + "`";
+    }
     return true;
   }
 
@@ -651,6 +669,8 @@
   public boolean isValid() {
     assert !isInterface()
         || Arrays.stream(virtualMethods).noneMatch(method -> method.accessFlags.isFinal());
+    assert verifyCorrectnessOfMethodHolders(methods());
+    assert verifyNoDuplicateMethods();
     return true;
   }
 }
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index 1757459..e7b3967 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -140,6 +140,8 @@
   public final DexString contentEqualsMethodName = createString("contentEquals");
   public final DexString indexOfMethodName = createString("indexOf");
   public final DexString lastIndexOfMethodName = createString("lastIndexOf");
+  public final DexString compareToMethodName = createString("compareTo");
+  public final DexString compareToIgnoreCaseMethodName = createString("compareToIgnoreCase");
   public final DexString cloneMethodName = createString("clone");
 
   public final DexString valueOfMethodName = createString("valueOf");
@@ -613,6 +615,8 @@
     public final DexMethod indexOfString;
     public final DexMethod lastIndexOfInt;
     public final DexMethod lastIndexOfString;
+    public final DexMethod compareTo;
+    public final DexMethod compareToIgnoreCase;
 
     public final DexMethod valueOf;
     public final DexMethod toString;
@@ -649,6 +653,11 @@
           createMethod(stringDescriptor, lastIndexOfMethodName, intDescriptor, needsOneString);
       lastIndexOfInt =
           createMethod(stringDescriptor, lastIndexOfMethodName, intDescriptor, needsOneInt);
+      compareTo =
+          createMethod(stringDescriptor, compareToMethodName, intDescriptor, needsOneString);
+      compareToIgnoreCase =
+          createMethod(stringDescriptor, compareToIgnoreCaseMethodName, intDescriptor,
+              needsOneString);
 
       valueOf = createMethod(
           stringDescriptor, valueOfMethodName, stringDescriptor, needsOneObject);
diff --git a/src/main/java/com/android/tools/r8/ir/code/Value.java b/src/main/java/com/android/tools/r8/ir/code/Value.java
index 55bc508..977c90b 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Value.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Value.java
@@ -292,6 +292,13 @@
     debugData = null;
   }
 
+  public boolean hasSameOrNoLocal(Value other) {
+    assert other != null;
+    return hasLocalInfo()
+        ? other.getLocalInfo() == this.getLocalInfo()
+        : !other.hasLocalInfo();
+  }
+
   public List<Instruction> getDebugLocalStarts() {
     if (debugData == null) {
       return Collections.emptyList();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index 30712e6..f7baf3e 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -48,6 +48,7 @@
 import com.android.tools.r8.graph.ParameterUsagesInfo.ParameterUsage;
 import com.android.tools.r8.graph.ParameterUsagesInfo.ParameterUsageBuilder;
 import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis.AnalysisAssumption;
+import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.code.AlwaysMaterializingNop;
@@ -1632,10 +1633,30 @@
       Instruction current = iterator.next();
       if (current.isInvokeMethod()) {
         InvokeMethod invoke = current.asInvokeMethod();
-        if (invoke.outValue() != null && !invoke.outValue().hasLocalInfo()) {
+        Value outValue = invoke.outValue();
+        // TODO(b/124246610): extend to other variants that receive error messages or supplier.
+        if (invoke.getInvokedMethod() == dexItemFactory.objectsMethods.requireNonNull) {
+          Value obj = invoke.arguments().get(0);
+          if ((outValue == null && obj.hasLocalInfo())
+              || (outValue != null && !obj.hasSameOrNoLocal(outValue))) {
+            continue;
+          }
+          Nullability nullability = obj.getTypeLattice().nullability();
+          if (nullability.isDefinitelyNotNull()) {
+            if (outValue != null) {
+              outValue.replaceUsers(obj);
+              needToNarrowValues.addAll(outValue.affectedValues());
+            }
+            iterator.removeOrReplaceByDebugLocalRead();
+          } else if (nullability.isDefinitelyNull()) {
+            // TODO(b/124246610): throw NPE.
+            // Refactor UninstantiatedTypeOptimization#replaceCurrentInstructionWithThrowNull
+            // and move it to iterator.
+          }
+        } else if (outValue != null && !outValue.hasLocalInfo()) {
           if (libraryMethodsReturningReceiver.contains(invoke.getInvokedMethod())) {
             if (checkArgumentType(invoke, 0)) {
-              invoke.outValue().replaceUsers(invoke.arguments().get(0));
+              outValue.replaceUsers(invoke.arguments().get(0));
               invoke.setOutValue(null);
             }
           } else if (appInfoWithLiveness != null) {
@@ -1650,7 +1671,6 @@
                 // Replace the out value of the invoke with the argument and ignore the out value.
                 if (argumentIndex >= 0 && checkArgumentType(invoke, argumentIndex)) {
                   Value argument = invoke.arguments().get(argumentIndex);
-                  Value outValue = invoke.outValue();
                   assert outValue.verifyCompatible(argument.outType());
                   if (argument.getTypeLattice().lessThanOrEqual(
                       outValue.getTypeLattice(), appInfo)) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java b/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java
index 3fc442a..5dfbb78 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/string/StringOptimizer.java
@@ -16,6 +16,7 @@
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.analysis.EscapeAnalysis;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
@@ -53,16 +54,18 @@
 
   // int String#length()
   // boolean String#isEmpty()
-  // boolean String#startsWith(str)
-  // boolean String#endsWith(str)
-  // boolean String#contains(str)
-  // boolean String#equals(str)
-  // boolean String#equalsIgnoreCase(str)
-  // boolean String#contentEquals(str)
-  // int String#indexOf(str)
+  // boolean String#startsWith(String)
+  // boolean String#endsWith(String)
+  // boolean String#contains(String)
+  // boolean String#equals(String)
+  // boolean String#equalsIgnoreCase(String)
+  // boolean String#contentEquals(String)
+  // int String#indexOf(String)
   // int String#indexOf(int)
-  // int String#lastIndexOf(str)
+  // int String#lastIndexOf(String)
   // int String#lastIndexOf(int)
+  // int String#compareTo(String)
+  // int String#compareToIgnoreCase(String)
   public void computeTrivialOperationsOnConstString(IRCode code) {
     if (!code.hasConstString) {
       return;
@@ -102,6 +105,10 @@
         operatorWithInt = String::lastIndexOf;
       } else if (invokedMethod == factory.stringMethods.lastIndexOfString) {
         operatorWithString = String::lastIndexOf;
+      } else if (invokedMethod == factory.stringMethods.compareTo) {
+        operatorWithString = String::compareTo;
+      } else if (invokedMethod == factory.stringMethods.compareToIgnoreCase) {
+        operatorWithString = String::compareToIgnoreCase;
       } else {
         continue;
       }
@@ -111,12 +118,12 @@
           || !rcv.isConstant()) {
         continue;
       }
+      DexString rcvString = rcv.definition.asConstString().getValue();
 
       ConstNumber constNumber;
       if (operatorWithNoArg != null) {
         assert invoke.inValues().size() == 1;
-        ConstString rcvString = rcv.definition.asConstString();
-        int v = operatorWithNoArg.apply(rcvString.getValue().toString());
+        int v = operatorWithNoArg.apply(rcvString.toString());
         constNumber = code.createIntConstant(v);
       } else if (operatorWithString != null) {
         assert invoke.inValues().size() == 2;
@@ -126,10 +133,9 @@
             || !arg.isConstant()) {
           continue;
         }
-        ConstString rcvString = rcv.definition.asConstString();
-        ConstString argString = arg.definition.asConstString();
         int v = operatorWithString.apply(
-            rcvString.getValue().toString(), argString.getValue().toString());
+            rcvString.toString(),
+            arg.definition.asConstString().getValue().toString());
         constNumber = code.createIntConstant(v);
       } else {
         assert operatorWithInt != null;
@@ -140,10 +146,9 @@
             || !arg.isConstant()) {
           continue;
         }
-        ConstString rcvString = rcv.definition.asConstString();
-        ConstNumber argInt = arg.definition.asConstNumber();
         int v = operatorWithInt.apply(
-            rcvString.getValue().toString(), argInt.getIntValue());
+            rcvString.toString(),
+            arg.definition.asConstNumber().getIntValue());
         constNumber = code.createIntConstant(v);
       }
 
diff --git a/src/main/java/com/android/tools/r8/naming/FieldNameMinifier.java b/src/main/java/com/android/tools/r8/naming/FieldNameMinifier.java
index bbb3391..90dbbdb 100644
--- a/src/main/java/com/android/tools/r8/naming/FieldNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/FieldNameMinifier.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.shaking.RootSetBuilder.RootSet;
 import com.android.tools.r8.utils.InternalOptions;
 import com.android.tools.r8.utils.Timing;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Sets;
 import java.util.Map;
 import java.util.function.Function;
@@ -33,7 +34,7 @@
     }
   }
 
-  Map<DexField, DexString> computeRenaming(Timing timing) {
+  FieldRenaming computeRenaming(Timing timing) {
     // Reserve names in all classes first. We do this in subtyping order so we do not
     // shadow a reserved field in subclasses. While there is no concept of virtual field
     // dispatch in Java, field resolution still traverses the super type chain and external
@@ -55,7 +56,20 @@
     timing.begin("rename-references");
     renameNonReboundReferences();
     timing.end();
-    return renaming;
+    return new FieldRenaming(renaming);
+  }
+
+  static class FieldRenaming {
+
+    final Map<DexField, DexString> renaming;
+
+    private FieldRenaming(Map<DexField, DexString> renaming) {
+      this.renaming = renaming;
+    }
+
+    public static FieldRenaming empty() {
+      return new FieldRenaming(ImmutableMap.of());
+    }
   }
 
   private void reserveNamesInSubtypes(DexType type, NamingState<DexType, ?> state) {
diff --git a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
index 5f990ac..21e6bf9 100644
--- a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
@@ -18,6 +18,7 @@
 import com.android.tools.r8.utils.Timing;
 import com.google.common.base.Equivalence;
 import com.google.common.base.Equivalence.Wrapper;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Sets;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -96,6 +97,8 @@
   private final Equivalence<DexMethod> equivalence;
   private final Map<DexCallSite, DexString> callSiteRenaming = new IdentityHashMap<>();
 
+  private final Map<DexType, DexType> frontierMap = new IdentityHashMap<>();
+
   MethodNameMinifier(
       AppInfoWithLiveness appInfo,
       RootSet rootSet,
@@ -121,6 +124,7 @@
   }
 
   static class MethodRenaming {
+
     final Map<DexMethod, DexString> renaming;
     final Map<DexCallSite, DexString> callSiteRenaming;
 
@@ -129,26 +133,27 @@
       this.renaming = renaming;
       this.callSiteRenaming = callSiteRenaming;
     }
+
+    public static MethodRenaming empty() {
+      return new MethodRenaming(ImmutableMap.of(), ImmutableMap.of());
+    }
   }
 
   MethodRenaming computeRenaming(Timing timing) {
     // Phase 1: Reserve all the names that need to be kept and allocate linked state in the
     //          library part.
     timing.begin("Phase 1");
-    Map<DexType, DexType> frontierMap = new IdentityHashMap<>();
-    reserveNamesInClasses(appInfo.dexItemFactory.objectType,
-        appInfo.dexItemFactory.objectType,
-        null, frontierMap);
+    reserveNamesInClasses(
+        appInfo.dexItemFactory.objectType, appInfo.dexItemFactory.objectType, null);
     timing.end();
     // Phase 2: Reserve all the names that are required for interfaces.
     timing.begin("Phase 2");
-    DexType.forAllInterfaces(
-        appInfo.dexItemFactory, iface -> reserveNamesInInterfaces(iface, frontierMap));
+    DexType.forAllInterfaces(appInfo.dexItemFactory, this::reserveNamesInInterfaces);
     timing.end();
     // Phase 3: Assign names to interface methods. These are assigned by finding a name that is
     //          free in all naming states that may hold an implementation.
     timing.begin("Phase 3");
-    assignNamesToInterfaceMethods(frontierMap, timing);
+    assignNamesToInterfaceMethods(timing);
     timing.end();
     // Phase 4: Assign names top-down by traversing the subtype hierarchy.
     timing.begin("Phase 4");
@@ -201,8 +206,7 @@
     }
   }
 
-  private Set<NamingState<DexProto, ?>> getReachableStates(DexType type,
-      Map<DexType, DexType> frontierMap) {
+  private Set<NamingState<DexProto, ?>> getReachableStates(DexType type) {
     Set<DexType> interfaces = Sets.newIdentityHashSet();
     interfaces.add(type);
     collectSuperInterfaces(type, interfaces);
@@ -221,7 +225,7 @@
     return reachableStates;
   }
 
-  private void assignNamesToInterfaceMethods(Map<DexType, DexType> frontierMap, Timing timing) {
+  private void assignNamesToInterfaceMethods(Timing timing) {
     // First compute a map from method signatures to a set of naming states for interfaces and
     // frontier states of classes that implement them. We add the frontier states so that we can
     // reserve the names for later method naming.
@@ -232,17 +236,20 @@
     Map<Wrapper<DexMethod>, Set<DexMethod>> sourceMethodsMap = new HashMap<>();
     // A map from DexMethods to the first interface state it was seen in. Used to pick good names.
     Map<Wrapper<DexMethod>, NamingState<DexProto, ?>> originStates = new HashMap<>();
-    DexType.forAllInterfaces(appInfo.dexItemFactory, iface -> {
-      assert iface.isInterface();
-      DexClass clazz = appInfo.definitionFor(iface);
-      if (clazz != null) {
-        Set<NamingState<DexProto, ?>> collectedStates = getReachableStates(iface, frontierMap);
-        for (DexEncodedMethod method : shuffleMethods(clazz.methods())) {
-          addStatesToGlobalMapForMethod(
-              method, collectedStates, globalStateMap, sourceMethodsMap, originStates, iface);
-        }
-      }
-    });
+    DexType.forAllInterfaces(
+        appInfo.dexItemFactory,
+        iface -> {
+          assert iface.isInterface();
+          DexClass clazz = appInfo.definitionFor(iface);
+          if (clazz != null) {
+            assert clazz.isInterface();
+            Set<NamingState<DexProto, ?>> collectedStates = getReachableStates(iface);
+            for (DexEncodedMethod method : shuffleMethods(clazz.methods())) {
+              addStatesToGlobalMapForMethod(
+                  method, collectedStates, globalStateMap, sourceMethodsMap, originStates, iface);
+            }
+          }
+        });
     // Collect the live call sites for multi-interface lambda expression renaming. For code with
     // desugared lambdas this is a conservative estimate, as we don't track if the generated
     // lambda classes survive into the output. As multi-interface lambda expressions are rare
@@ -272,7 +279,7 @@
           for (DexEncodedMethod method : implementedMethods) {
             DexType iface = method.method.holder;
             assert iface.isInterface();
-            Set<NamingState<DexProto, ?>> collectedStates = getReachableStates(iface, frontierMap);
+            Set<NamingState<DexProto, ?>> collectedStates = getReachableStates(iface);
             addStatesToGlobalMapForMethod(
                 method, collectedStates, globalStateMap, sourceMethodsMap, originStates, iface);
             callSiteMethods.add(equivalence.wrap(method.method));
@@ -434,34 +441,33 @@
     return false;
   }
 
-  private void reserveNamesInClasses(DexType type, DexType libraryFrontier,
-      NamingState<DexProto, ?> parent,
-      Map<DexType, DexType> frontierMap) {
+  private void reserveNamesInClasses(
+      DexType type, DexType libraryFrontier, NamingState<DexProto, ?> parent) {
     assert !type.isInterface();
     DexClass holder = appInfo.definitionFor(type);
-    NamingState<DexProto, ?> state = allocateNamingStateAndReserve(holder, type, libraryFrontier,
-        parent, frontierMap);
+    NamingState<DexProto, ?> state =
+        allocateNamingStateAndReserve(holder, type, libraryFrontier, parent);
     // If this is a library class (or effectively a library class as it is missing) move the
     // frontier forward.
-    type.forAllExtendsSubtypes(subtype -> {
-      assert !subtype.isInterface();
-      reserveNamesInClasses(subtype,
-          holder == null || holder.isLibraryClass() ? subtype : libraryFrontier,
-          state, frontierMap);
-    });
+    type.forAllExtendsSubtypes(
+        subtype -> {
+          assert !subtype.isInterface();
+          reserveNamesInClasses(
+              subtype,
+              holder == null || holder.isLibraryClass() ? subtype : libraryFrontier,
+              state);
+        });
   }
 
-  private void reserveNamesInInterfaces(DexType type, Map<DexType, DexType> frontierMap) {
+  private void reserveNamesInInterfaces(DexType type) {
     assert type.isInterface();
     frontierMap.put(type, type);
     DexClass holder = appInfo.definitionFor(type);
-    allocateNamingStateAndReserve(holder, type, type, null, frontierMap);
+    allocateNamingStateAndReserve(holder, type, type, null);
   }
 
-  private NamingState<DexProto, ?> allocateNamingStateAndReserve(DexClass holder, DexType type,
-      DexType libraryFrontier,
-      NamingState<DexProto, ?> parent,
-      Map<DexType, DexType> frontierMap) {
+  private NamingState<DexProto, ?> allocateNamingStateAndReserve(
+      DexClass holder, DexType type, DexType libraryFrontier, NamingState<DexProto, ?> parent) {
     frontierMap.put(type, libraryFrontier);
     NamingState<DexProto, ?> state =
         computeStateIfAbsent(
diff --git a/src/main/java/com/android/tools/r8/naming/Minifier.java b/src/main/java/com/android/tools/r8/naming/Minifier.java
index e4ccbcd..becc643 100644
--- a/src/main/java/com/android/tools/r8/naming/Minifier.java
+++ b/src/main/java/com/android/tools/r8/naming/Minifier.java
@@ -15,6 +15,7 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.graph.InnerClassAttribute;
 import com.android.tools.r8.naming.ClassNameMinifier.ClassRenaming;
+import com.android.tools.r8.naming.FieldNameMinifier.FieldRenaming;
 import com.android.tools.r8.naming.MethodNameMinifier.MethodRenaming;
 import com.android.tools.r8.optimize.MemberRebindingAnalysis;
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
@@ -56,21 +57,28 @@
     ClassNameMinifier classNameMinifier = new ClassNameMinifier(appInfo, rootSet, options);
     ClassRenaming classRenaming = classNameMinifier.computeRenaming(timing);
     timing.end();
+
+    assert new MinifiedRenaming(
+            classRenaming, MethodRenaming.empty(), FieldRenaming.empty(), appInfo)
+        .verifyNoCollisions(appInfo.classes(), appInfo.dexItemFactory);
+
     timing.begin("MinifyMethods");
     MethodRenaming methodRenaming =
         new MethodNameMinifier(appInfo, rootSet, desugaredCallSites, options)
             .computeRenaming(timing);
     timing.end();
+
+    assert new MinifiedRenaming(classRenaming, methodRenaming, FieldRenaming.empty(), appInfo)
+        .verifyNoCollisions(appInfo.classes(), appInfo.dexItemFactory);
+
     timing.begin("MinifyFields");
-    Map<DexField, DexString> fieldRenaming =
+    FieldRenaming fieldRenaming =
         new FieldNameMinifier(appInfo, rootSet, options).computeRenaming(timing);
     timing.end();
-    NamingLens lens =
-        new MinifiedRenaming(
-            classRenaming,
-            methodRenaming,
-            fieldRenaming,
-            appInfo);
+
+    NamingLens lens = new MinifiedRenaming(classRenaming, methodRenaming, fieldRenaming, appInfo);
+    assert lens.verifyNoCollisions(appInfo.classes(), appInfo.dexItemFactory);
+
     timing.begin("MinifyIdentifiers");
     new IdentifierMinifier(
         appInfo, options.getProguardConfiguration().getAdaptClassStrings(), lens).run();
@@ -87,14 +95,14 @@
     private MinifiedRenaming(
         ClassRenaming classRenaming,
         MethodRenaming methodRenaming,
-        Map<DexField, DexString> fieldRenaming,
+        FieldRenaming fieldRenaming,
         AppInfo appInfo) {
       this.appInfo = appInfo;
       this.packageRenaming = classRenaming.packageRenaming;
       renaming.putAll(classRenaming.classRenaming);
       renaming.putAll(methodRenaming.renaming);
       renaming.putAll(methodRenaming.callSiteRenaming);
-      renaming.putAll(fieldRenaming);
+      renaming.putAll(fieldRenaming.renaming);
     }
 
     @Override
diff --git a/src/main/java/com/android/tools/r8/naming/NamingLens.java b/src/main/java/com/android/tools/r8/naming/NamingLens.java
index cee867e..aecae1e 100644
--- a/src/main/java/com/android/tools/r8/naming/NamingLens.java
+++ b/src/main/java/com/android/tools/r8/naming/NamingLens.java
@@ -7,10 +7,14 @@
 import static com.android.tools.r8.utils.DescriptorUtils.descriptorToJavaType;
 
 import com.android.tools.r8.graph.DexCallSite;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexItem;
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexReference;
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
@@ -19,7 +23,10 @@
 import com.android.tools.r8.utils.DescriptorUtils;
 import com.android.tools.r8.utils.InternalOptions;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Sets;
+import java.util.Arrays;
 import java.util.Map;
+import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -70,6 +77,40 @@
     return lookupName(reference.asDexField());
   }
 
+  public final DexField lookupField(DexField field, DexItemFactory dexItemFactory) {
+    return dexItemFactory.createField(
+        lookupType(field.clazz, dexItemFactory),
+        lookupType(field.type, dexItemFactory),
+        lookupName(field));
+  }
+
+  public final DexMethod lookupMethod(DexMethod method, DexItemFactory dexItemFactory) {
+    return dexItemFactory.createMethod(
+        lookupType(method.holder, dexItemFactory),
+        lookupProto(method.proto, dexItemFactory),
+        lookupName(method));
+  }
+
+  private DexProto lookupProto(DexProto proto, DexItemFactory dexItemFactory) {
+    return dexItemFactory.createProto(
+        lookupType(proto.returnType, dexItemFactory),
+        Arrays.stream(proto.parameters.values)
+            .map(type -> lookupType(type, dexItemFactory))
+            .toArray(DexType[]::new));
+  }
+
+  public final DexType lookupType(DexType type, DexItemFactory dexItemFactory) {
+    if (type.isPrimitiveType() || type.isVoidType()) {
+      return type;
+    }
+    if (type.isArrayType()) {
+      DexType newBaseType = lookupType(type.toBaseType(dexItemFactory), dexItemFactory);
+      return type.replaceBaseType(newBaseType, dexItemFactory);
+    }
+    assert type.isClassType();
+    return dexItemFactory.createType(lookupDescriptor(type));
+  }
+
   public static NamingLens getIdentityLens() {
     return new IdentityLens();
   }
@@ -97,6 +138,34 @@
    */
   public abstract boolean checkTargetCanBeTranslated(DexMethod item);
 
+  public final boolean verifyNoCollisions(
+      Iterable<DexProgramClass> classes, DexItemFactory dexItemFactory) {
+    Set<DexReference> references = Sets.newIdentityHashSet();
+    for (DexProgramClass clazz : classes) {
+      {
+        DexType newType = lookupType(clazz.type, dexItemFactory);
+        boolean referencesChanged = references.add(newType);
+        assert referencesChanged
+            : "Duplicate definition of type `" + newType.toSourceString() + "`";
+      }
+
+      for (DexEncodedField field : clazz.fields()) {
+        DexField newField = lookupField(field.field, dexItemFactory);
+        boolean referencesChanged = references.add(newField);
+        assert referencesChanged
+            : "Duplicate definition of field `" + newField.toSourceString() + "`";
+      }
+
+      for (DexEncodedMethod method : clazz.methods()) {
+        DexMethod newMethod = lookupMethod(method.method, dexItemFactory);
+        boolean referencesChanged = references.add(newMethod);
+        assert referencesChanged
+            : "Duplicate definition of method `" + newMethod.toSourceString() + "`";
+      }
+    }
+    return true;
+  }
+
   private static class IdentityLens extends NamingLens {
 
     private IdentityLens() {
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index a51ca83..f011931 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -177,10 +177,10 @@
    * for these.
    */
   private final Set<DexType> liveTypes = Sets.newIdentityHashSet();
-  /**
-   * Set of annotation types that are instantiated.
-   */
-  private final Set<DexType> instantiatedAnnotations = Sets.newIdentityHashSet();
+
+  /** Set of annotation types that are instantiated. */
+  private final SetWithReason<DexAnnotation> instantiatedAnnotations =
+      new SetWithReason<>(this::registerAnnotation);
   /** Set of types that are actually instantiated. These cannot be abstract. */
   private final SetWithReason<DexType> instantiatedTypes = new SetWithReason<>(this::registerType);
   /**
@@ -803,9 +803,6 @@
           }
         }
       }
-      if (!holder.annotations.isEmpty()) {
-        processAnnotations(holder.annotations.annotations);
-      }
       // We also need to add the corresponding <clinit> to the set of live methods, as otherwise
       // static field initialization (and other class-load-time sideeffects) will not happen.
       KeepReason reason = KeepReason.reachableFromLiveType(type);
@@ -821,10 +818,15 @@
         enqueueFirstNonSerializableClassInitializer(holder, reason);
       }
 
-      // If this type has deferred annotations, we have to process those now, too.
-      Set<DexAnnotation> annotations = deferredAnnotations.remove(type);
-      if (annotations != null) {
-        annotations.forEach(this::handleAnnotationOfLiveType);
+      if (!holder.isLibraryClass()) {
+        if (!holder.annotations.isEmpty()) {
+          processAnnotations(holder, holder.annotations.annotations);
+        }
+        // If this type has deferred annotations, we have to process those now, too.
+        Set<DexAnnotation> annotations = deferredAnnotations.remove(type);
+        if (annotations != null) {
+          annotations.forEach(annotation -> handleAnnotationOfLiveType(holder, annotation));
+        }
       }
 
       Map<DexReference, Set<ProguardKeepRule>> dependentItems = rootSet.getDependentItems(holder);
@@ -834,36 +836,33 @@
     }
   }
 
-  private void handleAnnotationOfLiveType(DexAnnotation annotation) {
-    DexType type = annotation.annotation.type;
-    // Record that it is instantiated if it should be kept when its type is live.
-    if (shouldKeepAnnotation(annotation, true, appInfo.dexItemFactory, options)) {
-      instantiatedAnnotations.add(type);
-    }
-    AnnotationReferenceMarker referenceMarker = new AnnotationReferenceMarker(
-        annotation.annotation.type, appInfo.dexItemFactory);
-    annotation.annotation.collectIndexedItems(referenceMarker);
+  private void handleAnnotationOfLiveType(DexDefinition holder, DexAnnotation annotation) {
+    handleAnnotation(holder, annotation, true);
   }
 
-  private void processAnnotations(DexAnnotation[] annotations) {
+  private void processAnnotations(DexDefinition holder, DexAnnotation[] annotations) {
     for (DexAnnotation annotation : annotations) {
-      processAnnotation(annotation);
+      processAnnotation(holder, annotation);
     }
   }
 
-  private void processAnnotation(DexAnnotation annotation) {
+  private void processAnnotation(DexDefinition holder, DexAnnotation annotation) {
+    handleAnnotation(holder, annotation, false);
+  }
+
+  private void handleAnnotation(DexDefinition holder, DexAnnotation annotation, boolean forceLive) {
+    assert !holder.isDexClass() || !holder.asDexClass().isLibraryClass();
     DexType type = annotation.annotation.type;
-    if (liveTypes.contains(type)) {
-      // The type of this annotation is already live, so pick up its dependencies.
-      handleAnnotationOfLiveType(annotation);
-    } else {
-      // Record that it is instantiated if it should be kept although its type is not live.
-      if (shouldKeepAnnotation(annotation, false, appInfo.dexItemFactory, options)) {
-        instantiatedAnnotations.add(type);
-      }
+    boolean isLive = forceLive || liveTypes.contains(type);
+    if (!shouldKeepAnnotation(annotation, isLive, appInfo.dexItemFactory, options)) {
       // Remember this annotation for later.
       deferredAnnotations.computeIfAbsent(type, ignore -> new HashSet<>()).add(annotation);
+      return;
     }
+    instantiatedAnnotations.add(annotation, KeepReason.annotatedOn(holder));
+    AnnotationReferenceMarker referenceMarker =
+        new AnnotationReferenceMarker(annotation.annotation.type, appInfo.dexItemFactory);
+    annotation.annotation.collectIndexedItems(referenceMarker);
   }
 
   private void handleInvokeOfStaticTarget(DexMethod method, KeepReason reason) {
@@ -956,8 +955,11 @@
     }
     markTypeAsLive(method.method.holder);
     markParameterAndReturnTypesAsLive(method);
-    processAnnotations(method.annotations.annotations);
-    method.parameterAnnotationsList.forEachAnnotation(this::processAnnotation);
+    if (!appInfo.definitionFor(method.method.holder).isLibraryClass()) {
+      processAnnotations(method, method.annotations.annotations);
+      method.parameterAnnotationsList.forEachAnnotation(
+          annotation -> processAnnotation(method, annotation));
+    }
     if (Log.ENABLED) {
       Log.verbose(getClass(), "Method `%s` is targeted.", method.method);
     }
@@ -1614,8 +1616,11 @@
         }
       }
       markParameterAndReturnTypesAsLive(method);
-      processAnnotations(method.annotations.annotations);
-      method.parameterAnnotationsList.forEachAnnotation(this::processAnnotation);
+      if (!appInfo.definitionFor(method.method.holder).isLibraryClass()) {
+        processAnnotations(method, method.annotations.annotations);
+        method.parameterAnnotationsList.forEachAnnotation(
+            annotation -> processAnnotation(method, annotation));
+      }
       method.registerCodeReferences(new UseRegistry(options.itemFactory, method));
       // Add all dependent members to the workqueue.
       enqueueRootItems(rootSet.getDependentItems(method));
@@ -2013,8 +2018,11 @@
       super(appInfo);
       this.liveTypes = ImmutableSortedSet.copyOf(
           PresortedComparable<DexType>::slowCompareTo, enqueuer.liveTypes);
-      this.instantiatedAnnotations = ImmutableSortedSet.copyOf(
-          PresortedComparable<DexType>::slowCompareTo, enqueuer.instantiatedAnnotations);
+      ImmutableSortedSet.Builder<DexType> builder =
+          ImmutableSortedSet.orderedBy(PresortedComparable<DexType>::slowCompareTo);
+      enqueuer.instantiatedAnnotations.items.forEach(
+          annotation -> builder.add(annotation.annotation.type));
+      this.instantiatedAnnotations = builder.build();
       this.instantiatedTypes = ImmutableSortedSet.copyOf(
           PresortedComparable<DexType>::slowCompareTo, enqueuer.instantiatedTypes.getItems());
       this.instantiatedLambdas =
@@ -2795,6 +2803,14 @@
     registerEdge(getClassGraphNode(type), reason);
   }
 
+  private void registerAnnotation(DexAnnotation annotation, KeepReason reason) {
+    assert getSourceNode(reason) != null;
+    if (keptGraphConsumer == null) {
+      return;
+    }
+    registerEdge(getAnnotationGraphNode(annotation.annotation.type), reason);
+  }
+
   private void registerMethod(DexEncodedMethod method, KeepReason reason) {
     if (reason.edgeKind() == EdgeKind.IsLibraryMethod) {
       // Don't report edges to actual library methods.
diff --git a/src/main/java/com/android/tools/r8/shaking/KeepReason.java b/src/main/java/com/android/tools/r8/shaking/KeepReason.java
index a797742..2dd52eb 100644
--- a/src/main/java/com/android/tools/r8/shaking/KeepReason.java
+++ b/src/main/java/com/android/tools/r8/shaking/KeepReason.java
@@ -6,6 +6,7 @@
 import com.android.tools.r8.experimental.graphinfo.GraphEdgeInfo;
 import com.android.tools.r8.experimental.graphinfo.GraphEdgeInfo.EdgeKind;
 import com.android.tools.r8.experimental.graphinfo.GraphNode;
+import com.android.tools.r8.graph.DexDefinition;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexItem;
 import com.android.tools.r8.graph.DexType;
@@ -17,6 +18,10 @@
 
   public abstract GraphNode getSourceNode(Enqueuer enqueuer);
 
+  static KeepReason annotatedOn(DexDefinition definition) {
+    return new AnnotatedOn(definition);
+  }
+
   static KeepReason dueToKeepRule(ProguardKeepRule rule) {
     return new DueToKeepRule(rule);
   }
@@ -302,6 +307,32 @@
     }
   }
 
+  private static class AnnotatedOn extends KeepReason {
+
+    private final DexDefinition holder;
+
+    private AnnotatedOn(DexDefinition holder) {
+      this.holder = holder;
+    }
+
+    @Override
+    public EdgeKind edgeKind() {
+      return EdgeKind.AnnotatedOn;
+    }
+
+    @Override
+    public GraphNode getSourceNode(Enqueuer enqueuer) {
+      if (holder.isDexClass()) {
+        return enqueuer.getClassGraphNode(holder.asDexClass().type);
+      } else if (holder.isDexEncodedField()) {
+        return enqueuer.getFieldGraphNode(holder.asDexEncodedField().field);
+      } else {
+        assert holder.isDexEncodedMethod();
+        return enqueuer.getMethodGraphNode(holder.asDexEncodedMethod().method);
+      }
+    }
+  }
+
   private static class ReflectiveUseFrom extends BasedOnOtherMethod {
 
     private ReflectiveUseFrom(DexEncodedMethod method) {
diff --git a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
index 6d34f44..5b5cf9d 100644
--- a/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunArtTestsTest.java
@@ -104,7 +104,7 @@
   private static final String JCTF_COMMON_JAR = "build/libs/jctfCommon.jar";
 
   // Parent dir for on-the-fly compiled jctf dex output.
-  private static final String JCTF_TESTS_PREFIX = "build/classes/jctfTests";
+  private static final String JCTF_TESTS_PREFIX = "build/classes/java/jctfTests";
   private static final String JCTF_TESTS_LIB_PREFIX =
       JCTF_TESTS_PREFIX + "/com/google/jctf/test/lib";
   private static final String JUNIT_TEST_RUNNER = "org.junit.runner.JUnitCore";
diff --git a/src/test/java/com/android/tools/r8/code/InstructionFactoryTest.java b/src/test/java/com/android/tools/r8/code/InstructionFactoryTest.java
index ddd4f69..a1cfe7b 100644
--- a/src/test/java/com/android/tools/r8/code/InstructionFactoryTest.java
+++ b/src/test/java/com/android/tools/r8/code/InstructionFactoryTest.java
@@ -19,7 +19,7 @@
     ByteBuffer emptyBuffer = ByteBuffer.allocate(0);
     InstructionFactory factory = new InstructionFactory();
     Instruction[] instructions =
-        factory.readSequenceFrom(emptyBuffer, 0, 0, new OffsetToObjectMapping());
+        factory.readSequenceFrom(emptyBuffer.asShortBuffer(), 0, 0, new OffsetToObjectMapping());
     assertTrue(instructions.length == 0);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
new file mode 100644
index 0000000..f8ef59e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/ObjectsRequireNonNullTest.java
@@ -0,0 +1,139 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.optimize;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.VmTestRunner;
+import com.android.tools.r8.VmTestRunner.IgnoreIfVmOlderThan;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.google.common.collect.Streams;
+import java.util.Objects;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+class ObjectsRequireNonNullTestMain {
+
+  static class Foo {
+    @NeverInline
+    void bar() {
+      System.out.println("Foo::bar");
+    }
+
+    @NeverInline
+    @Override
+    public String toString() {
+      return "Foo::toString";
+    }
+  }
+
+  @NeverInline
+  static void unknownArg(Foo foo) {
+    // It's unclear the argument is definitely null or not null.
+    Foo checked = Objects.requireNonNull(foo);
+    checked.bar();
+  }
+
+  public static void main(String[] args) {
+    Foo instance = new Foo();
+    // Not removable in debug mode.
+    Object nonNull = Objects.requireNonNull(instance);
+    System.out.println(nonNull);
+    // Removable because associated locals are changed while type casting.
+    Foo checked = Objects.requireNonNull(instance);
+    checked.bar();
+
+    unknownArg(instance);
+    try {
+      unknownArg(null);
+    } catch (NullPointerException npe) {
+      System.out.println("Expected NPE");
+    }
+  }
+}
+
+@RunWith(VmTestRunner.class)
+public class ObjectsRequireNonNullTest extends TestBase {
+  private static final String JAVA_OUTPUT = StringUtils.lines(
+      "Foo::toString",
+      "Foo::bar",
+      "Foo::bar",
+      "Expected NPE"
+  );
+  private static final Class<?> MAIN = ObjectsRequireNonNullTestMain.class;
+
+  @Test
+  public void testJvmOutput() throws Exception {
+    testForJvm().addTestClasspath().run(MAIN).assertSuccessWithOutput(JAVA_OUTPUT);
+  }
+
+  private static boolean isObjectsRequireNonNull(DexMethod method) {
+    return method.toSourceString().equals(
+        "java.lang.Object java.util.Objects.requireNonNull(java.lang.Object)");
+  }
+
+  private long countObjectsRequireNonNull(MethodSubject method) {
+    return Streams.stream(method.iterateInstructions(instructionSubject -> {
+      if (instructionSubject.isInvoke()) {
+        return isObjectsRequireNonNull(instructionSubject.getMethod());
+      }
+      return false;
+    })).count();
+  }
+
+  private void test(TestRunResult result, int expectedCount) throws Exception {
+    CodeInspector codeInspector = result.inspector();
+    ClassSubject mainClass = codeInspector.clazz(MAIN);
+    MethodSubject mainMethod = mainClass.mainMethod();
+    assertThat(mainMethod, isPresent());
+    long count = countObjectsRequireNonNull(mainMethod);
+    assertEquals(expectedCount, count);
+
+    MethodSubject unknownArg = mainClass.uniqueMethodWithName("unknownArg");
+    assertThat(unknownArg, isPresent());
+    // Due to the nullable argument, requireNonNull should remain.
+    assertEquals(1, countObjectsRequireNonNull(unknownArg));
+  }
+
+  @Test
+  @IgnoreIfVmOlderThan(Version.V4_4_4)
+  public void testD8() throws Exception {
+    TestRunResult result = testForD8()
+        .debug()
+        .addProgramClassesAndInnerClasses(MAIN)
+        .run(MAIN)
+        .assertSuccessWithOutput(JAVA_OUTPUT);
+    test(result, 2);
+
+    result = testForD8()
+        .release()
+        .addProgramClassesAndInnerClasses(MAIN)
+        .run(MAIN)
+        .assertSuccessWithOutput(JAVA_OUTPUT);
+    test(result, 0);
+  }
+
+  @Test
+  @IgnoreIfVmOlderThan(Version.V4_4_4)
+  public void testR8() throws Exception {
+    // CF disables move result optimization.
+    TestRunResult result = testForR8(Backend.DEX)
+        .addProgramClassesAndInnerClasses(MAIN)
+        .enableInliningAnnotations()
+        .addKeepMainRule(MAIN)
+        .run(MAIN)
+        .assertSuccessWithOutput(JAVA_OUTPUT);
+    test(result, 0);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java
index cd3a131..7044366 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringContentCheckTest.java
@@ -35,7 +35,9 @@
         && "CONST".equalsIgnoreCase(arg)
         && "CONST".contentEquals(arg)
         && "CONST".indexOf(arg) > 0
-        && "CONST".lastIndexOf(arg) > 0;
+        && "CONST".lastIndexOf(arg) > 0
+        && "CONST".compareTo(arg) > 0
+        && "CONST".compareToIgnoreCase(arg) > 0;
   }
 
   public static void main(String[] args) {
@@ -52,6 +54,8 @@
       System.out.println(s1.indexOf("ix"));
       System.out.println(s1.lastIndexOf('f'));
       System.out.println(s1.lastIndexOf("ix"));
+      System.out.println(s1.compareTo("prefix-CONST-suffix") == 0);
+      System.out.println(s1.compareToIgnoreCase("PREFIX-const-SUFFIX") == 0);
     }
 
     {
@@ -68,6 +72,8 @@
       System.out.println(s2.indexOf("ix"));
       System.out.println(s2.lastIndexOf('f'));
       System.out.println(s2.lastIndexOf("ix"));
+      System.out.println(s2.compareTo("prefix-CONST-suffix") == 0);
+      System.out.println(s2.compareToIgnoreCase("pre-con-suf") == 0);
     }
 
     {
@@ -90,15 +96,15 @@
       StringContentCheckTestMain.class
   );
   private static final String JAVA_OUTPUT = StringUtils.lines(
-      // s1, contains
+      // s1, contains(String)
       "true",
-      // s1, startsWith
+      // s1, startsWith(String)
       "true",
-      // s1, endsWith
+      // s1, endsWith(String)
       "true",
-      // s1, equals
+      // s1, equals(String)
       "true",
-      // s1, equalsIgnoreCase
+      // s1, equalsIgnoreCase(String)
       "true",
       // s1, contentEquals(CharSequence)
       "true",
@@ -112,15 +118,19 @@
       "16",
       // s1, lastIndexOf(String)
       "17",
-      // s2, contains
+      // s1, compareTo(String)
+      "true",
+      // s1, compareToIgnoreCase(String)
+      "true",
+      // s2, contains(String)
       "false",
-      // s2, startsWith
+      // s2, startsWith(String)
       "false",
-      // s2, endsWith
+      // s2, endsWith(String)
       "false",
-      // s2, equals
+      // s2, equals(String)
       "false",
-      // s2, equalsIgnoreCase
+      // s2, equalsIgnoreCase(String)
       "false",
       // s2, contentEquals(CharSequence)
       "false",
@@ -134,6 +144,10 @@
       "-1",
       // s2, lastIndexOf(String)
       "-1",
+      // s2, compareTo(String)
+      "false",
+      // s2, compareToIgnoreCase(String)
+      "false",
       // argCouldBeNull
       "false"
   );
@@ -166,7 +180,9 @@
             || method.name.toString().equals("equalsIgnoreCase")
             || method.name.toString().equals("contentEquals")
             || method.name.toString().equals("indexOf")
-            || method.name.toString().equals("lastIndexOf"));
+            || method.name.toString().equals("lastIndexOf")
+            || method.name.toString().equals("compareTo")
+            || method.name.toString().equals("compareToIgnoreCase"));
   }
 
   private long countStringContentChecker(MethodSubject method) {
@@ -190,7 +206,7 @@
         "boolean", "argCouldBeNull", ImmutableList.of("java.lang.String"));
     assertThat(argCouldBeNull, isPresent());
     // Because of nullable argument, all checkers should remain.
-    assertEquals(8, countStringContentChecker(argCouldBeNull));
+    assertEquals(10, countStringContentChecker(argCouldBeNull));
   }
 
   @Test
@@ -202,14 +218,14 @@
         .addProgramClasses(CLASSES)
         .run(MAIN)
         .assertSuccessWithOutput(JAVA_OUTPUT);
-    test(result, 22);
+    test(result, 26);
 
     result = testForD8()
         .release()
         .addProgramClasses(CLASSES)
         .run(MAIN)
         .assertSuccessWithOutput(JAVA_OUTPUT);
-    test(result, 12);
+    test(result, 14);
   }
 
   @Test
@@ -221,6 +237,6 @@
         .addKeepMainRule(MAIN)
         .run(MAIN)
         .assertSuccessWithOutput(JAVA_OUTPUT);
-    test(result, 12);
+    test(result, 14);
   }
 }
diff --git a/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java b/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
index 877ffc0..4209cb6 100644
--- a/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/PackageNamingTest.java
@@ -312,11 +312,15 @@
     assertEquals("Lnaming101/a/a;", naming.lookupDescriptor(aa).toSourceString());
     DexType ba = dexItemFactory.createType("Lnaming101/b/a;");
     assertEquals("Lnaming101/b/a;", naming.lookupDescriptor(ba).toSourceString());
-    // Due to package-private access, classes in the same package should remain as-is.
-    DexType ab = dexItemFactory.createType("Lnaming101/a/b;");
-    assertEquals("Lnaming101/a/b;", naming.lookupDescriptor(ab).toSourceString());
+    // Due to package-private access, classes in the same package should remain in the same package.
+    DexType ac = dexItemFactory.createType("Lnaming101/a/c;");
+    assertEquals(
+        getPackageNameFromDescriptor(naming.lookupDescriptor(aa).toString()),
+        getPackageNameFromDescriptor(naming.lookupDescriptor(ac).toString()));
     DexType bb = dexItemFactory.createType("Lnaming101/b/b;");
-    assertEquals("Lnaming101/b/b;", naming.lookupDescriptor(bb).toSourceString());
+    assertEquals(
+        getPackageNameFromDescriptor(naming.lookupDescriptor(ba).toString()),
+        getPackageNameFromDescriptor(naming.lookupDescriptor(bb).toString()));
 
     // All other classes can be repackaged to naming101.a, but naming101.a.a exists to make a name
     // conflict. Thus, those should not be renamed to 'a'.
@@ -340,11 +344,15 @@
     assertEquals("Lnaming101/a/a;", naming.lookupDescriptor(aa).toSourceString());
     DexType ba = dexItemFactory.createType("Lnaming101/b/a;");
     assertEquals("Lnaming101/b/a;", naming.lookupDescriptor(ba).toSourceString());
-    // Due to package-private access, classes in the same package should remain as-is.
-    DexType ab = dexItemFactory.createType("Lnaming101/a/b;");
-    assertEquals("Lnaming101/a/b;", naming.lookupDescriptor(ab).toSourceString());
+    // Due to package-private access, classes in the same package should remain in the same package.
+    DexType ac = dexItemFactory.createType("Lnaming101/a/c;");
+    assertEquals(
+        getPackageNameFromDescriptor(naming.lookupDescriptor(aa).toString()),
+        getPackageNameFromDescriptor(naming.lookupDescriptor(ac).toString()));
     DexType bb = dexItemFactory.createType("Lnaming101/b/b;");
-    assertEquals("Lnaming101/b/b;", naming.lookupDescriptor(bb).toSourceString());
+    assertEquals(
+        getPackageNameFromDescriptor(naming.lookupDescriptor(ba).toString()),
+        getPackageNameFromDescriptor(naming.lookupDescriptor(bb).toString()));
 
     // All other packages are flattened to naming101, hence all other classes will be in
     // naming101.* package. Due to naming101.a.a, prefix naming101.a is already used. So,
diff --git a/src/test/java/com/android/tools/r8/shaking/UnusedTypeInThrowingTest.java b/src/test/java/com/android/tools/r8/shaking/UnusedTypeInThrowingTest.java
index 6a03a43..d199f57 100644
--- a/src/test/java/com/android/tools/r8/shaking/UnusedTypeInThrowingTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/UnusedTypeInThrowingTest.java
@@ -4,16 +4,21 @@
 
 package com.android.tools.r8.shaking;
 
+import static junit.framework.TestCase.assertTrue;
+
 import com.android.tools.r8.CompilationFailedException;
 import com.android.tools.r8.TestBase;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import java.io.IOException;
-import org.junit.Ignore;
+import java.util.concurrent.ExecutionException;
 import org.junit.Test;
 
 class UnusedTypeInThrowing {
 
+  public static final String EXPECTED = "42";
+
   public static void main(String[] args) throws UnusedTypeInThrowingThrowable {
-    System.out.print("42");
+    System.out.print(EXPECTED);
   }
 }
 
@@ -25,14 +30,20 @@
   static final Class MAIN_CLASS = UnusedTypeInThrowing.class;
 
   @Test
-  @Ignore("b/124019003")
-  public void testTypeIsMarkedAsLive() throws IOException, CompilationFailedException {
-    testForR8(Backend.CF)
-        .addProgramClasses(MAIN_CLASS)
-        .addProgramClasses(THROWABLE_CLASS)
-        .addKeepMainRule(MAIN_CLASS)
-        .addKeepRules("-keepattributes Exceptions")
-        .run(MAIN_CLASS)
-        .assertSuccessWithOutput("42");
+  public void testTypeIsMarkedAsLive()
+      throws IOException, CompilationFailedException, ExecutionException, NoSuchMethodException {
+    CodeInspector inspector =
+        testForR8(Backend.CF)
+            .enableGraphInspector()
+            .addProgramClasses(MAIN_CLASS)
+            .addProgramClasses(THROWABLE_CLASS)
+            .addKeepMainRule(MAIN_CLASS)
+            .addKeepRules("-keepattributes Exceptions")
+            .run(MAIN_CLASS)
+            .assertSuccessWithOutput(UnusedTypeInThrowing.EXPECTED)
+            .inspector();
+
+    assertTrue(inspector.clazz(THROWABLE_CLASS).isPresent());
+    // TODO(b/124217402) When done check that THROWABLE_CLASS is kept by the throwing annotation.
   }
 }
diff --git a/src/test/java/com/android/tools/r8/shaking/UnusedTypeInThrowingTestRunner.java b/src/test/java/com/android/tools/r8/shaking/UnusedTypeInThrowingTestRunner.java
deleted file mode 100644
index 2bf42a1..0000000
--- a/src/test/java/com/android/tools/r8/shaking/UnusedTypeInThrowingTestRunner.java
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.shaking;
-
-import com.android.tools.r8.CompilationFailedException;
-import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.TestBase;
-import com.google.common.collect.ImmutableList;
-import java.io.IOException;
-import java.nio.file.Path;
-import org.junit.Ignore;
-import org.junit.Test;
-
-public class UnusedTypeInThrowingTestRunner extends TestBase {
-
-  static final Class THROWABLE_CLASS = UnusedTypeInThrowingThrowable.class;
-  static final Class MAIN_CLASS = UnusedTypeInThrowingTest.class;
-
-  @Test
-  @Ignore("b/124019003")
-  public void testTypeIsMarkedAsLive() throws IOException, CompilationFailedException {
-    Path outDex = temp.newFile("out.zip").toPath();
-    testForR8(Backend.CF)
-        .addProgramClasses(MAIN_CLASS)
-        .addProgramClasses(THROWABLE_CLASS)
-        .addKeepMainRule(MAIN_CLASS)
-        .addKeepRules(ImmutableList.of("-keepattributes Exceptions"))
-        .setMode(CompilationMode.RELEASE)
-        .enableInliningAnnotations()
-        .minification(true)
-        .compile()
-        .run(MAIN_CLASS)
-        .assertSuccessWithOutput("42");
-  }
-}
diff --git a/tools/api_sample_coverage.py b/tools/api_sample_coverage.py
index b14ad1a..4eea8c7 100755
--- a/tools/api_sample_coverage.py
+++ b/tools/api_sample_coverage.py
@@ -8,6 +8,7 @@
 '''
 
 import argparse
+import jdk
 import os
 import subprocess
 import utils
@@ -23,16 +24,17 @@
   if output_dir is None:
     output_dir = ''
 
+  javaExecutable = jdk.GetJavaExecutable()
   printseeds_path = os.path.join(output_dir, 'keep-seeds.txt')
   printseeds_args = [
-    'java', '-jar', utils.R8_JAR, 'printseeds',
+    javaExecutable, '-jar', utils.R8_JAR, 'printseeds',
     utils.RT_JAR, utils.R8_JAR, utils.R8LIB_KEEP_RULES,
   ]
   write_sorted_lines(printseeds_args, printseeds_path)
 
   printuses_path = os.path.join(output_dir, 'sample-uses.txt')
   printuses_args = [
-    'java', '-jar', utils.R8_JAR, 'printuses',
+    javaExecutable, '-jar', utils.R8_JAR, 'printuses',
     utils.RT_JAR, utils.R8_JAR, API_SAMPLE_JAR,
   ]
   write_sorted_lines(printuses_args, printuses_path)
diff --git a/tools/archive.py b/tools/archive.py
index d8fb4d0..9de199c 100755
--- a/tools/archive.py
+++ b/tools/archive.py
@@ -5,6 +5,7 @@
 
 import create_maven_release
 import gradle
+import jdk
 import optparse
 import os
 import shutil
@@ -25,7 +26,9 @@
   return result.parse_args()
 
 def GetToolVersion(jar_path):
-  output = subprocess.check_output(['java', '-jar', jar_path, '--version'])
+  output = subprocess.check_output([
+    jdk.GetJavaExecutable(), '-jar', jar_path, '--version'
+  ])
   return output.splitlines()[0].strip()
 
 def GetVersion():
diff --git a/tools/asmifier.py b/tools/asmifier.py
index 280c6f1..3080378 100755
--- a/tools/asmifier.py
+++ b/tools/asmifier.py
@@ -4,6 +4,7 @@
 # BSD-style license that can be found in the LICENSE file.
 
 import gradle
+import jdk
 import os
 import subprocess
 import sys
@@ -13,7 +14,7 @@
   if build:
     gradle.RunGradle(['copyMavenDeps'])
   cmd = []
-  cmd.append('java')
+  cmd.append(jdk.GetJavaExecutable())
   cp = ":".join([os.path.join(utils.REPO_ROOT, 'build/deps/asm-6.2.1.jar'),
                  os.path.join(utils.REPO_ROOT, 'build/deps/asm-util-6.2.1.jar')])
   cmd.extend(['-cp', cp])
diff --git a/tools/build_r8lib.py b/tools/build_r8lib.py
index 5368f6f..980715e 100755
--- a/tools/build_r8lib.py
+++ b/tools/build_r8lib.py
@@ -10,6 +10,7 @@
 
 import argparse
 import gradle
+import jdk
 import os
 import subprocess
 import toolhelper
@@ -76,7 +77,8 @@
 
 def test_d8sample(paths):
   with utils.TempDir() as path:
-    args = ['java', '-cp', '%s:%s' % (SAMPLE_JAR, ":".join(paths)),
+    args = [jdk.GetJavaExecutable(),
+            '-cp', '%s:%s' % (SAMPLE_JAR, ":".join(paths)),
             'com.android.tools.apiusagesample.D8ApiUsageSample',
             '--output', path,
             '--min-api', str(API_LEVEL),
@@ -94,7 +96,8 @@
     # R8CommandParser should have been minified in LIB_JAR.
     # Just in case R8CommandParser is also present in LIB_JAR, we put
     # SAMPLE_JAR first on the classpath to use its version of R8CommandParser.
-    args = ['java', '-cp', '%s:%s' % (SAMPLE_JAR, ":".join(paths)),
+    args = [jdk.GetJavaExecutable(),
+            '-cp', '%s:%s' % (SAMPLE_JAR, ":".join(paths)),
             'com.android.tools.r8.R8CommandParser',
             '--output', path + "/output.zip",
             '--min-api', str(API_LEVEL),
@@ -111,7 +114,8 @@
     # R8CommandParser should have been minified in LIB_JAR.
     # Just in case R8CommandParser is also present in LIB_JAR, we put
     # SAMPLE_JAR first on the classpath to use its version of R8CommandParser.
-    args = ['java', '-cp', '%s:%s' % (SAMPLE_JAR, ":".join(paths)),
+    args = [jdk.GetJavaExecutable(),
+            '-cp', '%s:%s' % (SAMPLE_JAR, ":".join(paths)),
             'com.android.tools.r8.R8CommandParser',
             '--classfile',
             '--output', path + "/output.jar",
diff --git a/tools/build_sample_apk.py b/tools/build_sample_apk.py
index 9053e23..29f7459 100755
--- a/tools/build_sample_apk.py
+++ b/tools/build_sample_apk.py
@@ -8,6 +8,7 @@
 import apk_utils
 import fnmatch
 import glob
+import jdk
 import optparse
 import os
 import shutil
@@ -21,7 +22,7 @@
 DEFAULT_AAPT = 'aapt' # Assume in path.
 DEFAULT_D8 = os.path.join(utils.REPO_ROOT, 'tools', 'd8.py')
 DEFAULT_DEXSPLITTER = os.path.join(utils.REPO_ROOT, 'tools', 'dexsplitter.py')
-DEFAULT_JAVAC = 'javac'
+DEFAULT_JAVAC = jdk.GetJavacExecutable()
 SRC_LOCATION = 'src/com/android/tools/r8/sample/{app}/*.java'
 DEFAULT_KEYSTORE = os.path.join(os.getenv('HOME'), '.android', 'debug.keystore')
 PACKAGE_PREFIX = 'com.android.tools.r8.sample'
diff --git a/tools/defines.py b/tools/defines.py
new file mode 100644
index 0000000..6fdd24f
--- /dev/null
+++ b/tools/defines.py
@@ -0,0 +1,22 @@
+# Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+# for details. All rights reserved. Use of this source code is governed by a
+# BSD-style license that can be found in the LICENSE file.
+
+import os
+import sys
+
+# Static defines for use in tools (and utils.py).
+# There must be no dependencies on other utils from this file!
+
+TOOLS_DIR = os.path.abspath(os.path.normpath(os.path.join(__file__, '..')))
+REPO_ROOT = os.path.realpath(os.path.join(TOOLS_DIR, '..'))
+THIRD_PARTY = os.path.join(REPO_ROOT, 'third_party')
+
+def IsWindows():
+  return sys.platform.startswith('win')
+
+def IsLinux():
+  return sys.platform.startswith('linux')
+
+def IsOsX():
+  return sys.platform.startswith('darwin')
\ No newline at end of file
diff --git a/tools/gradle.py b/tools/gradle.py
index 374f885..232e96d 100755
--- a/tools/gradle.py
+++ b/tools/gradle.py
@@ -44,9 +44,15 @@
   utils.EnsureDepFromGoogleCloudStorage(
     GRADLE, GRADLE_TGZ, GRADLE_SHA1, 'Gradle binary')
 
+def EnsureJdk():
+  jdkHome = jdk.GetJdkHome()
+  jdkTgz = jdkHome + '.tar.gz'
+  jdkSha1 = jdkTgz + '.sha1'
+  utils.EnsureDepFromGoogleCloudStorage(jdkHome, jdkTgz, jdkSha1, 'JDK')
+
 def EnsureDeps():
   EnsureGradle()
-  jdk.EnsureJdk()
+  EnsureJdk()
 
 def RunGradleIn(gradleCmd, args, cwd, throw_on_failure=True, env=None):
   EnsureDeps()
diff --git a/tools/jdk.py b/tools/jdk.py
index 5a20901..5791e50 100755
--- a/tools/jdk.py
+++ b/tools/jdk.py
@@ -3,40 +3,33 @@
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
+import defines
 import os
 import sys
-import utils
 
-JDK_DIR = os.path.join(utils.REPO_ROOT, 'third_party', 'openjdk')
+JDK_DIR = os.path.join(defines.THIRD_PARTY, 'openjdk')
 
 def GetJdkHome():
   root = os.path.join(JDK_DIR, 'openjdk-9.0.4')
-  if utils.IsLinux():
+  if defines.IsLinux():
     return os.path.join(root, 'linux')
-  elif utils.IsOsX():
+  elif defines.IsOsX():
     return os.path.join(root, 'osx')
-  elif utils.IsWindows():
+  elif defines.IsWindows():
     return os.path.join(root, 'windows')
   else:
     return os.environ['JAVA_HOME']
-  return jdkHome
 
 def GetJavaExecutable(jdkHome=None):
   jdkHome = jdkHome if jdkHome else GetJdkHome()
-  executable = 'java.exe' if utils.IsWindows() else 'java'
+  executable = 'java.exe' if defines.IsWindows() else 'java'
   return os.path.join(jdkHome, 'bin', executable) if jdkHome else executable
 
 def GetJavacExecutable(jdkHome=None):
   jdkHome = jdkHome if jdkHome else GetJdkHome()
-  executable = 'javac.exe' if utils.IsWindows() else 'javac'
+  executable = 'javac.exe' if defines.IsWindows() else 'javac'
   return os.path.join(jdkHome, 'bin', executable) if jdkHome else executable
 
-def EnsureJdk():
-  jdkHome = GetJdkHome()
-  jdkTgz = jdkHome + '.tar.gz'
-  jdkSha1 = jdkTgz + '.sha1'
-  utils.EnsureDepFromGoogleCloudStorage(jdkHome, jdkTgz, jdkSha1, 'JDK')
-
 def Main():
   print GetJdkHome()
 
diff --git a/tools/proguard.py b/tools/proguard.py
index 640094f..b1bde54 100755
--- a/tools/proguard.py
+++ b/tools/proguard.py
@@ -6,6 +6,7 @@
 # Run ProGuard, Google's internal version
 
 from __future__ import print_function
+import jdk
 import os
 import subprocess
 import sys
@@ -19,7 +20,7 @@
   cmd = []
   if track_memory_file:
     cmd.extend(['tools/track_memory.sh', track_memory_file])
-  cmd.extend(['java', '-jar', PROGUARD_JAR])
+  cmd.extend([jdk.GetJavaExecutable(), '-jar', PROGUARD_JAR])
   cmd.extend(args)
   utils.PrintCmd(cmd)
   subprocess.call(cmd, stdout=stdout, stderr=stderr)
diff --git a/tools/retrace.py b/tools/retrace.py
index 1b77e9a..44120f2 100755
--- a/tools/retrace.py
+++ b/tools/retrace.py
@@ -5,6 +5,7 @@
 
 import archive
 import argparse
+import jdk
 import subprocess
 import sys
 import tempfile
@@ -49,7 +50,9 @@
       print('Could not find map file from argument: %s.' % hashOrVersion)
       return 1
 
-  retrace_args = ['java', '-jar', utils.RETRACE_JAR, r8lib_map_path]
+  retrace_args = [
+    jdk.GetJavaExecutable(), '-jar', utils.RETRACE_JAR, r8lib_map_path
+  ]
   if args.stacktrace:
     retrace_args.append(args.stacktrace)
 
diff --git a/tools/run_on_as_app.py b/tools/run_on_as_app.py
index 2889d74..506c583 100755
--- a/tools/run_on_as_app.py
+++ b/tools/run_on_as_app.py
@@ -7,6 +7,7 @@
 import apk_utils
 import golem
 import gradle
+import jdk
 import os
 import optparse
 import shutil
@@ -177,7 +178,7 @@
 
   # Use the copy of r8.jar if it is there.
   if os.path.isfile(r8_jar):
-    cmd = ['java', '-ea', '-jar', r8_jar, 'extractmarker', apk]
+    cmd = [jdk.GetJavaExecutable(), '-ea', '-jar', r8_jar, 'extractmarker', apk]
   else:
     script = os.path.join(utils.TOOLS_DIR, 'extractmarker.py')
     cmd = ['python', script, apk]
@@ -493,7 +494,7 @@
   # is 'r8'.
   entry_point = 'com.android.tools.r8.R8'
 
-  cmd = ['java', '-ea:com.android.tools.r8...', '-cp', r8_jar, entry_point,
+  cmd = [jdk.GetJavaExecutable(), '-ea:com.android.tools.r8...', '-cp', r8_jar, entry_point,
       '--release', '--min-api', str(min_sdk), '--pg-conf', proguard_config_file,
       '--lib', android_jar, '--output', zip_dest, apk]
 
diff --git a/tools/run_proguard_dx_on_app.py b/tools/run_proguard_dx_on_app.py
index e78d5d1..4e408ff 100755
--- a/tools/run_proguard_dx_on_app.py
+++ b/tools/run_proguard_dx_on_app.py
@@ -13,6 +13,7 @@
 import argparse
 import fnmatch
 import gmscore_data
+import jdk
 import os
 import stat
 import sys
@@ -140,7 +141,7 @@
     if options.print_memoryuse:
       track_memory_file = join(temp, utils.MEMORY_USE_TMP_FILE)
       cmd.extend(['tools/track_memory.sh', track_memory_file])
-    cmd.extend(['java', '-jar', jar, '--multi-dex',
+    cmd.extend([jdk.GetJavaExecutable(), '-jar', jar, '--multi-dex',
         '--output=' + outdir])
     if 'min-api' in values_proguarded:
       cmd.append('--min-sdk-version=' + values_proguarded['min-api'])
diff --git a/tools/test_aosp_jar.py b/tools/test_aosp_jar.py
index bf12045..6f7e8f5 100755
--- a/tools/test_aosp_jar.py
+++ b/tools/test_aosp_jar.py
@@ -10,6 +10,7 @@
 from itertools import chain
 from os.path import join
 import argparse
+import jdk
 import os
 import subprocess
 import sys
@@ -36,7 +37,7 @@
   if not args.no_build:
     gradle.RunGradle(['CompatDx'])
 
-  cmd = [REPLAY_SCRIPT, 'java', '-jar', utils.COMPATDX_JAR]
+  cmd = [REPLAY_SCRIPT, jdk.GetJavaExecutable(), '-jar', utils.COMPATDX_JAR]
   utils.PrintCmd(cmd)
   subprocess.check_call(cmd)
 
diff --git a/tools/test_framework.py b/tools/test_framework.py
index 7400541..f30d7d9 100755
--- a/tools/test_framework.py
+++ b/tools/test_framework.py
@@ -21,6 +21,7 @@
 from glob import glob
 import argparse
 import golem
+import jdk
 import os
 import re
 import subprocess
@@ -96,7 +97,7 @@
 
     if tool_file.endswith('.jar'):
       assert xmx is not None
-      cmd.extend(['java', xmx, '-jar'])
+      cmd.extend([jdk.GetJavaExecutable(), xmx, '-jar'])
 
     cmd.extend([tool_file] + tool_args + [FRAMEWORK_JAR])
 
diff --git a/tools/test_self_retrace.py b/tools/test_self_retrace.py
index 6e48aa6..46cb1d9 100755
--- a/tools/test_self_retrace.py
+++ b/tools/test_self_retrace.py
@@ -7,6 +7,7 @@
 from __future__ import division
 from __future__ import print_function
 import gradle
+import jdk
 import os
 import subprocess
 import sys
@@ -37,7 +38,9 @@
     raise Exception("Only one argument is allowed, see '--help'.")
 
   # Run 'r8 --help' which throws an exception.
-  cmd = ['java','-cp', r8lib, 'com.android.tools.r8.R8', '--help']
+  cmd = [
+    jdk.GetJavaExecutable(),'-cp', r8lib, 'com.android.tools.r8.R8', '--help'
+  ]
   os.environ["R8_THROW_EXCEPTION_FOR_TESTING_RETRACE"] = "1"
   utils.PrintCmd(cmd)
   p = subprocess.Popen(cmd, stderr=subprocess.PIPE)
@@ -48,7 +51,7 @@
   assert('SelfRetraceTest' not in stacktrace)
 
   # Run the retrace tool.
-  cmd = ['java', '-jar', utils.RETRACE_JAR, r8lib + ".map"]
+  cmd = [jdk.GetJavaExecutable(), '-jar', utils.RETRACE_JAR, r8lib + ".map"]
   utils.PrintCmd(cmd)
   p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
   retrace_stdout, _ = p.communicate(stacktrace)
diff --git a/tools/toolhelper.py b/tools/toolhelper.py
index 9371fb9..10da97d 100644
--- a/tools/toolhelper.py
+++ b/tools/toolhelper.py
@@ -4,7 +4,7 @@
 
 import glob
 import gradle
-import os
+import jdk
 import subprocess
 from threading import Timer
 import utils
@@ -19,7 +19,7 @@
   cmd = []
   if track_memory_file:
     cmd.extend(['tools/track_memory.sh', track_memory_file])
-  cmd.append('java')
+  cmd.append(jdk.GetJavaExecutable())
   if extra_args:
     cmd.extend(extra_args)
   if debug:
@@ -61,7 +61,7 @@
       'compileTestJava',
     ])
   cmd = []
-  cmd.append('java')
+  cmd.append(jdk.GetJavaExecutable())
   if extra_args:
     cmd.extend(extra_args)
   if debug:
diff --git a/tools/utils.py b/tools/utils.py
index 20d7bc7..892fe7d 100644
--- a/tools/utils.py
+++ b/tools/utils.py
@@ -4,7 +4,9 @@
 
 # Different utility functions used accross scripts
 
+import defines
 import hashlib
+import jdk
 import os
 import re
 import shutil
@@ -16,9 +18,9 @@
 
 ANDROID_JAR_DIR = 'third_party/android_jar/lib-v{api}'
 ANDROID_JAR = os.path.join(ANDROID_JAR_DIR, 'android.jar')
-TOOLS_DIR = os.path.abspath(os.path.normpath(os.path.join(__file__, '..')))
-REPO_ROOT = os.path.realpath(os.path.join(TOOLS_DIR, '..'))
-THIRD_PARTY = os.path.join(REPO_ROOT, 'third_party')
+TOOLS_DIR = defines.TOOLS_DIR
+REPO_ROOT = defines.REPO_ROOT
+THIRD_PARTY = defines.THIRD_PARTY
 MEMORY_USE_TMP_FILE = 'memory_use.tmp'
 DEX_SEGMENTS_RESULT_PATTERN = re.compile('- ([^:]+): ([0-9]+)')
 BUILD = os.path.join(REPO_ROOT, 'build')
@@ -156,13 +158,13 @@
       return stdout
 
 def IsWindows():
-  return sys.platform.startswith('win')
+  return defines.IsWindows()
 
 def IsLinux():
-  return sys.platform.startswith('linux')
+  return defines.IsLinux()
 
 def IsOsX():
-  return sys.platform.startswith('darwin')
+  return defines.IsOsX()
 
 def EnsureDepFromGoogleCloudStorage(dep, tgz, sha1, msg):
   if not os.path.exists(dep) or os.path.getmtime(tgz) < os.path.getmtime(sha1):
@@ -385,7 +387,7 @@
 # Return a dictionary: {segment_name -> segments_size}
 def getDexSegmentSizes(dex_files):
   assert len(dex_files) > 0
-  cmd = ['java', '-jar', R8_JAR, 'dexsegments']
+  cmd = [jdk.GetJavaExecutable(), '-jar', R8_JAR, 'dexsegments']
   cmd.extend(dex_files)
   PrintCmd(cmd)
   output = subprocess.check_output(cmd)
@@ -405,7 +407,7 @@
 
 # Return a dictionary: {segment_name -> segments_size}
 def getCfSegmentSizes(cfFile):
-  cmd = ['java',
+  cmd = [jdk.GetJavaExecutable(),
          '-cp',
          CF_SEGMENTS_TOOL,
          'com.android.tools.r8.cf_segments.MeasureLib',
@@ -443,7 +445,7 @@
 
 # Ensure that we are not benchmarking with a google jvm.
 def check_java_version():
-  cmd= ['java', '-version']
+  cmd= [jdk.GetJavaExecutable(), '-version']
   output = subprocess.check_output(cmd, stderr = subprocess.STDOUT)
   m = re.search('openjdk version "([^"]*)"', output)
   if m is None: