CompileCommand: exclude org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.getExtendedRange bool exclude = true
!SESSION 2025-06-24 01:09:54.591 -----------------------------------------------
eclipse.buildId=4.37.0.I20250623-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/I20250623-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/I20250623-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/I20250623-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/I20250623-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/I20250623-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-24 01:10:06.183
!MESSAGE starting DumpStackTracesTimer with timeout=7080000 at 2025-06-24 01:10:06 +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	ImportDeclaration
2	NullLiteral
2	PrimitiveType
2	ParameterizedType
10	QualifiedName
2	EnhancedForStatement
2	MethodDeclaration
8	MethodInvocation
2	PackageDeclaration
2	CompilationUnit
4	Block
8	ExpressionStatement
2	VariableDeclarationFragment
2	TypeDeclaration
4	Modifier
2	VariableDeclarationStatement
58	SimpleName
8	SimpleType
4	SingleVariableDeclaration
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	ImportDeclaration
1	NullLiteral
1	ParameterizedType
1	PrimitiveType
5	QualifiedName
1	EnhancedForStatement
1	MethodDeclaration
4	MethodInvocation
1	PackageDeclaration
1	CompilationUnit
2	Block
4	ExpressionStatement
1	VariableDeclarationFragment
2	Modifier
1	TypeDeclaration
1	VariableDeclarationStatement
29	SimpleName
4	SimpleType
2	SingleVariableDeclaration
Collection<String> arr	78	class org.eclipse.jdt.core.dom.SingleVariableDeclaration
String var	137	class org.eclipse.jdt.core.dom.SingleVariableDeclaration
Collection coll=null;
	106	class org.eclipse.jdt.core.dom.VariableDeclarationStatement
coll=null	117	class org.eclipse.jdt.core.dom.VariableDeclarationFragment
Collection<String> arr	class org.eclipse.jdt.core.dom.SingleVariableDeclaration
===>null

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

Collection coll=null;
	class org.eclipse.jdt.core.dom.VariableDeclarationStatement
===>null

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

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

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

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

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

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

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

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

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

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

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

End 32 :coll.add(var)
Start 32 :it2.next()                     class org.eclipse.jdt.core.dom.MethodInvocation
[strings, it2, it, strings2, s2]
Start 32 :it.next()                      class org.eclipse.jdt.core.dom.MethodInvocation
[strings, it2, it, strings2, s2]

!ENTRY org.eclipse.jdt.core 1 0 2025-06-24 01:11:51.251
!MESSAGE Can not index not existing zip /TestSetupProject1d8/JDTFlagsTest18.zip
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;
	}
}


!ENTRY org.eclipse.jdt.core 4 4 2025-06-24 01:12:46.078
!MESSAGE Error checking whether PackageFragmentRoot is on module path!
!STACK 1
Java Model Exception: Error in Java Model (code 1006): src [in TestSetupProject11] is not on its project's build path
	at org.eclipse.jdt.internal.core.PackageFragmentRoot.getRawClasspathEntry(PackageFragmentRoot.java:622)
	at org.eclipse.jdt.internal.core.search.matching.JavaSearchNameEnvironment.computeModuleFor(JavaSearchNameEnvironment.java:610)
	at org.eclipse.jdt.internal.core.search.matching.JavaSearchNameEnvironment.mapToClassPathLocation(JavaSearchNameEnvironment.java:302)
	at org.eclipse.jdt.internal.core.search.matching.JavaSearchNameEnvironment.computeClasspathLocations(JavaSearchNameEnvironment.java:215)
	at org.eclipse.jdt.internal.core.search.matching.JavaSearchNameEnvironment.computeClasspathLocations(JavaSearchNameEnvironment.java:187)
	at org.eclipse.jdt.internal.core.search.matching.JavaSearchNameEnvironment.<init>(JavaSearchNameEnvironment.java:95)
	at org.eclipse.jdt.internal.core.search.indexing.SourceIndexer.resolveDocument(SourceIndexer.java:186)
	at org.eclipse.jdt.internal.core.search.JavaSearchParticipant.resolveDocument(JavaSearchParticipant.java:125)
	at org.eclipse.jdt.internal.core.search.indexing.IndexManager.indexResolvedDocument(IndexManager.java:669)
	at org.eclipse.jdt.internal.core.search.indexing.IndexManager$2.execute(IndexManager.java:1273)
	at org.eclipse.jdt.internal.core.search.processing.JobManager.indexerLoop(JobManager.java:541)
	at java.base/java.lang.Thread.run(Thread.java:1447)
