CompileCommand: exclude org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.getExtendedRange bool exclude = true
!SESSION 2025-07-08 01:18:36.278 -----------------------------------------------
eclipse.buildId=4.37.0.I20250707-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/I20250707-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/I20250707-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/I20250707-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/I20250707-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/I20250707-1800/eclipse-testing/results/ep437I-unit-linux-x86_64-java24_linux.gtk.x86_64_24

!ENTRY org.eclipse.e4.ui.workbench3 1 0 2025-07-08 01:18:47.607
!MESSAGE starting DumpStackTracesTimer with timeout=7080000 at 2025-07-08 01:18:47 +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
4	Modifier
2	NullLiteral
4	SingleVariableDeclaration
4	Block
8	ExpressionStatement
2	PackageDeclaration
2	ParameterizedType
2	EnhancedForStatement
2	CompilationUnit
2	TypeDeclaration
10	QualifiedName
2	VariableDeclarationFragment
2	VariableDeclarationStatement
2	MethodDeclaration
8	MethodInvocation
58	SimpleName
2	PrimitiveType
8	SimpleType
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
2	Modifier
1	NullLiteral
2	SingleVariableDeclaration
4	ExpressionStatement
2	Block
1	PackageDeclaration
1	ParameterizedType
1	EnhancedForStatement
1	CompilationUnit
5	QualifiedName
1	TypeDeclaration
1	VariableDeclarationFragment
1	VariableDeclarationStatement
1	MethodDeclaration
4	MethodInvocation
29	SimpleName
1	PrimitiveType
4	SimpleType
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	78	class org.eclipse.jdt.core.dom.SingleVariableDeclaration
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

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

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

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

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

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

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

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

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

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

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

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

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

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

other.b=newB;

other.b=newB;

other.other.b=newB;

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

e
a
a
a
int a=1;

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

while (!(a instanceof String)) {
}

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

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

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

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

while (b instanceof String) return;

while (b instanceof String) return;

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

while (!(b instanceof String)) return;

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

!ENTRY org.eclipse.jdt.ui 1 0 2025-07-08 01:22:56.970
!MESSAGE Expecting an error message to be logged after this.

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

            i = i + conflictingName;
        }

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

        i = i + conflictingName;

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

        i = i + conflictingName;

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

        i = i + conflictingName;

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

        i = i + conflictingName;

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

        i = i + conflictingName;

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

        i = i + conflictingName;

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

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

        return i;
    }

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

        return i;
    }

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

        return i;
    }

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

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

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

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

        return 0;
    }

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

        return 0;
    }

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

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

        return -1;
    }

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

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

        i = i + conflictingName;

        return i;
    }

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

        return i;
    }

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

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

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

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

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

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

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

package test1;

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

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

	public boolean bar() {
		return true;
	}
}

package test1;

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

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

	public boolean bar() {
		return true;
	}
}


!ENTRY org.eclipse.jdt.core 4 4 2025-07-08 01:23:57.189
!MESSAGE Error checking whether PackageFragmentRoot is on module path!
!STACK 1
Java Model Exception: Error in Java Model (code 1006): src [in TestSetupProject10] 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:670)
	at org.eclipse.jdt.internal.core.search.indexing.IndexManager$2.execute(IndexManager.java:1274)
	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-07-08 01:23:57.190
!MESSAGE src [in TestSetupProject10] is not on its project's build path

!ENTRY org.eclipse.jdt.core 4 4 2025-07-08 01:23:57.191
!MESSAGE Error indexing package names!
!STACK 1
Java Model Exception: Error in Java Model (code 1006): src [in TestSetupProject10] 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:670)
	at org.eclipse.jdt.internal.core.search.indexing.IndexManager$2.execute(IndexManager.java:1274)
	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-07-08 01:23:57.191
