CompileCommand: exclude org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.getExtendedRange bool exclude = true
!SESSION 2025-06-17 01:01:23.118 -----------------------------------------------
eclipse.buildId=4.37.0.I20250616-1800
java.version=24
java.vendor=Oracle Corporation
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-java24/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-java24/workarea/I20250616-1800/eclipse-testing/results/ep437I-unit-linux-x86_64-java24_linux.gtk.x86_64_24
Command-line arguments:  -application org.eclipse.test.uitestapplication -data /home/jenkins/agent/workspace/AutomatedTests/ep437I-unit-linux-x86_64-java24/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-java24/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-java24/workarea/I20250616-1800/eclipse-testing/results/ep437I-unit-linux-x86_64-java24_linux.gtk.x86_64_24

!ENTRY org.eclipse.e4.ui.workbench3 1 0 2025-06-17 01:01:33.757
!MESSAGE starting DumpStackTracesTimer with timeout=7080000 at 2025-06-17 01:01:33 +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
2	MethodDeclaration
2	ParameterizedType
2	VariableDeclarationStatement
2	EnhancedForStatement
2	TypeDeclaration
2	VariableDeclarationFragment
2	CompilationUnit
10	QualifiedName
4	SingleVariableDeclaration
2	PrimitiveType
2	PackageDeclaration
8	ExpressionStatement
8	SimpleType
58	SimpleName
2	ImportDeclaration
4	Modifier
4	Block
2	NullLiteral
8	MethodInvocation
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
1	ParameterizedType
1	MethodDeclaration
1	VariableDeclarationStatement
1	EnhancedForStatement
1	VariableDeclarationFragment
1	TypeDeclaration
1	CompilationUnit
5	QualifiedName
1	PrimitiveType
2	SingleVariableDeclaration
1	PackageDeclaration
4	ExpressionStatement
4	SimpleType
29	SimpleName
1	ImportDeclaration
2	Modifier
1	NullLiteral
2	Block
4	MethodInvocation
Collection coll=null;
	106	class org.eclipse.jdt.core.dom.VariableDeclarationStatement
coll=null	117	class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Collection<String> arr	78	class org.eclipse.jdt.core.dom.SingleVariableDeclaration
String var	137	class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Collection coll=null;
	class org.eclipse.jdt.core.dom.VariableDeclarationStatement
===>null

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

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

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

#################
=============
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

=============
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

=====================
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
e
int d=a + b + c;

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
b
i > 1
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:05:10.963
!MESSAGE Expecting an error message to be logged after this.

!ENTRY org.eclipse.jdt.ui 4 4 2025-06-17 01:05:10.972
!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:104)
	at java.base/java.lang.reflect.Method.invoke(Method.java:565)
	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:186)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:215)
	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:570)
	at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:560)
	at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:153)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:176)
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:265)
	at java.base/java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:636)
	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:186)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:215)
	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:570)
	at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:560)
	at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:153)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:176)
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:265)
	at java.base/java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:636)
	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:104)
	at java.base/java.lang.reflect.Method.invoke(Method.java:565)
	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;
	}
}

