CompileCommand: exclude org/eclipse/jdt/internal/core/dom/rewrite/ASTRewriteAnalyzer.getExtendedRange bool exclude = true
!SESSION 2025-07-08 01:36:30.618 -----------------------------------------------
eclipse.buildId=4.37.0.I20250707-1800
java.version=21.0.5
java.vendor=Eclipse Adoptium
BootLoader constants: OS=macosx, ARCH=aarch64, WS=cocoa, NL=en_US
Framework arguments:  -application org.eclipse.test.uitestapplication formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,/Users/genie.releng/workspace/AutomatedTests/ep437I-unit-macosx-aarch64-java21/workarea/I20250707-1800/eclipse-testing/test-eclipse/Eclipse.app/Contents/Eclipse/org.eclipse.jdt.ui.tests.AutomatedSuite.xml -testPluginName org.eclipse.jdt.ui.tests -className org.eclipse.jdt.ui.tests.AutomatedSuite -timeout 7200000 -junitReportOutput /Users/genie.releng/workspace/AutomatedTests/ep437I-unit-macosx-aarch64-java21/workarea/I20250707-1800/eclipse-testing/results/ep437I-unit-macosx-aarch64-java21_macosx.cocoa.aarch64_21
Command-line arguments:  -application org.eclipse.test.uitestapplication -data /Users/genie.releng/workspace/AutomatedTests/ep437I-unit-macosx-aarch64-java21/workarea/I20250707-1800/eclipse-testing/test-eclipse/Eclipse.app/Contents/Eclipse/jdt_folder formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,/Users/genie.releng/workspace/AutomatedTests/ep437I-unit-macosx-aarch64-java21/workarea/I20250707-1800/eclipse-testing/test-eclipse/Eclipse.app/Contents/Eclipse/org.eclipse.jdt.ui.tests.AutomatedSuite.xml -testPluginName org.eclipse.jdt.ui.tests -className org.eclipse.jdt.ui.tests.AutomatedSuite -os macosx -ws cocoa -arch aarch64 -consolelog -timeout 7200000 -junitReportOutput /Users/genie.releng/workspace/AutomatedTests/ep437I-unit-macosx-aarch64-java21/workarea/I20250707-1800/eclipse-testing/results/ep437I-unit-macosx-aarch64-java21_macosx.cocoa.aarch64_21

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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;
	}
}

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
removeIf
list
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:38:40.657
!MESSAGE Expecting an error message to be logged after this.

