diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 16b75f5..ae8d4ae 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -681,8 +681,8 @@
         timing.end();
       } else {
         if (appView.appInfo().hasLiveness()) {
-          // TODO(124726014): Rewrite signature annotations in lens rewriting instead of here?
-          new GenericSignatureRewriter(appView.withLiveness()).run();
+          // TODO(b/124726014): Rewrite signature annotations in lens rewriting instead of here?
+          new GenericSignatureRewriter(appView.withLiveness()).run(appView.appInfo().classes());
         }
         namingLens = NamingLens.getIdentityLens();
       }
diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index 1027b71..375cc0b 100644
--- a/src/main/java/com/android/tools/r8/Version.java
+++ b/src/main/java/com/android/tools/r8/Version.java
@@ -11,7 +11,7 @@
 
   // This field is accessed from release scripts using simple pattern matching.
   // Therefore, changing this field could break our release scripts.
-  public static final String LABEL = "1.5.34";
+  public static final String LABEL = "1.5.35";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java
index 166ec88..a3e71e6 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/UnusedArgumentsCollector.java
@@ -21,7 +21,8 @@
 import com.android.tools.r8.ir.optimize.MemberPoolCollection.MemberPool;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.MethodSignatureEquivalence;
-import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.SymbolGenerationUtils;
+import com.android.tools.r8.utils.SymbolGenerationUtils.MixedCasing;
 import com.android.tools.r8.utils.ThreadUtils;
 import com.android.tools.r8.utils.Timing;
 import com.google.common.base.Equivalence.Wrapper;
@@ -148,8 +149,10 @@
               appView
                   .dexItemFactory()
                   .createString(
-                      StringUtils.numberToIdentifier(
-                          count, method.method.name.toSourceString().toCharArray()));
+                      SymbolGenerationUtils.numberToIdentifier(
+                          count,
+                          MixedCasing.USE_MIXED_CASE,
+                          method.method.name.toSourceString().toCharArray()));
         } else {
           // Constructors must be named `<init>`.
           return null;
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java b/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java
index 1b50601..8018a2d 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java
@@ -30,8 +30,6 @@
 import com.google.common.collect.Sets;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
@@ -50,8 +48,6 @@
 
   private final Map<DexType, DexString> renaming = Maps.newIdentityHashMap();
   private final Map<String, Namespace> states = new HashMap<>();
-  private final List<String> packageDictionary;
-  private final List<String> classDictionary;
   private final boolean keepInnerClassStructure;
 
   private final Namespace topLevelState;
@@ -69,8 +65,6 @@
     this.packageObfuscationMode = options.getProguardConfiguration().getPackageObfuscationMode();
     this.isAccessModificationAllowed =
         options.getProguardConfiguration().isAccessModificationAllowed();
-    this.packageDictionary = options.getProguardConfiguration().getPackageObfuscationDictionary();
-    this.classDictionary = options.getProguardConfiguration().getClassObfuscationDictionary();
     this.keepInnerClassStructure =
         options.getProguardConfiguration().getKeepAttributes().signature
             || options.getProguardConfiguration().getKeepAttributes().innerClasses;
@@ -134,7 +128,7 @@
     timing.end();
 
     timing.begin("rename-generic");
-    new GenericSignatureRewriter(appView, renaming).run();
+    new GenericSignatureRewriter(appView, renaming).run(classes);
     timing.end();
 
     timing.begin("rename-arrays");
@@ -356,12 +350,12 @@
     }
   }
 
