CompileCommand: exclude org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.getExtendedRange bool exclude = true
!SESSION 2025-06-17 01:02:15.349 -----------------------------------------------
eclipse.buildId=4.37.0.I20250616-1800
java.version=21.0.7
java.vendor=Eclipse Adoptium
BootLoader constants: OS=linux, ARCH=x86_64, WS=gtk, NL=en_US
Framework arguments:  -application org.eclipse.test.uitestapplication formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,/home/jenkins/agent/workspace/AutomatedTests/ep437I-unit-linux-x86_64-java21/workarea/I20250616-1800/eclipse-testing/test-eclipse/eclipse/org.eclipse.jdt.ui.tests.AutomatedSuite.xml -testPluginName org.eclipse.jdt.ui.tests -className org.eclipse.jdt.ui.tests.AutomatedSuite -timeout 7200000 -junitReportOutput /home/jenkins/agent/workspace/AutomatedTests/ep437I-unit-linux-x86_64-java21/workarea/I20250616-1800/eclipse-testing/results/ep437I-unit-linux-x86_64-java21_linux.gtk.x86_64_21
Command-line arguments:  -application org.eclipse.test.uitestapplication -data /home/jenkins/agent/workspace/AutomatedTests/ep437I-unit-linux-x86_64-java21/workarea/I20250616-1800/eclipse-testing/test-eclipse/eclipse/jdt_folder formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,/home/jenkins/agent/workspace/AutomatedTests/ep437I-unit-linux-x86_64-java21/workarea/I20250616-1800/eclipse-testing/test-eclipse/eclipse/org.eclipse.jdt.ui.tests.AutomatedSuite.xml -testPluginName org.eclipse.jdt.ui.tests -className org.eclipse.jdt.ui.tests.AutomatedSuite -os linux -ws gtk -arch x86_64 -consolelog -timeout 7200000 -junitReportOutput /home/jenkins/agent/workspace/AutomatedTests/ep437I-unit-linux-x86_64-java21/workarea/I20250616-1800/eclipse-testing/results/ep437I-unit-linux-x86_64-java21_linux.gtk.x86_64_21

!ENTRY org.eclipse.e4.ui.workbench3 1 0 2025-06-17 01:02:26.726
!MESSAGE starting DumpStackTracesTimer with timeout=7080000 at 2025-06-17 01:02:26 +0000
coll.add(var)
System.out.println(var)
System.err.println(var)
System.out.println(arr)
coll.add(var)
Start 15 :package test;
import java.util.Collection;
public class E {
  public void hui(  Collection<String> arr){
    Collection coll=null;
    for (    String var : arr) {
      coll.add(var);
      System.out.println(var);
      System.err.println(var);
    }
    System.out.println(arr);
  }
}
 class org.eclipse.jdt.core.dom.CompilationUnit
Start 35 :package test;
                 class org.eclipse.jdt.core.dom.PackageDeclaration
Start 42 :test                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :test                           class org.eclipse.jdt.core.dom.SimpleName
End   35 :package test;
                 class org.eclipse.jdt.core.dom.PackageDeclaration
Start 26 :import java.util.Collection;
  class org.eclipse.jdt.core.dom.ImportDeclaration
Start 40 :java.util.Collection           class org.eclipse.jdt.core.dom.QualifiedName
Start 40 :java.util                      class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :java                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :java                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :util                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :util                           class org.eclipse.jdt.core.dom.SimpleName
End   40 :java.util                      class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   40 :java.util.Collection           class org.eclipse.jdt.core.dom.QualifiedName
End   26 :import java.util.Collection;
  class org.eclipse.jdt.core.dom.ImportDeclaration
Start 55 :public class E {
  public void hui(  Collection<String> arr){
    Collection coll=null;
    for (    String var : arr) {
      coll.add(var);
      System.out.println(var);
      System.err.println(var);
    }
    System.out.println(arr);
  }
}
 class org.eclipse.jdt.core.dom.TypeDeclaration
Start 83 :public                         class org.eclipse.jdt.core.dom.Modifier
End   83 :public                         class org.eclipse.jdt.core.dom.Modifier
Start 42 :E                              class org.eclipse.jdt.core.dom.SimpleName
End   42 :E                              class org.eclipse.jdt.core.dom.SimpleName
Start 31 :public void hui(Collection<String> arr){
  Collection coll=null;
  for (  String var : arr) {
    coll.add(var);
    System.out.println(var);
    System.err.println(var);
  }
  System.out.println(arr);
}
 class org.eclipse.jdt.core.dom.MethodDeclaration
Start 83 :public                         class org.eclipse.jdt.core.dom.Modifier
End   83 :public                         class org.eclipse.jdt.core.dom.Modifier
Start 39 :void                           class org.eclipse.jdt.core.dom.PrimitiveType
End   39 :void                           class org.eclipse.jdt.core.dom.PrimitiveType
Start 42 :hui                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :hui                            class org.eclipse.jdt.core.dom.SimpleName
Start 44 :Collection<String> arr         class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 74 :Collection<String>             class org.eclipse.jdt.core.dom.ParameterizedType
Start 43 :Collection                     class org.eclipse.jdt.core.dom.SimpleType
Start 42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   43 :Collection                     class org.eclipse.jdt.core.dom.SimpleType
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   43 :String                         class org.eclipse.jdt.core.dom.SimpleType
End   74 :Collection<String>             class org.eclipse.jdt.core.dom.ParameterizedType
Start 42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
End   44 :Collection<String> arr         class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 8 :{
  Collection coll=null;
  for (  String var : arr) {
    coll.add(var);
    System.out.println(var);
    System.err.println(var);
  }
  System.out.println(arr);
}
 class org.eclipse.jdt.core.dom.Block
Start 60 :Collection coll=null;
         class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 43 :Collection                     class org.eclipse.jdt.core.dom.SimpleType
Start 42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   43 :Collection                     class org.eclipse.jdt.core.dom.SimpleType
Start 59 :coll=null                      class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 42 :coll                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :coll                           class org.eclipse.jdt.core.dom.SimpleName
Start 33 :null                           class org.eclipse.jdt.core.dom.NullLiteral
End   33 :null                           class org.eclipse.jdt.core.dom.NullLiteral
End   59 :coll=null                      class org.eclipse.jdt.core.dom.VariableDeclarationFragment
End   60 :Collection coll=null;
         class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 70 :for (String var : arr) {
  coll.add(var);
  System.out.println(var);
  System.err.println(var);
}
 class org.eclipse.jdt.core.dom.EnhancedForStatement
Start 44 :String var                     class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   44 :String var                     class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
Start 8 :{
  coll.add(var);
  System.out.println(var);
  System.err.println(var);
}
 class org.eclipse.jdt.core.dom.Block
Start 21 :coll.add(var);
                class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :coll.add(var)                  class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :coll                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :coll                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :add                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :add                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   32 :coll.add(var)                  class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :coll.add(var);
                class org.eclipse.jdt.core.dom.ExpressionStatement
Start 21 :System.out.println(var);
      class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.out.println(var)        class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   32 :System.out.println(var)        class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :System.out.println(var);
      class org.eclipse.jdt.core.dom.ExpressionStatement
Start 21 :System.err.println(var);
      class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.err.println(var)        class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.err                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :err                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :err                            class org.eclipse.jdt.core.dom.SimpleName
End   40 :System.err                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   32 :System.err.println(var)        class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :System.err.println(var);
      class org.eclipse.jdt.core.dom.ExpressionStatement
End   8 :{
  coll.add(var);
  System.out.println(var);
  System.err.println(var);
}
 class org.eclipse.jdt.core.dom.Block
End   70 :for (String var : arr) {
  coll.add(var);
  System.out.println(var);
  System.err.println(var);
}
 class org.eclipse.jdt.core.dom.EnhancedForStatement
Start 21 :System.out.println(arr);
      class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.out.println(arr)        class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
End   32 :System.out.println(arr)        class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :System.out.println(arr);
      class org.eclipse.jdt.core.dom.ExpressionStatement
End   8 :{
  Collection coll=null;
  for (  String var : arr) {
    coll.add(var);
    System.out.println(var);
    System.err.println(var);
  }
  System.out.println(arr);
}
 class org.eclipse.jdt.core.dom.Block
End   31 :public void hui(Collection<String> arr){
  Collection coll=null;
  for (  String var : arr) {
    coll.add(var);
    System.out.println(var);
    System.err.println(var);
  }
  System.out.println(arr);
}
 class org.eclipse.jdt.core.dom.MethodDeclaration
End   55 :public class E {
  public void hui(  Collection<String> arr){
    Collection coll=null;
    for (    String var : arr) {
      coll.add(var);
      System.out.println(var);
      System.err.println(var);
    }
    System.out.println(arr);
  }
}
 class org.eclipse.jdt.core.dom.TypeDeclaration
End   15 :package test;
import java.util.Collection;
public class E {
  public void hui(  Collection<String> arr){
    Collection coll=null;
    for (    String var : arr) {
      coll.add(var);
      System.out.println(var);
      System.err.println(var);
    }
    System.out.println(arr);
  }
}
 class org.eclipse.jdt.core.dom.CompilationUnit
Start 44 :Collection<String> arr         class org.eclipse.jdt.core.dom.SingleVariableDeclaration
End   44 :Collection<String> arr         class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 60 :Collection coll=null;
         class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 59 :coll=null                      class org.eclipse.jdt.core.dom.VariableDeclarationFragment
End   59 :coll=null                      class org.eclipse.jdt.core.dom.VariableDeclarationFragment
End   60 :Collection coll=null;
         class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 44 :String var                     class org.eclipse.jdt.core.dom.SingleVariableDeclaration