!MESSAGE src [in TestSetupProject10] is not on its project's build path
1751937879174 launch added     : ATestCase: org.eclipse.debug.core.Launch@4f6cc323
1751937879255 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4f6cc323 [JUnit]
1751937879840 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4f6cc323 [JUnit]
1751937879966 launch added     : ATestCase: org.eclipse.debug.core.Launch@6ed0cb18
1751937879975 launch changed   : ATestCase: org.eclipse.debug.core.Launch@6ed0cb18 [JUnit]
1751937880307 launch terminated: ATestCase: org.eclipse.debug.core.Launch@6ed0cb18 [JUnit]
1751937880352 launch added     : ATestCase: org.eclipse.debug.core.Launch@2877dd7e
1751937880360 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2877dd7e [JUnit]
1751937880642 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2877dd7e [JUnit]
1751937880682 launch added     : ATestCase: org.eclipse.debug.core.Launch@2a42c707
1751937880692 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2a42c707 [JUnit]
1751937880976 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2a42c707 [JUnit]
1751937881038 launch added     : MyTestSuite: org.eclipse.debug.core.Launch@5810aa58
1751937881045 launch changed   : MyTestSuite: org.eclipse.debug.core.Launch@5810aa58 [JUnit]
1751937881402 launch terminated: MyTestSuite: org.eclipse.debug.core.Launch@5810aa58 [JUnit]
1751937881452 launch added     : ATestCase: org.eclipse.debug.core.Launch@1b61240d
1751937881464 launch changed   : ATestCase: org.eclipse.debug.core.Launch@1b61240d [JUnit]
1751937881912 launch terminated: ATestCase: org.eclipse.debug.core.Launch@1b61240d [JUnit]
1751937881970 launch added     : ATestCase: org.eclipse.debug.core.Launch@2a4123f6
1751937881989 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2a4123f6 [JUnit]
1751937882438 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2a4123f6 [JUnit]
1751937882478 launch added     : ATestCase: org.eclipse.debug.core.Launch@667a24e1
1751937882493 launch changed   : ATestCase: org.eclipse.debug.core.Launch@667a24e1 [JUnit]
1751937882844 launch terminated: ATestCase: org.eclipse.debug.core.Launch@667a24e1 [JUnit]
1751937882892 launch added     : ATestCase: org.eclipse.debug.core.Launch@12e71e8b
1751937882902 launch changed   : ATestCase: org.eclipse.debug.core.Launch@12e71e8b [JUnit]
1751937883312 launch terminated: ATestCase: org.eclipse.debug.core.Launch@12e71e8b [JUnit]
1751937883356 launch added     : ATestCase: org.eclipse.debug.core.Launch@17535482
1751937883366 launch changed   : ATestCase: org.eclipse.debug.core.Launch@17535482 [JUnit]
1751937883839 launch terminated: ATestCase: org.eclipse.debug.core.Launch@17535482 [JUnit]
1751937883881 launch added     : ATestCase: org.eclipse.debug.core.Launch@35a7c3b8
1751937883892 launch changed   : ATestCase: org.eclipse.debug.core.Launch@35a7c3b8 [JUnit]
1751937884349 launch terminated: ATestCase: org.eclipse.debug.core.Launch@35a7c3b8 [JUnit]
1751937884404 launch added     : ATestCase: org.eclipse.debug.core.Launch@4126b58c
1751937884414 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4126b58c [JUnit]
1751937884910 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4126b58c [JUnit]
1751937884963 launch added     : ATestCase: org.eclipse.debug.core.Launch@667ff69e
1751937884973 launch changed   : ATestCase: org.eclipse.debug.core.Launch@667ff69e [JUnit]
1751937885331 launch terminated: ATestCase: org.eclipse.debug.core.Launch@667ff69e [JUnit]
1751937885378 launch added     : ATestCase: org.eclipse.debug.core.Launch@409052fd
1751937885394 launch changed   : ATestCase: org.eclipse.debug.core.Launch@409052fd [JUnit]
1751937885783 launch terminated: ATestCase: org.eclipse.debug.core.Launch@409052fd [JUnit]
1751937885830 launch added     : ATestCase: org.eclipse.debug.core.Launch@5ea1af07
1751937885839 launch changed   : ATestCase: org.eclipse.debug.core.Launch@5ea1af07 [JUnit]
1751937886194 launch terminated: ATestCase: org.eclipse.debug.core.Launch@5ea1af07 [JUnit]
1751937886238 launch added     : ATestCase: org.eclipse.debug.core.Launch@3f2cd5c4
1751937886249 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3f2cd5c4 [JUnit]
1751937886757 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3f2cd5c4 [JUnit]
1751937886797 launch added     : ATestCase: org.eclipse.debug.core.Launch@125a6851
1751937886806 launch changed   : ATestCase: org.eclipse.debug.core.Launch@125a6851 [JUnit]
1751937887210 launch terminated: ATestCase: org.eclipse.debug.core.Launch@125a6851 [JUnit]
1751937887312 launch added     : ATestCase: org.eclipse.debug.core.Launch@7ad8a7d9
1751937887323 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7ad8a7d9 [JUnit]
1751937887744 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7ad8a7d9 [JUnit]
1751937887922 launch added     : ATestCase: org.eclipse.debug.core.Launch@2e12a9ea
1751937887958 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2e12a9ea [JUnit]
1751937888989 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2e12a9ea [JUnit]
1751937889134 launch added     : ATestCase: org.eclipse.debug.core.Launch@fddb2bb
1751937889153 launch changed   : ATestCase: org.eclipse.debug.core.Launch@fddb2bb [JUnit]
1751937889970 launch terminated: ATestCase: org.eclipse.debug.core.Launch@fddb2bb [JUnit]
1751937890088 launch added     : ATestCase: org.eclipse.debug.core.Launch@64dfeea9
1751937890106 launch changed   : ATestCase: org.eclipse.debug.core.Launch@64dfeea9 [JUnit]
1751937890814 launch terminated: ATestCase: org.eclipse.debug.core.Launch@64dfeea9 [JUnit]
1751937890980 launch added     : ATestCase: org.eclipse.debug.core.Launch@37f183a4
1751937891032 launch changed   : ATestCase: org.eclipse.debug.core.Launch@37f183a4 [JUnit]
1751937891865 launch terminated: ATestCase: org.eclipse.debug.core.Launch@37f183a4 [JUnit]
1751937891979 launch added     : ATestCase: org.eclipse.debug.core.Launch@5ed94ff1
1751937891996 launch changed   : ATestCase: org.eclipse.debug.core.Launch@5ed94ff1 [JUnit]
1751937892864 launch terminated: ATestCase: org.eclipse.debug.core.Launch@5ed94ff1 [JUnit]
1751937892911 launch added     : ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@144a5479
1751937892918 launch changed   : ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@144a5479 [JUnit]
1751937893296 launch terminated: ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@144a5479 [JUnit]
1751937893338 launch added     : ATestCase test2Fail: org.eclipse.debug.core.Launch@52c761ef
1751937893344 launch changed   : ATestCase test2Fail: org.eclipse.debug.core.Launch@52c761ef [JUnit]
1751937893706 launch terminated: ATestCase test2Fail: org.eclipse.debug.core.Launch@52c761ef [JUnit]
1751937893754 launch added     : ATestCase test1Succeed: org.eclipse.debug.core.Launch@5d797ccf
1751937893761 launch changed   : ATestCase test1Succeed: org.eclipse.debug.core.Launch@5d797ccf [JUnit]
1751937894108 launch terminated: ATestCase test1Succeed: org.eclipse.debug.core.Launch@5d797ccf [JUnit]
1751937894153 launch added     : ATestCase testDiv[1]: org.eclipse.debug.core.Launch@6acc2fbd
1751937894160 launch changed   : ATestCase testDiv[1]: org.eclipse.debug.core.Launch@6acc2fbd [JUnit]
1751937894512 launch terminated: ATestCase testDiv[1]: org.eclipse.debug.core.Launch@6acc2fbd [JUnit]
1751937894558 launch added     : ATestCase testDiv: org.eclipse.debug.core.Launch@3239c6d9
1751937894566 launch changed   : ATestCase testDiv: org.eclipse.debug.core.Launch@3239c6d9 [JUnit]
1751937894911 launch terminated: ATestCase testDiv: org.eclipse.debug.core.Launch@3239c6d9 [JUnit]
1751937894953 launch added     : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@2c4125a7
1751937894960 launch changed   : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@2c4125a7 [JUnit]
1751937895337 launch terminated: ATestCase testDiv[0]: org.eclipse.debug.core.Launch@2c4125a7 [JUnit]
1751937895393 launch added     : ATestCase [1]: org.eclipse.debug.core.Launch@28669770
1751937895401 launch changed   : ATestCase [1]: org.eclipse.debug.core.Launch@28669770 [JUnit]
1751937895758 launch terminated: ATestCase [1]: org.eclipse.debug.core.Launch@28669770 [JUnit]
1751937895801 launch added     : ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@51fd9cfb
1751937895809 launch changed   : ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@51fd9cfb [JUnit]
1751937896166 launch terminated: ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@51fd9cfb [JUnit]
1751937896221 launch added     : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@79fba7f1
1751937896228 launch changed   : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@79fba7f1 [JUnit]
1751937896748 launch terminated: ATestCase testDiv[0]: org.eclipse.debug.core.Launch@79fba7f1 [JUnit]
1751937896801 launch added     : ATestCase [0]: org.eclipse.debug.core.Launch@5d804251
1751937896810 launch changed   : ATestCase [0]: org.eclipse.debug.core.Launch@5d804251 [JUnit]
1751937897168 launch terminated: ATestCase [0]: org.eclipse.debug.core.Launch@5d804251 [JUnit]
1751937897213 launch added     : FailingSuite: org.eclipse.debug.core.Launch@646632f8
1751937897220 launch changed   : FailingSuite: org.eclipse.debug.core.Launch@646632f8 [JUnit]
1751937897509 launch terminated: FailingSuite: org.eclipse.debug.core.Launch@646632f8 [JUnit]
1751937897566 launch added     : AllTests: org.eclipse.debug.core.Launch@bd434b6
1751937897573 launch changed   : AllTests: org.eclipse.debug.core.Launch@bd434b6 [JUnit]
1751937898842 launch terminated: AllTests: org.eclipse.debug.core.Launch@bd434b6 [JUnit]
1751937898906 launch added     : ATestSuite: org.eclipse.debug.core.Launch@5f876863
1751937898913 launch changed   : ATestSuite: org.eclipse.debug.core.Launch@5f876863 [JUnit]
1751937900150 launch terminated: ATestSuite: org.eclipse.debug.core.Launch@5f876863 [JUnit]
1751937900251 launch added     : ATestCase.testSucceed: org.eclipse.debug.core.Launch@53de5b81
1751937900260 launch changed   : ATestCase.testSucceed: org.eclipse.debug.core.Launch@53de5b81 [JUnit]
1751937900515 launch terminated: ATestCase.testSucceed: org.eclipse.debug.core.Launch@53de5b81 [JUnit]
1751937900563 launch added     : ATestCase: org.eclipse.debug.core.Launch@5694ff68
1751937900570 launch changed   : ATestCase: org.eclipse.debug.core.Launch@5694ff68 [JUnit]
1751937901790 launch terminated: ATestCase: org.eclipse.debug.core.Launch@5694ff68 [JUnit]
1751937901909 launch added     : Failures: org.eclipse.debug.core.Launch@3399b7ca
1751937901919 launch changed   : Failures: org.eclipse.debug.core.Launch@3399b7ca [JUnit]
1751937902258 launch terminated: Failures: org.eclipse.debug.core.Launch@3399b7ca [JUnit]
1751937902448 launch added     : AllTests: org.eclipse.debug.core.Launch@7091d9da
1751937902468 launch changed   : AllTests: org.eclipse.debug.core.Launch@7091d9da [JUnit]
1751937904076 launch terminated: AllTests: org.eclipse.debug.core.Launch@7091d9da [JUnit]
1751937904179 launch added     : ATestSuite: org.eclipse.debug.core.Launch@39345a31
1751937904194 launch changed   : ATestSuite: org.eclipse.debug.core.Launch@39345a31 [JUnit]
1751937905602 launch terminated: ATestSuite: org.eclipse.debug.core.Launch@39345a31 [JUnit]
1751937905725 launch added     : ATestCase: org.eclipse.debug.core.Launch@6e0dd809
1751937905740 launch changed   : ATestCase: org.eclipse.debug.core.Launch@6e0dd809 [JUnit]
1751937907121 launch terminated: ATestCase: org.eclipse.debug.core.Launch@6e0dd809 [JUnit]
1751937907191 launch added     : Failures: org.eclipse.debug.core.Launch@49270d84
1751937907207 launch changed   : Failures: org.eclipse.debug.core.Launch@49270d84 [JUnit]
1751937907585 launch terminated: Failures: org.eclipse.debug.core.Launch@49270d84 [JUnit]
1751937909748 launch added     : ATestCase: org.eclipse.debug.core.Launch@24ddb4db
1751937909759 launch changed   : ATestCase: org.eclipse.debug.core.Launch@24ddb4db [JUnit]
1751937910453 launch terminated: ATestCase: org.eclipse.debug.core.Launch@24ddb4db [JUnit]

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

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

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

!ENTRY org.eclipse.jdt.ui 4 10001 2025-07-08 01:25:13.407
!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-07-08 01:25:13.414
!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-07-08 01:25:13.416
!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-07-08 01:26:06.673
!MESSAGE The workspace will exit with unsaved changes in this session.