1750122406858 launch added     : ATestCase: org.eclipse.debug.core.Launch@47c1b279
1750122406959 launch changed   : ATestCase: org.eclipse.debug.core.Launch@47c1b279 [JUnit]
1750122407698 launch terminated: ATestCase: org.eclipse.debug.core.Launch@47c1b279 [JUnit]
1750122407904 launch added     : ATestCase: org.eclipse.debug.core.Launch@15c598eb
1750122407916 launch changed   : ATestCase: org.eclipse.debug.core.Launch@15c598eb [JUnit]
1750122408305 launch terminated: ATestCase: org.eclipse.debug.core.Launch@15c598eb [JUnit]
1750122408386 launch added     : ATestCase: org.eclipse.debug.core.Launch@4c800e1f
1750122408394 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4c800e1f [JUnit]
1750122408781 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4c800e1f [JUnit]
1750122408847 launch added     : ATestCase: org.eclipse.debug.core.Launch@7c4b2e05
1750122408858 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7c4b2e05 [JUnit]
1750122409260 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7c4b2e05 [JUnit]
1750122409361 launch added     : MyTestSuite: org.eclipse.debug.core.Launch@2aeafac4
1750122409368 launch changed   : MyTestSuite: org.eclipse.debug.core.Launch@2aeafac4 [JUnit]
1750122409898 launch terminated: MyTestSuite: org.eclipse.debug.core.Launch@2aeafac4 [JUnit]
1750122409964 launch added     : ATestCase: org.eclipse.debug.core.Launch@68fcbb59
1750122409973 launch changed   : ATestCase: org.eclipse.debug.core.Launch@68fcbb59 [JUnit]
1750122410360 launch terminated: ATestCase: org.eclipse.debug.core.Launch@68fcbb59 [JUnit]
1750122410403 launch added     : ATestCase: org.eclipse.debug.core.Launch@6be57828
1750122410412 launch changed   : ATestCase: org.eclipse.debug.core.Launch@6be57828 [JUnit]
1750122410750 launch terminated: ATestCase: org.eclipse.debug.core.Launch@6be57828 [JUnit]
1750122410790 launch added     : ATestCase: org.eclipse.debug.core.Launch@4dc3f275
1750122410796 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4dc3f275 [JUnit]
1750122411041 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4dc3f275 [JUnit]
1750122411086 launch added     : ATestCase: org.eclipse.debug.core.Launch@629fd96b
1750122411093 launch changed   : ATestCase: org.eclipse.debug.core.Launch@629fd96b [JUnit]
1750122411368 launch terminated: ATestCase: org.eclipse.debug.core.Launch@629fd96b [JUnit]
1750122411411 launch added     : ATestCase: org.eclipse.debug.core.Launch@35855793
1750122411420 launch changed   : ATestCase: org.eclipse.debug.core.Launch@35855793 [JUnit]
1750122411885 launch terminated: ATestCase: org.eclipse.debug.core.Launch@35855793 [JUnit]
1750122411928 launch added     : ATestCase: org.eclipse.debug.core.Launch@7fc74ee3
1750122411953 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7fc74ee3 [JUnit]
1750122412323 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7fc74ee3 [JUnit]
1750122412368 launch added     : ATestCase: org.eclipse.debug.core.Launch@3b28aacd
1750122412377 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3b28aacd [JUnit]
1750122412761 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3b28aacd [JUnit]
1750122412804 launch added     : ATestCase: org.eclipse.debug.core.Launch@426d2e43
1750122412812 launch changed   : ATestCase: org.eclipse.debug.core.Launch@426d2e43 [JUnit]
1750122413304 launch terminated: ATestCase: org.eclipse.debug.core.Launch@426d2e43 [JUnit]
1750122413392 launch added     : ATestCase: org.eclipse.debug.core.Launch@350294df
1750122413401 launch changed   : ATestCase: org.eclipse.debug.core.Launch@350294df [JUnit]
1750122414041 launch terminated: ATestCase: org.eclipse.debug.core.Launch@350294df [JUnit]
1750122414092 launch added     : ATestCase: org.eclipse.debug.core.Launch@621df0f2
1750122414101 launch changed   : ATestCase: org.eclipse.debug.core.Launch@621df0f2 [JUnit]
1750122414529 launch terminated: ATestCase: org.eclipse.debug.core.Launch@621df0f2 [JUnit]
1750122414576 launch added     : ATestCase: org.eclipse.debug.core.Launch@3c2c86ee
1750122414588 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3c2c86ee [JUnit]
1750122414960 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3c2c86ee [JUnit]
1750122415014 launch added     : ATestCase: org.eclipse.debug.core.Launch@1683b151
1750122415023 launch changed   : ATestCase: org.eclipse.debug.core.Launch@1683b151 [JUnit]
1750122415520 launch terminated: ATestCase: org.eclipse.debug.core.Launch@1683b151 [JUnit]
1750122415593 launch added     : ATestCase: org.eclipse.debug.core.Launch@560bb236
1750122415605 launch changed   : ATestCase: org.eclipse.debug.core.Launch@560bb236 [JUnit]
1750122416075 launch terminated: ATestCase: org.eclipse.debug.core.Launch@560bb236 [JUnit]
1750122416199 launch added     : ATestCase: org.eclipse.debug.core.Launch@3b291e25
1750122416238 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3b291e25 [JUnit]
1750122416993 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3b291e25 [JUnit]
1750122417108 launch added     : ATestCase: org.eclipse.debug.core.Launch@7b147b32
1750122417122 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7b147b32 [JUnit]
1750122417868 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7b147b32 [JUnit]
1750122417975 launch added     : ATestCase: org.eclipse.debug.core.Launch@3ef6d112
1750122417988 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3ef6d112 [JUnit]
1750122418672 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3ef6d112 [JUnit]
1750122418838 launch added     : ATestCase: org.eclipse.debug.core.Launch@47b44054
1750122418875 launch changed   : ATestCase: org.eclipse.debug.core.Launch@47b44054 [JUnit]
1750122419760 launch terminated: ATestCase: org.eclipse.debug.core.Launch@47b44054 [JUnit]
1750122419901 launch added     : ATestCase: org.eclipse.debug.core.Launch@2e1638
1750122419917 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2e1638 [JUnit]
1750122421169 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2e1638 [JUnit]
1750122421212 launch added     : ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@24d154e3
1750122421218 launch changed   : ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@24d154e3 [JUnit]
1750122421526 launch terminated: ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@24d154e3 [JUnit]
1750122421570 launch added     : ATestCase test2Fail: org.eclipse.debug.core.Launch@3bc55c7
1750122421576 launch changed   : ATestCase test2Fail: org.eclipse.debug.core.Launch@3bc55c7 [JUnit]
1750122421894 launch terminated: ATestCase test2Fail: org.eclipse.debug.core.Launch@3bc55c7 [JUnit]
1750122421932 launch added     : ATestCase test1Succeed: org.eclipse.debug.core.Launch@6556fdaa
1750122421938 launch changed   : ATestCase test1Succeed: org.eclipse.debug.core.Launch@6556fdaa [JUnit]
1750122422274 launch terminated: ATestCase test1Succeed: org.eclipse.debug.core.Launch@6556fdaa [JUnit]
1750122422317 launch added     : ATestCase testDiv[1]: org.eclipse.debug.core.Launch@1f5f6c6c
1750122422343 launch changed   : ATestCase testDiv[1]: org.eclipse.debug.core.Launch@1f5f6c6c [JUnit]
1750122422672 launch terminated: ATestCase testDiv[1]: org.eclipse.debug.core.Launch@1f5f6c6c [JUnit]
1750122422718 launch added     : ATestCase testDiv: org.eclipse.debug.core.Launch@234c09ca
1750122422725 launch changed   : ATestCase testDiv: org.eclipse.debug.core.Launch@234c09ca [JUnit]
1750122423117 launch terminated: ATestCase testDiv: org.eclipse.debug.core.Launch@234c09ca [JUnit]
1750122423156 launch added     : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@b1fc00b
1750122423162 launch changed   : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@b1fc00b [JUnit]
1750122423483 launch terminated: ATestCase testDiv[0]: org.eclipse.debug.core.Launch@b1fc00b [JUnit]
1750122423524 launch added     : ATestCase [1]: org.eclipse.debug.core.Launch@561522be
1750122423530 launch changed   : ATestCase [1]: org.eclipse.debug.core.Launch@561522be [JUnit]
1750122423871 launch terminated: ATestCase [1]: org.eclipse.debug.core.Launch@561522be [JUnit]
1750122423909 launch added     : ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@190cc13
1750122423914 launch changed   : ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@190cc13 [JUnit]
1750122424259 launch terminated: ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@190cc13 [JUnit]
1750122424300 launch added     : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@5663c365
1750122424305 launch changed   : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@5663c365 [JUnit]
1750122424655 launch terminated: ATestCase testDiv[0]: org.eclipse.debug.core.Launch@5663c365 [JUnit]
1750122424694 launch added     : ATestCase [0]: org.eclipse.debug.core.Launch@55cbfe48
1750122424700 launch changed   : ATestCase [0]: org.eclipse.debug.core.Launch@55cbfe48 [JUnit]
1750122425028 launch terminated: ATestCase [0]: org.eclipse.debug.core.Launch@55cbfe48 [JUnit]
1750122425070 launch added     : FailingSuite: org.eclipse.debug.core.Launch@527fd896
1750122425075 launch changed   : FailingSuite: org.eclipse.debug.core.Launch@527fd896 [JUnit]
1750122425323 launch terminated: FailingSuite: org.eclipse.debug.core.Launch@527fd896 [JUnit]
1750122425388 launch added     : AllTests: org.eclipse.debug.core.Launch@18ce4822
1750122425394 launch changed   : AllTests: org.eclipse.debug.core.Launch@18ce4822 [JUnit]
1750122426656 launch terminated: AllTests: org.eclipse.debug.core.Launch@18ce4822 [JUnit]
1750122426737 launch added     : ATestSuite: org.eclipse.debug.core.Launch@6d10e0b8
1750122426742 launch changed   : ATestSuite: org.eclipse.debug.core.Launch@6d10e0b8 [JUnit]
1750122428079 launch terminated: ATestSuite: org.eclipse.debug.core.Launch@6d10e0b8 [JUnit]
1750122428242 launch added     : ATestCase.testSucceed: org.eclipse.debug.core.Launch@577587b5
1750122428252 launch changed   : ATestCase.testSucceed: org.eclipse.debug.core.Launch@577587b5 [JUnit]
1750122428669 launch terminated: ATestCase.testSucceed: org.eclipse.debug.core.Launch@577587b5 [JUnit]
1750122428740 launch added     : ATestCase: org.eclipse.debug.core.Launch@520636a7
1750122428746 launch changed   : ATestCase: org.eclipse.debug.core.Launch@520636a7 [JUnit]
1750122429995 launch terminated: ATestCase: org.eclipse.debug.core.Launch@520636a7 [JUnit]
1750122430053 launch added     : Failures: org.eclipse.debug.core.Launch@3cc50dc9
1750122430059 launch changed   : Failures: org.eclipse.debug.core.Launch@3cc50dc9 [JUnit]
1750122430290 launch terminated: Failures: org.eclipse.debug.core.Launch@3cc50dc9 [JUnit]
1750122430350 launch added     : AllTests: org.eclipse.debug.core.Launch@375ddff7
1750122430364 launch changed   : AllTests: org.eclipse.debug.core.Launch@375ddff7 [JUnit]
1750122431709 launch terminated: AllTests: org.eclipse.debug.core.Launch@375ddff7 [JUnit]
1750122431796 launch added     : ATestSuite: org.eclipse.debug.core.Launch@27a9dd2
1750122431810 launch changed   : ATestSuite: org.eclipse.debug.core.Launch@27a9dd2 [JUnit]
1750122433243 launch terminated: ATestSuite: org.eclipse.debug.core.Launch@27a9dd2 [JUnit]
1750122433360 launch added     : ATestCase: org.eclipse.debug.core.Launch@129868f4
1750122433372 launch changed   : ATestCase: org.eclipse.debug.core.Launch@129868f4 [JUnit]
1750122434737 launch terminated: ATestCase: org.eclipse.debug.core.Launch@129868f4 [JUnit]
1750122434813 launch added     : Failures: org.eclipse.debug.core.Launch@219afe07
1750122434825 launch changed   : Failures: org.eclipse.debug.core.Launch@219afe07 [JUnit]
1750122435156 launch terminated: Failures: org.eclipse.debug.core.Launch@219afe07 [JUnit]
1750122437642 launch added     : ATestCase: org.eclipse.debug.core.Launch@7053d8c6
1750122437654 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7053d8c6 [JUnit]
1750122438263 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7053d8c6 [JUnit]

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

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

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

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

!ENTRY org.eclipse.jdt.ui 4 10001 2025-06-17 01:07:21.099
!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:07:21.105
!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:07:21.106
!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:08:07.367
!MESSAGE The workspace will exit with unsaved changes in this session.