End   44 :String var                     class org.eclipse.jdt.core.dom.SingleVariableDeclaration
4	SingleVariableDeclaration
2	CompilationUnit
58	SimpleName
4	Modifier
10	QualifiedName
2	TypeDeclaration
8	SimpleType
4	Block
2	ImportDeclaration
8	ExpressionStatement
2	NullLiteral
2	VariableDeclarationStatement
2	VariableDeclarationFragment
2	MethodDeclaration
2	PrimitiveType
2	PackageDeclaration
8	MethodInvocation
2	EnhancedForStatement
2	ParameterizedType
coll.add(var)
Start 15 :package test;
import java.util.*;
public class Test {
  void m(  List<String> strings,  List<String> strings2){
    Collections.reverse(strings);
    Iterator it=strings.iterator();
    while (it.hasNext()) {
      Iterator it2=strings2.iterator();
      while (it2.hasNext()) {
        String s2=(String)it2.next();
        System.out.println(s2);
      }
      System.out.println(it.next());
    }
    System.out.println();
  }
}
 class org.eclipse.jdt.core.dom.CompilationUnit
Start 35 :package test;
                 class org.eclipse.jdt.core.dom.PackageDeclaration
Start 42 :test                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :test                           class org.eclipse.jdt.core.dom.SimpleName
End   35 :package test;
                 class org.eclipse.jdt.core.dom.PackageDeclaration
Start 26 :import java.util.*;
           class org.eclipse.jdt.core.dom.ImportDeclaration
Start 40 :java.util                      class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :java                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :java                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :util                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :util                           class org.eclipse.jdt.core.dom.SimpleName
End   40 :java.util                      class org.eclipse.jdt.core.dom.QualifiedName
End   26 :import java.util.*;
           class org.eclipse.jdt.core.dom.ImportDeclaration
Start 55 :public class Test {
  void m(  List<String> strings,  List<String> strings2){
    Collections.reverse(strings);
    Iterator it=strings.iterator();
    while (it.hasNext()) {
      Iterator it2=strings2.iterator();
      while (it2.hasNext()) {
        String s2=(String)it2.next();
        System.out.println(s2);
      }
      System.out.println(it.next());
    }
    System.out.println();
  }
}
 class org.eclipse.jdt.core.dom.TypeDeclaration
Start 83 :public                         class org.eclipse.jdt.core.dom.Modifier
End   83 :public                         class org.eclipse.jdt.core.dom.Modifier
Start 42 :Test                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :Test                           class org.eclipse.jdt.core.dom.SimpleName
Start 31 :void m(List<String> strings,List<String> strings2){
  Collections.reverse(strings);
  Iterator it=strings.iterator();
  while (it.hasNext()) {
    Iterator it2=strings2.iterator();
    while (it2.hasNext()) {
      String s2=(String)it2.next();
      System.out.println(s2);
    }
    System.out.println(it.next());
  }
  System.out.println();
}
 class org.eclipse.jdt.core.dom.MethodDeclaration
Start 39 :void                           class org.eclipse.jdt.core.dom.PrimitiveType
End   39 :void                           class org.eclipse.jdt.core.dom.PrimitiveType
Start 42 :m                              class org.eclipse.jdt.core.dom.SimpleName
End   42 :m                              class org.eclipse.jdt.core.dom.SimpleName
Start 44 :List<String> strings           class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 74 :List<String>                   class org.eclipse.jdt.core.dom.ParameterizedType
Start 43 :List                           class org.eclipse.jdt.core.dom.SimpleType
Start 42 :List                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :List                           class org.eclipse.jdt.core.dom.SimpleName
End   43 :List                           class org.eclipse.jdt.core.dom.SimpleType
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   43 :String                         class org.eclipse.jdt.core.dom.SimpleType
End   74 :List<String>                   class org.eclipse.jdt.core.dom.ParameterizedType
Start 42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
End   44 :List<String> strings           class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 44 :List<String> strings2          class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 74 :List<String>                   class org.eclipse.jdt.core.dom.ParameterizedType
Start 43 :List                           class org.eclipse.jdt.core.dom.SimpleType
Start 42 :List                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :List                           class org.eclipse.jdt.core.dom.SimpleName
End   43 :List                           class org.eclipse.jdt.core.dom.SimpleType
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   43 :String                         class org.eclipse.jdt.core.dom.SimpleType
End   74 :List<String>                   class org.eclipse.jdt.core.dom.ParameterizedType
Start 42 :strings2                       class org.eclipse.jdt.core.dom.SimpleName
End   42 :strings2                       class org.eclipse.jdt.core.dom.SimpleName
End   44 :List<String> strings2          class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 8 :{
  Collections.reverse(strings);
  Iterator it=strings.iterator();
  while (it.hasNext()) {
    Iterator it2=strings2.iterator();
    while (it2.hasNext()) {
      String s2=(String)it2.next();
      System.out.println(s2);
    }
    System.out.println(it.next());
  }
  System.out.println();
}
 class org.eclipse.jdt.core.dom.Block
Start 21 :Collections.reverse(strings);
 class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :Collections.reverse(strings)   class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :Collections                    class org.eclipse.jdt.core.dom.SimpleName
End   42 :Collections                    class org.eclipse.jdt.core.dom.SimpleName
Start 42 :reverse                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :reverse                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
End   32 :Collections.reverse(strings)   class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :Collections.reverse(strings);
 class org.eclipse.jdt.core.dom.ExpressionStatement
Start 60 :Iterator it=strings.iterator();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 43 :Iterator                       class org.eclipse.jdt.core.dom.SimpleType
Start 42 :Iterator                       class org.eclipse.jdt.core.dom.SimpleName
End   42 :Iterator                       class org.eclipse.jdt.core.dom.SimpleName
End   43 :Iterator                       class org.eclipse.jdt.core.dom.SimpleType
Start 59 :it=strings.iterator()          class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 42 :it                             class org.eclipse.jdt.core.dom.SimpleName
End   42 :it                             class org.eclipse.jdt.core.dom.SimpleName
Start 32 :strings.iterator()             class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :iterator                       class org.eclipse.jdt.core.dom.SimpleName
End   42 :iterator                       class org.eclipse.jdt.core.dom.SimpleName
End   32 :strings.iterator()             class org.eclipse.jdt.core.dom.MethodInvocation
End   59 :it=strings.iterator()          class org.eclipse.jdt.core.dom.VariableDeclarationFragment
End   60 :Iterator it=strings.iterator();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 61 :while (it.hasNext()) {
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}
 class org.eclipse.jdt.core.dom.WhileStatement
Start 32 :it.hasNext()                   class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :it                             class org.eclipse.jdt.core.dom.SimpleName
End   42 :it                             class org.eclipse.jdt.core.dom.SimpleName
Start 42 :hasNext                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :hasNext                        class org.eclipse.jdt.core.dom.SimpleName
End   32 :it.hasNext()                   class org.eclipse.jdt.core.dom.MethodInvocation
Start 8 :{
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}
 class org.eclipse.jdt.core.dom.Block
Start 60 :Iterator it2=strings2.iterator();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 43 :Iterator                       class org.eclipse.jdt.core.dom.SimpleType
Start 42 :Iterator                       class org.eclipse.jdt.core.dom.SimpleName
End   42 :Iterator                       class org.eclipse.jdt.core.dom.SimpleName
End   43 :Iterator                       class org.eclipse.jdt.core.dom.SimpleType
Start 59 :it2=strings2.iterator()        class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
Start 32 :strings2.iterator()            class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :strings2                       class org.eclipse.jdt.core.dom.SimpleName
End   42 :strings2                       class org.eclipse.jdt.core.dom.SimpleName
Start 42 :iterator                       class org.eclipse.jdt.core.dom.SimpleName
End   42 :iterator                       class org.eclipse.jdt.core.dom.SimpleName
End   32 :strings2.iterator()            class org.eclipse.jdt.core.dom.MethodInvocation
End   59 :it2=strings2.iterator()        class org.eclipse.jdt.core.dom.VariableDeclarationFragment
End   60 :Iterator it2=strings2.iterator();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 61 :while (it2.hasNext()) {
  String s2=(String)it2.next();
  System.out.println(s2);
}
 class org.eclipse.jdt.core.dom.WhileStatement
Start 32 :it2.hasNext()                  class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :hasNext                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :hasNext                        class org.eclipse.jdt.core.dom.SimpleName
End   32 :it2.hasNext()                  class org.eclipse.jdt.core.dom.MethodInvocation
Start 8 :{
  String s2=(String)it2.next();
  System.out.println(s2);
}
 class org.eclipse.jdt.core.dom.Block
Start 60 :String s2=(String)it2.next();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 59 :s2=(String)it2.next()          class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 42 :s2                             class org.eclipse.jdt.core.dom.SimpleName
End   42 :s2                             class org.eclipse.jdt.core.dom.SimpleName
Start 11 :(String)it2.next()             class org.eclipse.jdt.core.dom.CastExpression
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 32 :it2.next()                     class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :next                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :next                           class org.eclipse.jdt.core.dom.SimpleName
End   32 :it2.next()                     class org.eclipse.jdt.core.dom.MethodInvocation
End   11 :(String)it2.next()             class org.eclipse.jdt.core.dom.CastExpression
End   59 :s2=(String)it2.next()          class org.eclipse.jdt.core.dom.VariableDeclarationFragment
End   60 :String s2=(String)it2.next();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 21 :System.out.println(s2);
       class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.out.println(s2)         class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :s2                             class org.eclipse.jdt.core.dom.SimpleName
End   42 :s2                             class org.eclipse.jdt.core.dom.SimpleName
End   32 :System.out.println(s2)         class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :System.out.println(s2);
       class org.eclipse.jdt.core.dom.ExpressionStatement
End   8 :{
  String s2=(String)it2.next();
  System.out.println(s2);
}
 class org.eclipse.jdt.core.dom.Block
End   61 :while (it2.hasNext()) {
  String s2=(String)it2.next();
  System.out.println(s2);
}
 class org.eclipse.jdt.core.dom.WhileStatement
Start 21 :System.out.println(it.next());
 class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.out.println(it.next())  class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 32 :it.next()                      class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :it                             class org.eclipse.jdt.core.dom.SimpleName
End   42 :it                             class org.eclipse.jdt.core.dom.SimpleName
Start 42 :next                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :next                           class org.eclipse.jdt.core.dom.SimpleName
End   32 :it.next()                      class org.eclipse.jdt.core.dom.MethodInvocation
End   32 :System.out.println(it.next())  class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :System.out.println(it.next());
 class org.eclipse.jdt.core.dom.ExpressionStatement
