diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index 845eecd..69126be 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -25,10 +25,9 @@
 import com.android.tools.r8.dex.JumboStringRewriter;
 import com.android.tools.r8.dex.MixedSectionCollection;
 import com.android.tools.r8.graph.AppInfo.ResolutionResult;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo.ParameterUsage;
+import com.android.tools.r8.graph.ParameterUsagesInfo.ParameterUsage;
 import com.android.tools.r8.ir.code.IRCode;
 import com.android.tools.r8.ir.code.Invoke;
-import com.android.tools.r8.ir.code.Invoke.Type;
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.ValueNumberGenerator;
 import com.android.tools.r8.ir.code.ValueType;
@@ -45,13 +44,11 @@
 import com.android.tools.r8.naming.NamingLens;
 import com.android.tools.r8.origin.Origin;
 import com.android.tools.r8.utils.InternalOptions;
-import com.google.common.collect.ImmutableList;
 import java.util.Arrays;
 import java.util.BitSet;
 import java.util.Collections;
 import java.util.List;
 import java.util.function.Consumer;
-import java.util.stream.Collectors;
 
 public class DexEncodedMethod extends KeyedDexItem<DexMethod> implements ResolutionResult {
 
@@ -621,51 +618,6 @@
     }
   }
 
-  public static final class ParameterUsagesInfo {
-    private ImmutableList<ParameterUsage> parametersUsages;
-
-    public ParameterUsagesInfo(List<ParameterUsage> usages) {
-      assert !usages.isEmpty();
-      parametersUsages = ImmutableList.copyOf(usages);
-      assert parametersUsages.size() ==
-          parametersUsages.stream().map(usage -> usage.index).collect(Collectors.toSet()).size();
-    }
-
-    public static abstract class ParameterUsage {
-      public final int index;
-
-      ParameterUsage(int index) {
-        this.index = index;
-      }
-    }
-
-    public static class SingleCallOfArgumentMethod extends ParameterUsage {
-      public final Invoke.Type type;
-      public final DexMethod method;
-
-      public SingleCallOfArgumentMethod(int index, Type type, DexMethod method) {
-        super(index);
-        this.type = type;
-        this.method = method;
-      }
-    }
-
-    public static class NotUsed extends ParameterUsage {
-      public NotUsed(int index) {
-        super(index);
-      }
-    }
-
-    ParameterUsage getParameterUsage(int parameter) {
-      for (ParameterUsage usage : parametersUsages) {
-        if (usage.index == parameter) {
-          return usage;
-        }
-      }
-      return null;
-    }
-  }
-
   public static class OptimizationInfo {
 
     private int returnedArgument = -1;
diff --git a/src/main/java/com/android/tools/r8/graph/ParameterUsagesInfo.java b/src/main/java/com/android/tools/r8/graph/ParameterUsagesInfo.java
new file mode 100644
index 0000000..84cf331
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/ParameterUsagesInfo.java
@@ -0,0 +1,102 @@
+// Copyright (c) 2018, 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.graph;
+
+import com.android.tools.r8.ir.code.If.Type;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.Invoke;
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.utils.Pair;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public final class ParameterUsagesInfo {
+  private ImmutableList<ParameterUsage> parametersUsages;
+
+  public ParameterUsagesInfo(List<ParameterUsage> usages) {
+    assert !usages.isEmpty();
+    parametersUsages = ImmutableList.copyOf(usages);
+    assert parametersUsages.size() ==
+        parametersUsages.stream().map(usage -> usage.index).collect(Collectors.toSet()).size();
+  }
+
+  ParameterUsage getParameterUsage(int parameter) {
+    for (ParameterUsage usage : parametersUsages) {
+      if (usage.index == parameter) {
+        return usage;
+      }
+    }
+    return null;
+  }
+
+  public final static class ParameterUsage {
+    public final int index;
+    public final Set<Type> ifZeroTest;
+    public final List<Pair<Invoke.Type, DexMethod>> callsReceiver;
+    public final boolean returnValue;
+
+    ParameterUsage(int index, Set<Type> ifZeroTest,
+        List<Pair<Invoke.Type, DexMethod>> callsReceiver, boolean returnValue) {
+      this.index = index;
+      this.ifZeroTest = ifZeroTest.isEmpty()
+          ? Collections.emptySet() : ImmutableSet.copyOf(ifZeroTest);
+      this.callsReceiver = callsReceiver.isEmpty()
+          ? Collections.emptyList() : ImmutableList.copyOf(callsReceiver);
+      this.returnValue = returnValue;
+    }
+
+    public boolean notUsed() {
+      return ifZeroTest == null && callsReceiver == null && !returnValue;
+    }
+  }
+
+  public static class ParameterUsageBuilder {
+    private final int index;
+    private final Value arg;
+    private final Set<Type> ifZeroTestTypes = new HashSet<>();
+    private final List<Pair<Invoke.Type, DexMethod>> callsOnReceiver = new ArrayList<>();
+    private boolean returnValue = false;
+
+    public ParameterUsageBuilder(Value arg, int index) {
+      this.arg = arg;
+      this.index = index;
+    }
+
+    // Returns false if the instruction is not supported.
+    public boolean note(Instruction instruction) {
+      if (instruction.isInvokeMethodWithReceiver() &&
+          instruction.inValues().lastIndexOf(arg) == 0) {
+        callsOnReceiver.add(new Pair<>(
+            instruction.asInvokeMethodWithReceiver().getType(),
+            instruction.asInvokeMethodWithReceiver().getInvokedMethod()));
+        return true;
+      }
+
+      if (instruction.isIf() && instruction.asIf().isZeroTest()) {
+        assert instruction.inValues().size() == 1 && instruction.inValues().get(0) == arg;
+        ifZeroTestTypes.add(instruction.asIf().getType());
+        return true;
+      }
+
+      if (instruction.isReturn()) {
+        assert instruction.inValues().size() == 1 && instruction.inValues().get(0) == arg;
+        returnValue = true;
+        return true;
+      }
+
+      return false;
+    }
+
+    public ParameterUsage build() {
+      return new ParameterUsage(index, ifZeroTestTypes, callsOnReceiver, returnValue);
+    }
+  }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index 590b0c5..3288aa9 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -745,7 +745,7 @@
           Suppliers.memoize(() -> inliner.createDefaultOracle(
               method, code, effectivelyFinalTypeEnvironment,
               isProcessedConcurrently, callSiteInformation,
-              Integer.MAX_VALUE, Integer.MAX_VALUE)
+              Integer.MAX_VALUE / 2, Integer.MAX_VALUE / 2)
           )
       );
       assert code.isConsistentSSA();
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java
index ad6d66d..c26aecf 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedback.java
@@ -6,7 +6,7 @@
 
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo;
+import com.android.tools.r8.graph.ParameterUsagesInfo;
 import com.android.tools.r8.graph.DexEncodedMethod.TrivialInitializer;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import java.util.BitSet;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java
