diff --git a/src/main/java/com/android/tools/r8/D8.java b/src/main/java/com/android/tools/r8/D8.java
index d9c37c0..70ad1f6 100644
--- a/src/main/java/com/android/tools/r8/D8.java
+++ b/src/main/java/com/android/tools/r8/D8.java
@@ -55,7 +55,7 @@
  */
 public final class D8 {
 
-  private static final String VERSION = "v0.1.20";
+  private static final String VERSION = "v0.1.21";
   private static final int STATUS_ERROR = 1;
 
   private D8() {}
diff --git a/src/main/java/com/android/tools/r8/GenerateMainDexList.java b/src/main/java/com/android/tools/r8/GenerateMainDexList.java
index 77917af..7c34d93 100644
--- a/src/main/java/com/android/tools/r8/GenerateMainDexList.java
+++ b/src/main/java/com/android/tools/r8/GenerateMainDexList.java
@@ -28,7 +28,7 @@
 import java.util.stream.Collectors;
 
 public class GenerateMainDexList {
-  private static final String VERSION = "v0.1.20";
+  private static final String VERSION = "v0.1.21";
   private final Timing timing = new Timing("maindex");
   private final InternalOptions options;
 
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 3378afa..1a6e1b0 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -71,7 +71,7 @@
 
 public class R8 {
 
-  private static final String VERSION = "v0.1.20";
+  private static final String VERSION = "v0.1.21";
   private final Timing timing = new Timing("R8");
   private final InternalOptions options;
 
diff --git a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
index d99e854..82b7c5e 100644
--- a/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
+++ b/src/main/java/com/android/tools/r8/ir/regalloc/LinearScanRegisterAllocator.java
@@ -137,9 +137,9 @@
   // List of active intervals.
   private List<LiveIntervals> active = new LinkedList<>();
   // List of intervals where the current instruction falls into one of their live range holes.
-  private List<LiveIntervals> inactive = new LinkedList<>();
+  protected List<LiveIntervals> inactive = new LinkedList<>();
   // List of intervals that no register has been allocated to sorted by first live range.
-  private PriorityQueue<LiveIntervals> unhandled =
+  protected PriorityQueue<LiveIntervals> unhandled =
       new PriorityQueue<>(Comparator.comparingInt(LiveIntervals::getStart));
 
   // The first register used for parallel moves. After register allocation the parallel move
@@ -1553,7 +1553,7 @@
     splitOverlappingInactiveIntervals(unhandledInterval, needsRegisterPair, candidate);
   }
 
-  private void splitOverlappingInactiveIntervals(
+  protected void splitOverlappingInactiveIntervals(
       LiveIntervals unhandledInterval,
       boolean needsRegisterPair,
       int candidate) {
@@ -1565,10 +1565,16 @@
           (needsRegisterPair && intervals.usesRegister(candidate + 1))) &&
           intervals.overlaps(unhandledInterval)) {
         if (intervals.isLinked() && !intervals.isArgumentInterval()) {
+          // If the inactive register is linked but not an argument, it needs to get the
+          // same register again at the next use after the start of the unhandled interval.
+          // If there are no such uses, we can use a different register for the remainder
+          // of the inactive interval and therefore do not have to split here.
           int nextUsePosition = intervals.firstUseAfter(unhandledInterval.getStart());
-          LiveIntervals split = intervals.splitBefore(nextUsePosition);
-          split.setRegister(intervals.getRegister());
-          newInactive.add(split);
+          if (nextUsePosition != Integer.MAX_VALUE) {
+            LiveIntervals split = intervals.splitBefore(nextUsePosition);
+            split.setRegister(intervals.getRegister());
+            newInactive.add(split);
+          }
         }
         if (intervals.getStart() > unhandledInterval.getStart()) {
           // The inactive live intervals hasn't started yet. Clear the temporary register
diff --git a/src/test/java/com/android/tools/r8/ir/regalloc/Regress68656641.java b/src/test/java/com/android/tools/r8/ir/regalloc/Regress68656641.java
new file mode 100644
index 0000000..c3a177d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/regalloc/Regress68656641.java
@@ -0,0 +1,83 @@
+// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.ir.regalloc;
+
+import com.android.tools.r8.graph.DexApplication;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.MoveType;
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.code.ValueNumberGenerator;
+import com.android.tools.r8.smali.SmaliTestBase;
+import com.android.tools.r8.utils.InternalOptions;
+import com.google.common.collect.ImmutableList;
+import java.util.PriorityQueue;
+import org.junit.Test;
+
+public class Regress68656641 extends SmaliTestBase {
+
+  private static class MyRegisterAllocator extends LinearScanRegisterAllocator {
+    public MyRegisterAllocator(IRCode code, InternalOptions options) {
+      super(code, options);
+    }
+
+    public void addInactiveIntervals(LiveIntervals intervals) {
+      inactive.add(intervals);
+    }
+
+    public void splitOverlappingInactiveIntervals(LiveIntervals intervals, int register) {
+      splitOverlappingInactiveIntervals(intervals, false, register);
+    }
+
+    public PriorityQueue<LiveIntervals> getUnhandled() {
+      return unhandled;
+    }
+  }
+
+  IRCode simpleCode(InternalOptions options) throws Exception {
+    SmaliBuilder builder = new SmaliBuilder(DEFAULT_CLASS_NAME);
+    MethodSignature signature = builder.addStaticMethod(
+        "void",
+        DEFAULT_METHOD_NAME,
+        ImmutableList.of(),
+        1,
+        "    return-void");
+    DexApplication application = buildApplication(builder, options);
+    // Build the code, and split the code into three blocks.
+    ValueNumberGenerator valueNumberGenerator = new ValueNumberGenerator();
+    DexEncodedMethod method = getMethod(application, signature);
+    IRCode code = method.buildIR(valueNumberGenerator, new InternalOptions());
+    return code;
+  }
+
+
+  @Test
+  public void splitOverlappingInactiveIntervalWithNoNextUse() throws Exception {
+    InternalOptions options = new InternalOptions();
+    IRCode code = simpleCode(options);
+    MyRegisterAllocator allocator = new MyRegisterAllocator(code, options);
+    // Setup live an inactive live interval with ranges [0, 10[ and [20, 30[ with only
+    // uses in the first interval and which is linked to another interval.
+    LiveIntervals inactiveIntervals = new LiveIntervals(new Value(0, MoveType.SINGLE, null));
+    inactiveIntervals.addRange(new LiveRange(0, 10));
+    inactiveIntervals.addUse(new LiveIntervalsUse(0, 10));
+    inactiveIntervals.addUse(new LiveIntervalsUse(4, 10));
+    inactiveIntervals.addRange(new LiveRange(20, 30));
+    inactiveIntervals.setRegister(0);
+    LiveIntervals linked = new LiveIntervals(new Value(1, MoveType.SINGLE, null));
+    linked.setRegister(1);
+    inactiveIntervals.link(linked);
+    allocator.addInactiveIntervals(inactiveIntervals);
+    // Setup an unhandled interval that overlaps the inactive interval.
+    LiveIntervals unhandledIntervals = new LiveIntervals(new Value(2, MoveType.SINGLE, null));
+    unhandledIntervals.addRange(new LiveRange(12, 24));
+    // Split the overlapping inactive intervals and check that after the split, the second
+    // part of the inactive interval is unhandled and will therefore get a new register
+    // assigned later during allocation.
+    allocator.splitOverlappingInactiveIntervals(unhandledIntervals, 0);
+    assert allocator.getUnhandled().size() == 1;
+    assert allocator.getUnhandled().peek().getStart() == 20;
+    assert allocator.getUnhandled().peek().getEnd() == 30;
+  }
+}