End   8 :{
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}
 class org.eclipse.jdt.core.dom.Block
End   61 :while (it.hasNext()) {
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}
 class org.eclipse.jdt.core.dom.WhileStatement
Start 21 :System.out.println();
         class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.out.println()           class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :println                        class org.eclipse.jdt.core.dom.SimpleName
End   32 :System.out.println()           class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :System.out.println();
         class org.eclipse.jdt.core.dom.ExpressionStatement
End   8 :{
  Collections.reverse(strings);
  Iterator it=strings.iterator();
  while (it.hasNext()) {
    Iterator it2=strings2.iterator();
    while (it2.hasNext()) {
      String s2=(String)it2.next();
      System.out.println(s2);
    }
    System.out.println(it.next());
  }
  System.out.println();
}
 class org.eclipse.jdt.core.dom.Block
End   31 :void m(List<String> strings,List<String> strings2){
  Collections.reverse(strings);
  Iterator it=strings.iterator();
  while (it.hasNext()) {
    Iterator it2=strings2.iterator();
    while (it2.hasNext()) {
      String s2=(String)it2.next();
      System.out.println(s2);
    }
    System.out.println(it.next());
  }
  System.out.println();
}
 class org.eclipse.jdt.core.dom.MethodDeclaration
End   55 :public class Test {
  void m(  List<String> strings,  List<String> strings2){
    Collections.reverse(strings);
    Iterator it=strings.iterator();
    while (it.hasNext()) {
      Iterator it2=strings2.iterator();
      while (it2.hasNext()) {
        String s2=(String)it2.next();
        System.out.println(s2);
      }
      System.out.println(it.next());
    }
    System.out.println();
  }
}
 class org.eclipse.jdt.core.dom.TypeDeclaration
End   15 :package test;
import java.util.*;
public class Test {
  void m(  List<String> strings,  List<String> strings2){
    Collections.reverse(strings);
    Iterator it=strings.iterator();
    while (it.hasNext()) {
      Iterator it2=strings2.iterator();
      while (it2.hasNext()) {
        String s2=(String)it2.next();
        System.out.println(s2);
      }
      System.out.println(it.next());
    }
    System.out.println();
  }
}
 class org.eclipse.jdt.core.dom.CompilationUnit
Start 15 :package test;
import java.util.*;
public class Test {
  void m(  List<String> strings,  List<String> strings2){
    Collections.reverse(strings);
    Iterator it=strings.iterator();
    while (it.hasNext()) {
      Iterator it2=strings2.iterator();
      while (it2.hasNext()) {
        String s2=(String)it2.next();
        System.out.println(s2);
      }
      System.out.println(it.next());
    }
    System.out.println();
  }
}
 class org.eclipse.jdt.core.dom.CompilationUnit
Start 35 :package test;
                 class org.eclipse.jdt.core.dom.PackageDeclaration
Start 42 :test                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :test                           class org.eclipse.jdt.core.dom.SimpleName
Start 35 :package test;
                 class org.eclipse.jdt.core.dom.PackageDeclaration
Start 26 :import java.util.*;
           class org.eclipse.jdt.core.dom.ImportDeclaration
Start 40 :java.util                      class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :java                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :java                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :util                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :util                           class org.eclipse.jdt.core.dom.SimpleName
Start 40 :java.util                      class org.eclipse.jdt.core.dom.QualifiedName
Start 26 :import java.util.*;
           class org.eclipse.jdt.core.dom.ImportDeclaration
Start 55 :public class Test {
  void m(  List<String> strings,  List<String> strings2){
    Collections.reverse(strings);
    Iterator it=strings.iterator();
    while (it.hasNext()) {
      Iterator it2=strings2.iterator();
      while (it2.hasNext()) {
        String s2=(String)it2.next();
        System.out.println(s2);
      }
      System.out.println(it.next());
    }
    System.out.println();
  }
}
 class org.eclipse.jdt.core.dom.TypeDeclaration
Start 83 :public                         class org.eclipse.jdt.core.dom.Modifier
Start 83 :public                         class org.eclipse.jdt.core.dom.Modifier
Start 42 :Test                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :Test                           class org.eclipse.jdt.core.dom.SimpleName
Start 31 :void m(List<String> strings,List<String> strings2){
  Collections.reverse(strings);
  Iterator it=strings.iterator();
  while (it.hasNext()) {
    Iterator it2=strings2.iterator();
    while (it2.hasNext()) {
      String s2=(String)it2.next();
      System.out.println(s2);
    }
    System.out.println(it.next());
  }
  System.out.println();
}
 class org.eclipse.jdt.core.dom.MethodDeclaration
Start 39 :void                           class org.eclipse.jdt.core.dom.PrimitiveType
Start 39 :void                           class org.eclipse.jdt.core.dom.PrimitiveType
Start 42 :m                              class org.eclipse.jdt.core.dom.SimpleName
Start 42 :m                              class org.eclipse.jdt.core.dom.SimpleName
Start 44 :List<String> strings           class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 74 :List<String>                   class org.eclipse.jdt.core.dom.ParameterizedType
Start 43 :List                           class org.eclipse.jdt.core.dom.SimpleType
Start 42 :List                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :List                           class org.eclipse.jdt.core.dom.SimpleName
Start 43 :List                           class org.eclipse.jdt.core.dom.SimpleType
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 74 :List<String>                   class org.eclipse.jdt.core.dom.ParameterizedType
Start 42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
Start 44 :List<String> strings           class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 44 :List<String> strings2          class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 74 :List<String>                   class org.eclipse.jdt.core.dom.ParameterizedType
Start 43 :List                           class org.eclipse.jdt.core.dom.SimpleType
Start 42 :List                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :List                           class org.eclipse.jdt.core.dom.SimpleName
Start 43 :List                           class org.eclipse.jdt.core.dom.SimpleType
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 74 :List<String>                   class org.eclipse.jdt.core.dom.ParameterizedType
Start 42 :strings2                       class org.eclipse.jdt.core.dom.SimpleName
Start 42 :strings2                       class org.eclipse.jdt.core.dom.SimpleName
Start 44 :List<String> strings2          class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 8 :{
  Collections.reverse(strings);
  Iterator it=strings.iterator();
  while (it.hasNext()) {
    Iterator it2=strings2.iterator();
    while (it2.hasNext()) {
      String s2=(String)it2.next();
      System.out.println(s2);
    }
    System.out.println(it.next());
  }
  System.out.println();
}
 class org.eclipse.jdt.core.dom.Block
Start 21 :Collections.reverse(strings);
 class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :Collections.reverse(strings)   class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :Collections                    class org.eclipse.jdt.core.dom.SimpleName
Start 42 :Collections                    class org.eclipse.jdt.core.dom.SimpleName
Start 42 :reverse                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :reverse                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
Start 32 :Collections.reverse(strings)   class org.eclipse.jdt.core.dom.MethodInvocation
Start 21 :Collections.reverse(strings);
 class org.eclipse.jdt.core.dom.ExpressionStatement
Start 60 :Iterator it=strings.iterator();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 43 :Iterator                       class org.eclipse.jdt.core.dom.SimpleType
Start 42 :Iterator                       class org.eclipse.jdt.core.dom.SimpleName
Start 42 :Iterator                       class org.eclipse.jdt.core.dom.SimpleName
Start 43 :Iterator                       class org.eclipse.jdt.core.dom.SimpleType
Start 59 :it=strings.iterator()          class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 42 :it                             class org.eclipse.jdt.core.dom.SimpleName
Start 42 :it                             class org.eclipse.jdt.core.dom.SimpleName
Start 32 :strings.iterator()             class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :strings                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :iterator                       class org.eclipse.jdt.core.dom.SimpleName
Start 42 :iterator                       class org.eclipse.jdt.core.dom.SimpleName
Start 32 :strings.iterator()             class org.eclipse.jdt.core.dom.MethodInvocation
Start 59 :it=strings.iterator()          class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 60 :Iterator it=strings.iterator();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 61 :while (it.hasNext()) {
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}
 class org.eclipse.jdt.core.dom.WhileStatement
Start 32 :it.hasNext()                   class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :it                             class org.eclipse.jdt.core.dom.SimpleName
Start 42 :it                             class org.eclipse.jdt.core.dom.SimpleName
Start 42 :hasNext                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :hasNext                        class org.eclipse.jdt.core.dom.SimpleName
Start 32 :it.hasNext()                   class org.eclipse.jdt.core.dom.MethodInvocation
Start 8 :{
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}
 class org.eclipse.jdt.core.dom.Block
Start 60 :Iterator it2=strings2.iterator();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 43 :Iterator                       class org.eclipse.jdt.core.dom.SimpleType
Start 42 :Iterator                       class org.eclipse.jdt.core.dom.SimpleName
Start 42 :Iterator                       class org.eclipse.jdt.core.dom.SimpleName
Start 43 :Iterator                       class org.eclipse.jdt.core.dom.SimpleType
Start 59 :it2=strings2.iterator()        class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
Start 32 :strings2.iterator()            class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :strings2                       class org.eclipse.jdt.core.dom.SimpleName
Start 42 :strings2                       class org.eclipse.jdt.core.dom.SimpleName
Start 42 :iterator                       class org.eclipse.jdt.core.dom.SimpleName
Start 42 :iterator                       class org.eclipse.jdt.core.dom.SimpleName
Start 32 :strings2.iterator()            class org.eclipse.jdt.core.dom.MethodInvocation
Start 59 :it2=strings2.iterator()        class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 60 :Iterator it2=strings2.iterator();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 61 :while (it2.hasNext()) {
  String s2=(String)it2.next();
  System.out.println(s2);
}
 class org.eclipse.jdt.core.dom.WhileStatement
Start 32 :it2.hasNext()                  class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :hasNext                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :hasNext                        class org.eclipse.jdt.core.dom.SimpleName
Start 32 :it2.hasNext()                  class org.eclipse.jdt.core.dom.MethodInvocation
Start 8 :{
  String s2=(String)it2.next();
  System.out.println(s2);
}
 class org.eclipse.jdt.core.dom.Block