!ENTRY org.eclipse.jdt.ui 4 4 2025-07-08 01:38:40.662
!MESSAGE Error during computation of Annotate proposals: Could not resolve type Missing
!STACK 0
org.eclipse.jdt.internal.corext.fix.ExternalNullAnnotationChangeProposals$MissingBindingException: Could not resolve type Missing
	at org.eclipse.jdt.internal.corext.fix.ExternalNullAnnotationChangeProposals.resolveBinding(ExternalNullAnnotationChangeProposals.java:353)
	at org.eclipse.jdt.internal.corext.fix.ExternalNullAnnotationChangeProposals.collectExternalAnnotationProposals(ExternalNullAnnotationChangeProposals.java:473)
	at org.eclipse.jdt.internal.ui.text.correction.ExternalNullAnnotationQuickAssistProcessor.computeQuickAssistProposals(ExternalNullAnnotationQuickAssistProcessor.java:101)
	at org.eclipse.jdt.ui.tests.quickfix.AbstractAnnotateAssistTests.collectAnnotateProposals(AbstractAnnotateAssistTests.java:117)
	at org.eclipse.jdt.ui.tests.quickfix.AnnotateAssistTest1d5.testBug466232(AnnotateAssistTest1d5.java:706)
	at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
	at java.base/java.lang.reflect.Method.invoke(Method.java:580)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:59)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:56)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:26)
	at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:27)
	at org.junit.rules.ExternalResource$1.evaluate(ExternalResource.java:54)
	at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
	at org.junit.runners.BlockJUnit4ClassRunner$1.evaluate(BlockJUnit4ClassRunner.java:100)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:366)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:103)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:63)
	at org.junit.runners.ParentRunner$4.run(ParentRunner.java:331)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:79)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:329)
	at org.junit.runners.ParentRunner.access$100(ParentRunner.java:66)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:293)
	at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:413)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
	at org.junit.vintage.engine.execution.RunnerExecutor.execute(RunnerExecutor.java:42)
	at org.junit.vintage.engine.execution.VintageExecutor.executeClassesAndMethodsSequentially(VintageExecutor.java:93)
	at org.junit.vintage.engine.execution.VintageExecutor.executeAllChildren(VintageExecutor.java:73)
	at org.junit.vintage.engine.VintageTestEngine.execute(VintageTestEngine.java:70)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.executeEngine(EngineExecutionOrchestrator.java:230)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.failOrExecuteEngine(EngineExecutionOrchestrator.java:204)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:172)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:101)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:84)
	at org.junit.platform.suite.engine.SuiteLauncher.execute(SuiteLauncher.java:65)
	at org.junit.platform.suite.engine.SuiteTestDescriptor.executeTests(SuiteTestDescriptor.java:188)
	at org.junit.platform.suite.engine.SuiteTestDescriptor.execute(SuiteTestDescriptor.java:156)
	at org.junit.platform.suite.engine.SuiteTestEngine.lambda$execute$0(SuiteTestEngine.java:76)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.Iterator.forEachRemaining(Iterator.java:133)
	at java.base/java.util.Spliterators$IteratorSpliterator.forEachRemaining(Spliterators.java:1939)
	at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
	at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
	at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:174)
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.base/java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:596)
	at org.junit.platform.suite.engine.SuiteTestEngine.execute(SuiteTestEngine.java:76)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.executeEngine(EngineExecutionOrchestrator.java:230)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.failOrExecuteEngine(EngineExecutionOrchestrator.java:204)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:172)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:101)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:84)
	at org.junit.platform.suite.engine.SuiteLauncher.execute(SuiteLauncher.java:65)
	at org.junit.platform.suite.engine.SuiteTestDescriptor.executeTests(SuiteTestDescriptor.java:188)
	at org.junit.platform.suite.engine.SuiteTestDescriptor.execute(SuiteTestDescriptor.java:156)
	at org.junit.platform.suite.engine.SuiteTestEngine.lambda$execute$0(SuiteTestEngine.java:76)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.accept(ForEachOps.java:184)
	at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
	at java.base/java.util.Iterator.forEachRemaining(Iterator.java:133)
	at java.base/java.util.Spliterators$IteratorSpliterator.forEachRemaining(Spliterators.java:1939)
	at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
	at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
	at java.base/java.util.stream.ForEachOps$ForEachOp.evaluateSequential(ForEachOps.java:151)
	at java.base/java.util.stream.ForEachOps$ForEachOp$OfRef.evaluateSequential(ForEachOps.java:174)
	at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
	at java.base/java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:596)
	at org.junit.platform.suite.engine.SuiteTestEngine.execute(SuiteTestEngine.java:76)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.executeEngine(EngineExecutionOrchestrator.java:230)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.failOrExecuteEngine(EngineExecutionOrchestrator.java:204)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:172)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:101)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.lambda$execute$0(EngineExecutionOrchestrator.java:64)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.withInterceptedStreams(EngineExecutionOrchestrator.java:150)
	at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:63)
	at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:109)
	at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:91)
	at org.junit.platform.launcher.core.DelegatingLauncher.execute(DelegatingLauncher.java:47)
	at org.junit.platform.launcher.core.InterceptingLauncher.lambda$execute$1(InterceptingLauncher.java:39)
	at org.junit.platform.launcher.core.ClasspathAlignmentCheckingLauncherInterceptor.intercept(ClasspathAlignmentCheckingLauncherInterceptor.java:25)
	at org.junit.platform.launcher.core.InterceptingLauncher.execute(InterceptingLauncher.java:38)
	at org.junit.platform.launcher.core.DelegatingLauncher.execute(DelegatingLauncher.java:47)
	at org.junit.platform.launcher.core.SessionPerRequestLauncher.execute(SessionPerRequestLauncher.java:66)
	at org.eclipse.test.EclipseTestRunner.runTests(EclipseTestRunner.java:212)
	at org.eclipse.test.EclipseTestRunner.run(EclipseTestRunner.java:187)
	at org.eclipse.test.UITestApplication.lambda$0(UITestApplication.java:101)
	at org.eclipse.e4.ui.internal.workbench.swt.E4Testable.lambda$1(E4Testable.java:127)
	at org.eclipse.swt.widgets.RunnableLock.run(RunnableLock.java:40)
	at org.eclipse.swt.widgets.Synchronizer.runAsyncMessages(Synchronizer.java:132)
	at org.eclipse.swt.widgets.Display.runAsyncMessages(Display.java:4382)
	at org.eclipse.swt.widgets.Display.readAndDispatch(Display.java:4005)
	at org.eclipse.e4.ui.internal.workbench.swt.PartRenderingEngine$5.run(PartRenderingEngine.java:1151)
	at org.eclipse.core.databinding.observable.Realm.runWithDefault(Realm.java:339)
	at org.eclipse.e4.ui.internal.workbench.swt.PartRenderingEngine.run(PartRenderingEngine.java:1042)
	at org.eclipse.e4.ui.internal.workbench.E4Workbench.createAndRunUI(E4Workbench.java:153)
	at org.eclipse.ui.internal.Workbench.lambda$3(Workbench.java:678)
	at org.eclipse.core.databinding.observable.Realm.runWithDefault(Realm.java:339)
	at org.eclipse.ui.internal.Workbench.createAndRunWorkbench(Workbench.java:583)
	at org.eclipse.ui.PlatformUI.createAndRunWorkbench(PlatformUI.java:173)
	at org.eclipse.ui.internal.ide.application.IDEApplication.start(IDEApplication.java:185)
	at org.eclipse.test.UITestApplication.run(UITestApplication.java:48)
	at org.eclipse.test.UITestApplication.start(UITestApplication.java:116)
	at org.eclipse.equinox.internal.app.EclipseAppHandle.run(EclipseAppHandle.java:219)
	at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.runApplication(EclipseAppLauncher.java:149)
	at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.start(EclipseAppLauncher.java:115)
	at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:467)
	at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:298)
	at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:103)
	at java.base/java.lang.reflect.Method.invoke(Method.java:580)
	at org.eclipse.equinox.launcher.Main.invokeFramework(Main.java:627)
	at org.eclipse.equinox.launcher.Main.basicRun(Main.java:575)
	at org.eclipse.equinox.launcher.Main.run(Main.java:1431)
	at org.eclipse.equinox.launcher.Main.main(Main.java:1403)