!SUBENTRY 1 org.eclipse.jdt.core 4 1006 2025-06-24 01:12:46.079
!MESSAGE src [in TestSetupProject11] is not on its project's build path

!ENTRY org.eclipse.jdt.core 4 4 2025-06-24 01:12:46.079
!MESSAGE Error indexing package names!
!STACK 1
Java Model Exception: Error in Java Model (code 1006): src [in TestSetupProject11] is not on its project's build path
	at org.eclipse.jdt.internal.core.JavaElement.newJavaModelException(JavaElement.java:558)
	at org.eclipse.jdt.internal.core.Openable.generateInfos(Openable.java:238)
	at org.eclipse.jdt.internal.core.JavaElement.openWhenClosed(JavaElement.java:571)
	at org.eclipse.jdt.internal.core.JavaElement.getElementInfo(JavaElement.java:294)
	at org.eclipse.jdt.internal.core.JavaElement.getElementInfo(JavaElement.java:280)
	at org.eclipse.jdt.internal.core.JavaElement.getChildren(JavaElement.java:235)
	at org.eclipse.jdt.internal.core.search.matching.JavaSearchNameEnvironment.indexPackageNames(JavaSearchNameEnvironment.java:229)
	at org.eclipse.jdt.internal.core.search.matching.JavaSearchNameEnvironment.computeClasspathLocations(JavaSearchNameEnvironment.java:218)
	at org.eclipse.jdt.internal.core.search.matching.JavaSearchNameEnvironment.computeClasspathLocations(JavaSearchNameEnvironment.java:187)
	at org.eclipse.jdt.internal.core.search.matching.JavaSearchNameEnvironment.<init>(JavaSearchNameEnvironment.java:95)
	at org.eclipse.jdt.internal.core.search.indexing.SourceIndexer.resolveDocument(SourceIndexer.java:186)
	at org.eclipse.jdt.internal.core.search.JavaSearchParticipant.resolveDocument(JavaSearchParticipant.java:125)
	at org.eclipse.jdt.internal.core.search.indexing.IndexManager.indexResolvedDocument(IndexManager.java:669)
	at org.eclipse.jdt.internal.core.search.indexing.IndexManager$2.execute(IndexManager.java:1273)
	at org.eclipse.jdt.internal.core.search.processing.JobManager.indexerLoop(JobManager.java:541)
	at java.base/java.lang.Thread.run(Thread.java:1447)