index 326fa03..2b1a6db 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackDirect.java
@@ -6,7 +6,7 @@
 
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo;
+import com.android.tools.r8.graph.ParameterUsagesInfo;
 import com.android.tools.r8.graph.DexEncodedMethod.TrivialInitializer;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import java.util.BitSet;
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java
index 359c90d..a547b36 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/OptimizationFeedbackIgnore.java
@@ -6,7 +6,7 @@
 
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo;
+import com.android.tools.r8.graph.ParameterUsagesInfo;
 import com.android.tools.r8.graph.DexEncodedMethod.TrivialInitializer;
 import com.android.tools.r8.ir.optimize.Inliner.Constraint;
 import java.util.BitSet;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
index 5066f87..ee64165 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CodeRewriter.java
@@ -13,10 +13,6 @@
 import com.android.tools.r8.graph.DexEncodedField;
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo.NotUsed;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo.ParameterUsage;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo.SingleCallOfArgumentMethod;
 import com.android.tools.r8.graph.DexEncodedMethod.TrivialInitializer;
 import com.android.tools.r8.graph.DexEncodedMethod.TrivialInitializer.TrivialClassInitializer;
 import com.android.tools.r8.graph.DexEncodedMethod.TrivialInitializer.TrivialInstanceInitializer;
@@ -37,6 +33,9 @@
 import com.android.tools.r8.graph.DexValue.DexValueNull;
 import com.android.tools.r8.graph.DexValue.DexValueShort;
 import com.android.tools.r8.graph.DexValue.DexValueString;
