diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index 9438632..b2fa014 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -250,6 +250,7 @@
     internal.minApiLevel = getMinApiLevel();
     internal.intermediate = intermediate;
     internal.readCompileTimeAnnotations = intermediate;
+
     // Assert and fixup defaults.
     assert !internal.isShrinking();
     assert !internal.isMinifying();
@@ -268,6 +269,8 @@
     assert !internal.enableValuePropagation;
     assert !internal.enableLambdaMerging;
 
+    // TODO(b/137168535) Disable non-null tracking for now.
+    internal.enableNonNullTracking = false;
     internal.enableDesugaring = getEnableDesugaring();
     internal.enableInheritanceClassInDexDistributor = isOptimizeMultidexForLinearAlloc();
     return internal;
diff --git a/src/main/java/com/android/tools/r8/Version.java b/src/main/java/com/android/tools/r8/Version.java
index e601407..821a8b6 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.61";
+  public static final String LABEL = "1.5.62";
 
   private Version() {
   }
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
index b42cd39..f3d277d 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
@@ -208,6 +208,11 @@
             if (prototypeChanges.hasBeenChangedToReturnVoid() && invoke.outValue() != null) {
               constantReturnMaterializingInstruction =
                   prototypeChanges.getConstantReturn(code, invoke.getPosition());
+              if (invoke.outValue().hasLocalInfo()) {
+                constantReturnMaterializingInstruction
+                    .outValue()
+                    .setLocalInfo(invoke.outValue().getLocalInfo());
+              }
               invoke.outValue().replaceUsers(constantReturnMaterializingInstruction.outValue());
             }
 
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index 603d213..7018e4e 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -154,7 +154,9 @@
   public boolean enableNonNullTracking = true;
   public boolean enableInlining =
       !Version.isDev() || System.getProperty("com.android.tools.r8.disableinlining") == null;
-  public boolean enableInliningOfInvokesWithNullableReceivers = true;
+  public boolean enableInliningOfInvokesWithNullableReceivers =
+      System.getProperty("com.android.tools.r8.enableInliningOfInvokesWithNullableReceivers")
+          != null;
   public boolean enableClassInlining = true;
   // TODO(119626580): Turn on class staticizer when fixed.
   public boolean enableClassStaticizer = false;
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/SimplifyIfNotNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/SimplifyIfNotNullTest.java
index 15e9729..466b6fd 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/SimplifyIfNotNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/SimplifyIfNotNullTest.java
@@ -35,6 +35,7 @@
     CodeInspector codeInspector =
         testForD8()
             .addProgramClasses(testClass)
+            .addOptionsModification(options -> options.enableNonNullTracking = true)
             .compile()
             .inspector();
     verifyAbsenceOfIf(codeInspector, testClass, signatures);
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java
index c00b563..fb65a23 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineInvokeWithNullableReceiverTest.java
@@ -46,6 +46,7 @@
             .addInnerClasses(InlineInvokeWithNullableReceiverTest.class)
             .addKeepMainRule(TestClass.class)
             .setMinApi(parameters.getRuntime())
+            .addOptionsModification(o -> o.enableInliningOfInvokesWithNullableReceivers = true)
             .compile()
             .inspect(this::verifyMethodHasBeenInlined);
 
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
index c75d6e4..7f63b30 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/string/StringValueOfTest.java
@@ -219,6 +219,7 @@
             .debug()
             .addProgramClassesAndInnerClasses(MAIN)
             .setMinApi(parameters.getRuntime())
+            .addOptionsModification(options -> options.enableNonNullTracking = true)
             .run(parameters.getRuntime(), MAIN)
             .assertSuccessWithOutput(JAVA_OUTPUT);
     test(result, 7, 1, 0, 1, 0);
@@ -228,6 +229,7 @@
             .release()
             .addProgramClassesAndInnerClasses(MAIN)
             .setMinApi(parameters.getRuntime())
+            .addOptionsModification(options -> options.enableNonNullTracking = true)
             .run(parameters.getRuntime(), MAIN)
             .assertSuccessWithOutput(JAVA_OUTPUT);
     test(result, 5, 1, 1, 1, 0);
diff --git a/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java b/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
index 40cd981..42ddc98 100644
--- a/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
+++ b/src/test/java/com/android/tools/r8/naming/b130791310/B130791310.java
@@ -149,6 +149,7 @@
             .addProgramClasses(CLASSES)
             .addLibraryFiles(ToolHelper.getDefaultAndroidJar())
             .addKeepClassAndMembersRules(MAIN)
+            .addOptionsModification(o -> o.enableInliningOfInvokesWithNullableReceivers = true)
             .addKeepRules(RULES);
     if (!enableClassMerging) {
       builder.addOptionsModification(o -> o.enableVerticalClassMerging = false);