!SUBENTRY 1 org.eclipse.jdt.core 4 1006 2025-06-24 01:12:46.079
!MESSAGE src [in TestSetupProject11] is not on its project's build path
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
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
1750727637822 launch added     : ATestCase: org.eclipse.debug.core.Launch@78503209
1750727637886 launch changed   : ATestCase: org.eclipse.debug.core.Launch@78503209 [JUnit]
1750727638555 launch terminated: ATestCase: org.eclipse.debug.core.Launch@78503209 [JUnit]
1750727638660 launch added     : ATestCase: org.eclipse.debug.core.Launch@58e7a4f
1750727638668 launch changed   : ATestCase: org.eclipse.debug.core.Launch@58e7a4f [JUnit]
1750727639054 launch terminated: ATestCase: org.eclipse.debug.core.Launch@58e7a4f [JUnit]
1750727639094 launch added     : ATestCase: org.eclipse.debug.core.Launch@4073a2d3
1750727639101 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4073a2d3 [JUnit]
1750727639396 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4073a2d3 [JUnit]
1750727639470 launch added     : ATestCase: org.eclipse.debug.core.Launch@78fbcee3
1750727639479 launch changed   : ATestCase: org.eclipse.debug.core.Launch@78fbcee3 [JUnit]
1750727639886 launch terminated: ATestCase: org.eclipse.debug.core.Launch@78fbcee3 [JUnit]
1750727639972 launch added     : MyTestSuite: org.eclipse.debug.core.Launch@6a9cacf9
1750727639980 launch changed   : MyTestSuite: org.eclipse.debug.core.Launch@6a9cacf9 [JUnit]
1750727640541 launch terminated: MyTestSuite: org.eclipse.debug.core.Launch@6a9cacf9 [JUnit]
1750727640592 launch added     : ATestCase: org.eclipse.debug.core.Launch@66cfa5d3
1750727640604 launch changed   : ATestCase: org.eclipse.debug.core.Launch@66cfa5d3 [JUnit]
1750727640986 launch terminated: ATestCase: org.eclipse.debug.core.Launch@66cfa5d3 [JUnit]
1750727641153 launch added     : ATestCase: org.eclipse.debug.core.Launch@2d004ebd
1750727641165 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2d004ebd [JUnit]
1750727641848 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2d004ebd [JUnit]
1750727641899 launch added     : ATestCase: org.eclipse.debug.core.Launch@17655d0e
1750727641907 launch changed   : ATestCase: org.eclipse.debug.core.Launch@17655d0e [JUnit]
1750727642336 launch terminated: ATestCase: org.eclipse.debug.core.Launch@17655d0e [JUnit]
1750727642385 launch added     : ATestCase: org.eclipse.debug.core.Launch@60eec42f
1750727642393 launch changed   : ATestCase: org.eclipse.debug.core.Launch@60eec42f [JUnit]
1750727642836 launch terminated: ATestCase: org.eclipse.debug.core.Launch@60eec42f [JUnit]
1750727642896 launch added     : ATestCase: org.eclipse.debug.core.Launch@78ef910c
1750727642907 launch changed   : ATestCase: org.eclipse.debug.core.Launch@78ef910c [JUnit]
1750727643398 launch terminated: ATestCase: org.eclipse.debug.core.Launch@78ef910c [JUnit]
1750727643483 launch added     : ATestCase: org.eclipse.debug.core.Launch@7393085c
1750727643494 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7393085c [JUnit]
1750727643987 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7393085c [JUnit]
1750727644058 launch added     : ATestCase: org.eclipse.debug.core.Launch@5e03f353
1750727644071 launch changed   : ATestCase: org.eclipse.debug.core.Launch@5e03f353 [JUnit]
1750727644691 launch terminated: ATestCase: org.eclipse.debug.core.Launch@5e03f353 [JUnit]
1750727644756 launch added     : ATestCase: org.eclipse.debug.core.Launch@4e6414b6
1750727644765 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4e6414b6 [JUnit]
1750727645121 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4e6414b6 [JUnit]
1750727645187 launch added     : ATestCase: org.eclipse.debug.core.Launch@c7f2c7d
1750727645199 launch changed   : ATestCase: org.eclipse.debug.core.Launch@c7f2c7d [JUnit]
1750727645738 launch terminated: ATestCase: org.eclipse.debug.core.Launch@c7f2c7d [JUnit]
1750727645779 launch added     : ATestCase: org.eclipse.debug.core.Launch@dad4510
1750727645789 launch changed   : ATestCase: org.eclipse.debug.core.Launch@dad4510 [JUnit]
1750727646153 launch terminated: ATestCase: org.eclipse.debug.core.Launch@dad4510 [JUnit]
1750727646198 launch added     : ATestCase: org.eclipse.debug.core.Launch@417419
1750727646210 launch changed   : ATestCase: org.eclipse.debug.core.Launch@417419 [JUnit]
1750727646592 launch terminated: ATestCase: org.eclipse.debug.core.Launch@417419 [JUnit]
1750727646681 launch added     : ATestCase: org.eclipse.debug.core.Launch@369d10ce
1750727646691 launch changed   : ATestCase: org.eclipse.debug.core.Launch@369d10ce [JUnit]
1750727647196 launch terminated: ATestCase: org.eclipse.debug.core.Launch@369d10ce [JUnit]
1750727647266 launch added     : ATestCase: org.eclipse.debug.core.Launch@605cf45c
1750727647277 launch changed   : ATestCase: org.eclipse.debug.core.Launch@605cf45c [JUnit]
1750727647720 launch terminated: ATestCase: org.eclipse.debug.core.Launch@605cf45c [JUnit]
1750727647830 launch added     : ATestCase: org.eclipse.debug.core.Launch@2a2a3380
1750727647849 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2a2a3380 [JUnit]
1750727648698 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2a2a3380 [JUnit]
1750727648821 launch added     : ATestCase: org.eclipse.debug.core.Launch@7270641b
1750727648837 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7270641b [JUnit]
1750727649750 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7270641b [JUnit]
1750727649855 launch added     : ATestCase: org.eclipse.debug.core.Launch@e459018
1750727649870 launch changed   : ATestCase: org.eclipse.debug.core.Launch@e459018 [JUnit]
1750727650714 launch terminated: ATestCase: org.eclipse.debug.core.Launch@e459018 [JUnit]
1750727650896 launch added     : ATestCase: org.eclipse.debug.core.Launch@6c54fc63
1750727650985 launch changed   : ATestCase: org.eclipse.debug.core.Launch@6c54fc63 [JUnit]
1750727651899 launch terminated: ATestCase: org.eclipse.debug.core.Launch@6c54fc63 [JUnit]
1750727652020 launch added     : ATestCase: org.eclipse.debug.core.Launch@103e944f
1750727652037 launch changed   : ATestCase: org.eclipse.debug.core.Launch@103e944f [JUnit]
1750727653055 launch terminated: ATestCase: org.eclipse.debug.core.Launch@103e944f [JUnit]
1750727653096 launch added     : ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@dd5d441
1750727653104 launch changed   : ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@dd5d441 [JUnit]
1750727653643 launch terminated: ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@dd5d441 [JUnit]
1750727653689 launch added     : ATestCase test2Fail: org.eclipse.debug.core.Launch@e686c99
1750727653697 launch changed   : ATestCase test2Fail: org.eclipse.debug.core.Launch@e686c99 [JUnit]
1750727654247 launch terminated: ATestCase test2Fail: org.eclipse.debug.core.Launch@e686c99 [JUnit]
1750727654295 launch added     : ATestCase test1Succeed: org.eclipse.debug.core.Launch@53530035
1750727654302 launch changed   : ATestCase test1Succeed: org.eclipse.debug.core.Launch@53530035 [JUnit]
1750727654693 launch terminated: ATestCase test1Succeed: org.eclipse.debug.core.Launch@53530035 [JUnit]
1750727654742 launch added     : ATestCase testDiv[1]: org.eclipse.debug.core.Launch@3902040c
1750727654754 launch changed   : ATestCase testDiv[1]: org.eclipse.debug.core.Launch@3902040c [JUnit]
1750727655137 launch terminated: ATestCase testDiv[1]: org.eclipse.debug.core.Launch@3902040c [JUnit]
1750727655179 launch added     : ATestCase testDiv: org.eclipse.debug.core.Launch@46c3daf3
1750727655187 launch changed   : ATestCase testDiv: org.eclipse.debug.core.Launch@46c3daf3 [JUnit]
1750727655609 launch terminated: ATestCase testDiv: org.eclipse.debug.core.Launch@46c3daf3 [JUnit]
1750727655654 launch added     : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@53af7bd
1750727655661 launch changed   : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@53af7bd [JUnit]
1750727656025 launch terminated: ATestCase testDiv[0]: org.eclipse.debug.core.Launch@53af7bd [JUnit]
1750727656095 launch added     : ATestCase [1]: org.eclipse.debug.core.Launch@1723a1c6
1750727656108 launch changed   : ATestCase [1]: org.eclipse.debug.core.Launch@1723a1c6 [JUnit]
1750727656587 launch terminated: ATestCase [1]: org.eclipse.debug.core.Launch@1723a1c6 [JUnit]
1750727656630 launch added     : ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@1242540c
1750727656639 launch changed   : ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@1242540c [JUnit]
1750727657020 launch terminated: ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@1242540c [JUnit]
1750727657075 launch added     : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@37f86b03
1750727657081 launch changed   : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@37f86b03 [JUnit]
1750727657566 launch terminated: ATestCase testDiv[0]: org.eclipse.debug.core.Launch@37f86b03 [JUnit]
1750727657619 launch added     : ATestCase [0]: org.eclipse.debug.core.Launch@7f17aa40
1750727657626 launch changed   : ATestCase [0]: org.eclipse.debug.core.Launch@7f17aa40 [JUnit]
1750727658066 launch terminated: ATestCase [0]: org.eclipse.debug.core.Launch@7f17aa40 [JUnit]
1750727658110 launch added     : FailingSuite: org.eclipse.debug.core.Launch@5df8467c
1750727658116 launch changed   : FailingSuite: org.eclipse.debug.core.Launch@5df8467c [JUnit]
1750727658500 launch terminated: FailingSuite: org.eclipse.debug.core.Launch@5df8467c [JUnit]
1750727658632 launch added     : AllTests: org.eclipse.debug.core.Launch@7a2ae20f
1750727658639 launch changed   : AllTests: org.eclipse.debug.core.Launch@7a2ae20f [JUnit]
1750727660012 launch terminated: AllTests: org.eclipse.debug.core.Launch@7a2ae20f [JUnit]
1750727660087 launch added     : ATestSuite: org.eclipse.debug.core.Launch@1c7b7610
1750727660093 launch changed   : ATestSuite: org.eclipse.debug.core.Launch@1c7b7610 [JUnit]
1750727661348 launch terminated: ATestSuite: org.eclipse.debug.core.Launch@1c7b7610 [JUnit]
1750727661438 launch added     : ATestCase.testSucceed: org.eclipse.debug.core.Launch@3d265bb8
1750727661444 launch changed   : ATestCase.testSucceed: org.eclipse.debug.core.Launch@3d265bb8 [JUnit]
1750727661852 launch terminated: ATestCase.testSucceed: org.eclipse.debug.core.Launch@3d265bb8 [JUnit]
1750727661896 launch added     : ATestCase: org.eclipse.debug.core.Launch@9feaab7
1750727661902 launch changed   : ATestCase: org.eclipse.debug.core.Launch@9feaab7 [JUnit]
1750727663149 launch terminated: ATestCase: org.eclipse.debug.core.Launch@9feaab7 [JUnit]
1750727663201 launch added     : Failures: org.eclipse.debug.core.Launch@774ae4b2
1750727663207 launch changed   : Failures: org.eclipse.debug.core.Launch@774ae4b2 [JUnit]
1750727663451 launch terminated: Failures: org.eclipse.debug.core.Launch@774ae4b2 [JUnit]
1750727663520 launch added     : AllTests: org.eclipse.debug.core.Launch@361fb93c
1750727663534 launch changed   : AllTests: org.eclipse.debug.core.Launch@361fb93c [JUnit]
1750727664919 launch terminated: AllTests: org.eclipse.debug.core.Launch@361fb93c [JUnit]
1750727664997 launch added     : ATestSuite: org.eclipse.debug.core.Launch@3f7f33c1
1750727665011 launch changed   : ATestSuite: org.eclipse.debug.core.Launch@3f7f33c1 [JUnit]
1750727666401 launch terminated: ATestSuite: org.eclipse.debug.core.Launch@3f7f33c1 [JUnit]
1750727666513 launch added     : ATestCase: org.eclipse.debug.core.Launch@66dcb58f
1750727666534 launch changed   : ATestCase: org.eclipse.debug.core.Launch@66dcb58f [JUnit]
1750727667976 launch terminated: ATestCase: org.eclipse.debug.core.Launch@66dcb58f [JUnit]
1750727668071 launch added     : Failures: org.eclipse.debug.core.Launch@698747d5
1750727668085 launch changed   : Failures: org.eclipse.debug.core.Launch@698747d5 [JUnit]
1750727668418 launch terminated: Failures: org.eclipse.debug.core.Launch@698747d5 [JUnit]
1750727670991 launch added     : ATestCase: org.eclipse.debug.core.Launch@30a83ef3
1750727671002 launch changed   : ATestCase: org.eclipse.debug.core.Launch@30a83ef3 [JUnit]
1750727671583 launch terminated: ATestCase: org.eclipse.debug.core.Launch@30a83ef3 [JUnit]

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

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

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

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

!ENTRY org.eclipse.jdt.ui 4 10001 2025-06-24 01:14:34.912
!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-24 01:14:34.918
!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-24 01:14:34.920
!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-24 01:15:04.169
!MESSAGE The workspace will exit with unsaved changes in this session.