+import com.android.tools.r8.graph.ParameterUsagesInfo;
+import com.android.tools.r8.graph.ParameterUsagesInfo.ParameterUsage;
+import com.android.tools.r8.graph.ParameterUsagesInfo.ParameterUsageBuilder;
 import com.android.tools.r8.ir.analysis.type.TypeEnvironment;
 import com.android.tools.r8.ir.analysis.type.TypeLatticeElement;
 import com.android.tools.r8.ir.code.ArrayPut;
@@ -851,28 +850,27 @@
     List<Value> values = code.collectArguments(true);
     for (int i = 0; i < values.size(); i++) {
       Value value = values.get(i);
-
-      int numberOfAllUsages = value.numberOfAllUsers();
-      if (numberOfAllUsages == 0) {
-        usages.add(new NotUsed(i));
+      if (value.numberOfPhiUsers() > 0) {
         continue;
       }
-
-      if (numberOfAllUsages == 1 && value.numberOfUsers() == 1) {
-        Instruction instruction = value.singleUniqueUser();
-        if (instruction.isInvokeMethodWithReceiver() &&
-            instruction.inValues().lastIndexOf(value) == 0) {
-          usages.add(new SingleCallOfArgumentMethod(i,
-              instruction.asInvokeMethodWithReceiver().getType(),
-              instruction.asInvokeMethodWithReceiver().getInvokedMethod()));
-        }
-        continue;
+      ParameterUsage usage = collectParameterUsages(i, value);
+      if (usage != null) {
+        usages.add(usage);
       }
     }
-
     feedback.setParameterUsages(method, usages.isEmpty() ? null : new ParameterUsagesInfo(usages));
   }
 
+  private ParameterUsage collectParameterUsages(int i, Value value) {
+    ParameterUsageBuilder builder = new ParameterUsageBuilder(value, i);
+    for (Instruction user : value.uniqueUsers()) {
+      if (!builder.note(user)) {
+        return null;
+      }
+    }
+    return builder.build();
+  }
+
   // This method defines trivial instance initializer as follows:
   //
   // ** The initializer may call the initializer of the base class, which
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
index 4d6e3b1..8556905 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
@@ -9,9 +9,6 @@
 import com.android.tools.r8.graph.DexEncodedMethod;
 import com.android.tools.r8.graph.DexEncodedMethod.ClassInlinerEligibility;
 import com.android.tools.r8.graph.DexEncodedMethod.OptimizationInfo;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo.NotUsed;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo.ParameterUsage;
-import com.android.tools.r8.graph.DexEncodedMethod.ParameterUsagesInfo.SingleCallOfArgumentMethod;
 import com.android.tools.r8.graph.DexEncodedMethod.TrivialInitializer;
 import com.android.tools.r8.graph.DexEncodedMethod.TrivialInitializer.TrivialClassInitializer;
 import com.android.tools.r8.graph.DexEncodedMethod.TrivialInitializer.TrivialInstanceInitializer;
@@ -19,6 +16,7 @@
 import com.android.tools.r8.graph.DexItemFactory;
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.ParameterUsagesInfo.ParameterUsage;
 import com.android.tools.r8.ir.code.BasicBlock;
 import com.android.tools.r8.ir.code.ConstNumber;
 import com.android.tools.r8.ir.code.IRCode;
@@ -38,7 +36,9 @@
 import com.android.tools.r8.kotlin.KotlinInfo;
 import com.android.tools.r8.shaking.Enqueuer.AppInfoWithLiveness;
 import com.android.tools.r8.utils.Pair;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 import java.util.ArrayList;
 import java.util.IdentityHashMap;
 import java.util.LinkedList;
@@ -48,6 +48,9 @@
 import java.util.function.Supplier;
 
 final class InlineCandidateProcessor {
+  private static final ImmutableSet<If.Type> ALLOWED_ZERO_TEST_TYPES =
+      ImmutableSet.of(If.Type.EQ, If.Type.NE);
+
   private final DexItemFactory factory;
   private final AppInfoWithLiveness appInfo;
   private final Predicate<DexType> isClassEligible;
@@ -532,13 +535,24 @@
   //      eligible according to the same rules defined for direct method call eligibility
   //      (except we require the method receiver to not be used in return instruction)
   //
+  //   -- eligible instance is used in zero-test 'if' instructions testing if the value
+  //      is null/not-null (since we know the instance is not null, those checks can
+  //      be rewritten)
+  //
   //   -- method itself can be inlined
   //
-  private synchronized boolean isExtraMethodCallEligible(
+  private boolean isExtraMethodCallEligible(
       Supplier<InliningOracle> defaultOracle, InvokeMethod invokeMethod) {
 
     List<Value> arguments = Lists.newArrayList(invokeMethod.inValues());
 
+    // Don't consider constructor invocations and super calls, since
+    // we don't want to forcibly inline them.
+    if (invokeMethod.isInvokeSuper() ||
+        (invokeMethod.isInvokeDirect() && factory.isConstructor(invokeMethod.getInvokedMethod()))) {
+      return false;
+    }
+
     // Remove receiver from arguments.
     if (invokeMethod.isInvokeMethodWithReceiver()) {
       if (arguments.get(0) == eligibleInstance) {
@@ -569,35 +583,44 @@
         return false;  // Don't know anything.
       }
 
-      if (parameterUsage instanceof NotUsed) {
+      if (parameterUsage.notUsed()) {
         // Reference can be removed since it's not used.
         unusedArguments.add(new Pair<>(invokeMethod, argIndex));
         continue;
       }
 
-      if (parameterUsage instanceof SingleCallOfArgumentMethod) {
-        // Method exactly one time calls a method on passed eligibleInstance.
-        SingleCallOfArgumentMethod info = (SingleCallOfArgumentMethod) parameterUsage;
-        if (info.type != Type.VIRTUAL && info.type != Type.INTERFACE) {
-          return false; // Don't support direct and super calls yet.
-        }
-
-        // Is the method called indirectly still eligible?
-        InliningInfo potentialInliningInfo = isEligibleIndirectMethodCall(info.method);
-        if (potentialInliningInfo != null) {
-          // Check if the method is inline-able by standard inliner.
-          InlineAction inlineAction =
-              invokeMethod.computeInlining(defaultOracle.get(), method.method.holder);
-          if (inlineAction != null) {
-            extraMethodCalls.put(invokeMethod, new InliningInfo(singleTarget, null));
-            continue;
-          }
-        }
-
+      if (parameterUsage.returnValue &&
+          !(invokeMethod.outValue() == null || invokeMethod.outValue().numberOfAllUsers() == 0)) {
+        // Used as return value which is not ignored.
         return false;
       }
 
-      return false; // All other argument usages are not eligible.
+      if (!Sets.difference(parameterUsage.ifZeroTest, ALLOWED_ZERO_TEST_TYPES).isEmpty()) {
+        // Used in unsupported zero-check-if kinds.
+        return false;
+      }
+
+      for (Pair<Type, DexMethod> call : parameterUsage.callsReceiver) {
+        if (call.getFirst() != Type.VIRTUAL && call.getFirst() != Type.INTERFACE) {
+          // Don't support direct and super calls yet.
+          return false;
+        }
+
+        // Is the method called indirectly still eligible?
+        InliningInfo potentialInliningInfo = isEligibleIndirectMethodCall(call.getSecond());
+        if (potentialInliningInfo == null) {
+          return false;
+        }
+
+        // Check if the method is inline-able by standard inliner.
+        InlineAction inlineAction =
+            invokeMethod.computeInlining(defaultOracle.get(), method.method.holder);
+        if (inlineAction == null) {
+          return false;
+        }
+      }
+
+      extraMethodCalls.put(invokeMethod, new InliningInfo(singleTarget, null));
     }
 
     // Looks good.
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
index a690429..81e12a1 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
@@ -114,6 +114,21 @@
           "class_inliner_lambda_k_style.MainKt$testKotlinSequencesStateless$1").isPresent());
       assertTrue(inspector.clazz(
           "class_inliner_lambda_k_style.MainKt$testKotlinSequencesStateful$1").isPresent());
+      assertTrue(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethod$1").isPresent());
+      assertTrue(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethod2$1").isPresent());
+      assertTrue(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethod3$1").isPresent());
+      assertTrue(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda$1")
+          .isPresent());
+      assertTrue(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda2$1")
+          .isPresent());
+      assertTrue(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda3$1")
+          .isPresent());
     });
 
     runTest("class_inliner_lambda_k_style", mainClassName, true, (app) -> {
@@ -136,6 +151,31 @@
 
       assertFalse(inspector.clazz(
           "class_inliner_lambda_k_style.MainKt$testKotlinSequencesStateful$1").isPresent());
+
+      assertEquals(
+          Sets.newHashSet(),
+          collectAccessedLambdaTypes(lambdaCheck, clazz, "testBigExtraMethod"));
+
+      assertFalse(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethod$1").isPresent());
+      assertFalse(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethod2$1").isPresent());
+      assertFalse(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethod3$1").isPresent());
+
+      assertEquals(
+          Sets.newHashSet(),
+          collectAccessedLambdaTypes(lambdaCheck, clazz, "testBigExtraMethodReturningLambda"));
+
+      assertFalse(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda$1")
+          .isPresent());
+      assertFalse(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda2$1")
+          .isPresent());
+      assertFalse(inspector.clazz(
+          "class_inliner_lambda_k_style.MainKt$testBigExtraMethodReturningLambda3$1")
+          .isPresent());
     });
   }
 
diff --git a/src/test/kotlinR8TestResources/class_inliner_lambda_k_style/main.kt b/src/test/kotlinR8TestResources/class_inliner_lambda_k_style/main.kt
index 136f72d..06b937e 100644
--- a/src/test/kotlinR8TestResources/class_inliner_lambda_k_style/main.kt
+++ b/src/test/kotlinR8TestResources/class_inliner_lambda_k_style/main.kt
@@ -11,6 +11,8 @@
 fun main(args: Array<String>) {
     testKotlinSequencesStateless(produceSequence(10))
     testKotlinSequencesStateful(5, 2, produceSequence(10))
+    testBigExtraMethod()
+    testBigExtraMethodReturningLambda()
 }
 
 data class Record(val foo: String, val good: Boolean)
@@ -38,12 +40,57 @@
     }
 }
 
-private fun produceSequence(size: Int): Sequence<String> {
+@Synchronized
+fun testBigExtraMethod() {
+    useRecord()
+    bigUserWithNotNullChecksAndTwoCalls(next()) { next() }
+    testBigExtraMethod2()
+    testBigExtraMethod3()
+}
+
+fun testBigExtraMethod2() {
+    bigUserWithNotNullChecksAndTwoCalls(next()) { next() }
+}
+
+fun testBigExtraMethod3() {
+    bigUserWithNotNullChecksAndTwoCalls(next()) { next() }
+}
+
+fun bigUserWithNotNullChecksAndTwoCalls(id: String, lambda: () -> String): String {
+    useRecord()
+    println("[A] logging call#$id returning ${lambda()}")
+    return "$id: ${lambda()}"
+}
+
+@Synchronized
+fun testBigExtraMethodReturningLambda() {
+    useRecord()
+    bigUserReturningLambda(next()) { next() } // Not used
+    testBigExtraMethodReturningLambda2()
+    testBigExtraMethodReturningLambda3()
+}
+
+fun testBigExtraMethodReturningLambda2() {
+    bigUserReturningLambda(next()) { next() } // Not used
+}
+
+fun testBigExtraMethodReturningLambda3() {
+    bigUserReturningLambda(next()) { next() } // Not used
+}
+
+fun bigUserReturningLambda(id: String, lambda: () -> String): () -> String {
+    useRecord()
+    println("[B] logging call#$id returning ${lambda()}")
+    println("[C] logging call#$id returning ${lambda()}")
+    return lambda
+}
+
+fun produceSequence(size: Int): Sequence<String> {
     var count = size
     return generateSequence { if (count-- > 0) next() else null }
 }
 
 // Need this to make sure testKotlinSequenceXXX is not processed
 // concurrently with invoke() on lambdas.
-fun useRecord() = useRecord2()
-fun useRecord2() = Record("", true)
+@Synchronized fun useRecord() = useRecord2()
+@Synchronized fun useRecord2() = Record("", true)