1751953138409 launch added     : ATestCase: org.eclipse.debug.core.Launch@2c873608
1751953138432 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2c873608 [JUnit]
1751953138584 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2c873608 [JUnit]
1751953138715 launch added     : ATestCase: org.eclipse.debug.core.Launch@702bac94
1751953138721 launch changed   : ATestCase: org.eclipse.debug.core.Launch@702bac94 [JUnit]
1751953138842 launch terminated: ATestCase: org.eclipse.debug.core.Launch@702bac94 [JUnit]
1751953138864 launch added     : ATestCase: org.eclipse.debug.core.Launch@51a4b8cf
1751953138869 launch changed   : ATestCase: org.eclipse.debug.core.Launch@51a4b8cf [JUnit]
1751953138986 launch terminated: ATestCase: org.eclipse.debug.core.Launch@51a4b8cf [JUnit]
1751953139012 launch added     : ATestCase: org.eclipse.debug.core.Launch@6e10dfd7
1751953139018 launch changed   : ATestCase: org.eclipse.debug.core.Launch@6e10dfd7 [JUnit]
1751953139137 launch terminated: ATestCase: org.eclipse.debug.core.Launch@6e10dfd7 [JUnit]
1751953139167 launch added     : MyTestSuite: org.eclipse.debug.core.Launch@5d6c511e
1751953139172 launch changed   : MyTestSuite: org.eclipse.debug.core.Launch@5d6c511e [JUnit]
1751953139319 launch terminated: MyTestSuite: org.eclipse.debug.core.Launch@5d6c511e [JUnit]
1751953139338 launch added     : ATestCase: org.eclipse.debug.core.Launch@7643117c
1751953139345 launch changed   : ATestCase: org.eclipse.debug.core.Launch@7643117c [JUnit]
1751953139497 launch terminated: ATestCase: org.eclipse.debug.core.Launch@7643117c [JUnit]
1751953139517 launch added     : ATestCase: org.eclipse.debug.core.Launch@31e67e27
1751953139524 launch changed   : ATestCase: org.eclipse.debug.core.Launch@31e67e27 [JUnit]
1751953139661 launch terminated: ATestCase: org.eclipse.debug.core.Launch@31e67e27 [JUnit]
1751953139680 launch added     : ATestCase: org.eclipse.debug.core.Launch@544c0770
1751953139685 launch changed   : ATestCase: org.eclipse.debug.core.Launch@544c0770 [JUnit]
1751953139806 launch terminated: ATestCase: org.eclipse.debug.core.Launch@544c0770 [JUnit]
1751953139830 launch added     : ATestCase: org.eclipse.debug.core.Launch@2b5afff2
1751953139849 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2b5afff2 [JUnit]
1751953139971 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2b5afff2 [JUnit]
1751953140008 launch added     : ATestCase: org.eclipse.debug.core.Launch@43b30e95
1751953140016 launch changed   : ATestCase: org.eclipse.debug.core.Launch@43b30e95 [JUnit]
1751953140185 launch terminated: ATestCase: org.eclipse.debug.core.Launch@43b30e95 [JUnit]
1751953140212 launch added     : ATestCase: org.eclipse.debug.core.Launch@4c444628
1751953140219 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4c444628 [JUnit]
1751953140365 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4c444628 [JUnit]
1751953140384 launch added     : ATestCase: org.eclipse.debug.core.Launch@45205934
1751953140390 launch changed   : ATestCase: org.eclipse.debug.core.Launch@45205934 [JUnit]
1751953140533 launch terminated: ATestCase: org.eclipse.debug.core.Launch@45205934 [JUnit]
1751953140552 launch added     : ATestCase: org.eclipse.debug.core.Launch@3074799a
1751953140558 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3074799a [JUnit]
1751953140699 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3074799a [JUnit]
1751953140721 launch added     : ATestCase: org.eclipse.debug.core.Launch@43061b04
1751953140726 launch changed   : ATestCase: org.eclipse.debug.core.Launch@43061b04 [JUnit]
1751953140866 launch terminated: ATestCase: org.eclipse.debug.core.Launch@43061b04 [JUnit]
1751953140889 launch added     : ATestCase: org.eclipse.debug.core.Launch@2bbe2c5
1751953140895 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2bbe2c5 [JUnit]
1751953141043 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2bbe2c5 [JUnit]
1751953141066 launch added     : ATestCase: org.eclipse.debug.core.Launch@1eff88b4
1751953141074 launch changed   : ATestCase: org.eclipse.debug.core.Launch@1eff88b4 [JUnit]
1751953141231 launch terminated: ATestCase: org.eclipse.debug.core.Launch@1eff88b4 [JUnit]
1751953141255 launch added     : ATestCase: org.eclipse.debug.core.Launch@4e4aabe8
1751953141261 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4e4aabe8 [JUnit]
1751953141420 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4e4aabe8 [JUnit]
1751953141445 launch added     : ATestCase: org.eclipse.debug.core.Launch@42b75f34
1751953141452 launch changed   : ATestCase: org.eclipse.debug.core.Launch@42b75f34 [JUnit]
1751953141607 launch terminated: ATestCase: org.eclipse.debug.core.Launch@42b75f34 [JUnit]
1751953141665 launch added     : ATestCase: org.eclipse.debug.core.Launch@2be0f361
1751953141675 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2be0f361 [JUnit]
1751953141937 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2be0f361 [JUnit]
1751953141990 launch added     : ATestCase: org.eclipse.debug.core.Launch@360387fb
1751953142009 launch changed   : ATestCase: org.eclipse.debug.core.Launch@360387fb [JUnit]
1751953142263 launch terminated: ATestCase: org.eclipse.debug.core.Launch@360387fb [JUnit]
1751953142314 launch added     : ATestCase: org.eclipse.debug.core.Launch@3fa1734a
1751953142324 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3fa1734a [JUnit]
1751953142574 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3fa1734a [JUnit]
1751953142645 launch added     : ATestCase: org.eclipse.debug.core.Launch@15daaa07
1751953142687 launch changed   : ATestCase: org.eclipse.debug.core.Launch@15daaa07 [JUnit]
1751953142879 launch terminated: ATestCase: org.eclipse.debug.core.Launch@15daaa07 [JUnit]
1751953142937 launch added     : ATestCase: org.eclipse.debug.core.Launch@2a1ad754
1751953142947 launch changed   : ATestCase: org.eclipse.debug.core.Launch@2a1ad754 [JUnit]
1751953143209 launch terminated: ATestCase: org.eclipse.debug.core.Launch@2a1ad754 [JUnit]
1751953143229 launch added     : ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@61d65605
1751953143234 launch changed   : ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@61d65605 [JUnit]
1751953143379 launch terminated: ATestCase thisdoesnotexist: org.eclipse.debug.core.Launch@61d65605 [JUnit]
1751953143398 launch added     : ATestCase test2Fail: org.eclipse.debug.core.Launch@212a7689
1751953143403 launch changed   : ATestCase test2Fail: org.eclipse.debug.core.Launch@212a7689 [JUnit]
1751953143560 launch terminated: ATestCase test2Fail: org.eclipse.debug.core.Launch@212a7689 [JUnit]
1751953143580 launch added     : ATestCase test1Succeed: org.eclipse.debug.core.Launch@453659a4
1751953143584 launch changed   : ATestCase test1Succeed: org.eclipse.debug.core.Launch@453659a4 [JUnit]
1751953143725 launch terminated: ATestCase test1Succeed: org.eclipse.debug.core.Launch@453659a4 [JUnit]
1751953143746 launch added     : ATestCase testDiv[1]: org.eclipse.debug.core.Launch@6bf5c8d2
1751953143750 launch changed   : ATestCase testDiv[1]: org.eclipse.debug.core.Launch@6bf5c8d2 [JUnit]
1751953143896 launch terminated: ATestCase testDiv[1]: org.eclipse.debug.core.Launch@6bf5c8d2 [JUnit]
1751953143916 launch added     : ATestCase testDiv: org.eclipse.debug.core.Launch@6b455526
1751953143921 launch changed   : ATestCase testDiv: org.eclipse.debug.core.Launch@6b455526 [JUnit]
1751953144085 launch terminated: ATestCase testDiv: org.eclipse.debug.core.Launch@6b455526 [JUnit]
1751953144106 launch added     : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@75bdeb48
1751953144111 launch changed   : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@75bdeb48 [JUnit]
1751953144260 launch terminated: ATestCase testDiv[0]: org.eclipse.debug.core.Launch@75bdeb48 [JUnit]
1751953144302 launch added     : ATestCase [1]: org.eclipse.debug.core.Launch@23f8073
1751953144308 launch changed   : ATestCase [1]: org.eclipse.debug.core.Launch@23f8073 [JUnit]
1751953144471 launch terminated: ATestCase [1]: org.eclipse.debug.core.Launch@23f8073 [JUnit]
1751953144497 launch added     : ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@1f63548c
1751953144502 launch changed   : ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@1f63548c [JUnit]
1751953144653 launch terminated: ATestCase pack.ATestCase: org.eclipse.debug.core.Launch@1f63548c [JUnit]
1751953144721 launch added     : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@2fcfb037
1751953144727 launch changed   : ATestCase testDiv[0]: org.eclipse.debug.core.Launch@2fcfb037 [JUnit]
1751953144873 launch terminated: ATestCase testDiv[0]: org.eclipse.debug.core.Launch@2fcfb037 [JUnit]
1751953144896 launch added     : ATestCase [0]: org.eclipse.debug.core.Launch@7a9c37
1751953144901 launch changed   : ATestCase [0]: org.eclipse.debug.core.Launch@7a9c37 [JUnit]
1751953145046 launch terminated: ATestCase [0]: org.eclipse.debug.core.Launch@7a9c37 [JUnit]
1751953145067 launch added     : FailingSuite: org.eclipse.debug.core.Launch@977b953
1751953145072 launch changed   : FailingSuite: org.eclipse.debug.core.Launch@977b953 [JUnit]
1751953145188 launch terminated: FailingSuite: org.eclipse.debug.core.Launch@977b953 [JUnit]
1751953145223 launch added     : AllTests: org.eclipse.debug.core.Launch@4c9e0f02
1751953145227 launch changed   : AllTests: org.eclipse.debug.core.Launch@4c9e0f02 [JUnit]
1751953146371 launch terminated: AllTests: org.eclipse.debug.core.Launch@4c9e0f02 [JUnit]
1751953146439 launch added     : ATestSuite: org.eclipse.debug.core.Launch@74f0d705
1751953146444 launch changed   : ATestSuite: org.eclipse.debug.core.Launch@74f0d705 [JUnit]
1751953147590 launch terminated: ATestSuite: org.eclipse.debug.core.Launch@74f0d705 [JUnit]
1751953147669 launch added     : ATestCase.testSucceed: org.eclipse.debug.core.Launch@37a12130
1751953147673 launch changed   : ATestCase.testSucceed: org.eclipse.debug.core.Launch@37a12130 [JUnit]
1751953147794 launch terminated: ATestCase.testSucceed: org.eclipse.debug.core.Launch@37a12130 [JUnit]
1751953147818 launch added     : ATestCase: org.eclipse.debug.core.Launch@4f34bb2f
1751953147822 launch changed   : ATestCase: org.eclipse.debug.core.Launch@4f34bb2f [JUnit]
1751953148952 launch terminated: ATestCase: org.eclipse.debug.core.Launch@4f34bb2f [JUnit]
1751953149007 launch added     : Failures: org.eclipse.debug.core.Launch@c03be60
1751953149012 launch changed   : Failures: org.eclipse.debug.core.Launch@c03be60 [JUnit]
1751953149136 launch terminated: Failures: org.eclipse.debug.core.Launch@c03be60 [JUnit]
1751953149169 launch added     : AllTests: org.eclipse.debug.core.Launch@aa5f8d6
1751953149179 launch changed   : AllTests: org.eclipse.debug.core.Launch@aa5f8d6 [JUnit]
1751953150390 launch terminated: AllTests: org.eclipse.debug.core.Launch@aa5f8d6 [JUnit]
1751953150442 launch added     : ATestSuite: org.eclipse.debug.core.Launch@214074b8
1751953150449 launch changed   : ATestSuite: org.eclipse.debug.core.Launch@214074b8 [JUnit]
1751953151621 launch terminated: ATestSuite: org.eclipse.debug.core.Launch@214074b8 [JUnit]
1751953151716 launch added     : ATestCase: org.eclipse.debug.core.Launch@806e345
1751953151724 launch changed   : ATestCase: org.eclipse.debug.core.Launch@806e345 [JUnit]
1751953152890 launch terminated: ATestCase: org.eclipse.debug.core.Launch@806e345 [JUnit]
1751953152956 launch added     : Failures: org.eclipse.debug.core.Launch@56120066
1751953152964 launch changed   : Failures: org.eclipse.debug.core.Launch@56120066 [JUnit]
1751953153122 launch terminated: Failures: org.eclipse.debug.core.Launch@56120066 [JUnit]
1751953154099 launch added     : ATestCase: org.eclipse.debug.core.Launch@3d47cf99
1751953154105 launch changed   : ATestCase: org.eclipse.debug.core.Launch@3d47cf99 [JUnit]
1751953154454 launch terminated: ATestCase: org.eclipse.debug.core.Launch@3d47cf99 [JUnit]

!ENTRY org.eclipse.jdt.ui 4 10001 2025-07-08 01:39:16.872
!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:39:16.876
!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:39:16.877
!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:39:51.560
!MESSAGE The workspace will exit with unsaved changes in this session.
CoreSVG has logged an error. Set environment variabe "CORESVG_VERBOSE" to learn more.