Start 60 :String s2=(String)it2.next();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 59 :s2=(String)it2.next()          class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 42 :s2                             class org.eclipse.jdt.core.dom.SimpleName
Start 42 :s2                             class org.eclipse.jdt.core.dom.SimpleName
Start 11 :(String)it2.next()             class org.eclipse.jdt.core.dom.CastExpression
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 32 :it2.next()                     class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :it2                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :next                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :next                           class org.eclipse.jdt.core.dom.SimpleName
Start 32 :it2.next()                     class org.eclipse.jdt.core.dom.MethodInvocation
Start 11 :(String)it2.next()             class org.eclipse.jdt.core.dom.CastExpression
Start 59 :s2=(String)it2.next()          class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 60 :String s2=(String)it2.next();
 class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 21 :System.out.println(s2);
       class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.out.println(s2)         class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :s2                             class org.eclipse.jdt.core.dom.SimpleName
Start 42 :s2                             class org.eclipse.jdt.core.dom.SimpleName
Start 32 :System.out.println(s2)         class org.eclipse.jdt.core.dom.MethodInvocation
Start 21 :System.out.println(s2);
       class org.eclipse.jdt.core.dom.ExpressionStatement
Start 8 :{
  String s2=(String)it2.next();
  System.out.println(s2);
}
 class org.eclipse.jdt.core.dom.Block
Start 61 :while (it2.hasNext()) {
  String s2=(String)it2.next();
  System.out.println(s2);
}
 class org.eclipse.jdt.core.dom.WhileStatement
Start 21 :System.out.println(it.next());
 class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.out.println(it.next())  class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 32 :it.next()                      class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :it                             class org.eclipse.jdt.core.dom.SimpleName
Start 42 :it                             class org.eclipse.jdt.core.dom.SimpleName
Start 42 :next                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :next                           class org.eclipse.jdt.core.dom.SimpleName
Start 32 :it.next()                      class org.eclipse.jdt.core.dom.MethodInvocation
Start 32 :System.out.println(it.next())  class org.eclipse.jdt.core.dom.MethodInvocation
Start 21 :System.out.println(it.next());
 class org.eclipse.jdt.core.dom.ExpressionStatement
Start 8 :{
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}
 class org.eclipse.jdt.core.dom.Block
Start 61 :while (it.hasNext()) {
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}
 class org.eclipse.jdt.core.dom.WhileStatement
Start 21 :System.out.println();
         class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.out.println()           class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 32 :System.out.println()           class org.eclipse.jdt.core.dom.MethodInvocation
Start 21 :System.out.println();
         class org.eclipse.jdt.core.dom.ExpressionStatement
Start 8 :{
  Collections.reverse(strings);
  Iterator it=strings.iterator();
  while (it.hasNext()) {
    Iterator it2=strings2.iterator();
    while (it2.hasNext()) {
      String s2=(String)it2.next();
      System.out.println(s2);
    }
    System.out.println(it.next());
  }
  System.out.println();
}
 class org.eclipse.jdt.core.dom.Block
Start 31 :void m(List<String> strings,List<String> strings2){
  Collections.reverse(strings);
  Iterator it=strings.iterator();
  while (it.hasNext()) {
    Iterator it2=strings2.iterator();
    while (it2.hasNext()) {
      String s2=(String)it2.next();
      System.out.println(s2);
    }
    System.out.println(it.next());
  }
  System.out.println();
}
 class org.eclipse.jdt.core.dom.MethodDeclaration
Start 55 :public class Test {
  void m(  List<String> strings,  List<String> strings2){
    Collections.reverse(strings);
    Iterator it=strings.iterator();
    while (it.hasNext()) {
      Iterator it2=strings2.iterator();
      while (it2.hasNext()) {
        String s2=(String)it2.next();
        System.out.println(s2);
      }
      System.out.println(it.next());
    }
    System.out.println();
  }
}
 class org.eclipse.jdt.core.dom.TypeDeclaration
Start 15 :package test;
import java.util.*;
public class Test {
  void m(  List<String> strings,  List<String> strings2){
    Collections.reverse(strings);
    Iterator it=strings.iterator();
    while (it.hasNext()) {
      Iterator it2=strings2.iterator();
      while (it2.hasNext()) {
        String s2=(String)it2.next();
        System.out.println(s2);
      }
      System.out.println(it.next());
    }
    System.out.println();
  }
}
 class org.eclipse.jdt.core.dom.CompilationUnit
Start 15 :package test;
import java.util.Collection;
public class E {
  public void hui(  Collection<String> arr){
    Collection coll=null;
    for (    String var : arr) {
      coll.add(var);
      System.out.println(var);
      System.err.println(var);
    }
    System.out.println(arr);
  }
}
 class org.eclipse.jdt.core.dom.CompilationUnit
Start 35 :package test;
                 class org.eclipse.jdt.core.dom.PackageDeclaration
Start 42 :test                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :test                           class org.eclipse.jdt.core.dom.SimpleName
End   35 :package test;
                 class org.eclipse.jdt.core.dom.PackageDeclaration
Start 26 :import java.util.Collection;
  class org.eclipse.jdt.core.dom.ImportDeclaration
Start 40 :java.util.Collection           class org.eclipse.jdt.core.dom.QualifiedName
Start 40 :java.util                      class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :java                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :java                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :util                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :util                           class org.eclipse.jdt.core.dom.SimpleName
End   40 :java.util                      class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   40 :java.util.Collection           class org.eclipse.jdt.core.dom.QualifiedName
End   26 :import java.util.Collection;
  class org.eclipse.jdt.core.dom.ImportDeclaration
Start 55 :public class E {
  public void hui(  Collection<String> arr){
    Collection coll=null;
    for (    String var : arr) {
      coll.add(var);
      System.out.println(var);
      System.err.println(var);
    }
    System.out.println(arr);
  }
}
 class org.eclipse.jdt.core.dom.TypeDeclaration
Start 83 :public                         class org.eclipse.jdt.core.dom.Modifier
End   83 :public                         class org.eclipse.jdt.core.dom.Modifier
Start 42 :E                              class org.eclipse.jdt.core.dom.SimpleName
End   42 :E                              class org.eclipse.jdt.core.dom.SimpleName
Start 31 :public void hui(Collection<String> arr){
  Collection coll=null;
  for (  String var : arr) {
    coll.add(var);
    System.out.println(var);
    System.err.println(var);
  }
  System.out.println(arr);
}
 class org.eclipse.jdt.core.dom.MethodDeclaration
Start 83 :public                         class org.eclipse.jdt.core.dom.Modifier
End   83 :public                         class org.eclipse.jdt.core.dom.Modifier
Start 39 :void                           class org.eclipse.jdt.core.dom.PrimitiveType
End   39 :void                           class org.eclipse.jdt.core.dom.PrimitiveType
Start 42 :hui                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :hui                            class org.eclipse.jdt.core.dom.SimpleName
Start 44 :Collection<String> arr         class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 74 :Collection<String>             class org.eclipse.jdt.core.dom.ParameterizedType
Start 43 :Collection                     class org.eclipse.jdt.core.dom.SimpleType
Start 42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   43 :Collection                     class org.eclipse.jdt.core.dom.SimpleType
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   43 :String                         class org.eclipse.jdt.core.dom.SimpleType
End   74 :Collection<String>             class org.eclipse.jdt.core.dom.ParameterizedType
Start 42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
End   44 :Collection<String> arr         class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 8 :{
  Collection coll=null;
  for (  String var : arr) {
    coll.add(var);
    System.out.println(var);
    System.err.println(var);
  }
  System.out.println(arr);
}
 class org.eclipse.jdt.core.dom.Block
Start 60 :Collection coll=null;
         class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 43 :Collection                     class org.eclipse.jdt.core.dom.SimpleType
Start 42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   42 :Collection                     class org.eclipse.jdt.core.dom.SimpleName
End   43 :Collection                     class org.eclipse.jdt.core.dom.SimpleType
Start 59 :coll=null                      class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Start 42 :coll                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :coll                           class org.eclipse.jdt.core.dom.SimpleName
Start 33 :null                           class org.eclipse.jdt.core.dom.NullLiteral
End   33 :null                           class org.eclipse.jdt.core.dom.NullLiteral
End   59 :coll=null                      class org.eclipse.jdt.core.dom.VariableDeclarationFragment
End   60 :Collection coll=null;
         class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 70 :for (String var : arr) {
  coll.add(var);
  System.out.println(var);
  System.err.println(var);
}
 class org.eclipse.jdt.core.dom.EnhancedForStatement
Start 44 :String var                     class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :String                         class org.eclipse.jdt.core.dom.SimpleName
End   43 :String                         class org.eclipse.jdt.core.dom.SimpleType
Start 42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   44 :String var                     class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
Start 8 :{
  coll.add(var);
  System.out.println(var);
  System.err.println(var);
}
 class org.eclipse.jdt.core.dom.Block
Start 21 :coll.add(var);
                class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :coll.add(var)                  class org.eclipse.jdt.core.dom.MethodInvocation
Start 42 :coll                           class org.eclipse.jdt.core.dom.SimpleName
End   42 :coll                           class org.eclipse.jdt.core.dom.SimpleName
Start 42 :add                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :add                            class org.eclipse.jdt.core.dom.SimpleName
Start 42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   32 :coll.add(var)                  class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :coll.add(var);
                class org.eclipse.jdt.core.dom.ExpressionStatement
Start 21 :System.out.println(var);
      class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.out.println(var)        class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   32 :System.out.println(var)        class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :System.out.println(var);
      class org.eclipse.jdt.core.dom.ExpressionStatement
Start 21 :System.err.println(var);
      class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.err.println(var)        class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.err                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :err                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :err                            class org.eclipse.jdt.core.dom.SimpleName
End   40 :System.err                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :var                            class org.eclipse.jdt.core.dom.SimpleName
End   32 :System.err.println(var)        class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :System.err.println(var);
      class org.eclipse.jdt.core.dom.ExpressionStatement