-  protected class Namespace {
+  protected class Namespace implements InternalNamingState {
 
     private final String packageName;
     private final char[] packagePrefix;
-    private final Iterator<String> packageDictionaryIterator;
-    private final Iterator<String> classDictionaryIterator;
+    private int dictionaryIndex = 0;
+    private int nameIndex = 1;
 
     Namespace(String packageName) {
       this(packageName, String.valueOf(DESCRIPTOR_PACKAGE_SEPARATOR));
@@ -373,8 +367,6 @@
           // L or La/b/ (or La/b/C$)
           + (packageName.isEmpty() ? "" : separator))
           .toCharArray();
-      this.packageDictionaryIterator = packageDictionary.iterator();
-      this.classDictionaryIterator = classDictionary.iterator();
 
       // R.class in Android, which contains constant IDs to assets, can be bundled at any time.
       // Insert `R` immediately so that the class name minifier can skip that name by default.
@@ -386,63 +378,49 @@
       return packageName;
     }
 
-    private DexString nextSuggestedNameForClass(DexType type) {
-      StringBuilder nextName = new StringBuilder();
-      if (!classNamingStrategy.bypassDictionary() && classDictionaryIterator.hasNext()) {
-        nextName.append(packagePrefix).append(classDictionaryIterator.next()).append(';');
-        return appView.dexItemFactory().createString(nextName.toString());
-      } else {
-        return classNamingStrategy.next(this, type, packagePrefix);
-      }
-    }
-
     DexString nextTypeName(DexType type) {
       DexString candidate;
       do {
-        candidate = nextSuggestedNameForClass(type);
+        candidate = classNamingStrategy.next(type, packagePrefix, this);
       } while (usedTypeNames.contains(candidate));
       usedTypeNames.add(candidate);
       return candidate;
     }
 
-    private String nextSuggestedNameForSubpackage() {
-      // Note that the differences between this method and the other variant for class renaming are
-      // 1) this one uses the different dictionary and counter,
-      // 2) this one does not append ';' at the end, and
-      // 3) this one removes 'L' at the beginning to make the return value a binary form.
-      if (!packageNamingStrategy.bypassDictionary() && packageDictionaryIterator.hasNext()) {
-        StringBuilder nextName = new StringBuilder();
-        nextName.append(packagePrefix).append(packageDictionaryIterator.next());
-        return nextName.toString().substring(1);
-      } else {
-        return packageNamingStrategy.next(this, packagePrefix);
-      }
-    }
-
     String nextPackagePrefix() {
       String candidate;
       do {
-        candidate = nextSuggestedNameForSubpackage();
+        candidate = packageNamingStrategy.next(packagePrefix, this);
       } while (usedPackagePrefixes.contains(candidate));
       usedPackagePrefixes.add(candidate);
       return candidate;
     }
+
+    @Override
+    public int getDictionaryIndex() {
+      return dictionaryIndex;
+    }
+
+    @Override
+    public int incrementDictionaryIndex() {
+      return dictionaryIndex++;
+    }
+
+    @Override
+    public int incrementNameIndex(boolean isDirectMethodCall) {
+      assert !isDirectMethodCall;
+      return nameIndex++;
+    }
   }
 
   protected interface ClassNamingStrategy {
-
-    DexString next(Namespace namespace, DexType type, char[] packagePrefix);
-
-    boolean bypassDictionary();
+    DexString next(DexType type, char[] packagePrefix, InternalNamingState state);
 
     boolean noObfuscation(DexType type);
   }
 
   protected interface PackageNamingStrategy {
-
-    String next(Namespace namespace, char[] packagePrefix);
-
-    boolean bypassDictionary();
+    String next(char[] packagePrefix, InternalNamingState state);
   }
 
   /**
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 aeac240..437d78b 100644
--- a/src/main/java/com/android/tools/r8/naming/FieldNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/FieldNameMinifier.java
@@ -85,11 +85,15 @@
     for (DexClass clazz : appView.appInfo().app().asDirect().allClasses()) {
       ReservedFieldNamingState reservedNames = null;
       for (DexEncodedField field : clazz.fields()) {
-        if (shouldReserveName(clazz, field)) {
+        DexString reservedName = strategy.getReservedNameOrDefault(field, clazz, null);
+        if (reservedName != null) {
           if (reservedNames == null) {
             reservedNames = getOrCreateReservedFieldNamingState(clazz.type);
           }
-          reservedNames.markReservedDirectly(field.field);
+          reservedNames.markReservedDirectly(reservedName, field.field.type);
+          if (reservedName != field.field.name) {
+            renaming.put(field.field, reservedName);
+          }
         }
       }
 
@@ -109,17 +113,6 @@
     propagateReservedFieldNamesUpwards();
   }
 
-  private boolean shouldReserveName(DexClass clazz, DexEncodedField field) {
-    if (clazz.isLibraryClass()) {
-      return true;
-    }
-    if (!appView.options().getProguardConfiguration().hasApplyMappingFile()
-        && appView.rootSet().mayNotBeMinified(field.field, appView)) {
-      return true;
-    }
-    return false;
-  }
-
   private void propagateReservedFieldNamesUpwards() {
     BottomUpClassHierarchyTraversal.forProgramClasses(appView)
         .visit(
diff --git a/src/main/java/com/android/tools/r8/naming/FieldNamingState.java b/src/main/java/com/android/tools/r8/naming/FieldNamingState.java
index b713582..d8cb81d 100644
--- a/src/main/java/com/android/tools/r8/naming/FieldNamingState.java
+++ b/src/main/java/com/android/tools/r8/naming/FieldNamingState.java
@@ -12,7 +12,6 @@
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.naming.FieldNamingState.InternalState;
-import com.android.tools.r8.naming.MemberNamingStrategy.MemberNamingInternalState;
 import java.util.IdentityHashMap;
 import java.util.Map;
 
@@ -51,14 +50,15 @@
     DexEncodedField encodedField = appView.appInfo().resolveField(field);
     if (encodedField != null) {
       DexClass clazz = appView.definitionFor(encodedField.field.holder);
-      if (clazz == null || clazz.isLibraryClass()) {
+      if (clazz == null) {
         return field.name;
       }
-      if (!appView.options().getProguardConfiguration().hasApplyMappingFile()
-          && appView.rootSet().mayNotBeMinified(encodedField.field, appView)) {
-        return field.name;
+      DexString reservedName = strategy.getReservedNameOrDefault(encodedField, clazz, null);
+      if (reservedName != null) {
+        return reservedName;
       }
     }
+    // TODO(b/133208730) If we cannot resolve the field, are we then allowed to rename it?
     return getOrCreateInternalState(field).createNewName(field);
   }
 
@@ -80,7 +80,7 @@
     return new FieldNamingState(appView, strategy, reservedNames, internalStatesClone);
   }
 
-  class InternalState implements MemberNamingInternalState, Cloneable {
+  class InternalState implements InternalNamingState, Cloneable {
 
     private int dictionaryIndex;
     private int nextNameIndex;
@@ -98,8 +98,7 @@
       DexString name;
       do {
         name = strategy.next(field, this);
-      } while (reservedNames.isReserved(name, field.type)
-          && !strategy.breakOnNotAvailable(field, name));
+      } while (reservedNames.isReserved(name, field.type));
       return name;
     }
 
diff --git a/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java b/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
index a43dcb8..4c751c6 100644
--- a/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
@@ -289,7 +289,7 @@
 
       for (MethodNamingState<?> namingState : globalStateMap.get(wrapper)) {
         if (!namingState.isReserved(unifiedMethod.name, unifiedMethod.proto)) {
-          namingState.reserveName(unifiedMethod.name, unifiedMethod.proto);
+          namingState.reserveName(unifiedMethod.name, unifiedMethod.proto, unifiedMethod.name);
           changed = true;
         }
       }
diff --git a/src/main/java/com/android/tools/r8/naming/InternalNamingState.java b/src/main/java/com/android/tools/r8/naming/InternalNamingState.java
new file mode 100644
index 0000000..e5749c1
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/naming/InternalNamingState.java
@@ -0,0 +1,14 @@
+// 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.naming;
+
+interface InternalNamingState {
+
+  int getDictionaryIndex();
+
+  int incrementDictionaryIndex();
+
+  int incrementNameIndex(boolean isDirectMethodCall);
+}
diff --git a/src/main/java/com/android/tools/r8/naming/MemberNamingStrategy.java b/src/main/java/com/android/tools/r8/naming/MemberNamingStrategy.java
index 260b176..f33027b 100644
--- a/src/main/java/com/android/tools/r8/naming/MemberNamingStrategy.java
+++ b/src/main/java/com/android/tools/r8/naming/MemberNamingStrategy.java
@@ -4,6 +4,9 @@
 
 package com.android.tools.r8.naming;
 
+import com.android.tools.r8.graph.DexClass;
+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.DexMethod;
 import com.android.tools.r8.graph.DexReference;
@@ -11,20 +14,17 @@
 
 public interface MemberNamingStrategy {
 
-  DexString next(DexMethod method, MemberNamingInternalState internalState);
+  DexString next(DexMethod method, InternalNamingState internalState);
 
-  DexString next(DexField field, MemberNamingInternalState internalState);
+  DexString next(DexField field, InternalNamingState internalState);
 
-  boolean breakOnNotAvailable(DexReference source, DexString name);
+  DexString getReservedNameOrDefault(
+      DexEncodedMethod method, DexClass holder, DexString defaultValue);
 
-  boolean noObfuscation(DexReference reference);
+  DexString getReservedNameOrDefault(
+      DexEncodedField field, DexClass holder, DexString defaultValue);
 
-  interface MemberNamingInternalState {
+  boolean allowMemberRenaming(DexClass holder);
 
-    int getDictionaryIndex();
-
-    int incrementDictionaryIndex();
-
-    int incrementNameIndex(boolean isDirectMethodCall);
-  }
+  void reportReservationError(DexReference source, DexString name);
 }
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 029f65a..9b07115 100644
--- a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
@@ -37,7 +37,8 @@
  * <p>As in the Dalvik VM method dispatch takes argument and return types of methods into account,
  * we can further reuse names if the prototypes of two methods differ. For this, we store the above
  * state separately for each proto using a map from protos to {@link
- * MethodNamingState.InternalState} objects. These internal state objects are also linked.
+ * MethodNamingState.InternalReservationState} objects. These internal state objects are also
+ * linked.
  *
  * <p>Name assignment happens in 4 stages. In the first stage, we record all names that are used by
  * library classes or are flagged using a keep rule as reserved. This step also allocates the {@link
@@ -72,9 +73,9 @@
  * states of classes. Hence, skipping over names during interface naming does not impact their
  * availability in the next phase.
  *
- * <p>In the final stage, we assign names to methods by traversing the subtype tree, now allocating
- * separate naming states for each class starting from the frontier. In the first swoop, we allocate
- * all non-private methods, updating naming states accordingly.
+ * <p>In stage 4, we assign names to methods by traversing the subtype tree, now allocating separate
+ * naming states for each class starting from the frontier. In the first swoop, we allocate all
+ * non-private methods, updating naming states accordingly.
  *
  * <p>Finally, the computed renamings are returned as a map from {@link DexMethod} to {@link
  * DexString}. The MethodNameMinifier object should not be retained to ensure all intermediate state
@@ -139,11 +140,6 @@
     return states.computeIfAbsent(type, f);
   }
 
-  private boolean alwaysReserveMemberNames(DexClass holder) {
-    return !appView.options().getProguardConfiguration().hasApplyMappingFile()
-        && holder.isNotProgramClass();
-  }
-
   private Function<DexProto, ?> getKeyTransform() {
     if (appView.options().getProguardConfiguration().isOverloadAggressively()) {
       // Use the full proto as key, hence reuse names based on full signature.
@@ -184,10 +180,12 @@
     InterfaceMethodNameMinifier interfaceMethodNameMinifier =
         new InterfaceMethodNameMinifier(
             appView, desugaredCallSites, equivalence, frontierState, minifierState);
+    timing.end();
+    timing.begin("Phase 3");
     interfaceMethodNameMinifier.assignNamesToInterfaceMethods(timing, interfaces);
     timing.end();
-    // Phase 3: Assign names top-down by traversing the subtype hierarchy.
-    timing.begin("Phase 3");
+    // Phase 4: Assign names top-down by traversing the subtype hierarchy.
+    timing.begin("Phase 4");
     assignNamesToClassesMethods(appView.dexItemFactory().objectType);
     timing.end();
 
@@ -207,31 +205,42 @@
     //
     // A simple way to ensure this is to process virtual methods first and then direct methods.
     DexClass holder = appView.definitionFor(type);
-    boolean shouldAssignName = holder != null && !alwaysReserveMemberNames(holder);
+    boolean shouldAssignName = holder != null && strategy.allowMemberRenaming(holder);
     if (shouldAssignName) {
       MethodNamingState<?> state =
           computeStateIfAbsent(type, k -> minifierState.getState(holder.superType).createChild());
       for (DexEncodedMethod method : holder.virtualMethodsSorted()) {
-        assignNameToMethod(method, state);
+        assignNameToMethod(method, state, holder);
       }
       for (DexEncodedMethod method : holder.directMethodsSorted()) {
-        assignNameToMethod(method, state);
+        assignNameToMethod(method, state, holder);
       }
     }
-    appView.appInfo().forAllExtendsSubtypes(type, subtype -> assignNamesToClassesMethods(subtype));
+
+    appView.appInfo().forAllExtendsSubtypes(type, this::assignNamesToClassesMethods);
   }
 
-  private void assignNameToMethod(DexEncodedMethod encodedMethod, MethodNamingState<?> state) {
+  private void assignNameToMethod(
+      DexEncodedMethod encodedMethod, MethodNamingState<?> state, DexClass holder) {
     if (encodedMethod.accessFlags.isConstructor()) {
       return;
     }
     DexMethod method = encodedMethod.method;
-    if (!state.isReserved(method.name, method.proto)) {
-      DexString renamedName = state.assignNewNameFor(method, method.name, method.proto);
-      renaming.put(method, renamedName);
-      if (!encodedMethod.accessFlags.isPrivate()) {
-        state.addRenaming(method.name, method.proto, renamedName);
-      }
+    DexString reservedName = strategy.getReservedNameOrDefault(encodedMethod, holder, method.name);
+    if (state.isReserved(reservedName, method.proto)) {
+      return;
+    }
+    DexString newName = state.assignNewNameFor(method, method.name, method.proto);
+    if (newName != method.name) {
+      addRenaming(encodedMethod, state, newName);
+    }
+  }
+
+  private void addRenaming(
+      DexEncodedMethod encodedMethod, MethodNamingState<?> state, DexString renamedName) {
+    renaming.put(encodedMethod.method, renamedName);
+    if (!encodedMethod.accessFlags.isPrivate()) {
+      state.addRenaming(encodedMethod.method.name, encodedMethod.method.proto, renamedName);
     }
   }
 
@@ -276,14 +285,38 @@
 
       DexClass holder = appView.definitionFor(type);
       if (holder != null) {
-        boolean keepAll = alwaysReserveMemberNames(holder) || holder.accessFlags.isAnnotation();
         for (DexEncodedMethod method : shuffleMethods(holder.methods(), appView.options())) {
-          // TODO(christofferqa): Wouldn't it be sufficient only to reserve names for non-private
-          //  methods?
-          if (keepAll
-              || method.accessFlags.isConstructor()
-              || strategy.noObfuscation(method.method)) {
-            reserveNamesForMethod(method.method, state);
+          DexString reservedName = strategy.getReservedNameOrDefault(method, holder, null);
+          if (reservedName != null) {
+            // If the mapping is incorrect, we might try to map a method to an existing name.
+            // class A {
+            //   int m1(String foo) { ... }
+            // }
+            //
+            // class B extends A {
+            //   int m2(String bar) { ... }
+            // }
+            //
+            // and the following reservations (mapping):
+            // A -> a:
+            //   int m1(String foo) -> a
+            // B -> b:
+            //   int m2(String foo) -> a <- ERROR
+            //
+            // In the example, the mapping file specifies that A.m1() should become a.a() and that
+            // B.m2() should become b.a(). This should not be allowed, since b.a() now overrides
+            // a.a(), unlike in the original program.
+            DexString previouslyReservedOriginalName =
+                state.getReservedOriginalName(reservedName, method.method.proto);
+            if (previouslyReservedOriginalName != null
+                && previouslyReservedOriginalName != method.method.name) {
+              strategy.reportReservationError(method.method, reservedName);
+            }
+            state.reserveName(reservedName, method.method.proto, method.method.name);
+            globalState.reserveName(reservedName, method.method.proto, method.method.name);
+            if (reservedName != method.method.name) {
+              addRenaming(method, state, reservedName);
+            }
           }
         }
       }
@@ -291,11 +324,6 @@
       return state;
     }
 
-    private void reserveNamesForMethod(DexMethod method, MethodNamingState<?> state) {
-      state.reserveName(method.name, method.proto);
-      globalState.reserveName(method.name, method.proto);
-    }
-
     public DexType get(DexType type) {
       return frontiers.getOrDefault(type, type);
     }
diff --git a/src/main/java/com/android/tools/r8/naming/MethodNamingState.java b/src/main/java/com/android/tools/r8/naming/MethodNamingState.java
index 7b0c5fb..adbc1c3 100644
--- a/src/main/java/com/android/tools/r8/naming/MethodNamingState.java
+++ b/src/main/java/com/android/tools/r8/naming/MethodNamingState.java
@@ -7,19 +7,16 @@
 import com.android.tools.r8.graph.DexProto;
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
-import com.android.tools.r8.naming.MemberNamingStrategy.MemberNamingInternalState;
-import com.android.tools.r8.utils.StringUtils;
-import com.google.common.collect.Sets;
 import java.io.PrintStream;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Set;
 import java.util.function.Function;
 
 class MethodNamingState<KeyType> {
 
   private final MethodNamingState<KeyType> parent;
-  private final Map<KeyType, InternalState> usedNames = new HashMap<>();
+  private final Map<KeyType, InternalReservationState> usedNames = new HashMap<>();
+  private final Map<KeyType, InternalNewNameState> newNameStates = new HashMap<>();
   private final Function<DexProto, KeyType> keyTransform;
   private final MemberNamingStrategy strategy;
 
@@ -37,74 +34,104 @@
     this.strategy = strategy;
   }
 
-  public MethodNamingState<KeyType> createChild() {
+  MethodNamingState<KeyType> createChild() {
     return new MethodNamingState<>(this, keyTransform, strategy);
   }
 
-  private InternalState findInternalStateFor(KeyType key) {
-    InternalState result = usedNames.get(key);
+  private InternalReservationState findInternalReservationStateFor(KeyType key) {
+    InternalReservationState result = usedNames.get(key);
     if (result == null && parent != null) {
-      result = parent.findInternalStateFor(key);
+      result = parent.findInternalReservationStateFor(key);
     }
     return result;
   }
 
-  private InternalState getOrCreateInternalStateFor(KeyType key) {
-    // TODO(herhut): Maybe allocate these sparsely and search via state chain.
-    InternalState result = usedNames.get(key);
+  private InternalReservationState getOrCreateInternalReservationStateFor(KeyType key) {
+    InternalReservationState result = usedNames.get(key);
     if (result == null) {
-      InternalState parentState = parent != null ? parent.getOrCreateInternalStateFor(key) : null;
-      result = new InternalState(parentState);
+      InternalReservationState parentState =
+          parent != null ? parent.getOrCreateInternalReservationStateFor(key) : null;
+      result = new InternalReservationState(parentState);
       usedNames.put(key, result);
     }
     return result;
   }
 
+  private InternalNewNameState findInternalNewNameStateFor(KeyType key) {
+    InternalNewNameState result = newNameStates.get(key);
+    if (result == null && parent != null) {
+      result = parent.findInternalNewNameStateFor(key);
+    }
+    return result;
+  }
+
+  private InternalNewNameState getOrCreateNewNameStateFor(KeyType key) {
+    InternalNewNameState result = newNameStates.get(key);
+    if (result == null) {
+      InternalReservationState reservationState = getOrCreateInternalReservationStateFor(key);
+      assert reservationState != null;
+      InternalNewNameState parentState =
+          parent != null ? parent.getOrCreateNewNameStateFor(key) : null;
+      result = new InternalNewNameState(parentState, reservationState);
+      newNameStates.put(key, result);
+    }
+    return result;
+  }
+
   private DexString getAssignedNameFor(DexString name, KeyType key) {
-    InternalState state = findInternalStateFor(key);
+    InternalReservationState state = findInternalReservationStateFor(key);
     if (state == null) {
       return null;
     }
     return state.getAssignedNameFor(name);
   }
 
-  public DexString assignNewNameFor(DexMethod source, DexString original, DexProto proto) {
+  DexString assignNewNameFor(DexMethod source, DexString original, DexProto proto) {
     KeyType key = keyTransform.apply(proto);
     DexString result = getAssignedNameFor(original, key);
     if (result == null) {
-      InternalState state = getOrCreateInternalStateFor(key);
+      InternalNewNameState state = getOrCreateNewNameStateFor(key);
       result = state.getNewNameFor(source);
     }
     return result;
   }
 
-  public void reserveName(DexString name, DexProto proto) {
+  void reserveName(DexString name, DexProto proto, DexString originalName) {
     KeyType key = keyTransform.apply(proto);
-    InternalState state = getOrCreateInternalStateFor(key);
-    state.reserveName(name);
+    InternalReservationState state = getOrCreateInternalReservationStateFor(key);
+    state.reserveName(name, originalName);
   }
 
-  public boolean isReserved(DexString name, DexProto proto) {
+  boolean isReserved(DexString name, DexProto proto) {
     KeyType key = keyTransform.apply(proto);
-    InternalState state = findInternalStateFor(key);
+    InternalReservationState state = findInternalReservationStateFor(key);
     if (state == null) {
       return false;
     }
     return state.isReserved(name);
   }
 
-  public boolean isAvailable(DexProto proto, DexString candidate) {
+  DexString getReservedOriginalName(DexString name, DexProto proto) {
     KeyType key = keyTransform.apply(proto);
-    InternalState state = findInternalStateFor(key);
+    InternalReservationState state = findInternalReservationStateFor(key);
+    if (state == null) {
+      return null;
+    }
+    return state.getReservedOriginalName(name);
+  }
+
+  boolean isAvailable(DexProto proto, DexString candidate) {
+    KeyType key = keyTransform.apply(proto);
+    InternalReservationState state = findInternalReservationStateFor(key);
     if (state == null) {
       return true;
     }
     return state.isAvailable(candidate);
   }
 
-  public void addRenaming(DexString original, DexProto proto, DexString newName) {
+  void addRenaming(DexString original, DexProto proto, DexString newName) {
     KeyType key = keyTransform.apply(proto);
-    InternalState state = getOrCreateInternalStateFor(key);
+    InternalReservationState state = getOrCreateInternalReservationStateFor(key);
     state.addRenaming(original, newName);
   }
 
@@ -114,7 +141,7 @@
       String indentation,
       PrintStream out) {
     KeyType key = keyTransform.apply(proto);
-    InternalState state = getOrCreateInternalStateFor(key);
+    InternalNewNameState state = getOrCreateNewNameStateFor(key);
     out.print(indentation);
     out.print("NamingState(node=`");
     out.print(stateKeyGetter.apply(this).toSourceString());
@@ -131,76 +158,29 @@
     }
   }
 
-  class InternalState implements MemberNamingInternalState {
-
-    private static final int INITIAL_NAME_COUNT = 1;
-    private static final int INITIAL_DICTIONARY_INDEX = 0;
-
-    private final InternalState parentInternalState;
-    private Set<DexString> reservedNames = null;
+  class InternalReservationState {
+    private final InternalReservationState parentInternalState;
+    private Map<DexString, DexString> reservedNames = null;
     private Map<DexString, DexString> renamings = null;
-    private int virtualNameCount;
-    private int directNameCount = 0;
-    private int dictionaryIndex;
 
-    private InternalState(InternalState parentInternalState) {
+    private InternalReservationState(InternalReservationState parentInternalState) {
       this.parentInternalState = parentInternalState;
-      this.dictionaryIndex =
-          parentInternalState == null
-              ? INITIAL_DICTIONARY_INDEX
-              : parentInternalState.dictionaryIndex;
-      this.virtualNameCount =
-          parentInternalState == null ? INITIAL_NAME_COUNT : parentInternalState.virtualNameCount;
     }
 
-    private boolean isReserved(DexString name) {
-      return (reservedNames != null && reservedNames.contains(name))
+    boolean isReserved(DexString name) {
+      return (reservedNames != null && reservedNames.containsKey(name))
           || (parentInternalState != null && parentInternalState.isReserved(name));
     }
 
-    private boolean isAvailable(DexString name) {
-      return !(renamings != null && renamings.containsValue(name))
-          && !(reservedNames != null && reservedNames.contains(name))
-          && (parentInternalState == null || parentInternalState.isAvailable(name));
-    }
-
-    void reserveName(DexString name) {
-      if (reservedNames == null) {
-        reservedNames = Sets.newIdentityHashSet();
+    DexString getReservedOriginalName(DexString name) {
+      DexString result = null;
+      if (reservedNames != null) {
+        result = reservedNames.get(name);
       }
-      reservedNames.add(name);
-    }
-
-    @Override
-    public int getDictionaryIndex() {
-      return dictionaryIndex;
-    }
-
-    @Override
-    public int incrementDictionaryIndex() {
-      return dictionaryIndex++;
-    }
-
-    private boolean checkParentPublicNameCountIsLessThanOrEqual() {
-      int maxParentCount = 0;
-      InternalState tmp = parentInternalState;
-      while (tmp != null) {
-        maxParentCount = Math.max(tmp.virtualNameCount, maxParentCount);
-        tmp = tmp.parentInternalState;
+      if (result == null && parentInternalState != null) {
+        result = parentInternalState.getReservedOriginalName(name);
       }
-      assert maxParentCount <= virtualNameCount;
-      return true;
-    }
-
-    @Override
-    public int incrementNameIndex(boolean isDirectMethodCall) {
-      assert checkParentPublicNameCountIsLessThanOrEqual();
-      if (isDirectMethodCall) {
-        return virtualNameCount + directNameCount++;
-      } else {
-        assert directNameCount == 0;
-        return virtualNameCount++;
-      }
+      return result;
     }
 
     DexString getAssignedNameFor(DexString original) {
@@ -214,12 +194,17 @@
       return result;
     }
 
-    private DexString getNewNameFor(DexMethod source) {
-      DexString name;
-      do {
-        name = strategy.next(source, this);
-      } while (!isAvailable(name) && !strategy.breakOnNotAvailable(source, name));
-      return name;
+    private boolean isAvailable(DexString name) {
+      return !(renamings != null && renamings.containsValue(name))
+          && !(reservedNames != null && reservedNames.containsKey(name))
+          && (parentInternalState == null || parentInternalState.isAvailable(name));
+    }
+
+    void reserveName(DexString name, DexString originalName) {
+      if (reservedNames == null) {
+        reservedNames = new HashMap<>();
+      }
+      reservedNames.put(name, originalName);
     }
 
     void addRenaming(DexString original, DexString newName) {
@@ -229,58 +214,17 @@
       renamings.put(original, newName);
     }
 
-    void printInternalState(
-        MethodNamingState<?> expectedNamingState,
-        Function<MethodNamingState<?>, DexType> stateKeyGetter,
-        String indentation,
-        PrintStream out) {
-      assert expectedNamingState == MethodNamingState.this;
-
-      DexType stateKey = stateKeyGetter.apply(expectedNamingState);
-      out.print(indentation);
-      out.print("InternalState(node=`");
-      out.print(stateKey != null ? stateKey.toSourceString() : "<GLOBAL>");
-      out.println("`)");
-
-      printLastName(indentation + "  ", out);
-      printReservedNames(indentation + "  ", out);
-      printRenamings(indentation + "  ", out);
-
-      if (parentInternalState != null) {
-        parentInternalState.printInternalState(
-            expectedNamingState.parent, stateKeyGetter, indentation + "  ", out);
-      }
-    }
-
-    void printLastName(String indentation, PrintStream out) {
-      out.print(indentation);
-      out.print("Last name: ");
-      int index = virtualNameCount + directNameCount;
-      if (index > 1) {
-        out.print(StringUtils.numberToIdentifier(index - 1));
-        out.print(" (public name count: ");
-        out.print(virtualNameCount);
-        out.print(")");
-        out.print(" (direct name count: ");
-        out.print(directNameCount);
-        out.print(")");
-      } else {
-        out.print("<NONE>");
-      }
-      out.println();
-    }
-
     void printReservedNames(String indentation, PrintStream out) {
       out.print(indentation);
       out.print("Reserved names:");
       if (reservedNames == null || reservedNames.isEmpty()) {
         out.print(" <NO RESERVED NAMES>");
       } else {
-        for (DexString reservedName : reservedNames) {
+        for (DexString reservedName : reservedNames.keySet()) {
           out.print(System.lineSeparator());
           out.print(indentation);
           out.print("  ");
-          out.print(reservedName.toSourceString());
+          out.print(reservedName.toSourceString() + "(by " + reservedNames.get(reservedName) + ")");
         }
       }
       out.println();
@@ -304,4 +248,102 @@
       out.println();
     }
   }
+
+  class InternalNewNameState implements InternalNamingState {
+
+    private final InternalNewNameState parentInternalState;
+    private final InternalReservationState reservationState;
+
+    private static final int INITIAL_NAME_COUNT = 1;
+    private static final int INITIAL_DICTIONARY_INDEX = 0;
+
+    private int virtualNameCount;
+    private int directNameCount = 0;
+    private int dictionaryIndex;
+
+    private InternalNewNameState(
+        InternalNewNameState parentInternalState, InternalReservationState reservationState) {
+      this.parentInternalState = parentInternalState;
+      this.reservationState = reservationState;
+      this.dictionaryIndex =
+          parentInternalState == null
+              ? INITIAL_DICTIONARY_INDEX
+              : parentInternalState.dictionaryIndex;
+      this.virtualNameCount =
+          parentInternalState == null ? INITIAL_NAME_COUNT : parentInternalState.virtualNameCount;
+      assert reservationState != null;
+    }
+
+    @Override
+    public int getDictionaryIndex() {
+      return dictionaryIndex;
+    }
+
+    @Override
+    public int incrementDictionaryIndex() {
+      return dictionaryIndex++;
+    }
+
+    private boolean checkParentPublicNameCountIsLessThanOrEqual() {
+      int maxParentCount = 0;
+      InternalNewNameState tmp = parentInternalState;
+      while (tmp != null) {
+        maxParentCount = Math.max(tmp.virtualNameCount, maxParentCount);
+        tmp = tmp.parentInternalState;
+      }
+      assert maxParentCount <= virtualNameCount;
+      return true;
+    }
+
+    @Override
+    public int incrementNameIndex(boolean isDirectMethodCall) {
+      assert checkParentPublicNameCountIsLessThanOrEqual();
+      if (isDirectMethodCall) {
+        return virtualNameCount + directNameCount++;
+      } else {
+        assert directNameCount == 0;
+        return virtualNameCount++;
+      }
+    }
+
+    private DexString getNewNameFor(DexMethod source) {
+      DexString name;
+      do {
+        name = strategy.next(source, this);
+      } while (!reservationState.isAvailable(name));
+      return name;
+    }
+
+    void printInternalState(
+        MethodNamingState<?> expectedNamingState,
+        Function<MethodNamingState<?>, DexType> stateKeyGetter,
+        String indentation,
+        PrintStream out) {
+      assert expectedNamingState == MethodNamingState.this;
+
+      DexType stateKey = stateKeyGetter.apply(expectedNamingState);
+      out.print(indentation);
+      out.print("InternalState(node=`");
+      out.print(stateKey != null ? stateKey.toSourceString() : "<GLOBAL>");
+      out.println("`)");
+
+      printLastName(indentation + "  ", out);
+      reservationState.printReservedNames(indentation + "  ", out);
+      reservationState.printRenamings(indentation + "  ", out);
+
+      if (parentInternalState != null) {
+        parentInternalState.printInternalState(
+            expectedNamingState.parent, stateKeyGetter, indentation + "  ", out);
+      }
+    }
+
+    void printLastName(String indentation, PrintStream out) {
+      out.print(indentation);
+      out.print("public name count: ");
+      out.print(virtualNameCount);
+      out.print(", ");
+      out.print("direct name count: ");
+      out.println(directNameCount);
+    }
+  }
 }
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 4bdf87c..6906a06 100644
--- a/src/main/java/com/android/tools/r8/naming/Minifier.java
+++ b/src/main/java/com/android/tools/r8/naming/Minifier.java
@@ -3,9 +3,12 @@
 // BSD-style license that can be found in the LICENSE file.
 package com.android.tools.r8.naming;
 
+import static com.android.tools.r8.utils.StringUtils.EMPTY_CHAR_ARRAY;
+
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexCallSite;
 import com.android.tools.r8.graph.DexClass;
+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.DexItemFactory;
@@ -15,15 +18,13 @@
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.naming.ClassNameMinifier.ClassNamingStrategy;
 import com.android.tools.r8.naming.ClassNameMinifier.ClassRenaming;
-import com.android.tools.r8.naming.ClassNameMinifier.Namespace;
 import com.android.tools.r8.naming.ClassNameMinifier.PackageNamingStrategy;
 import com.android.tools.r8.naming.FieldNameMinifier.FieldRenaming;
 import com.android.tools.r8.naming.MethodNameMinifier.MethodRenaming;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.SymbolGenerationUtils;
+import com.android.tools.r8.utils.SymbolGenerationUtils.MixedCasing;
 import com.android.tools.r8.utils.Timing;
-import it.unimi.dsi.fastutil.objects.Object2IntLinkedOpenHashMap;
-import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -50,7 +51,7 @@
         new ClassNameMinifier(
             appView,
             new MinificationClassNamingStrategy(appView),
-            new MinificationPackageNamingStrategy(),
+            new MinificationPackageNamingStrategy(appView),
             // Use deterministic class order to make sure renaming is deterministic.
             appView.appInfo().classesWithDeterministicOrder());
     ClassRenaming classRenaming = classNameMinifier.computeRenaming(timing);
@@ -84,29 +85,57 @@
     return lens;
   }
 
-  static class MinificationClassNamingStrategy implements ClassNamingStrategy {
+  abstract static class BaseMinificationNamingStrategy {
 
-    private final AppView<?> appView;
-    private final Object2IntMap<Namespace> namespaceCounters = new Object2IntLinkedOpenHashMap<>();
+    // We have to ensure that the names proposed by the minifier is not used in the obfuscation
+    // dictionary. We use a list for direct indexing based on a number and a set for looking up.
+    private final List<String> obfuscationDictionary;
+    private final Set<String> obfuscationDictionaryForLookup;
+    private final MixedCasing mixedCasing;
+
+    BaseMinificationNamingStrategy(List<String> obfuscationDictionary, boolean dontUseMixedCasing) {
+      this.obfuscationDictionary = obfuscationDictionary;
+      this.obfuscationDictionaryForLookup = new HashSet<>(this.obfuscationDictionary);
+      this.mixedCasing =
+          dontUseMixedCasing ? MixedCasing.DONT_USE_MIXED_CASE : MixedCasing.USE_MIXED_CASE;
+      assert obfuscationDictionary != null;
+    }
+
+    String nextName(char[] packagePrefix, InternalNamingState state, boolean isDirectMethodCall) {
+      StringBuilder nextName = new StringBuilder();
+      nextName.append(packagePrefix);
+      if (state.getDictionaryIndex() < obfuscationDictionary.size()) {
+        nextName.append(obfuscationDictionary.get(state.incrementDictionaryIndex()));
+      } else {
+        String nextString;
+        do {
+          nextString =
+              SymbolGenerationUtils.numberToIdentifier(
+                  state.incrementNameIndex(isDirectMethodCall), mixedCasing);
+        } while (obfuscationDictionaryForLookup.contains(nextString));
+        nextName.append(nextString);
+      }
+      return nextName.toString();
+    }
+  }
+
+  static class MinificationClassNamingStrategy extends BaseMinificationNamingStrategy
+      implements ClassNamingStrategy {
+
+    final AppView<?> appView;
+    private final DexItemFactory factory;
 
     MinificationClassNamingStrategy(AppView<?> appView) {
+      super(
+          appView.options().getProguardConfiguration().getClassObfuscationDictionary(),
+          appView.options().getProguardConfiguration().hasDontUseMixedCaseClassnames());
       this.appView = appView;
-      namespaceCounters.defaultReturnValue(1);
+      factory = appView.dexItemFactory();
     }
 
     @Override
-    public DexString next(Namespace namespace, DexType type, char[] packagePrefix) {
-      int counter = namespaceCounters.put(namespace, namespaceCounters.getInt(namespace) + 1);
-      DexString string =
-          appView
-              .dexItemFactory()
-              .createString(StringUtils.numberToIdentifier(counter, packagePrefix, true));
-      return string;
-    }
-
-    @Override
-    public boolean bypassDictionary() {
-      return false;
+    public DexString next(DexType type, char[] packagePrefix, InternalNamingState state) {
+      return factory.createString(nextName(packagePrefix, state, false) + ";");
     }
 
     @Override
@@ -115,84 +144,91 @@
     }
   }
 
-  static class MinificationPackageNamingStrategy implements PackageNamingStrategy {
+  static class MinificationPackageNamingStrategy extends BaseMinificationNamingStrategy
+      implements PackageNamingStrategy {
 
-    private final Object2IntMap<Namespace> namespaceCounters = new Object2IntLinkedOpenHashMap<>();
-
-    public MinificationPackageNamingStrategy() {
-      namespaceCounters.defaultReturnValue(1);
+    MinificationPackageNamingStrategy(AppView<?> appView) {
+      super(
+          appView.options().getProguardConfiguration().getPackageObfuscationDictionary(),
+          appView.options().getProguardConfiguration().hasDontUseMixedCaseClassnames());
     }
 
     @Override
-    public String next(Namespace namespace, char[] packagePrefix) {
+    public String next(char[] packagePrefix, InternalNamingState state) {
       // Note that the differences between this method and the other variant for class renaming are
       // 1) this one uses the different dictionary and counter,
       // 2) this one does not append ';' at the end, and
       // 3) this one removes 'L' at the beginning to make the return value a binary form.
-      int counter = namespaceCounters.put(namespace, namespaceCounters.getInt(namespace) + 1);
-      return StringUtils.numberToIdentifier(counter, packagePrefix, false).substring(1);
-    }
-
-    @Override
-    public boolean bypassDictionary() {
-      return false;
+      return nextName(packagePrefix, state, false).substring(1);
     }
   }
 
-  static class MinifierMemberNamingStrategy implements MemberNamingStrategy {
+  static class MinifierMemberNamingStrategy extends BaseMinificationNamingStrategy
+      implements MemberNamingStrategy {
 
+    final AppView<?> appView;
     private final DexItemFactory factory;
-    // We have to ensure that the names proposed by the minifier is not used in the obfuscation
-    // dictionary. We use a list for direct indexing based on a number and a set for looking up.
-    private final List<String> obfuscationDictionary;
-    private final Set<String> obfuscationDictionaryForLookup;
-
-    private final AppView<?> appView;
 
     public MinifierMemberNamingStrategy(AppView<?> appView) {
+      super(appView.options().getProguardConfiguration().getObfuscationDictionary(), false);
       this.appView = appView;
       this.factory = appView.dexItemFactory();
-      this.obfuscationDictionary =
-          appView.options().getProguardConfiguration().getObfuscationDictionary();
-      this.obfuscationDictionaryForLookup = new HashSet<>(this.obfuscationDictionary);
-      assert this.obfuscationDictionary != null;
     }
 
     @Override
-    public DexString next(DexMethod method, MemberNamingInternalState internalState) {
+    public DexString next(DexMethod method, InternalNamingState internalState) {
+      assert checkAllowMemberRenaming(method.holder);
       DexEncodedMethod encodedMethod = appView.definitionFor(method);
       boolean isDirectOrStatic = encodedMethod.isDirectMethod() || encodedMethod.isStatic();
       return getNextName(internalState, isDirectOrStatic);
     }
 
     @Override
-    public DexString next(DexField field, MemberNamingInternalState internalState) {
+    public DexString next(DexField field, InternalNamingState internalState) {
+      assert checkAllowMemberRenaming(field.holder);
       return getNextName(internalState, false);
     }
 
-    private DexString getNextName(
-        MemberNamingInternalState internalState, boolean isDirectOrStatic) {
-      if (internalState.getDictionaryIndex() < obfuscationDictionary.size()) {
-        return factory.createString(
-            obfuscationDictionary.get(internalState.incrementDictionaryIndex()));
-      } else {
-        String nextString;
-        do {
-          int counter = internalState.incrementNameIndex(isDirectOrStatic);
-          nextString = StringUtils.numberToIdentifier(counter);
-        } while (obfuscationDictionaryForLookup.contains(nextString));
-        return factory.createString(nextString);
+    private DexString getNextName(InternalNamingState internalState, boolean isDirectOrStatic) {
+      return factory.createString(nextName(EMPTY_CHAR_ARRAY, internalState, isDirectOrStatic));
+    }
+
+    @Override
+    public DexString getReservedNameOrDefault(
+        DexEncodedMethod method, DexClass holder, DexString defaultValue) {
+      if (!allowMemberRenaming(holder)
+          || holder.accessFlags.isAnnotation()
+          || method.accessFlags.isConstructor()
+          || appView.rootSet().mayNotBeMinified(method.method, appView)) {
+        return method.method.name;
       }
+      return defaultValue;
     }
 
     @Override
-    public boolean breakOnNotAvailable(DexReference source, DexString name) {
-      return false;
+    public DexString getReservedNameOrDefault(
+        DexEncodedField field, DexClass holder, DexString defaultValue) {
+      if (holder.isLibraryClass() || appView.rootSet().mayNotBeMinified(field.field, appView)) {
+        return field.field.name;
+      }
+      return defaultValue;
     }
 
     @Override
-    public boolean noObfuscation(DexReference reference) {
-      return appView.rootSet().mayNotBeMinified(reference, appView);
+    public boolean allowMemberRenaming(DexClass holder) {
+      return holder.isProgramClass();
+    }
+
+    public boolean checkAllowMemberRenaming(DexType holder) {
+      DexClass clazz = appView.definitionFor(holder);
+      assert clazz != null && allowMemberRenaming(clazz);
+      return true;
+    }
+
+    @Override
+    public void reportReservationError(DexReference source, DexString name) {
+      assert false;
+      // This should only happen when applymapping is used and will be caught in that strategy.
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java b/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
index 4c2c8cf..895b8c5 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
@@ -7,6 +7,8 @@
 import com.android.tools.r8.graph.AppView;
 import com.android.tools.r8.graph.DexCallSite;
 import com.android.tools.r8.graph.DexClass;
+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.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
@@ -14,31 +16,59 @@
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
-import com.android.tools.r8.naming.ClassNameMinifier.ClassNamingStrategy;
 import com.android.tools.r8.naming.ClassNameMinifier.ClassRenaming;
-import com.android.tools.r8.naming.ClassNameMinifier.Namespace;
 import com.android.tools.r8.naming.FieldNameMinifier.FieldRenaming;
 import com.android.tools.r8.naming.MemberNaming.FieldSignature;
 import com.android.tools.r8.naming.MemberNaming.MethodSignature;
 import com.android.tools.r8.naming.MemberNaming.Signature;
 import com.android.tools.r8.naming.MethodNameMinifier.MethodRenaming;
+import com.android.tools.r8.naming.Minifier.MinificationClassNamingStrategy;
 import com.android.tools.r8.naming.Minifier.MinificationPackageNamingStrategy;
+import com.android.tools.r8.naming.Minifier.MinifierMemberNamingStrategy;
 import com.android.tools.r8.position.Position;
 import com.android.tools.r8.shaking.AppInfoWithLiveness;
 import com.android.tools.r8.utils.Reporter;
 import com.android.tools.r8.utils.Timing;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Deque;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
 
+/**
+ * The ProguardMapMinifier will assign names to classes and members following the initial naming
+ * seed given by the mapping files.
+ *
+ * <p>First the object hierarchy is traversed maintaining a collection of all program classes and
+ * classes that needs to be renamed in {@link #mappedClasses}. For each level we keep track of all
+ * renamed members and propagate all non-private items to descendants. This is necessary to ensure
+ * that virtual methods are renamed when there are "gaps" in the hierarchy. We keep track of all
+ * namings such that future renaming of non-private members will not collide or fail with an error.
+ *
+ * <p>Second, we compute desugared default interface methods and companion classes to ensure these
+ * can be referred to by clients.
+ *
+ * <p>Third, we traverse all reachable interfaces for class mappings and add them to our tracking
+ * maps. Otherwise, the minification follows the ordinary minification.
+ */
 public class ProguardMapMinifier {
 
   private final AppView<AppInfoWithLiveness> appView;
   private final SeedMapper seedMapper;
   private final Set<DexCallSite> desugaredCallSites;
+  private final BiMap<DexType, DexString> mappedNames = HashBiMap.create();
+  private final List<DexClass> mappedClasses = new ArrayList<>();
+  private final Map<DexReference, MemberNaming> memberNames = new IdentityHashMap<>();
+  private final Map<DexType, DexString> syntheticCompanionClasses = new IdentityHashMap<>();
+  private final Map<DexMethod, DexString> defaultInterfaceMethodImplementationNames =
+      new IdentityHashMap<>();
+  private final Map<DexMethod, DexString> additionalMethodNamings = new IdentityHashMap<>();
+  private final Map<DexField, DexString> additionalFieldNamings = new IdentityHashMap<>();
 
   public ProguardMapMinifier(
       AppView<AppInfoWithLiveness> appView,
@@ -50,101 +80,63 @@
   }
 
   public NamingLens run(Timing timing) {
-    timing.begin("mapping classes");
+    timing.begin("MappingClasses");
+    computeMapping(appView.dexItemFactory().objectType, new ArrayDeque<>());
+    timing.end();
 
-    Map<DexType, DexString> mappedNames = new IdentityHashMap<>();
-    List<DexClass> mappedClasses = new ArrayList<>();
-    Map<DexReference, MemberNaming> memberNames = new IdentityHashMap<>();
-    Map<DexType, DexString> syntheticCompanionClasses = new IdentityHashMap<>();
-    Map<DexMethod, DexString> defaultInterfaceMethodImplementationNames = new IdentityHashMap<>();
-    for (String key : seedMapper.getKeyset()) {
-      ClassNamingForMapApplier classNaming = seedMapper.getMapping(key);
-      DexType type =
-          appView.dexItemFactory().lookupType(appView.dexItemFactory().createString(key));
-      if (type == null) {
-        // The map contains additional mapping of classes compared to what we have seen. This should
-        // have no effect.
-        continue;
+    timing.begin("MappingDefaultInterfaceMethods");
+    computeDefaultInterfaceMethodMethods();
+    timing.end();
+
+    timing.begin("ComputeInterfaces");
+    // We have to compute interfaces
+    Set<DexClass> interfaces = new TreeSet<>((a, b) -> a.type.slowCompareTo(b.type));
+    for (DexClass dexClass : appView.appInfo().computeReachableInterfaces(desugaredCallSites)) {
+      ClassNamingForMapApplier classNaming = seedMapper.getClassNaming(dexClass.type);
+      if (classNaming != null) {
+        DexString mappedName = appView.dexItemFactory().createString(classNaming.renamedName);
+        checkAndAddMappedNames(dexClass.type, mappedName, classNaming.position);
       }
-      DexClass dexClass = appView.definitionFor(type);
-      if (dexClass == null) {
-        computeDefaultInterfaceMethodMappings(
-            type,
-            classNaming,
-            syntheticCompanionClasses,
-            defaultInterfaceMethodImplementationNames);
-        continue;
-      }
-      DexString mappedName = appView.dexItemFactory().createString(classNaming.renamedName);
-      DexType mappedType = appView.dexItemFactory().lookupType(mappedName);
-      // The mappedType has to be available:
-      // - If it is null we have not seen it.
-      // - If the mapped type is itself the name is already reserved (by itself).
-      // - If the there is no definition for the mapped type we will not get a naming clash.
-      // Otherwise, there will be a naming conflict.
-      if (mappedType != null && type != mappedType && appView.definitionFor(mappedType) != null) {
-        appView
-            .options()
-            .reporter
-            .error(
-                ApplyMappingError.mapToExistingClass(
-                    type.toString(), mappedType.toString(), classNaming.position));
-      }
-      mappedNames.put(type, mappedName);
       mappedClasses.add(dexClass);
-      classNaming.forAllMethodNaming(
-          memberNaming -> {
-            Signature signature = memberNaming.getOriginalSignature();
-            assert !signature.isQualified();
-            DexMethod originalMethod =
-                ((MethodSignature) signature).toDexMethod(appView.dexItemFactory(), type);
-            assert !memberNames.containsKey(originalMethod);
-            memberNames.put(originalMethod, memberNaming);
-          });
-      classNaming.forAllFieldNaming(
-          memberNaming -> {
-            Signature signature = memberNaming.getOriginalSignature();
-            assert !signature.isQualified();
-            DexField originalField =
-                ((FieldSignature) signature).toDexField(appView.dexItemFactory(), type);
-            assert !memberNames.containsKey(originalField);
-            memberNames.put(originalField, memberNaming);
-          });
+      interfaces.add(dexClass);
     }
+    timing.end();
 
     appView.options().reporter.failIfPendingErrors();
 
+    // To keep the order deterministic, we sort the classes by their type, which is a unique key.
+    mappedClasses.sort((a, b) -> a.type.slowCompareTo(b.type));
+
+    timing.begin("MinifyClasses");
     ClassNameMinifier classNameMinifier =
         new ClassNameMinifier(
             appView,
-            new ApplyMappingClassNamingStrategy(mappedNames),
+            new ApplyMappingClassNamingStrategy(appView, mappedNames),
             // The package naming strategy will actually not be used since all classes and methods
             // will be output with identity name if not found in mapping. However, there is a check
             // in the ClassNameMinifier that the strategy should produce a "fresh" name so we just
             // use the existing strategy.
-            new MinificationPackageNamingStrategy(),
+            new MinificationPackageNamingStrategy(appView),
             mappedClasses);
     ClassRenaming classRenaming =
         classNameMinifier.computeRenaming(timing, syntheticCompanionClasses);
     timing.end();
 
-    Set<DexClass> interfaces = new TreeSet<>((a, b) -> a.type.slowCompareTo(b.type));
-    interfaces.addAll(appView.appInfo().computeReachableInterfaces(desugaredCallSites));
-
     ApplyMappingMemberNamingStrategy nameStrategy =
-        new ApplyMappingMemberNamingStrategy(
-            memberNames, appView.dexItemFactory(), appView.options().reporter);
+        new ApplyMappingMemberNamingStrategy(appView, memberNames);
     timing.begin("MinifyMethods");
     MethodRenaming methodRenaming =
         new MethodNameMinifier(appView, nameStrategy)
             .computeRenaming(interfaces, desugaredCallSites, timing);
     // Amend the method renamings with the default interface methods.
     methodRenaming.renaming.putAll(defaultInterfaceMethodImplementationNames);
+    methodRenaming.renaming.putAll(additionalMethodNamings);
     timing.end();
 
     timing.begin("MinifyFields");
     FieldRenaming fieldRenaming =
         new FieldNameMinifier(appView, nameStrategy).computeRenaming(interfaces, timing);
+    fieldRenaming.renaming.putAll(additionalFieldNamings);
     timing.end();
 
     appView.options().reporter.failIfPendingErrors();
@@ -158,7 +150,142 @@
     return lens;
   }
 
-  private void computeDefaultInterfaceMethodMappings(
+  private void computeMapping(DexType type, Deque<Map<DexReference, MemberNaming>> buildUpNames) {
+    ClassNamingForMapApplier classNaming = seedMapper.getClassNaming(type);
+    DexClass dexClass = appView.definitionFor(type);
+
+    // Keep track of classes that needs to get renamed.
+    if (dexClass != null && (classNaming != null || dexClass.isProgramClass())) {
+      mappedClasses.add(dexClass);
+    }
+
+    Map<DexReference, MemberNaming> nonPrivateMembers = new IdentityHashMap<>();
+
+    if (classNaming != null) {
+      // TODO(b/133091438) assert that !dexClass.isLibaryClass();
+      DexString mappedName = appView.dexItemFactory().createString(classNaming.renamedName);
+      checkAndAddMappedNames(type, mappedName, classNaming.position);
+
+      classNaming.forAllMethodNaming(
+          memberNaming -> {
+            Signature signature = memberNaming.getOriginalSignature();
+            assert !signature.isQualified();
+            DexMethod originalMethod =
+                ((MethodSignature) signature).toDexMethod(appView.dexItemFactory(), type);
+            assert !memberNames.containsKey(originalMethod);
+            memberNames.put(originalMethod, memberNaming);
+            DexEncodedMethod encodedMethod = appView.definitionFor(originalMethod);
+            if (encodedMethod == null || !encodedMethod.accessFlags.isPrivate()) {
+              nonPrivateMembers.put(originalMethod, memberNaming);
+            }
+          });
+      classNaming.forAllFieldNaming(
+          memberNaming -> {
+            Signature signature = memberNaming.getOriginalSignature();
+            assert !signature.isQualified();
+            DexField originalField =
+                ((FieldSignature) signature).toDexField(appView.dexItemFactory(), type);
+            assert !memberNames.containsKey(originalField);
+            memberNames.put(originalField, memberNaming);
+            DexEncodedField encodedField = appView.definitionFor(originalField);
+            if (encodedField == null || !encodedField.accessFlags.isPrivate()) {
+              nonPrivateMembers.put(originalField, memberNaming);
+            }
+          });
+    } else {
+      // We have to ensure we do not rename to an existing member, that cannot be renamed.
+      if (dexClass == null || !appView.options().isMinifying()) {
+        checkAndAddMappedNames(type, type.descriptor, Position.UNKNOWN);
+      } else if (appView.options().isMinifying()
+          && appView.rootSet().mayNotBeMinified(type, appView)) {
+        checkAndAddMappedNames(type, type.descriptor, Position.UNKNOWN);
+      }
+    }
+
+    for (Map<DexReference, MemberNaming> parentMembers : buildUpNames) {
+      for (DexReference key : parentMembers.keySet()) {
+        if (key.isDexMethod()) {
+          DexMethod parentReference = key.asDexMethod();
+          DexMethod parentReferenceOnCurrentType =
+              appView
+                  .dexItemFactory()
+                  .createMethod(type, parentReference.proto, parentReference.name);
+          addMemberNaming(
+              key, parentReferenceOnCurrentType, parentMembers, additionalMethodNamings);
+        } else {
+          DexField parentReference = key.asDexField();
+          DexField parentReferenceOnCurrentType =
+              appView
+                  .dexItemFactory()
+                  .createField(type, parentReference.type, parentReference.name);
+          addMemberNaming(key, parentReferenceOnCurrentType, parentMembers, additionalFieldNamings);
+        }
+      }
+    }
+
+    if (nonPrivateMembers.size() > 0) {
+      buildUpNames.addLast(nonPrivateMembers);
+      appView
+          .appInfo()
+          .forAllExtendsSubtypes(type, subType -> computeMapping(subType, buildUpNames));
+      buildUpNames.removeLast();
+    } else {
+      appView
+          .appInfo()
+          .forAllExtendsSubtypes(type, subType -> computeMapping(subType, buildUpNames));
+    }
+  }
+
+  private <T extends DexReference> void addMemberNaming(
+      DexReference key,
+      T member,
+      Map<DexReference, MemberNaming> parentMembers,
+      Map<T, DexString> additionalMemberNamings) {
+    // We might have overridden a naming in the direct class namings above.
+    if (!memberNames.containsKey(member)) {
+      DexString renamedName =
+          appView.dexItemFactory().createString(parentMembers.get(key).getRenamedName());
+      memberNames.put(member, parentMembers.get(key));
+      additionalMemberNamings.put(member, renamedName);
+    }
+  }
+
+  private void checkAndAddMappedNames(DexType type, DexString mappedName, Position position) {
+    if (mappedNames.inverse().containsKey(mappedName)) {
+      appView
+          .options()
+          .reporter
+          .error(
+              ApplyMappingError.mapToExistingClass(
+                  type.toString(), mappedName.toString(), position));
+    } else {
+      mappedNames.put(type, mappedName);
+    }
+  }
+
+  private void computeDefaultInterfaceMethodMethods() {
+    for (String key : seedMapper.getKeyset()) {
+      ClassNamingForMapApplier classNaming = seedMapper.getMapping(key);
+      DexType type =
+          appView.dexItemFactory().lookupType(appView.dexItemFactory().createString(key));
+      if (type == null) {
+        // The map contains additional mapping of classes compared to what we have seen. This should
+        // have no effect.
+        continue;
+      }
+      DexClass dexClass = appView.definitionFor(type);
+      if (dexClass == null) {
+        computeDefaultInterfaceMethodMappingsForType(
+            type,
+            classNaming,
+            syntheticCompanionClasses,
+            defaultInterfaceMethodImplementationNames);
+        continue;
+      }
+    }
+  }
+
+  private void computeDefaultInterfaceMethodMappingsForType(
       DexType type,
       ClassNamingForMapApplier classNaming,
       Map<DexType, DexString> syntheticCompanionClasses,
@@ -196,88 +323,110 @@
     }
   }
 
-  static class ApplyMappingClassNamingStrategy implements ClassNamingStrategy {
+  static class ApplyMappingClassNamingStrategy extends MinificationClassNamingStrategy {
 
     private final Map<DexType, DexString> mappings;
+    private final boolean isMinifying;
 
-    ApplyMappingClassNamingStrategy(Map<DexType, DexString> mappings) {
+    ApplyMappingClassNamingStrategy(AppView<?> appView, Map<DexType, DexString> mappings) {
+      super(appView);
       this.mappings = mappings;
+      this.isMinifying = appView.options().isMinifying();
     }
 
     @Override
-    public DexString next(Namespace namespace, DexType type, char[] packagePrefix) {
-      return mappings.getOrDefault(type, type.descriptor);
-    }
-
-    @Override
-    public boolean bypassDictionary() {
-      return true;
+    public DexString next(DexType type, char[] packagePrefix, InternalNamingState state) {
+      DexString nextName = mappings.get(type);
+      if (nextName != null) {
+        return nextName;
+      }
+      assert !(isMinifying && noObfuscation(type));
+      return isMinifying ? super.next(type, packagePrefix, state) : type.descriptor;
     }
 
     @Override
     public boolean noObfuscation(DexType type) {
-      // We have an explicit mapping from the proguard map thus everything might have to be renamed.
-      return false;
+      if (mappings.containsKey(type)) {
+        return false;
+      }
+      DexClass dexClass = appView.definitionFor(type);
+      if (dexClass == null || dexClass.isNotProgramClass()) {
+        return true;
+      }
+      return super.noObfuscation(type);
     }
   }
 
-  static class ApplyMappingMemberNamingStrategy implements MemberNamingStrategy {
+  static class ApplyMappingMemberNamingStrategy extends MinifierMemberNamingStrategy {
 
     private final Map<DexReference, MemberNaming> mappedNames;
     private final DexItemFactory factory;
     private final Reporter reporter;
 
     public ApplyMappingMemberNamingStrategy(
-        Map<DexReference, MemberNaming> mappedNames, DexItemFactory factory, Reporter reporter) {
+        AppView<?> appView, Map<DexReference, MemberNaming> mappedNames) {
+      super(appView);
       this.mappedNames = mappedNames;
-      this.factory = factory;
-      this.reporter = reporter;
+      this.factory = appView.dexItemFactory();
+      this.reporter = appView.options().reporter;
     }
 
     @Override
-    public DexString next(DexMethod method, MemberNamingInternalState internalState) {
-      return next(method);
+    public DexString next(DexMethod method, InternalNamingState internalState) {
+      assert !mappedNames.containsKey(method);
+      return canMinify(method, method.holder) ? super.next(method, internalState) : method.name;
     }
 
     @Override
-    public DexString next(DexField field, MemberNamingInternalState internalState) {
-      return next(field);
+    public DexString next(DexField field, InternalNamingState internalState) {
+      assert !mappedNames.containsKey(field);
+      return canMinify(field, field.holder) ? super.next(field, internalState) : field.name;
     }
 
-    private DexString next(DexReference reference) {
-      if (mappedNames.containsKey(reference)) {
-        return factory.createString(mappedNames.get(reference).getRenamedName());
-      } else if (reference.isDexMethod()) {
-        return reference.asDexMethod().name;
-      } else {
-        assert reference.isDexField();
-        return reference.asDexField().name;
+    private boolean canMinify(DexReference reference, DexType type) {
+      if (!appView.options().isMinifying()) {
+        return false;
       }
+      DexClass dexClass = appView.definitionFor(type);
+      if (dexClass == null || dexClass.isNotProgramClass()) {
+        return false;
+      }
+      return appView.rootSet().mayBeMinified(reference, appView);
     }
 
     @Override
-    public boolean breakOnNotAvailable(DexReference source, DexString name) {
-      // If we renamed a member to a name that exists in a subtype we should warn that potentially
-      // a member lookup may no longer visit its parent.
-      MemberNaming memberNaming = mappedNames.get(source);
-      assert source.isDexMethod() || source.isDexField();
-      ApplyMappingError applyMappingError = ApplyMappingError.mapToExistingMember(
-          source.toSourceString(),
-          name.toString(),
-          memberNaming == null ? Position.UNKNOWN : memberNaming.position);
-      if (source.isDexMethod()) {
-        reporter.error(applyMappingError);
-      } else {
-        // TODO(b/128868424) Check if we can remove this warning for fields.
-        reporter.warning(applyMappingError);
+    public DexString getReservedNameOrDefault(
+        DexEncodedMethod method, DexClass holder, DexString nullValue) {
+      if (mappedNames.containsKey(method.method)) {
+        return factory.createString(mappedNames.get(method.method).getRenamedName());
       }
+      return nullValue;
+    }
+
+    @Override
+    public DexString getReservedNameOrDefault(
+        DexEncodedField field, DexClass holder, DexString nullValue) {
+      if (mappedNames.containsKey(field.field)) {
+        return factory.createString(mappedNames.get(field.field).getRenamedName());
+      }
+      return nullValue;
+    }
+
+    @Override
+    public boolean allowMemberRenaming(DexClass holder) {
       return true;
     }
 
     @Override
-    public boolean noObfuscation(DexReference reference) {
-      // We have an explicit mapping from the proguard map thus everything might have to be renamed.
-      return false;
+    public void reportReservationError(DexReference source, DexString name) {
+      MemberNaming memberNaming = mappedNames.get(source);
+      assert source.isDexMethod() || source.isDexField();
+      ApplyMappingError applyMappingError =
+          ApplyMappingError.mapToExistingMember(
+              source.toSourceString(),
+              name.toString(),
+              memberNaming == null ? Position.UNKNOWN : memberNaming.position);
+      reporter.error(applyMappingError);
     }
   }
 }
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java b/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
index 81b745c..ef9aedd 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapReader.java
@@ -196,114 +196,76 @@
   }
 
   private void parseMemberMappings(ClassNaming.Builder classNamingBuilder) throws IOException {
+    MemberNaming lastAddedNaming = null;
     MemberNaming activeMemberNaming = null;
-    Range previousObfuscatedRange = null;
-    boolean previousWasPotentiallySynthesized = false;
-    Signature previousSignature = null;
-    String previousRenamedName = null;
-    boolean lastRound = false;
-    for (; ; ) {
-      Signature signature = null;
+    Range previousMappedRange = null;
+    do {
       Object originalRange = null;
-      String renamedName = null;
-      Range obfuscatedRange = null;
+      Range mappedRange = null;
 
-      // In the last round we're only here to flush the last line read (which may trigger adding a
-      // new MemberNaming) and flush activeMemberNaming, so skip parsing.
-      if (!lastRound) {
-        if (!Character.isWhitespace(peekCodePoint())) {
-          lastRound = true;
-          continue;
-        }
-        skipWhitespace();
-        Object maybeRangeOrInt = maybeParseRangeOrInt();
-        if (maybeRangeOrInt != null) {
-          if (!(maybeRangeOrInt instanceof Range)) {
-            throw new ParseException(
-                String.format("Invalid obfuscated line number range (%s).", maybeRangeOrInt));
-          }
-          obfuscatedRange = (Range) maybeRangeOrInt;
-          expect(':');
-        }
-        signature = parseSignature();
-        if (peekChar(0) == ':') {
-          // This is a mapping or inlining definition
-          nextChar();
-          originalRange = maybeParseRangeOrInt();
-          if (originalRange == null) {
-            throw new ParseException("No number follows the colon after the method signature.");
-          }
-        }
-        skipWhitespace();
-        skipArrow();
-        skipWhitespace();
-        renamedName = parseMethodName();
-      }
-
-      // If this line refers to a member that should be added to classNamingBuilder (as opposed to
-      // an inner inlined callee) and it's different from the activeMemberNaming, then flush (add)
-      // the current activeMemberNaming and create a new one.
-      // We're also entering this in the last round when there's no current line.
-      if (previousRenamedName != null
-          && (!Objects.equals(previousObfuscatedRange, obfuscatedRange)
-              || !Objects.equals(previousRenamedName, renamedName)
-              || (originalRange != null && originalRange instanceof Range))) {
-        // Flush activeMemberNaming if it's for a different member.
-        if (activeMemberNaming != null) {
-          if (!activeMemberNaming.getOriginalSignature().equals(previousSignature)) {
-            classNamingBuilder.addMemberEntry(activeMemberNaming);
-            activeMemberNaming = null;
-          } else {
-            if (activeMemberNaming.getRenamedName().equals(previousRenamedName)) {
-              // The method was potentially synthesized.
-              previousWasPotentiallySynthesized = previousObfuscatedRange == null;
-            } else {
-              assert previousWasPotentiallySynthesized;
-            }
-          }
-        }
-        if (activeMemberNaming == null) {
-          activeMemberNaming =
-              new MemberNaming(previousSignature, previousRenamedName, getPosition());
-        }
-      }
-
-      if (lastRound) {
-        if (activeMemberNaming != null) {
-          classNamingBuilder.addMemberEntry(activeMemberNaming);
-        }
+      // Parse the member line '  x:y:name:z:q -> renamedName'.
+      if (!Character.isWhitespace(peekCodePoint())) {
         break;
       }
-
-      // Interpret what we've just parsed.
-      if (obfuscatedRange == null) {
-        if (originalRange != null) {
-          throw new ParseException("No mapping for original range " + originalRange + ".");
+      skipWhitespace();
+      Object maybeRangeOrInt = maybeParseRangeOrInt();
+      if (maybeRangeOrInt != null) {
+        if (!(maybeRangeOrInt instanceof Range)) {
+          throw new ParseException(
+              String.format("Invalid obfuscated line number range (%s).", maybeRangeOrInt));
         }
-        // Here we have a line like 'a() -> b' or a field like 'a -> b'
-        if (activeMemberNaming != null) {
-          classNamingBuilder.addMemberEntry(activeMemberNaming);
-        }
-        activeMemberNaming = new MemberNaming(signature, renamedName, getPosition());
-      } else {
-
-        // Note that at this point originalRange may be null which either means, it's the same as
-        // the obfuscatedRange (identity mapping) or that it's unknown (source line number
-        // information was not available).
-        assert signature instanceof MethodSignature;
+        mappedRange = (Range) maybeRangeOrInt;
+        expect(':');
       }
+      Signature signature = parseSignature();
+      if (peekChar(0) == ':') {
+        // This is a mapping or inlining definition
+        nextChar();
+        originalRange = maybeParseRangeOrInt();
+        if (originalRange == null) {
+          throw new ParseException("No number follows the colon after the method signature.");
+        }
+      }
+      if (mappedRange == null && originalRange != null) {
+        throw new ParseException("No mapping for original range " + originalRange + ".");
+      }
+
+      skipWhitespace();
+      skipArrow();
+      skipWhitespace();
+      String renamedName = parseMethodName();
 
       if (signature instanceof MethodSignature) {
         classNamingBuilder.addMappedRange(
-            obfuscatedRange, (MethodSignature) signature, originalRange, renamedName);
+            mappedRange, (MethodSignature) signature, originalRange, renamedName);
       }
 
-      previousRenamedName = renamedName;
-      previousObfuscatedRange = obfuscatedRange;
-      previousSignature = signature;
+      assert mappedRange == null || signature instanceof MethodSignature;
 
-      if (!nextLine()) {
-        lastRound = true;
+      // If this line refers to a member that should be added to classNamingBuilder (as opposed to
+      // an inner inlined callee) and it's different from the the previous activeMemberNaming, then
+      // flush (add) the current activeMemberNaming.
+      if (activeMemberNaming != null) {
+        boolean changedName = !activeMemberNaming.getRenamedName().equals(renamedName);
+        boolean changedMappedRange = !Objects.equals(previousMappedRange, mappedRange);
+        boolean notAdded =
+            lastAddedNaming == null
+                || !lastAddedNaming.getOriginalSignature().equals(activeMemberNaming.signature);
+        if (changedName || previousMappedRange == null || (changedMappedRange && notAdded)) {
+          classNamingBuilder.addMemberEntry(activeMemberNaming);
+          lastAddedNaming = activeMemberNaming;
+        }
+      }
+      activeMemberNaming = new MemberNaming(signature, renamedName, getPosition());
+      previousMappedRange = mappedRange;
+    } while (nextLine());
+
+    if (activeMemberNaming != null) {
+      boolean notAdded =
+          lastAddedNaming == null
+              || !lastAddedNaming.getOriginalSignature().equals(activeMemberNaming.signature);
+      if (previousMappedRange == null || notAdded) {
+        classNamingBuilder.addMemberEntry(activeMemberNaming);
       }
     }
   }
diff --git a/src/main/java/com/android/tools/r8/naming/ReservedFieldNamingState.java b/src/main/java/com/android/tools/r8/naming/ReservedFieldNamingState.java
index 9885681..3e733fb 100644
--- a/src/main/java/com/android/tools/r8/naming/ReservedFieldNamingState.java
+++ b/src/main/java/com/android/tools/r8/naming/ReservedFieldNamingState.java
@@ -5,7 +5,6 @@
 package com.android.tools.r8.naming;
 
 import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexField;
 import com.android.tools.r8.graph.DexString;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.naming.ReservedFieldNamingState.InternalState;
@@ -25,10 +24,6 @@
     return internalState != null && internalState.isReserved(name);
   }
 
-  public void markReservedDirectly(DexField field) {
-    markReservedDirectly(field.name, field.type);
-  }
-
   public void markReservedDirectly(DexString name, DexType type) {
     getOrCreateInternalState(type).markReservedDirectly(name);
   }
diff --git a/src/main/java/com/android/tools/r8/naming/signature/GenericSignatureRewriter.java b/src/main/java/com/android/tools/r8/naming/signature/GenericSignatureRewriter.java
index f6eabad..7b3caa7 100644
--- a/src/main/java/com/android/tools/r8/naming/signature/GenericSignatureRewriter.java
+++ b/src/main/java/com/android/tools/r8/naming/signature/GenericSignatureRewriter.java
@@ -43,12 +43,15 @@
     this.reporter = appView.options().reporter;
   }
 
-  public void run() {
+  public void run(Iterable<? extends DexClass> classes) {
     final GenericSignatureCollector genericSignatureCollector = new GenericSignatureCollector();
     final GenericSignatureParser<DexType> genericSignatureParser =
         new GenericSignatureParser<>(genericSignatureCollector);
-
-    for (DexClass clazz : appView.appInfo().classes()) {
+    // classes may not be the same as appInfo().classes() if applymapping is used on classpath
+    // arguments. If that is the case, the ProguardMapMinifier will pass in all classes that is
+    // either ProgramClass or has a mapping. This is then transitively called inside the
+    // ClassNameMinifier.
+    for (DexClass clazz : classes) {
       clazz.annotations =
           rewriteGenericSignatures(
               clazz.annotations,
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfiguration.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfiguration.java
index d46a976..9d0adec 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfiguration.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfiguration.java
@@ -69,6 +69,7 @@
     private boolean overloadAggressively;
     private boolean keepRuleSynthesisForRecompilation = false;
     private boolean configurationDebugging = false;
+    private boolean dontUseMixedCaseClassnames = false;
 
     private Builder(DexItemFactory dexItemFactory, Reporter reporter) {
       this.dexItemFactory = dexItemFactory;
@@ -275,6 +276,10 @@
       this.configurationDebugging = configurationDebugging;
     }
 
+    public void setDontUseMixedCaseClassnames(boolean dontUseMixedCaseClassnames) {
+      this.dontUseMixedCaseClassnames = dontUseMixedCaseClassnames;
+    }
+
     /**
      * This synthesizes a set of keep rules that are necessary in order to be able to successfully
      * recompile the generated dex files with the same keep rules.
@@ -332,7 +337,8 @@
               adaptResourceFilenames.build(),
               adaptResourceFileContents.build(),
               keepDirectories.build(),
-              configurationDebugging);
+              configurationDebugging,
+              dontUseMixedCaseClassnames);
 
       reporter.failIfPendingErrors();
 
@@ -400,6 +406,7 @@
   private final ProguardPathFilter adaptResourceFileContents;
   private final ProguardPathFilter keepDirectories;
   private final boolean configurationDebugging;
+  private final boolean dontUseMixedCaseClassnames;
 
   private ProguardConfiguration(
       String parsedConfiguration,
@@ -438,7 +445,8 @@
       ProguardPathFilter adaptResourceFilenames,
       ProguardPathFilter adaptResourceFileContents,
       ProguardPathFilter keepDirectories,
-      boolean configurationDebugging) {
+      boolean configurationDebugging,
+      boolean dontUseMixedCaseClassnames) {
     this.parsedConfiguration = parsedConfiguration;
     this.dexItemFactory = factory;
     this.injars = ImmutableList.copyOf(injars);
@@ -476,6 +484,7 @@
     this.adaptResourceFileContents = adaptResourceFileContents;
     this.keepDirectories = keepDirectories;
     this.configurationDebugging = configurationDebugging;
+    this.dontUseMixedCaseClassnames = dontUseMixedCaseClassnames;
   }
 
   /**
@@ -638,6 +647,10 @@
     return configurationDebugging;
   }
 
+  public boolean hasDontUseMixedCaseClassnames() {
+    return dontUseMixedCaseClassnames;
+  }
+
   @Override
   public String toString() {
     StringBuilder builder = new StringBuilder();
diff --git a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
index 45105c2..a3d58a1 100644
--- a/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
+++ b/src/main/java/com/android/tools/r8/shaking/ProguardConfigurationParser.java
@@ -61,7 +61,6 @@
 
   private static final List<String> IGNORED_FLAG_OPTIONS = ImmutableList.of(
       "forceprocessing",
-      "dontusemixedcaseclassnames",
       "dontpreverify",
       "experimentalshrinkunusedprotofields",
       "filterlibraryjarswithorginalprogramjars",
@@ -398,6 +397,8 @@
         configurationBuilder.addRule(parseIfRule(optionStart));
       } else if (acceptString("addconfigurationdebugging")) {
         configurationBuilder.setConfigurationDebugging(true);
+      } else if (acceptString("dontusemixedcaseclassnames")) {
+        configurationBuilder.setDontUseMixedCaseClassnames(true);
       } else {
         String unknownOption = acceptString();
         String devMessage = "";
diff --git a/src/main/java/com/android/tools/r8/utils/StringUtils.java b/src/main/java/com/android/tools/r8/utils/StringUtils.java
index c5b5d6b..295de13 100644
--- a/src/main/java/com/android/tools/r8/utils/StringUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/StringUtils.java
@@ -17,10 +17,6 @@
   public static final String[] EMPTY_ARRAY = {};
   public static final String LINE_SEPARATOR = System.getProperty("line.separator");
 
-  private static final char[] IDENTIFIER_LETTERS
-      = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_".toCharArray();
-  private static final int NUMBER_OF_LETTERS = IDENTIFIER_LETTERS.length;
-
   public enum BraceType {
     PARENS,
     SQUARE,
@@ -257,40 +253,6 @@
     return Arrays.toString(digest);
   }
 
-  public static String numberToIdentifier(int nameCount) {
-    return numberToIdentifier(nameCount, EMPTY_CHAR_ARRAY, false);
-  }
-
-  public static String numberToIdentifier(int nameCount, char[] prefix) {
-    return numberToIdentifier(nameCount, prefix, false);
-  }
-
-  public static String numberToIdentifier(int nameCount, char[] prefix, boolean addSemicolon) {
-    // TODO(herhut): Add support for using numbers.
-    int size = addSemicolon ? 1 : 0;
-    int number = nameCount;
-    while (number >= NUMBER_OF_LETTERS) {
-      number /= NUMBER_OF_LETTERS;
-      size++;
-    }
-    size++;
-    char characters[] = Arrays.copyOfRange(prefix, 0, prefix.length + size);
-    number = nameCount;
-
-    int i = prefix.length;
-    while (number >= NUMBER_OF_LETTERS) {
-      characters[i++] = IDENTIFIER_LETTERS[number % NUMBER_OF_LETTERS];
-      number /= NUMBER_OF_LETTERS;
-    }
-    characters[i++] = IDENTIFIER_LETTERS[number - 1];
-    if (addSemicolon) {
-      characters[i++] = ';';
-    }
-    assert i == characters.length;
-
-    return new String(characters);
-  }
-
   public static String times(String string, int count) {
     StringBuilder builder = new StringBuilder();
     while (--count >= 0) {
diff --git a/src/main/java/com/android/tools/r8/utils/SymbolGenerationUtils.java b/src/main/java/com/android/tools/r8/utils/SymbolGenerationUtils.java
new file mode 100644
index 0000000..b66ca5d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/utils/SymbolGenerationUtils.java
@@ -0,0 +1,73 @@
+// 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.utils;
+
+import static com.android.tools.r8.utils.StringUtils.EMPTY_CHAR_ARRAY;
+
+import java.util.Arrays;
+
+public class SymbolGenerationUtils {
+
+  public enum MixedCasing {
+    USE_MIXED_CASE,
+    DONT_USE_MIXED_CASE
+  }
+
+  // These letters are used not creating fresh names to output and not for parsing dex/class files.
+  private static final char[] IDENTIFIER_CHARACTERS =
+      "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
+  private static final int NUMBER_OF_CHARACTERS = IDENTIFIER_CHARACTERS.length;
+  private static final int NUMBER_OF_CHARACTERS_MINUS_CAPITAL_LETTERS = NUMBER_OF_CHARACTERS - 26;
+  private static final int NON_ALLOWED_FIRST_CHARACTERS = 10;
+
+  public static String numberToIdentifier(int nameCount, MixedCasing mixedCasing) {
+    return numberToIdentifier(nameCount, mixedCasing, EMPTY_CHAR_ARRAY, false);
+  }
+
+  public static String numberToIdentifier(int nameCount, MixedCasing mixedCasing, char[] prefix) {
+    return numberToIdentifier(nameCount, mixedCasing, prefix, false);
+  }
+
+  public static String numberToIdentifier(
+      int nameCount, MixedCasing mixedCasing, char[] prefix, boolean addSemicolon) {
+    int size = 1;
+    int number = nameCount;
+    int maximumNumberOfCharacters =
+        mixedCasing == MixedCasing.USE_MIXED_CASE
+            ? NUMBER_OF_CHARACTERS
+            : NUMBER_OF_CHARACTERS_MINUS_CAPITAL_LETTERS;
+    int firstNumberOfCharacters = maximumNumberOfCharacters - NON_ALLOWED_FIRST_CHARACTERS;
+    int availableCharacters = firstNumberOfCharacters;
+    // We first do an initial computation to find the size of the resulting string to allocate an
+    // array that will fit in length.
+    while (number > availableCharacters) {
+      number = (number - 1) / availableCharacters;
+      availableCharacters = maximumNumberOfCharacters;
+      size++;
+    }
+    size += addSemicolon ? 1 : 0;
+    char characters[] = Arrays.copyOfRange(prefix, 0, prefix.length + size);
+    number = nameCount;
+
+    int i = prefix.length;
+    availableCharacters = firstNumberOfCharacters;
+    int firstLetterPadding = NON_ALLOWED_FIRST_CHARACTERS;
+    while (number > availableCharacters) {
+      characters[i++] =
+          IDENTIFIER_CHARACTERS[(number - 1) % availableCharacters + firstLetterPadding];
+      number = (number - 1) / availableCharacters;
+      availableCharacters = maximumNumberOfCharacters;
+      firstLetterPadding = 0;
+    }
+    characters[i++] = IDENTIFIER_CHARACTERS[number - 1 + firstLetterPadding];
+    if (addSemicolon) {
+      characters[i++] = ';';
+    }
+    assert i == characters.length;
+    assert !Character.isDigit(characters[prefix.length]);
+
+    return new String(characters);
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/ClassObfuscationDictionaryDuplicateTest.java b/src/test/java/com/android/tools/r8/naming/ClassObfuscationDictionaryDuplicateTest.java
new file mode 100644
index 0000000..4f3a868
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/ClassObfuscationDictionaryDuplicateTest.java
@@ -0,0 +1,79 @@
+// 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.naming;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static junit.framework.TestCase.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ClassObfuscationDictionaryDuplicateTest extends TestBase {
+
+  public static class A {}
+
+  public static class B {}
+
+  public static class C {
+    public static void main(String[] args) {
+      System.out.print("HELLO WORLD!");
+    }
+  }
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
+  }
+
+  public ClassObfuscationDictionaryDuplicateTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws IOException, CompilationFailedException, ExecutionException {
+    Path dictionary = temp.getRoot().toPath().resolve("dictionary.txt");
+    FileUtils.writeTextFile(dictionary, "a");
+
+    Set<String> finalNames = new HashSet<>();
+    finalNames.add(A.class.getPackage().getName() + ".a");
+    finalNames.add(B.class.getPackage().getName() + ".b");
+
+    testForR8(parameters.getBackend())
+        .addProgramClasses(A.class, B.class, C.class)
+        .noTreeShaking()
+        .addKeepRules("-classobfuscationdictionary " + dictionary.toString())
+        .addKeepMainRule(C.class)
+        .setMinApi(parameters.getRuntime())
+        .compile()
+        .run(parameters.getRuntime(), C.class)
+        .assertSuccessWithOutput("HELLO WORLD!")
+        .inspect(
+            inspector -> {
+              ClassSubject clazzA = inspector.clazz(A.class);
+              assertThat(clazzA, isPresent());
+              assertTrue(finalNames.contains(clazzA.getFinalName()));
+              finalNames.remove(clazzA.getFinalName());
+              ClassSubject clazzB = inspector.clazz(B.class);
+              assertThat(clazzB, isPresent());
+              assertTrue(finalNames.contains(clazzB.getFinalName()));
+            });
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/MinificationMixedCaseAndNumbersTest.java b/src/test/java/com/android/tools/r8/naming/MinificationMixedCaseAndNumbersTest.java
new file mode 100644
index 0000000..55b3a9a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/MinificationMixedCaseAndNumbersTest.java
@@ -0,0 +1,204 @@
+// 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.naming;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.SymbolGenerationUtils;
+import com.android.tools.r8.utils.SymbolGenerationUtils.MixedCasing;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MinificationMixedCaseAndNumbersTest extends TestBase {
+
+  private static final int NUMBER_OF_MINIFIED_CLASSES = 60;
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
+  }
+
+  public MinificationMixedCaseAndNumbersTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testNaming() throws ExecutionException, CompilationFailedException, IOException {
+    Set<String> allowedNames = new HashSet<>();
+    allowedNames.add("com.android.tools.r8.naming.MinificationMixedCaseAndNumbersTest$Main");
+    for (int i = 1; i < NUMBER_OF_MINIFIED_CLASSES; i++) {
+      String newString =
+          SymbolGenerationUtils.numberToIdentifier(i, MixedCasing.DONT_USE_MIXED_CASE);
+      assertFalse(Character.isDigit(newString.charAt(0)));
+      allowedNames.add("com.android.tools.r8.naming." + newString);
+    }
+    testForR8(parameters.getBackend())
+        .addInnerClasses(MinificationMixedCaseAndNumbersTest.class)
+        .addKeepMainRule(Main.class)
+        .noTreeShaking()
+        .addKeepRules("-dontusemixedcaseclassnames")
+        .setMinApi(parameters.getRuntime())
+        .run(parameters.getRuntime(), Main.class)
+        .inspect(
+            inspector -> {
+              List<FoundClassSubject> foundClassSubjects = new ArrayList<>(inspector.allClasses());
+              foundClassSubjects.forEach(
+                  foundClazz -> {
+                    assertTrue(allowedNames.contains(foundClazz.getFinalName()));
+                    allowedNames.remove(foundClazz.getFinalName());
+                  });
+            });
+    // The first identifier to use a number is 27 for MixedCasing.DONT_USE_MIXED_CASE.
+    assertTrue(allowedNames.isEmpty());
+    assertEquals(
+        "a0", SymbolGenerationUtils.numberToIdentifier(27, MixedCasing.DONT_USE_MIXED_CASE));
+    assertEquals(
+        "zz", SymbolGenerationUtils.numberToIdentifier(962, MixedCasing.DONT_USE_MIXED_CASE));
+    assertEquals(
+        "a00", SymbolGenerationUtils.numberToIdentifier(963, MixedCasing.DONT_USE_MIXED_CASE));
+  }
+
+  public static class A {}
+
+  public static class B {}
+
+  public static class C {}
+
+  public static class D {}
+
+  public static class E {}
+
+  public static class F {}
+
+  public static class G {}
+
+  public static class H {}
+
+  public static class I {}
+
+  public static class J {}
+
+  public static class K {}
+
+  public static class L {}
+
+  public static class M {}
+
+  public static class N {}
+
+  public static class O {}
+
+  public static class P {}
+
+  public static class Q {}
+
+  public static class R {}
+
+  public static class S {}
+
+  public static class T {}
+
+  public static class U {}
+
+  public static class V {}
+
+  public static class W {}
+
+  public static class X {}
+
+  public static class Y {}
+
+  public static class Z {}
+
+  public static class a {}
+
+  public static class b {}
+
+  public static class c {}
+
+  public static class d {}
+
+  public static class e {}
+
+  public static class f {}
+
+  public static class g {}
+
+  public static class h {}
+
+  public static class i {}
+
+  public static class j {}
+
+  public static class k {}
+
+  public static class l {}
+
+  public static class m {}
+
+  public static class n {}
+
+  public static class o {}
+
+  public static class p {}
+
+  public static class q {}
+
+  public static class r {}
+
+  public static class s {}
+
+  public static class t {}
+
+  public static class u {}
+
+  public static class v {}
+
+  public static class w {}
+
+  public static class x {}
+
+  public static class y {}
+
+  public static class z {}
+
+  public static class AA {}
+
+  public static class AB {}
+
+  public static class AC {}
+
+  public static class AD {}
+
+  public static class AE {}
+
+  public static class AF {}
+
+  public static class AG {}
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      System.out.println("HELLO WORLD");
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/PackageObfuscationDictionaryDuplicateTest.java b/src/test/java/com/android/tools/r8/naming/PackageObfuscationDictionaryDuplicateTest.java
new file mode 100644
index 0000000..f10947e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/PackageObfuscationDictionaryDuplicateTest.java
@@ -0,0 +1,65 @@
+// 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.naming;
+
+import static junit.framework.TestCase.assertTrue;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.naming.keeppackagenames.Top;
+import com.android.tools.r8.naming.packageobfucationdict.A;
+import com.android.tools.r8.utils.FileUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class PackageObfuscationDictionaryDuplicateTest extends TestBase {
+
+  public static class C {
+    public static void main(String[] args) {
+      System.out.print("HELLO WORLD!");
+    }
+  }
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
+  }
+
+  public PackageObfuscationDictionaryDuplicateTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test() throws IOException, CompilationFailedException, ExecutionException {
+    Path dictionary = temp.getRoot().toPath().resolve("dictionary.txt");
+    FileUtils.writeTextFile(dictionary, "a");
+    testForR8(parameters.getBackend())
+        .addProgramClassesAndInnerClasses(Top.class, A.class, C.class)
+        .noTreeShaking()
+        .addKeepRules("-packageobfuscationdictionary " + dictionary.toString())
+        .addKeepMainRule(C.class)
+        .setMinApi(parameters.getRuntime())
+        .compile()
+        .run(parameters.getRuntime(), C.class)
+        .assertSuccessWithOutput("HELLO WORLD!")
+        .inspect(
+            inspector -> {
+              ClassSubject clazzTop = inspector.clazz(Top.class);
+              assertTrue(clazzTop.getFinalName().endsWith(".a.a"));
+              ClassSubject clazzA = inspector.clazz(A.class);
+              assertTrue(clazzA.getFinalName().endsWith(".b.a"));
+            });
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/SeedMapperTests.java b/src/test/java/com/android/tools/r8/naming/SeedMapperTests.java
index 91da18d..4c265ef 100644
--- a/src/test/java/com/android/tools/r8/naming/SeedMapperTests.java
+++ b/src/test/java/com/android/tools/r8/naming/SeedMapperTests.java
@@ -162,4 +162,34 @@
       assertEquals(2, ((TextPosition) diagnostic.getPosition()).getLine());
     }
   }
+
+  @Test
+  public void testInliningFrames() throws IOException {
+    Path applyMappingFile =
+        getApplyMappingFile(
+            "A.B.C -> a:",
+            "  int foo(A) -> a",
+            "  1:2:int bar(A):3:4 -> a",
+            "  1:2:int baz(B):3 -> a");
+    TestDiagnosticMessagesImpl testDiagnosticMessages = new TestDiagnosticMessagesImpl();
+    Reporter reporter = new Reporter(testDiagnosticMessages);
+    SeedMapper.seedMapperFromFile(reporter, applyMappingFile);
+  }
+
+  @Test
+  public void testDuplicateInliningFrames() throws IOException {
+    Path applyMappingFile =
+        getApplyMappingFile(
+            "A.B.C -> a:",
+            "  int foo(Z) -> a",
+            "  1:1:int qux(A):3:3 -> a",
+            "  1:1:int bar(A):3 -> a",
+            "  2:2:int qux(A):3:3 -> a",
+            "  2:2:int bar(A):4 -> a",
+            "  3:3:int bar(A):5:5 -> a",
+            "  int qux(C) -> a");
+    TestDiagnosticMessagesImpl testDiagnosticMessages = new TestDiagnosticMessagesImpl();
+    Reporter reporter = new Reporter(testDiagnosticMessages);
+    SeedMapper.seedMapperFromFile(reporter, applyMappingFile);
+  }
 }
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterDevirtualizationTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterDevirtualizationTest.java
index 500dbf5..2587730 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterDevirtualizationTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingAfterDevirtualizationTest.java
@@ -13,7 +13,6 @@
 import com.android.tools.r8.utils.StringUtils;
 import com.android.tools.r8.utils.codeinspector.CodeInspector;
 import org.junit.Assume;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -99,7 +98,6 @@
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
   }
 
-  @Ignore("b/126503704")
   @Test
   public void devirtualizingNoRenamingOfOverriddenNotKeptInterfaceMethods() throws Exception {
     R8TestCompileResult libraryResult =
@@ -131,7 +129,6 @@
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
   }
 
-  @Ignore("b/126503704")
   @Test
   public void devirtualizingNoRenamingOfOverriddenKeptInterfaceMethods() throws Exception {
     R8TestCompileResult libraryResult =
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java
new file mode 100644
index 0000000..b920732
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingMinificationTest.java
@@ -0,0 +1,133 @@
+// 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.naming.applymapping;
+
+import static com.android.tools.r8.references.Reference.methodFromMethod;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static junit.framework.TestCase.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.NeverClassInline;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.FieldSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ApplyMappingMinificationTest extends TestBase {
+
+  @NeverClassInline
+  public static class A {
+    public int fieldA = 1;
+    public int fieldB = 2;
+
+    @NeverInline
+    public void methodA() {
+      System.out.println("A.methodA");
+    }
+
+    @NeverInline
+    public void methodB() {
+      System.out.println("A.methodB");
+    }
+
+    @NeverInline
+    public void methodC() {
+      System.out.println("A.methodC");
+    }
+  }
+
+  @NeverClassInline
+  public static class B {
+    @NeverInline
+    public void foo() {
+      System.out.println("B.foo");
+    }
+  }
+
+  public static class C {
+
+    public static void main(String[] args) {
+      System.out.println(new A().fieldA);
+      System.out.println(new A().fieldB);
+      new A().methodA();
+      new A().methodB();
+      new A().methodC();
+      new B().foo();
+    }
+  }
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
+  }
+
+  public ApplyMappingMinificationTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void testApplyMappingFollowedByMinification()
+      throws IOException, CompilationFailedException, ExecutionException, NoSuchMethodException {
+    String[] pgMap =
+        new String[] {
+          A.class.getTypeName() + " -> a:", "  int fieldA -> a", "  void methodA() -> a"
+        };
+    R8TestRunResult runResult =
+        testForR8(parameters.getBackend())
+            .addInnerClasses(ApplyMappingMinificationTest.class)
+            .addKeepMainRule(C.class)
+            .addKeepMethodRules(methodFromMethod(A.class.getDeclaredMethod("methodC")))
+            .enableInliningAnnotations()
+            .enableClassInliningAnnotations()
+            .addApplyMapping(StringUtils.lines(pgMap))
+            .setMinApi(parameters.getRuntime())
+            .run(parameters.getRuntime(), C.class)
+            .assertSuccessWithOutputLines("1", "2", "A.methodA", "A.methodB", "A.methodC", "B.foo")
+            .inspect(
+                inspector -> {
+                  ClassSubject clazzB = inspector.clazz(B.class);
+                  assertThat(clazzB, isPresent());
+                  assertTrue(clazzB.isRenamed());
+                  ClassSubject clazzA = inspector.clazz(A.class);
+                  assertThat(clazzA, isPresent());
+                  assertEquals("a", clazzA.getFinalName());
+                  FieldSubject fieldA = clazzA.uniqueFieldWithName("fieldA");
+                  assertThat(fieldA, isPresent());
+                  assertEquals("a", fieldA.getFinalName());
+                  MethodSubject methodA = clazzA.uniqueMethodWithName("methodA");
+                  assertThat(methodA, isPresent());
+                  assertEquals("a", methodA.getFinalName());
+                  FieldSubject fieldB = clazzA.uniqueFieldWithName("fieldB");
+                  assertThat(fieldB, isPresent());
+                  assertTrue(fieldB.isRenamed());
+                  MethodSubject methodB = clazzA.uniqueMethodWithName("methodB");
+                  assertThat(methodB, isPresent());
+                  assertTrue(methodB.isRenamed());
+                  MethodSubject methodC = clazzA.uniqueMethodWithName("methodC");
+                  assertThat(methodC, isPresent());
+                  assertFalse(methodC.isRenamed());
+                });
+    // Ensure that the proguard map is extended with all the new minified names.
+    for (String pgLine : pgMap) {
+      runResult.proguardMap().contains(pgLine);
+    }
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRotateNameClashTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRotateNameClashTest.java
new file mode 100644
index 0000000..ff87272
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingRotateNameClashTest.java
@@ -0,0 +1,58 @@
+// 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.naming.applymapping;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringUtils;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ApplyMappingRotateNameClashTest extends TestBase {
+
+  public static class A {}
+
+  public static class B {}
+
+  public static class C {
+    public static void main(String[] args) {
+      System.out.print("HELLO WORLD!");
+    }
+  }
+
+  private final TestParameters parameters;
+
+  @Parameterized.Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().build();
+  }
+
+  public ApplyMappingRotateNameClashTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void test_b131532229() throws ExecutionException, CompilationFailedException, IOException {
+    testForR8(parameters.getBackend())
+        .addLibraryClasses(A.class, B.class)
+        .addLibraryFiles(TestBase.runtimeJar(parameters.getBackend()))
+        .addProgramClasses(C.class)
+        .addKeepMainRule(C.class)
+        .noTreeShaking()
+        .addApplyMapping(
+            StringUtils.lines(
+                A.class.getTypeName() + " -> " + B.class.getTypeName() + ":",
+                B.class.getTypeName() + " -> " + A.class.getTypeName() + ":"))
+        .setMinApi(parameters.getRuntime())
+        .run(parameters.getRuntime(), C.class)
+        .assertSuccessWithOutput("HELLO WORLD!");
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingVirtualInvokeTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingVirtualInvokeTest.java
index 7989a29..cc4e99c 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingVirtualInvokeTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingVirtualInvokeTest.java
@@ -12,6 +12,7 @@
 import com.android.tools.r8.TestParameters;
 import com.android.tools.r8.TestParametersCollection;
 import com.android.tools.r8.naming.applymapping.ApplyMappingVirtualInvokeTest.TestClasses.LibraryBase;
+import com.android.tools.r8.naming.applymapping.ApplyMappingVirtualInvokeTest.TestClasses.LibraryInterface;
 import com.android.tools.r8.naming.applymapping.ApplyMappingVirtualInvokeTest.TestClasses.LibrarySubclass;
 import com.android.tools.r8.naming.applymapping.ApplyMappingVirtualInvokeTest.TestClasses.ProgramClass;
 import com.android.tools.r8.naming.applymapping.ApplyMappingVirtualInvokeTest.TestClasses.ProgramSubclass;
@@ -20,7 +21,6 @@
 import java.nio.file.Path;
 import java.util.concurrent.ExecutionException;
 import java.util.function.Function;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -28,17 +28,28 @@
 @RunWith(Parameterized.class)
 public class ApplyMappingVirtualInvokeTest extends TestBase {
 
-  public static final String EXPECTED_PROGRAM = StringUtils.lines("LibraryBase.foo");
+  public static final String EXPECTED_PROGRAM =
+      StringUtils.lines("LibraryBase.foo", "LibraryBase.bar");
   public static final String EXPECTED_PROGRAM_SUBCLASS =
-      StringUtils.lines("ProgramSubclass.foo", "LibraryBase.foo");
+      StringUtils.lines(
+          "ProgramSubclass.foo", "LibraryBase.foo", "ProgramSubclass.bar", "LibraryBase.bar");
 
   public static class TestClasses {
 
-    public static class LibraryBase {
+    public interface LibraryInterface {
+      void bar();
+    }
 
-      void foo() {
+    public static class LibraryBase implements LibraryInterface {
+
+      public void foo() {
         System.out.println("LibraryBase.foo");
       }
+
+      @Override
+      public void bar() {
+        System.out.println("LibraryBase.bar");
+      }
     }
 
     public static class LibrarySubclass extends LibraryBase {}
@@ -47,6 +58,7 @@
 
       public static void main(String[] args) {
         new LibrarySubclass().foo();
+        new LibrarySubclass().bar();
       }
     }
 
@@ -54,17 +66,26 @@
 
       public static void main(String[] args) {
         new ProgramSubclass().foo();
+        new ProgramSubclass().bar();
       }
 
       @Override
-      void foo() {
+      public void foo() {
         System.out.println("ProgramSubclass.foo");
         super.foo();
       }
+
+      @Override
+      public void bar() {
+        System.out.println("ProgramSubclass.bar");
+        super.bar();
+      }
     }
   }
 
-  private static final Class<?>[] LIBRARY_CLASSES = {LibraryBase.class, LibrarySubclass.class};
+  private static final Class<?>[] LIBRARY_CLASSES = {
+    LibraryInterface.class, LibraryBase.class, LibrarySubclass.class
+  };
   private static final Class<?>[] PROGRAM_CLASSES = {ProgramClass.class, ProgramSubclass.class};
   private final TestParameters parameters;
 
@@ -77,13 +98,15 @@
     this.parameters = parameters;
   }
 
-  private static Function<Backend, R8TestCompileResult> compilationResults =
+  private static Function<TestParameters, R8TestCompileResult> compilationResults =
       memoizeFunction(ApplyMappingVirtualInvokeTest::compile);
 
-  private static R8TestCompileResult compile(Backend backend) throws CompilationFailedException {
-    return testForR8(getStaticTemp(), backend)
+  private static R8TestCompileResult compile(TestParameters parameters)
+      throws CompilationFailedException {
+    return testForR8(getStaticTemp(), parameters.getBackend())
         .addProgramClasses(LIBRARY_CLASSES)
         .addKeepClassAndMembersRulesWithAllowObfuscation(LIBRARY_CLASSES)
+        .setMinApi(parameters.getRuntime())
         .addOptionsModification(
             options -> {
               options.enableInlining = false;
@@ -116,14 +139,12 @@
         .assertSuccessWithOutput(EXPECTED_PROGRAM_SUBCLASS);
   }
 
-  @Ignore("b/128868424")
   @Test
   public void testProgramClass()
       throws ExecutionException, CompilationFailedException, IOException {
     runTest(ProgramClass.class, EXPECTED_PROGRAM);
   }
 
-  @Ignore("b/128868424")
   @Test
   public void testProgramSubClass()
       throws ExecutionException, IOException, CompilationFailedException {
@@ -132,7 +153,7 @@
 
   private void runTest(Class<?> main, String expected)
       throws ExecutionException, IOException, CompilationFailedException {
-    R8TestCompileResult libraryCompileResult = compilationResults.apply(parameters.getBackend());
+    R8TestCompileResult libraryCompileResult = compilationResults.apply(parameters);
     Path outPath = temp.newFile("out.zip").toPath();
     libraryCompileResult.writeToZip(outPath);
     testForR8(parameters.getBackend())
@@ -140,7 +161,7 @@
         .noMinification()
         .addProgramClasses(PROGRAM_CLASSES)
         .addApplyMapping(libraryCompileResult.getProguardMap())
-        .addLibraryClasses(LIBRARY_CLASSES)
+        .addClasspathClasses(LIBRARY_CLASSES)
         .addLibraryFiles(runtimeJar(parameters.getBackend()))
         .setMinApi(parameters.getRuntime())
         .compile()
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java
index 3bcc25c..58cdef6 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/desugar/DefaultInterfaceMethodTest.java
@@ -99,6 +99,7 @@
         .addProgramClasses(ProgramClass.class)
         .addClasspathClasses(LibraryInterface.class)
         .addApplyMapping(libraryResult.getProguardMap())
+        .addKeepMainRule(ProgramClass.class)
         .setMinApi(parameters.getRuntime())
         .compile()
         .addRunClasspathFiles(libraryResult.writeToZip())
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/shared/NameClashTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/shared/NameClashTest.java
index 0fdbe2d..c2f0b8f 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/shared/NameClashTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/shared/NameClashTest.java
@@ -20,7 +20,6 @@
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.ClassRule;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 
@@ -140,6 +139,7 @@
         .addKeepMainRule(MAIN)
         .addKeepRules("-applymapping " + mappingFile)
         .noTreeShaking()
+        .noMinification()
         .compile()
         .run(MAIN)
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
@@ -181,18 +181,6 @@
         .assertSuccessWithOutput(EXPECTED_OUTPUT);
   }
 
-  private void testR8_minifiedLibraryJar(Path mappingFile) throws Exception {
-    testForR8(Backend.DEX)
-        .addLibraryFiles(ToolHelper.getDefaultAndroidJar(), libJar)
-        .addProgramFiles(prgJarThatUsesMinifiedLib)
-        .addKeepMainRule(MAIN)
-        .addKeepRules("-applymapping " + mappingFile)
-        .noTreeShaking()
-        .compile()
-        .run(MAIN)
-        .assertSuccessWithOutput(EXPECTED_OUTPUT);
-  }
-
   @Test
   public void testProguard_prgClassRenamedToExistingPrgClass() throws Exception {
     FileUtils.writeTextFile(mappingFile, mappingToAlreadyMappedName());
@@ -432,11 +420,4 @@
       assertThat(e.getMessage(), containsString("can't find superclass or interface A"));
     }
   }
-
-  @Ignore("b/121305642")
-  @Test
-  public void testR8_minifiedLib() throws Exception {
-    FileUtils.writeTextFile(mappingFile, invertedMapping());
-    testR8_minifiedLibraryJar(mappingFile);
-  }
 }
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/ApplyMappingTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/ApplyMappingTest.java
index f64424e..ec50858 100644
--- a/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/ApplyMappingTest.java
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/sourcelibrary/ApplyMappingTest.java
@@ -29,7 +29,6 @@
 import java.util.Iterator;
 import java.util.concurrent.ExecutionException;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -70,7 +69,6 @@
     out = temp.newFolder("out").toPath();
   }
 
-  @Ignore("b/128516926")
   @Test
   public void test044_apply() throws Exception {
     Path flag =
diff --git a/src/test/java/com/android/tools/r8/naming/packageobfucationdict/A.java b/src/test/java/com/android/tools/r8/naming/packageobfucationdict/A.java
new file mode 100644
index 0000000..012140e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/packageobfucationdict/A.java
@@ -0,0 +1,7 @@
+// 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.naming.packageobfucationdict;
+
+public class A {}