End   8 :{
  coll.add(var);
  System.out.println(var);
  System.err.println(var);
}
 class org.eclipse.jdt.core.dom.Block
End   70 :for (String var : arr) {
  coll.add(var);
  System.out.println(var);
  System.err.println(var);
}
 class org.eclipse.jdt.core.dom.EnhancedForStatement
Start 21 :System.out.println(arr);
      class org.eclipse.jdt.core.dom.ExpressionStatement
Start 32 :System.out.println(arr)        class org.eclipse.jdt.core.dom.MethodInvocation
Start 40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :System                         class org.eclipse.jdt.core.dom.SimpleName
End   42 :System                         class org.eclipse.jdt.core.dom.SimpleName
Start 42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :out                            class org.eclipse.jdt.core.dom.SimpleName
End   40 :System.out                     class org.eclipse.jdt.core.dom.QualifiedName
Start 42 :println                        class org.eclipse.jdt.core.dom.SimpleName
End   42 :println                        class org.eclipse.jdt.core.dom.SimpleName
Start 42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
End   42 :arr                            class org.eclipse.jdt.core.dom.SimpleName
End   32 :System.out.println(arr)        class org.eclipse.jdt.core.dom.MethodInvocation
End   21 :System.out.println(arr);
      class org.eclipse.jdt.core.dom.ExpressionStatement
End   8 :{
  Collection coll=null;
  for (  String var : arr) {
    coll.add(var);
    System.out.println(var);
    System.err.println(var);
  }
  System.out.println(arr);
}
 class org.eclipse.jdt.core.dom.Block
End   31 :public void hui(Collection<String> arr){
  Collection coll=null;
  for (  String var : arr) {
    coll.add(var);
    System.out.println(var);
    System.err.println(var);
  }
  System.out.println(arr);
}
 class org.eclipse.jdt.core.dom.MethodDeclaration
End   55 :public class E {
  public void hui(  Collection<String> arr){
    Collection coll=null;
    for (    String var : arr) {
      coll.add(var);
      System.out.println(var);
      System.err.println(var);
    }
    System.out.println(arr);
  }
}
 class org.eclipse.jdt.core.dom.TypeDeclaration
End   15 :package test;
import java.util.Collection;
public class E {
  public void hui(  Collection<String> arr){
    Collection coll=null;
    for (    String var : arr) {
      coll.add(var);
      System.out.println(var);
      System.err.println(var);
    }
    System.out.println(arr);
  }
}
 class org.eclipse.jdt.core.dom.CompilationUnit
Start 44 :Collection<String> arr         class org.eclipse.jdt.core.dom.SingleVariableDeclaration
End   44 :Collection<String> arr         class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 60 :Collection coll=null;
         class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 59 :coll=null                      class org.eclipse.jdt.core.dom.VariableDeclarationFragment
End   59 :coll=null                      class org.eclipse.jdt.core.dom.VariableDeclarationFragment
End   60 :Collection coll=null;
         class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 44 :String var                     class org.eclipse.jdt.core.dom.SingleVariableDeclaration
End   44 :String var                     class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 44 :Collection<String> arr         class org.eclipse.jdt.core.dom.SingleVariableDeclaration
End   44 :Collection<String> arr         class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Start 60 :Collection coll=null;
         class org.eclipse.jdt.core.dom.VariableDeclarationStatement
End   60 :Collection coll=null;
         class org.eclipse.jdt.core.dom.VariableDeclarationStatement
Start 44 :String var                     class org.eclipse.jdt.core.dom.SingleVariableDeclaration
End   44 :String var                     class org.eclipse.jdt.core.dom.SingleVariableDeclaration
2	SingleVariableDeclaration
29	SimpleName
1	CompilationUnit
2	Modifier
5	QualifiedName
1	TypeDeclaration
4	SimpleType
2	Block
1	ImportDeclaration
4	ExpressionStatement
1	NullLiteral
1	VariableDeclarationFragment
1	VariableDeclarationStatement
1	PrimitiveType
1	MethodDeclaration
1	PackageDeclaration
4	MethodInvocation
1	EnhancedForStatement
1	ParameterizedType
Collection coll=null;
	106	class org.eclipse.jdt.core.dom.VariableDeclarationStatement
String var	137	class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Collection<String> arr	78	class org.eclipse.jdt.core.dom.SingleVariableDeclaration
coll=null	117	class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Collection coll=null;
	class org.eclipse.jdt.core.dom.VariableDeclarationStatement
===>null

String var	class org.eclipse.jdt.core.dom.SingleVariableDeclaration
===>null

Collection<String> arr	class org.eclipse.jdt.core.dom.SingleVariableDeclaration
===>null

coll=null	class org.eclipse.jdt.core.dom.VariableDeclarationFragment
===>null

#################
=============
while (it.hasNext()) {
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}

init ===>Iterator it=strings.iterator();

while ===>while (it.hasNext()) {
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}

next ===>it.next()
name ===>it

=============
while (it2.hasNext()) {
  String s2=(String)it2.next();
  System.out.println(s2);
}

init ===>Iterator it2=strings2.iterator();

while ===>while (it2.hasNext()) {
  String s2=(String)it2.next();
  System.out.println(s2);
}

next ===>it2.next()
name ===>it2

=====================
iterator: Iterator it=strings.iterator();
while: while (it.hasNext()) {
  Iterator it2=strings2.iterator();
  while (it2.hasNext()) {
    String s2=(String)it2.next();
    System.out.println(s2);
  }
  System.out.println(it.next());
}
next: it.next()
=====================
iterator: Iterator it2=strings2.iterator();
while: while (it2.hasNext()) {
  String s2=(String)it2.next();
  System.out.println(s2);
}
next: it2.next()
init 60 :Iterator it=strings.iterator();

init 60 :Iterator it2=strings2.iterator();

End 32 :coll.add(var)
Start 32 :it2.next()                     class org.eclipse.jdt.core.dom.MethodInvocation
[strings, it2, it, strings2, s2]
Start 32 :it.next()                      class org.eclipse.jdt.core.dom.MethodInvocation
[strings, it2, it, strings2, s2]
package test1;
import org.eclipse.jdt.annotation.*;
public class E {
  public void f() {
    @NonNullByDefault({DefaultLocation.PARAMETER})
    Object local=new Object() {
      public void g() {
        @NonNullByDefault(value={DefaultLocation.PARAMETER})
        Object nested;
      };
    };
  }
}

foo
foo
foo
foo
foo
foo
foo
foo
foo
foo
s
String s="a";

other.b=newB;

other.b=newB;

other.other.b=newB;

d
d
d
d
d
a
d
a
d
a
d
a
int d=a + b + c;

e
a
a
a
int a=1;

b
strX
strX
foo
v1
v1
v2
v2
n1
n1
n2
n2
n3
n3
n4
n4
a1
a1
bar
bar
bar
bar
bar
bar
bar
bar
i
i
i
i
f
t1
t1
list
removeIf
x
x
x
x
c
c
c
c
fi
io
io
b
(i > 1)
b
(i > 1)
b
(i > 1)
b
(i > 1)
b
(i > 1)
b
(i > 1)
while (!(a instanceof String)) {
}

while (!(a instanceof String)) {
}

for (int i=0; !(a instanceof String); i++) {
}

for (int i=0; !(a instanceof String); i++) {
}

do {
}
 while (!(a instanceof String));

do {
}
 while (!(a instanceof String));

while (b instanceof String) return;

while (b instanceof String) return;

res
res
res
res
i
i
b
i > 1
i > 1
b
while (!(b instanceof String)) return;

while (!(b instanceof String)) return;

string
string
d
d
n
n
string
string
System.out
println
System.out
println

!ENTRY org.eclipse.jdt.ui 1 0 2025-06-17 01:06:11.392
!MESSAGE Expecting an error message to be logged after this.

!ENTRY org.eclipse.jdt.ui 4 4 2025-06-17 01:06:11.401
!MESSAGE Error during computation of Annotate proposals: Could not resolve type Missing
!STACK 0
org.eclipse.jdt.internal.corext.fix.ExternalNullAnnotationChangeProposals$MissingBindingException: Could not resolve type Missing
	at org.eclipse.jdt.internal.corext.fix.ExternalNullAnnotationChangeProposals.resolveBinding(ExternalNullAnnotationChangeProposals.java:353)
	at org.eclipse.jdt.internal.corext.fix.ExternalNullAnnotationChangeProposals.collectExternalAnnotationProposals(ExternalNullAnnotationChangeProposals.java:473)
	at org.eclipse.jdt.internal.ui.text.correction.ExternalNullAnnotationQuickAssistProcessor.computeQuickAssistProposals(ExternalNullAnnotationQuickAssistProcessor.java:101)
	at org.eclipse.jdt.ui.tests.quickfix.AbstractAnnotateAssistTests.collectAnnotateProposals(AbstractAnnotateAssistTests.java:117)
	at org.eclipse.jdt.ui.tests.quickfix.AnnotateAssistTest1d5.testBug466232(AnnotateAssistTest1d5.java:706)
	at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
	at java.base/java.lang.reflect.Method.invoke(Method.java:580)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:59)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:56)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
	at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:27)
	at org.junit.rules.ExternalResource$1.evaluate(ExternalResource.java:54)
	at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
	at org.junit.runners.BlockJUnit4ClassRunner$1.evaluate(BlockJUnit4ClassRunner.java:100)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:366)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:103)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:63)
	at org.junit.runners.ParentRunner$4.run(ParentRunner.java:331)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:79)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:329)
	at org.junit.runners.ParentRunner.access$100(ParentRunner.java:66)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:293)
	at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:413)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
	at org.junit.vintage.engine.execution.RunnerExecutor.execute(RunnerExecutor.java:42)
	at org.junit.vintage.engine.execution.VintageExecutor.executeClassesAndMethodsSequentially(VintageExecutor.java:93)
	at org.junit.vintage.engine.execution.VintageExecutor.executeAllChildren(VintageExecutor.java:73)
	at org.junit.vintage.engine.VintageTestEngine.execute(VintageTestEngine.java:70)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.executeEngine(EngineExecutionOrchestrator.java:230)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.failOrExecuteEngine(EngineExecutionOrchestrator.java:204)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:172)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:101)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:84)
	at org.junit.platform.suite.engine.SuiteLauncher.execute(SuiteLauncher.java:65)
	at org.junit.platform.suite.engine.SuiteTestDescriptor.executeTests(SuiteTestDescriptor.java:188)
	at org.junit.platform.suite.engine.SuiteTestDescriptor.execute(SuiteTestDescriptor.java:156)
	at org.junit.platform.suite.engine.SuiteTestEngine.lambda$execute$0(SuiteTestEngine.java:76)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.Iterator.forEachRemaining(Iterator.java:133)
	at java.base/java.util.Spliterators$IteratorSpliterator.forEachRemaining(Spliterators.java:1939)
	at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
	at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
	at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:174)
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.base/java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:596)
	at org.junit.platform.suite.engine.SuiteTestEngine.execute(SuiteTestEngine.java:76)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.executeEngine(EngineExecutionOrchestrator.java:230)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.failOrExecuteEngine(EngineExecutionOrchestrator.java:204)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:172)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:101)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:84)
	at org.junit.platform.suite.engine.SuiteLauncher.execute(SuiteLauncher.java:65)
	at org.junit.platform.suite.engine.SuiteTestDescriptor.executeTests(SuiteTestDescriptor.java:188)
	at org.junit.platform.suite.engine.SuiteTestDescriptor.execute(SuiteTestDescriptor.java:156)
	at org.junit.platform.suite.engine.SuiteTestEngine.lambda$execute$0(SuiteTestEngine.java:76)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.Iterator.forEachRemaining(Iterator.java:133)
	at java.base/java.util.Spliterators$IteratorSpliterator.forEachRemaining(Spliterators.java:1939)
	at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
	at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
	at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:174)
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.base/java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:596)
	at org.junit.platform.suite.engine.SuiteTestEngine.execute(SuiteTestEngine.java:76)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.executeEngine(EngineExecutionOrchestrator.java:230)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.failOrExecuteEngine(EngineExecutionOrchestrator.java:204)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:172)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:101)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.lambda$execute$0(EngineExecutionOrchestrator.java:64)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.withInterceptedStreams(EngineExecutionOrchestrator.java:150)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:63)
	at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:109)
	at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:91)
	at org.junit.platform.launcher.core.DelegatingLauncher.execute(DelegatingLauncher.java:47)
	at org.junit.platform.launcher.core.InterceptingLauncher.lambda$execute$1(InterceptingLauncher.java:39)
	at org.junit.platform.launcher.core.ClasspathAlignmentCheckingLauncherInterceptor.intercept(ClasspathAlignmentCheckingLauncherInterceptor.java:25)
	at org.junit.platform.launcher.core.InterceptingLauncher.execute(InterceptingLauncher.java:38)
	at org.junit.platform.launcher.core.DelegatingLauncher.execute(DelegatingLauncher.java:47)
	at org.junit.platform.launcher.core.SessionPerRequestLauncher.execute(SessionPerRequestLauncher.java:66)
	at org.eclipse.test.EclipseTestRunner.runTests(EclipseTestRunner.java:212)
	at org.eclipse.test.EclipseTestRunner.run(EclipseTestRunner.java:187)
	at org.eclipse.test.UITestApplication.lambda$0(UITestApplication.java:101)
	at org.eclipse.e4.ui.internal.workbench.swt.E4Testable.lambda$1(E4Testable.java:127)
	at org.eclipse.swt.widgets.RunnableLock.run(RunnableLock.java:40)
	at org.eclipse.swt.widgets.Synchronizer.runAsyncMessages(Synchronizer.java:132)
	at org.eclipse.swt.widgets.Display.runAsyncMessages(Display.java:5052)
	at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java:4525)
	at org.eclipse.e4.ui.internal.workbench.swt.PartRenderingEngine$5.run(PartRenderingEngine.java:1151)
	at org.eclipse.core.databinding.observable.Realm.runWithDefault(Realm.java:339)
	at org.eclipse.e4.ui.internal.workbench.swt.PartRenderingEngine.run(PartRenderingEngine.java:1042)
	at org.eclipse.e4.ui.internal.workbench.E4Workbench.createAndRunUI(E4Workbench.java:153)
	at org.eclipse.ui.internal.Workbench.lambda$3(Workbench.java:678)
	at org.eclipse.core.databinding.observable.Realm.runWithDefault(Realm.java:339)
	at org.eclipse.ui.internal.Workbench.createAndRunWorkbench(Workbench.java:583)
	at org.eclipse.ui.PlatformUI.createAndRunWorkbench(PlatformUI.java:173)
	at org.eclipse.ui.internal.ide.application.IDEApplication.start(IDEApplication.java:185)
	at org.eclipse.test.UITestApplication.run(UITestApplication.java:48)
	at org.eclipse.test.UITestApplication.start(UITestApplication.java:116)
	at org.eclipse.equinox.internal.app.EclipseAppHandle.run(EclipseAppHandle.java:219)
	at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.runApplication(EclipseAppLauncher.java:149)
	at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.start(EclipseAppLauncher.java:115)
	at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:467)
	at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:298)
	at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
	at java.base/java.lang.reflect.Method.invoke(Method.java:580)
	at org.eclipse.equinox.launcher.Main.invokeFramework(Main.java:627)
	at org.eclipse.equinox.launcher.Main.basicRun(Main.java:575)
	at org.eclipse.equinox.launcher.Main.run(Main.java:1431)
	at org.eclipse.equinox.launcher.Main.main(Main.java:1403)
package test1;

public class E {
    public boolean simplifyNormal(int x) {
        if (x > 0 && x < 7) {
            return true;
        } else {
            return false;
        }
    }

    public boolean simplifyReverse(int x) {
        if (x > 0 && x < 7) {
            return false;
        } else {
            return true;
        }
    }

	public boolean simplifyCompoundIf(int x) {
	    if (x < 0) {
	        return false;
	    }
        if (x < 7) {
	        return true;
	    } else {
	        return false;
	    }
	}

	public boolean simplifyNLS(String x) {
	    if (x.equals("abc")) { //$NON-NLS-1$
	        return true;
	    } else {
	        return false;
	    }
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            try {
                throw new Exception();
            } catch(Exception e) {
            }
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            return 1;
        }
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            } else {
                // Keep this comment also
                return 2;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }
            return 51;
        }
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }

            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0 /* comment */) {
            // Keep this comment too
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }

            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            try {
                for (String integer : integers) {
                    System.out.println("Reading " + (Integer.parseInt(integer) + 100));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers)
            if (integer > 0) {
                // Keep this comment too
                integer = integer + 1;
            } else {
                // Keep this comment
                return 0;
            }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals)
            if (real > 0) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                real = real + 1;
                System.out.println("New value: " + real);
            }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid)
            if (isActive)
                return 0; // This kind of comment is correctly handled
            else {
                System.out.println("Valid and active");
            }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            return 1;
        }
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            } else {
                // Keep this comment also
                return 2;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }
            return 51;
        }
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }

            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0 /* comment */) {
            // Keep this comment too
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }

            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            try {
                for (String integer : integers) {
                    System.out.println("Reading " + (Integer.parseInt(integer) + 100));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers)
            if (integer > 0) {
                // Keep this comment too
                integer = integer + 1;
            } else {
                // Keep this comment
                return 0;
            }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals)
            if (real > 0) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                real = real + 1;
                System.out.println("New value: " + real);
            }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid)
            if (isActive)
                return 0; // This kind of comment is correctly handled
            else {
                System.out.println("Valid and active");
            }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            } else {
                // Keep this comment also
                return 2;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }
            return 51;
        }
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }

            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0 /* comment */) {
            // Keep this comment too
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }

            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            try {
                for (String integer : integers) {
                    System.out.println("Reading " + (Integer.parseInt(integer) + 100));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers)
            if (integer > 0) {
                // Keep this comment too
                integer = integer + 1;
            } else {
                // Keep this comment
                return 0;
            }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals)
            if (real > 0) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                real = real + 1;
                System.out.println("New value: " + real);
            }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid)
            if (isActive)
                return 0; // This kind of comment is correctly handled
            else {
                System.out.println("Valid and active");
            }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }
            return 51;
        }
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }

            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0 /* comment */) {
            // Keep this comment too
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }

            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            try {
                for (String integer : integers) {
                    System.out.println("Reading " + (Integer.parseInt(integer) + 100));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers)
            if (integer > 0) {
                // Keep this comment too
                integer = integer + 1;
            } else {
                // Keep this comment
                return 0;
            }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals)
            if (real > 0) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                real = real + 1;
                System.out.println("New value: " + real);
            }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid)
            if (isActive)
                return 0; // This kind of comment is correctly handled
            else {
                System.out.println("Valid and active");
            }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }

            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0 /* comment */) {
            // Keep this comment too
            for (Integer integer : integers) {
                System.out.println("Reading " + integer);
            }

            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            try {
                for (String integer : integers) {
                    System.out.println("Reading " + (Integer.parseInt(integer) + 100));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return 0;
        } else {
            // Keep this comment also
            return 51;
        }
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers)
            if (integer > 0) {
                // Keep this comment too
                integer = integer + 1;
            } else {
                // Keep this comment
                return 0;
            }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals)
            if (real > 0) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                real = real + 1;
                System.out.println("New value: " + real);
            }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid)
            if (isActive)
                return 0; // This kind of comment is correctly handled
            else {
                System.out.println("Valid and active");
            }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid)
            if (isActive)
                return 0; // This kind of comment is correctly handled
            else {
                System.out.println("Valid and active");
            }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            } else {
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
            }
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        } else {
            // Keep this comment also
            int conflictingName = 123;

            i = i + conflictingName;
        }

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        int conflictingName = 123;

        i = i + conflictingName;

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        } else {
            // Keep this comment also
            i = i + 1;
        }

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        int conflictingName = 123;

        i = i + conflictingName;

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        int conflictingName = 123;

        i = i + conflictingName;

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            }
            // Keep this comment also
            System.out.println(integer);
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            } else {
                // Keep this comment also
                System.out.println(integer);
            }
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        int conflictingName = 123;

        i = i + conflictingName;

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            }
            // Keep this comment also
            System.out.println(integer);
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            }
            // Keep this comment also
            System.out.println(integer);
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        } else
            return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        int conflictingName = 123;

        i = i + conflictingName;

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            }
            // Keep this comment also
            System.out.println(integer);
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            }
            // Keep this comment also
            System.out.println(integer);
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        }
        return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
        } else {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        } else {
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        int conflictingName = 123;

        i = i + conflictingName;

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            }
            // Keep this comment also
            System.out.println(integer);
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            }
            // Keep this comment also
            System.out.println(integer);
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        }
        return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (!dates.isEmpty()) {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (!(date != null)) {
            System.out.println("null args: we should not be here");
        } else {
            return;
        }
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		} else if (b) {
			// comment 2
			return 2;
		} else {
			System.out.println("abc");
			return 3;
		}
	}
}

package test1;

import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class E {
    private Date conflictingName = new Date();

    public int refactorThen(int i) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 0;
        }
        // Keep this comment too
        i = i + 1;

        return i;
    }

    public int refactorElse(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public int refactorWithTryCatch(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        try {
            throw new Exception();
        } catch(Exception e) {
        }

        return i;
    }

    public int refactorIndentation(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        return 1;
    }

    public int refactorInTry(int i) {
        // Keep this comment
        try {
            if (i > 0) {
                // Keep this comment too
                return 1;
            }
            // Keep this comment also
            return 2;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int reduceIndentationFromElse(int i, List<Integer> integers) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }
        return 51;
    }

    public int reduceIndentationFromIf(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int negateCommentedCondition(int i, List<Integer> integers) {
        // Keep this comment
        if (i <= 0 /* comment */) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        for (Integer integer : integers) {
            System.out.println("Reading " + integer);
        }

        return 0;
    }

    public int reduceBigIndentationFromIf(int i, List<String> integers) {
        // Keep this comment
        if (i <= 0) {
            // Keep this comment also
            return 51;
        }
        // Keep this comment too
        try {
            for (String integer : integers) {
                System.out.println("Reading " + (Integer.parseInt(integer) + 100));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public int refactorThenInUnbrackettedForLoop(int[] integers) {
        for (int integer : integers) {
            if (integer <= 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            integer = integer + 1;
        }

        return -1;
    }

    public int refactorElseInUnbrackettedForLoop(double[] reals) {
        for (double real : reals) {
            if (real > 0) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            real = real + 1;
            System.out.println("New value: " + real);
        }

        return -1;
    }

    public int reduceWithUnbrackettedThenAndParent(boolean isValid, boolean isActive) {
        if (isValid) {
            if (isActive)
                return 0; // This kind of comment is correctly handled
            System.out.println("Valid and active");
        }

        return -1;
    }

    public int refactorElseInSwitch(int discriminant, boolean isVisible) {
        switch (discriminant) {
        case 0:
            if (isVisible) {
                // Keep this comment
                return 0;
            }
                // Keep this comment too
                discriminant = discriminant + 1;
                System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInTry(int discriminant, boolean isVisible) {
        try {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        } finally {
            System.out.println("Finally");
        }

        return -1;
    }

    public int refactorElseInCatch(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } catch (Exception e) {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorElseInFinally(int discriminant, boolean isVisible) {
        try {
            System.out.println("Very dangerous code");
        } finally {
            if (isVisible) {
                // Keep this comment
                return 0;
            }
            // Keep this comment too
            discriminant = discriminant + 1;
            System.out.println("New value: " + discriminant);
        }

        return -1;
    }

    public int refactorWithoutNameConflict(int i) {
        System.out.println("Today: " + conflictingName);

        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            return 0;
        }
        // Keep this comment also
        int conflictingName = 123;

        i = i + conflictingName;

        return i;
    }

    public int refactorWithThrow(int i) {
        // Keep this comment
        if (i > 0) {
            // Keep this comment too
            throw new IllegalArgumentException("Positive argument");
        }
        // Keep this comment also
        i = i + 1;

        return i;
    }

    public void refactorWithContinue(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                continue;
            }
            // Keep this comment also
            System.out.println(integer);
        }
    }

    public void refactorWithBreak(List<Integer> integers) {
        for (Integer integer : integers) {
            // Keep this comment
            if (integer > 0) {
                // Keep this comment too
                break;
            }
            // Keep this comment also
            System.out.println(integer);
        }
    }

    public int refactorElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return 0;
        }
        return 1;
    }

    public void refactorUnparameterizedReturn(List<Date> dates) {
        // Keep this comment
        if (!dates.isEmpty()) {
            return;
        }
    }

    public void refactorEmptyElse(List<Date> dates) {
        // Keep this comment
        if (dates.isEmpty()) {
            return;
        }
    }

    public void refactorNegativeCondition(Date date) {
        // Keep this comment
        if (date != null) {
            return;
        }
        System.out.println("null args: we should not be here");
        return;
    }

	public int refactorIfChain(boolean a, boolean b) {
		// comment 1
		if (a) {
			return 1;
		}
        if (b) {
			// comment 2
			return 2;
		}
        System.out.println("abc");
        return 3;
	}
}

package test1;

public class E1 {
    public void doNotRemoveUselessReturn(boolean arg) {
	    if (arg) {
		    return;
		}
        System.out.println("here");
    }

    public void doNotRemoveUselessContinue(boolean arg) {
		while (arg) {
			arg = bar();
			if (arg) {
				continue;
			} else {
				System.out.println("Hello World");
			}
		}
    }

	public boolean bar() {
		return true;
	}
}

package test1;

public class E1 {
    public void doNotRemoveUselessReturn(boolean arg) {
	    if (arg) {
		    return;
		}
        System.out.println("here");
    }

    public void doNotRemoveUselessContinue(boolean arg) {
		while (arg) {
			arg = bar();
			if (arg) {
				continue;
			}
            System.out.println("Hello World");
		}
    }

	public boolean bar() {
		return true;
	}
}

1750122465749 launch added     : ATestCase: org.eclipse.debug.core.Launch@5afa9732
1750122465825 launch changed   : ATestCase: org.eclipse.debug.core.Launch@5afa9732 [JUnit]
1750122466383 launch terminated: ATestCase: org.eclipse.debug.core.Launch@5afa9732 [JUnit]
1750122466635 launch added     : ATestCase: org.eclipse.debug.core.Launch@144b394e
1750122466643 launch changed   : ATestCase: org.eclipse.debug.core.Launch@144b394e [JUnit]
1750122466992 launch terminated: ATestCase: org.eclipse.debug.core.Launch@144b394e [JUnit]
1750122467067 launch added     : ATestCase: org.eclipse.debug.core.Launch@7c49239a
1750122467076 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7c49239a [JUnit]
1750122467390 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7c49239a [JUnit]
1750122467438 launch added     : ATestCase: org.eclipse.debug.core.Launch@753ff00
1750122467446 launch changed   : ATestCase: org.eclipse.debug.core.Launch@753ff00 [JUnit]
1750122467793 launch terminated: ATestCase: org.eclipse.debug.core.Launch@753ff00 [JUnit]
1750122467855 launch added     : MyTestSuite: org.eclipse.debug.core.Launch@62f407a1
1750122467861 launch changed   : MyTestSuite: org.eclipse.debug.core.Launch@62f407a1 [JUnit]
1750122468192 launch terminated: MyTestSuite: org.eclipse.debug.core.Launch@62f407a1 [JUnit]
1750122468231 launch added     : ATestCase: org.eclipse.debug.core.Launch@4a7a0e0
1750122468242 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4a7a0e0 [JUnit]
1750122468638 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4a7a0e0 [JUnit]
1750122468684 launch added     : ATestCase: org.eclipse.debug.core.Launch@5308c0e0
1750122468694 launch changed   : ATestCase: org.eclipse.debug.core.Launch@5308c0e0 [JUnit]
1750122469085 launch terminated: ATestCase: org.eclipse.debug.core.Launch@5308c0e0 [JUnit]
1750122469146 launch added     : ATestCase: org.eclipse.debug.core.Launch@59a3d801
1750122469152 launch changed   : ATestCase: org.eclipse.debug.core.Launch@59a3d801 [JUnit]
1750122469400 launch terminated: ATestCase: org.eclipse.debug.core.Launch@59a3d801 [JUnit]
1750122469454 launch added     : ATestCase: org.eclipse.debug.core.Launch@3ca0e108
1750122469461 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3ca0e108 [JUnit]
1750122469729 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3ca0e108 [JUnit]
1750122469777 launch added     : ATestCase: org.eclipse.debug.core.Launch@54ee4c30
1750122469788 launch changed   : ATestCase: org.eclipse.debug.core.Launch@54ee4c30 [JUnit]
1750122470246 launch terminated: ATestCase: org.eclipse.debug.core.Launch@54ee4c30 [JUnit]
1750122470292 launch added     : ATestCase: org.eclipse.debug.core.Launch@5990605e
1750122470302 launch changed   : ATestCase: org.eclipse.debug.core.Launch@5990605e [JUnit]
1750122470735 launch terminated: ATestCase: org.eclipse.debug.core.Launch@5990605e [JUnit]
1750122470787 launch added     : ATestCase: org.eclipse.debug.core.Launch@3cf75c35
1750122470797 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3cf75c35 [JUnit]
1750122471254 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3cf75c35 [JUnit]
1750122471320 launch added     : ATestCase: org.eclipse.debug.core.Launch@33dfce76
1750122471329 launch changed   : ATestCase: org.eclipse.debug.core.Launch@33dfce76 [JUnit]
1750122471704 launch terminated: ATestCase: org.eclipse.debug.core.Launch@33dfce76 [JUnit]
1750122471747 launch added     : ATestCase: org.eclipse.debug.core.Launch@6e680e7a
1750122471756 launch changed   : ATestCase: org.eclipse.debug.core.Launch@6e680e7a [JUnit]
1750122472187 launch terminated: ATestCase: org.eclipse.debug.core.Launch@6e680e7a [JUnit]
1750122472253 launch added     : ATestCase: org.eclipse.debug.core.Launch@636bad5f
1750122472261 launch changed   : ATestCase: org.eclipse.debug.core.Launch@636bad5f [JUnit]
1750122472564 launch terminated: ATestCase: org.eclipse.debug.core.Launch@636bad5f [JUnit]
1750122472611 launch added     : ATestCase: org.eclipse.debug.core.Launch@1010ee5c
1750122472621 launch changed   : ATestCase: org.eclipse.debug.core.Launch@1010ee5c [JUnit]
1750122472925 launch terminated: ATestCase: org.eclipse.debug.core.Launch@1010ee5c [JUnit]
1750122472978 launch added     : ATestCase: org.eclipse.debug.core.Launch@4c61ebc9
1750122472986 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4c61ebc9 [JUnit]
1750122473398 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4c61ebc9 [JUnit]
1750122473511 launch added     : ATestCase: org.eclipse.debug.core.Launch@622859cd
1750122473520 launch changed   : ATestCase: org.eclipse.debug.core.Launch@622859cd [JUnit]
1750122473842 launch terminated: ATestCase: org.eclipse.debug.core.Launch@622859cd [JUnit]
1750122474034 launch added     : ATestCase: org.eclipse.debug.core.Launch@28785c05
1750122474085 launch changed   : ATestCase: org.eclipse.debug.core.Launch@28785c05 [JUnit]
1750122475126 launch terminated: ATestCase: org.eclipse.debug.core.Launch@28785c05 [JUnit]
1750122475269 launch added     : ATestCase: org.eclipse.debug.core.Launch@40d5e756
1750122475286 launch changed   : ATestCase: org.eclipse.debug.core.Launch@40d5e756 [JUnit]
1750122475897 launch terminated: ATestCase: org.eclipse.debug.core.Launch@40d5e756 [JUnit]
1750122476023 launch added     : ATestCase: org.eclipse.debug.core.Launch@6c1384c2
1750122476035 launch changed   : ATestCase: org.eclipse.debug.core.Launch@6c1384c2 [JUnit]
1750122476600 launch terminated: ATestCase: org.eclipse.debug.core.Launch@6c1384c2 [JUnit]
1750122476741 launch added     : ATestCase: org.eclipse.debug.core.Launch@3a93af8a
1750122476779 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3a93af8a [JUnit]
1750122477538 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3a93af8a [JUnit]
1750122477671 launch added     : ATestCase: org.eclipse.debug.core.Launch@2900b440
1750122477686 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2900b440 [JUnit]
1750122478437 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2900b440 [JUnit]
1750122478488 launch added     : ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@1918be7b
1750122478494 launch changed   : ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@1918be7b [JUnit]
1750122478782 launch terminated: ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@1918be7b [JUnit]
1750122478827 launch added     : ATestCase test2Fail: org.eclipse.debug.core.Launch@374a839
1750122478833 launch changed   : ATestCase test2Fail: org.eclipse.debug.core.Launch@374a839 [JUnit]
1750122479147 launch terminated: ATestCase test2Fail: org.eclipse.debug.core.Launch@374a839 [JUnit]
1750122479186 launch added     : ATestCase test1Succeed: org.eclipse.debug.core.Launch@125a6851
1750122479192 launch changed   : ATestCase test1Succeed: org.eclipse.debug.core.Launch@125a6851 [JUnit]
1750122479497 launch terminated: ATestCase test1Succeed: org.eclipse.debug.core.Launch@125a6851 [JUnit]
1750122479570 launch added     : ATestCase testDiv[1]: org.eclipse.debug.core.Launch@1dcc740a
1750122479576 launch changed   : ATestCase testDiv[1]: org.eclipse.debug.core.Launch@1dcc740a [JUnit]
1750122479939 launch terminated: ATestCase testDiv[1]: org.eclipse.debug.core.Launch@1dcc740a [JUnit]
1750122479992 launch added     : ATestCase testDiv: org.eclipse.debug.core.Launch@39a51bad
1750122479998 launch changed   : ATestCase testDiv: org.eclipse.debug.core.Launch@39a51bad [JUnit]
1750122480433 launch terminated: ATestCase testDiv: org.eclipse.debug.core.Launch@39a51bad [JUnit]
1750122480493 launch added     : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@383a915a
1750122480499 launch changed   : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@383a915a [JUnit]
1750122480850 launch terminated: ATestCase testDiv[0]: org.eclipse.debug.core.Launch@383a915a [JUnit]
1750122480892 launch added     : ATestCase [1]: org.eclipse.debug.core.Launch@5760f858
1750122480898 launch changed   : ATestCase [1]: org.eclipse.debug.core.Launch@5760f858 [JUnit]
1750122481214 launch terminated: ATestCase [1]: org.eclipse.debug.core.Launch@5760f858 [JUnit]
1750122481254 launch added     : ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@3961e42d
1750122481261 launch changed   : ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@3961e42d [JUnit]
1750122481580 launch terminated: ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@3961e42d [JUnit]
1750122481622 launch added     : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@6064f654
1750122481628 launch changed   : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@6064f654 [JUnit]
1750122481948 launch terminated: ATestCase testDiv[0]: org.eclipse.debug.core.Launch@6064f654 [JUnit]
1750122481994 launch added     : ATestCase [0]: org.eclipse.debug.core.Launch@1440c5de
1750122482000 launch changed   : ATestCase [0]: org.eclipse.debug.core.Launch@1440c5de [JUnit]
1750122482345 launch terminated: ATestCase [0]: org.eclipse.debug.core.Launch@1440c5de [JUnit]
1750122482406 launch added     : FailingSuite: org.eclipse.debug.core.Launch@4313c6ec
1750122482412 launch changed   : FailingSuite: org.eclipse.debug.core.Launch@4313c6ec [JUnit]
1750122482692 launch terminated: FailingSuite: org.eclipse.debug.core.Launch@4313c6ec [JUnit]
1750122482747 launch added     : AllTests: org.eclipse.debug.core.Launch@273e768a
1750122482753 launch changed   : AllTests: org.eclipse.debug.core.Launch@273e768a [JUnit]
1750122483963 launch terminated: AllTests: org.eclipse.debug.core.Launch@273e768a [JUnit]
1750122484030 launch added     : ATestSuite: org.eclipse.debug.core.Launch@13a2aa1a
1750122484035 launch changed   : ATestSuite: org.eclipse.debug.core.Launch@13a2aa1a [JUnit]
1750122485312 launch terminated: ATestSuite: org.eclipse.debug.core.Launch@13a2aa1a [JUnit]
1750122485420 launch added     : ATestCase.testSucceed: org.eclipse.debug.core.Launch@b535432
1750122485425 launch changed   : ATestCase.testSucceed: org.eclipse.debug.core.Launch@b535432 [JUnit]
1750122485670 launch terminated: ATestCase.testSucceed: org.eclipse.debug.core.Launch@b535432 [JUnit]
1750122485722 launch added     : ATestCase: org.eclipse.debug.core.Launch@788e63ed
1750122485728 launch changed   : ATestCase: org.eclipse.debug.core.Launch@788e63ed [JUnit]
1750122486922 launch terminated: ATestCase: org.eclipse.debug.core.Launch@788e63ed [JUnit]
1750122486972 launch added     : Failures: org.eclipse.debug.core.Launch@5b3ec8c0
1750122486978 launch changed   : Failures: org.eclipse.debug.core.Launch@5b3ec8c0 [JUnit]
1750122487250 launch terminated: Failures: org.eclipse.debug.core.Launch@5b3ec8c0 [JUnit]
1750122487322 launch added     : AllTests: org.eclipse.debug.core.Launch@5ff6046e
1750122487337 launch changed   : AllTests: org.eclipse.debug.core.Launch@5ff6046e [JUnit]
1750122488683 launch terminated: AllTests: org.eclipse.debug.core.Launch@5ff6046e [JUnit]
1750122488827 launch added     : ATestSuite: org.eclipse.debug.core.Launch@75677ce7
1750122488876 launch changed   : ATestSuite: org.eclipse.debug.core.Launch@75677ce7 [JUnit]
1750122490312 launch terminated: ATestSuite: org.eclipse.debug.core.Launch@75677ce7 [JUnit]
1750122490422 launch added     : ATestCase: org.eclipse.debug.core.Launch@7ecacff8
1750122490435 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7ecacff8 [JUnit]
1750122491750 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7ecacff8 [JUnit]
1750122491813 launch added     : Failures: org.eclipse.debug.core.Launch@77a16c0f
1750122491826 launch changed   : Failures: org.eclipse.debug.core.Launch@77a16c0f [JUnit]
1750122492137 launch terminated: Failures: org.eclipse.debug.core.Launch@77a16c0f [JUnit]
1750122494231 launch added     : ATestCase: org.eclipse.debug.core.Launch@7bf30f1b
1750122494242 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7bf30f1b [JUnit]
1750122494983 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7bf30f1b [JUnit]

!ENTRY org.eclipse.jdt.core 1 0 2025-06-17 01:08:19.089
!MESSAGE Can not index empty zip /Dummy project/src/archive.zip

!ENTRY org.eclipse.jdt.core 1 0 2025-06-17 01:08:20.143
!MESSAGE Can not index empty zip /Dummy project/src/archive.zip

!ENTRY org.eclipse.jdt.ui 4 10001 2025-06-17 01:08:20.972
!MESSAGE Null entry for container 'org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-17'

!ENTRY org.eclipse.jdt.ui 4 10001 2025-06-17 01:08:20.978
!MESSAGE Null entry for container 'org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-17'

!ENTRY org.eclipse.jdt.ui 4 10001 2025-06-17 01:08:20.979
!MESSAGE Null entry for container 'org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.3'

!ENTRY org.eclipse.core.resources 2 10035 2025-06-17 01:09:06.553
!MESSAGE The workspace will exit with unsaved changes in this session.