nus-yam/ex-repair huggingface dataset:
Program: 12042
Project: 12042
Buggy source:
public CloneInstanceLocationInfo(String filePath,int startLine,int startColumn,int endLine,int endColumn){
  this(filePath);
  this.startLine=startLine;
  this.startColumn=startColumn;
  this.endLine=endLine;
  this.endColumn=endColumn;
  String[] lines=this.containingFileContents.split(LINE_FEED);
  int numberOfCharsForLines=getNumberOfCharsForLines(lines,startLine - 1);
  this.startOffset=numberOfCharsForLines + this.startColumn;
  numberOfCharsForLines=getNumberOfCharsForLines(lines,endLine - 1);
  int endOffset=numberOfCharsForLines + this.endColumn;
  this.length=endOffset - this.startOffset + 1;
}

Fixed version (ground truth):
public CloneInstanceLocationInfo(String filePath,int startLine,int startColumn,int endLine,int endColumn){
  this(filePath);
  this.startLine=startLine;
  this.startColumn=startColumn;
  this.endLine=endLine;
  this.endColumn=endColumn;
  String[] lines=this.containingFileContents.split(LINE_FEED);
  int numberOfCharsForLines=getNumberOfCharsForLines(lines,startLine - 1);
  this.startOffset=numberOfCharsForLines + this.startColumn;
  numberOfCharsForLines=getNumberOfCharsForLines(lines,endLine) - 1;
  int endOffset=numberOfCharsForLines + this.endColumn;
  this.length=endOffset - this.startOffset + 1;
}
Program: 12044
Project: 12044
Buggy source:
private void sortVariables(List<AbstractVariable> variables1,List<AbstractVariable> variables2,List<AbstractVariable> sortedVariables1,List<AbstractVariable> sortedVariables2){
  boolean requireVariableNameMatch=getRenamedVariables().isEmpty();
  for (int i=0; i < variables1.size(); i++) {
    AbstractVariable variable1=variables1.get(i);
    boolean found=false;
    for (int j=0; j < variables2.size(); j++) {
      AbstractVariable variable2=variables2.get(j);
      if (requireVariableNameMatch) {
        if (variable2.getVariableName().equals(variable1.getVariableName()) && variable2.getVariableType().equals(variable1.getVariableType()) && !sortedVariables2.contains(variable2)) {
          sortedVariables2.add(variable2);
          found=true;
          break;
        }
      }
 else {
        String renamedVariableName=findRenamedVariableName(variable2);
        if (renamedVariableName != null) {
          if (variable2.getVariableType().equals(variable1.getVariableType()) && variable1.getVariableName().equals(renamedVariableName) && !sortedVariables2.contains(variable2)) {
            sortedVariables2.add(variable2);
            found=true;
            break;
          }
        }
 else {
          if (variable2.getVariableType().equals(variable1.getVariableType()) && !sortedVariables2.contains(variable2)) {
            sortedVariables2.add(variable2);
            found=true;
            break;
          }
        }
      }
    }
    if (found) {
      sortedVariables1.add(variable1);
    }
  }
}

Fixed version (ground truth):
private void sortVariables(List<AbstractVariable> variables1,List<AbstractVariable> variables2,List<AbstractVariable> sortedVariables1,List<AbstractVariable> sortedVariables2){
  boolean requireVariableNameMatch=getRenamedVariables().isEmpty();
  for (int i=0; i < variables1.size(); i++) {
    AbstractVariable variable1=variables1.get(i);
    boolean found=false;
    for (int j=0; j < variables2.size(); j++) {
      AbstractVariable variable2=variables2.get(j);
      if (requireVariableNameMatch) {
        if (variable2.getVariableName().equals(variable1.getVariableName()) && variable2.getVariableType().equals(variable1.getVariableType()) && !sortedVariables2.contains(variable2)) {
          sortedVariables2.add(variable2);
          found=true;
          break;
        }
      }
 else {
        String renamedVariableName=findRenamedVariableName2(variable2);
        if (renamedVariableName != null) {
          if (variable2.getVariableType().equals(variable1.getVariableType()) && variable1.getVariableName().equals(renamedVariableName) && !sortedVariables2.contains(variable2)) {
            sortedVariables2.add(variable2);
            found=true;
            break;
          }
        }
 else         if (findRenamedVariableName1(variable1) == null) {
          if (variable2.getVariableType().equals(variable1.getVariableType()) && !sortedVariables2.contains(variable2)) {
            sortedVariables2.add(variable2);
            found=true;
            break;
          }
        }
      }
    }
    if (found) {
      sortedVariables1.add(variable1);
    }
  }
}
Program: 12047
Project: 12047
Buggy source:
private boolean commonPassedParametersAlreadyContainOneOfTheKeys(VariableBindingKeyPair keyPair){
  for (  VariableBindingKeyPair key : commonPassedParameters.keySet()) {
    if (key.getKey1().equals(keyPair.getKey1()) || key.getKey2().equals(keyPair.getKey2())) {
      return true;
    }
  }
  return false;
}

Fixed version (ground truth):
private VariableBindingKeyPair commonPassedParametersAlreadyContainOneOfTheKeys(VariableBindingKeyPair keyPair){
  for (  VariableBindingKeyPair key : commonPassedParameters.keySet()) {
    if (key.getKey1().equals(keyPair.getKey1()) || key.getKey2().equals(keyPair.getKey2())) {
      return key;
    }
  }
  return null;
}
Program: 12049
Project: 12049
Buggy source:
public Set<PlainVariable> getVariablesToBeReturnedG1(){
  return preconditionExaminer.getVariablesToBeReturnedG1();
}

Fixed version (ground truth):
public Set<VariableDeclaration> getVariablesToBeReturnedG1(){
  return preconditionExaminer.getVariablesToBeReturnedG1();
}
Program: 12050
Project: 12050
Buggy source:
public Set<PlainVariable> getVariablesToBeReturnedG2(){
  return preconditionExaminer.getVariablesToBeReturnedG2();
}

Fixed version (ground truth):
public Set<VariableDeclaration> getVariablesToBeReturnedG2(){
  return preconditionExaminer.getVariablesToBeReturnedG2();
}
Program: 12052
Project: 12052
Buggy source:
public Set<PlainVariable> getVariablesToBeReturnedG1(){
  return variablesToBeReturnedG1;
}

Fixed version (ground truth):
public Set<VariableDeclaration> getVariablesToBeReturnedG1(){
  Set<VariableDeclaration> declaredVariablesG1=new LinkedHashSet<VariableDeclaration>();
  Set<VariableDeclaration> variableDeclarationsInMethod1=pdg1.getVariableDeclarationsInMethod();
  for (  PlainVariable variable1 : this.variablesToBeReturnedG1) {
    for (    VariableDeclaration variableDeclaration : variableDeclarationsInMethod1) {
      if (variableDeclaration.resolveBinding().getKey().equals(variable1.getVariableBindingKey())) {
        declaredVariablesG1.add(variableDeclaration);
        break;
      }
    }
  }
  return declaredVariablesG1;
}
Program: 12053
Project: 12053
Buggy source:
public Set<PlainVariable> getVariablesToBeReturnedG2(){
  return variablesToBeReturnedG2;
}

Fixed version (ground truth):
public Set<VariableDeclaration> getVariablesToBeReturnedG2(){
  Set<VariableDeclaration> declaredVariablesG2=new LinkedHashSet<VariableDeclaration>();
  Set<VariableDeclaration> variableDeclarationsInMethod2=pdg2.getVariableDeclarationsInMethod();
  for (  AbstractVariable variable2 : this.variablesToBeReturnedG2) {
    for (    VariableDeclaration variableDeclaration : variableDeclarationsInMethod2) {
      if (variableDeclaration.resolveBinding().getKey().equals(variable2.getVariableBindingKey())) {
        declaredVariablesG2.add(variableDeclaration);
        break;
      }
    }
  }
  return declaredVariablesG2;
}
Program: 12054
Project: 12054
Buggy source:
private boolean variableIsPassedAsCommonParameter(VariableDeclaration variableDeclaration1,VariableDeclaration variableDeclaration2){
  for (  VariableBindingKeyPair pair : mapper.getCommonPassedParameters().keySet()) {
    if (pair.getKey1().equals(variableDeclaration1.resolveBinding().getKey()) && pair.getKey2().equals(variableDeclaration2.resolveBinding().getKey())) {
      return true;
    }
  }
  return false;
}

Fixed version (ground truth):
private boolean variableIsPassedAsCommonParameter(VariableDeclaration variableDeclaration){
  for (  VariableBindingKeyPair pair : mapper.getCommonPassedParameters().keySet()) {
    if (pair.getKey1().equals(variableDeclaration.resolveBinding().getKey()) || pair.getKey2().equals(variableDeclaration.resolveBinding().getKey())) {
      return true;
    }
  }
  return false;
}
Program: 12058
Project: 12058
Buggy source:
private void processCFGNode(PDGNode previousNode,CFGNode cfgNode,boolean controlType){
  if (cfgNode instanceof CFGBranchNode) {
    PDGControlPredicateNode predicateNode=new PDGControlPredicateNode(cfgNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
    nodes.add(predicateNode);
    if (monitor != null)     monitor.worked(1);
    PDGControlDependence controlDependence=new PDGControlDependence(previousNode,predicateNode,controlType);
    edges.add(controlDependence);
    processControlPredicate(predicateNode);
  }
 else {
    PDGNode pdgNode=null;
    if (cfgNode instanceof CFGExitNode)     pdgNode=new PDGExitNode(cfgNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
 else     pdgNode=new PDGStatementNode(cfgNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
    nodes.add(pdgNode);
    if (monitor != null)     monitor.worked(1);
    PDGControlDependence controlDependence=new PDGControlDependence(previousNode,pdgNode,controlType);
    edges.add(controlDependence);
  }
}

Fixed version (ground truth):
private void processCFGNode(PDGNode previousNode,CFGNode cfgNode,boolean controlType){
  if (cfgNode instanceof CFGBranchNode) {
    PDGControlPredicateNode predicateNode=new PDGControlPredicateNode(cfgNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
    nodes.add(predicateNode);
    if (monitor != null)     monitor.worked(1);
    PDGControlDependence controlDependence=new PDGControlDependence(previousNode,predicateNode,controlType);
    edges.add(controlDependence);
    processControlPredicate(predicateNode);
  }
 else {
    PDGNode pdgNode=null;
    if (cfgNode instanceof CFGExitNode)     pdgNode=new PDGExitNode(cfgNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
 else     if (cfgNode instanceof CFGTryNode)     pdgNode=new PDGTryNode((CFGTryNode)cfgNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
 else     if (cfgNode instanceof CFGSynchronizedNode)     pdgNode=new PDGSynchronizedNode((CFGSynchronizedNode)cfgNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
 else     pdgNode=new PDGStatementNode(cfgNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
    nodes.add(pdgNode);
    if (monitor != null)     monitor.worked(1);
    PDGControlDependence controlDependence=new PDGControlDependence(previousNode,pdgNode,controlType);
    edges.add(controlDependence);
  }
}
Program: 12059
Project: 12059
Buggy source:
private void createControlDependenciesFromEntryNode(){
  for (  GraphNode node : cfg.nodes) {
    CFGNode cfgNode=(CFGNode)node;
    if (!isNested(cfgNode)) {
      processCFGNode(entryNode,cfgNode,true);
    }
  }
  Map<CFGBlockNode,List<CFGNode>> directlyNestedNodesInBlocks=cfg.getDirectlyNestedNodesInBlocks();
  for (  CFGBlockNode blockNode : directlyNestedNodesInBlocks.keySet()) {
    PDGBlockNode pdgBlockNode=null;
    if (blockNode instanceof CFGTryNode) {
      CFGTryNode tryNode=(CFGTryNode)blockNode;
      pdgBlockNode=new PDGTryNode(tryNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
    }
 else     if (blockNode instanceof CFGSynchronizedNode) {
      CFGSynchronizedNode synchronizedNode=(CFGSynchronizedNode)blockNode;
      pdgBlockNode=new PDGSynchronizedNode(synchronizedNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
    }
    nodes.add(pdgBlockNode);
  }
}

Fixed version (ground truth):
private void createControlDependenciesFromEntryNode(){
  for (  GraphNode node : cfg.nodes) {
    CFGNode cfgNode=(CFGNode)node;
    if (!isNested(cfgNode)) {
      processCFGNode(entryNode,cfgNode,true);
    }
  }
  Map<CFGBlockNode,List<CFGNode>> directlyNestedNodesInBlocks=cfg.getDirectlyNestedNodesInBlocks();
  for (  CFGBlockNode blockNode : directlyNestedNodesInBlocks.keySet()) {
    if (!containsNodeWithID(blockNode.getId())) {
      PDGBlockNode pdgBlockNode=null;
      if (blockNode instanceof CFGTryNode) {
        CFGTryNode tryNode=(CFGTryNode)blockNode;
        pdgBlockNode=new PDGTryNode(tryNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
      }
 else       if (blockNode instanceof CFGSynchronizedNode) {
        CFGSynchronizedNode synchronizedNode=(CFGSynchronizedNode)blockNode;
        pdgBlockNode=new PDGSynchronizedNode(synchronizedNode,variableDeclarationsInMethod,fieldsAccessedInMethod);
      }
      if (pdgBlockNode != null) {
        nodes.add(pdgBlockNode);
      }
    }
  }
}
Program: 12069
Project: 12069
Buggy source:
public Map<String,ArrayList<VariableDeclaration>> getCommonPassedParameters(){
  Map<String,ArrayList<VariableDeclaration>> commonPassedParameters=new LinkedHashMap<String,ArrayList<VariableDeclaration>>();
  Set<VariableDeclaration> variableDeclarationsAndAccessedFieldsInMethod1=pdg1.getVariableDeclarationsAndAccessedFieldsInMethod();
  Set<VariableDeclaration> variableDeclarationsAndAccessedFieldsInMethod2=pdg2.getVariableDeclarationsAndAccessedFieldsInMethod();
  for (  String key : this.commonPassedParameters.keySet()) {
    ArrayList<AbstractVariable> value=this.commonPassedParameters.get(key);
    AbstractVariable variableDeclaration1=value.get(0);
    AbstractVariable variableDeclaration2=value.get(1);
    ArrayList<VariableDeclaration> variableDeclarations=new ArrayList<VariableDeclaration>();
    for (    VariableDeclaration variableDeclaration : variableDeclarationsAndAccessedFieldsInMethod1) {
      if (variableDeclaration.resolveBinding().getKey().equals(variableDeclaration1.getVariableBindingKey())) {
        variableDeclarations.add(variableDeclaration);
        break;
      }
    }
    for (    VariableDeclaration variableDeclaration : variableDeclarationsAndAccessedFieldsInMethod2) {
      if (variableDeclaration.resolveBinding().getKey().equals(variableDeclaration2.getVariableBindingKey())) {
        variableDeclarations.add(variableDeclaration);
        break;
      }
    }
    commonPassedParameters.put(key,variableDeclarations);
  }
  return commonPassedParameters;
}

Fixed version (ground truth):
public Map<VariableBindingKeyPair,ArrayList<VariableDeclaration>> getCommonPassedParameters(){
  Map<VariableBindingKeyPair,ArrayList<VariableDeclaration>> commonPassedParameters=new LinkedHashMap<VariableBindingKeyPair,ArrayList<VariableDeclaration>>();
  Set<VariableDeclaration> variableDeclarationsAndAccessedFieldsInMethod1=pdg1.getVariableDeclarationsAndAccessedFieldsInMethod();
  Set<VariableDeclaration> variableDeclarationsAndAccessedFieldsInMethod2=pdg2.getVariableDeclarationsAndAccessedFieldsInMethod();
  for (  VariableBindingKeyPair key : this.commonPassedParameters.keySet()) {
    ArrayList<AbstractVariable> value=this.commonPassedParameters.get(key);
    AbstractVariable variableDeclaration1=value.get(0);
    AbstractVariable variableDeclaration2=value.get(1);
    ArrayList<VariableDeclaration> variableDeclarations=new ArrayList<VariableDeclaration>();
    for (    VariableDeclaration variableDeclaration : variableDeclarationsAndAccessedFieldsInMethod1) {
      if (variableDeclaration.resolveBinding().getKey().equals(variableDeclaration1.getVariableBindingKey())) {
        variableDeclarations.add(variableDeclaration);
        break;
      }
    }
    for (    VariableDeclaration variableDeclaration : variableDeclarationsAndAccessedFieldsInMethod2) {
      if (variableDeclaration.resolveBinding().getKey().equals(variableDeclaration2.getVariableBindingKey())) {
        variableDeclarations.add(variableDeclaration);
        break;
      }
    }
    commonPassedParameters.put(key,variableDeclarations);
  }
  return commonPassedParameters;
}
Program: 12072
Project: 12072
Buggy source:
private boolean parameterIsUsedByNodesWithoutDifferences(VariableDeclaration variableDeclaration1,VariableDeclaration variableDeclaration2){
  PlainVariable variable1=new PlainVariable(variableDeclaration1);
  PlainVariable variable2=new PlainVariable(variableDeclaration2);
  for (  PDGNodeMapping pdgNodeMapping : sortedNodeMappings) {
    PDGNode node1=pdgNodeMapping.getNodeG1();
    PDGNode node2=pdgNodeMapping.getNodeG2();
    if (node1.usesLocalVariable(variable1) && node2.usesLocalVariable(variable2)) {
      List<ASTNodeDifference> differences=pdgNodeMapping.getNonOverlappingNodeDifferences();
      if (differences.isEmpty())       return true;
      for (      ASTNodeDifference difference : differences) {
        BindingSignaturePair signaturePair=difference.getBindingSignaturePair();
        if (!signaturePair.getSignature1().containsBinding(variableDeclaration1.resolveBinding().getKey()) && !signaturePair.getSignature2().containsBinding(variableDeclaration2.resolveBinding().getKey())) {
          return true;
        }
      }
    }
  }
  return false;
}

Fixed version (ground truth):
private boolean parameterIsUsedByNodesWithoutDifferences(VariableDeclaration variableDeclaration1,VariableDeclaration variableDeclaration2){
  PlainVariable variable1=new PlainVariable(variableDeclaration1);
  PlainVariable variable2=new PlainVariable(variableDeclaration2);
  for (  PDGNodeMapping pdgNodeMapping : sortedNodeMappings) {
    PDGNode node1=pdgNodeMapping.getNodeG1();
    PDGNode node2=pdgNodeMapping.getNodeG2();
    if (node1.usesLocalVariable(variable1) && node2.usesLocalVariable(variable2)) {
      List<ASTNodeDifference> differences=pdgNodeMapping.getNonOverlappingNodeDifferences();
      if (differences.isEmpty())       return true;
      boolean foundInDifferences=false;
      for (      ASTNodeDifference difference : differences) {
        BindingSignaturePair signaturePair=difference.getBindingSignaturePair();
        if (signaturePair.getSignature1().containsBinding(variableDeclaration1.resolveBinding().getKey()) && signaturePair.getSignature2().containsBinding(variableDeclaration2.resolveBinding().getKey())) {
          foundInDifferences=true;
          break;
        }
      }
      if (!foundInDifferences) {
        return true;
      }
    }
  }
  return false;
}
Program: 12077
Project: 12077
Buggy source:
public CodeFragmentDecomposer(Set<PDGNode> nodes){
  this.objectNodeMap=new LinkedHashMap<PlainVariable,Set<PDGNode>>();
  Set<PlainVariable> declaredVariables=getDeclaredVariables(nodes);
  for (  PlainVariable objectReference : declaredVariables) {
    Set<PDGNode> nodesDefiningAttributes=getNodesDefiningAttributesOfReference(objectReference,nodes);
    if (!nodesDefiningAttributes.isEmpty()) {
      Set<PDGNode> objectNodes=new LinkedHashSet<PDGNode>();
      PDGNode nodeDeclaringReference=getNodeDeclaringReference(objectReference,nodes);
      if (nodeDeclaringReference != null)       objectNodes.add(nodeDeclaringReference);
      objectNodes.addAll(nodesDefiningAttributes);
      objectNodeMap.put(objectReference,objectNodes);
    }
  }
}

Fixed version (ground truth):
public CodeFragmentDecomposer(Set<PDGNode> nodes,Set<VariableDeclaration> accessedFields){
  this.objectNodeMap=new LinkedHashMap<PlainVariable,Set<PDGNode>>();
  Set<PlainVariable> declaredVariables=getDeclaredVariables(nodes);
  for (  PlainVariable objectReference : declaredVariables) {
    Set<PDGNode> nodesDefiningAttributes=getNodesDefiningAttributesOfReference(objectReference,nodes);
    if (!nodesDefiningAttributes.isEmpty()) {
      Set<PDGNode> objectNodes=new LinkedHashSet<PDGNode>();
      PDGNode nodeDeclaringReference=getNodeDeclaringReference(objectReference,nodes);
      if (nodeDeclaringReference != null)       objectNodes.add(nodeDeclaringReference);
      objectNodes.addAll(nodesDefiningAttributes);
      objectNodeMap.put(objectReference,objectNodes);
    }
  }
  Map<PlainVariable,Set<PDGNode>> definedFieldMap=getDefinedFieldMap(nodes,accessedFields);
  objectNodeMap.putAll(definedFieldMap);
}
Program: 12078
Project: 12078
Buggy source:
private Set<PlainVariable> getDeclaredVariables(Set<PDGNode> nodes){
  Set<PlainVariable> declaredVariables=new LinkedHashSet<PlainVariable>();
  for (  PDGNode node : nodes) {
    Iterator<AbstractVariable> iterator=node.getDeclaredVariableIterator();
    if (iterator.hasNext()) {
      AbstractVariable declaredVariable=iterator.next();
      if (declaredVariable instanceof PlainVariable) {
        declaredVariables.add((PlainVariable)declaredVariable);
      }
    }
  }
  return declaredVariables;
}

Fixed version (ground truth):
private Set<PlainVariable> getDeclaredVariables(Set<PDGNode> nodes){
  Set<PlainVariable> declaredVariables=new LinkedHashSet<PlainVariable>();
  for (  PDGNode node : nodes) {
    Iterator<AbstractVariable> iterator=node.getDeclaredVariableIterator();
    while (iterator.hasNext()) {
      AbstractVariable declaredVariable=iterator.next();
      if (declaredVariable instanceof PlainVariable) {
        declaredVariables.add((PlainVariable)declaredVariable);
      }
    }
  }
  return declaredVariables;
}
Program: 12089
Project: 12089
Buggy source:
private void handleInputChanged(){
  String classNamePattern="String_Node_Str";
  for (  Text text : textMap.keySet()) {
    if (!Pattern.matches(classNamePattern,text.getText())) {
      setPageComplete(false);
      String message="String_Node_Str" + text.getText() + "String_Node_Str";
      setMessage(message,ERROR);
      return;
    }
 else     if (parentPackageClassNames.contains(text.getText())) {
      setPageComplete(false);
      String message="String_Node_Str" + text.getText() + "String_Node_Str"+ parentPackage.getElementName();
      setMessage(message,ERROR);
      return;
    }
 else     if (javaLangClassNames.contains(text.getText())) {
      setPageComplete(false);
      String message="String_Node_Str" + text.getText() + "String_Node_Str";
      setMessage(message,ERROR);
      return;
    }
 else {
      SimpleName namedConstant=textMap.get(text);
      refactoring.setTypeNameForNamedConstant(namedConstant,text.getText());
    }
  }
  setPageComplete(true);
  setMessage("String_Node_Str",NONE);
}

Fixed version (ground truth):
private void handleInputChanged(){
  String classNamePattern="String_Node_Str";
  for (  Text text : textMap.keySet()) {
    if (!Pattern.matches(classNamePattern,text.getText())) {
      setPageComplete(false);
      String message="String_Node_Str" + text.getText() + "String_Node_Str";
      setMessage(message,ERROR);
      return;
    }
 else     if (parentPackageClassNames.contains(text.getText())) {
      setPageComplete(false);
      String message="String_Node_Str" + text.getText() + "String_Node_Str";
      setMessage(message,ERROR);
      return;
    }
 else     if (javaLangClassNames.contains(text.getText())) {
      setPageComplete(false);
      String message="String_Node_Str" + text.getText() + "String_Node_Str";
      setMessage(message,ERROR);
      return;
    }
 else {
      SimpleName namedConstant=textMap.get(text);
      refactoring.setTypeNameForNamedConstant(namedConstant,text.getText());
    }
  }
  setPageComplete(true);
  setMessage("String_Node_Str",NONE);
}
Program: 12097
Project: 12097
Buggy source:
public void addThreeCompartments(){
  addFieldCompartment();
  extractMethodFigure.setBorder(new LineBorder());
  extractMethodFigure.setBackgroundColor(EntityFigure.entityColor);
  add(extractMethodFigure);
  add(methodFigure);
}

Fixed version (ground truth):
public void addThreeCompartments(){
  addFieldCompartment();
  extractMethodFigure.setBorder(new LineBorder());
  extractMethodFigure.setBackgroundColor(DecorationConstants.entityColor);
  add(extractMethodFigure);
  add(methodFigure);
}
Program: 12098
Project: 12098
Buggy source:
public ClassFigure(String name,Color color){
  ToolbarLayout layout=new ToolbarLayout();
  layout.setSpacing(5);
  setLayoutManager(layout);
  setBorder(new CompoundBorder(new LineBorder(1),new MarginBorder(0,0,0,0)));
  setBackgroundColor(color);
  setOpaque(true);
  Font classFont=new Font(null,"String_Node_Str",12,SWT.BOLD);
  Label className=new Label(name,CLASS);
  className.setToolTip(new Label(name));
  className.setFont(classFont);
  add(className);
  new ClassFigureMover(this);
}

Fixed version (ground truth):
public ClassFigure(String name,Color color){
  ToolbarLayout layout=new ToolbarLayout();
  layout.setSpacing(5);
  setLayoutManager(layout);
  setBorder(new CompoundBorder(new LineBorder(1),new MarginBorder(0,0,0,0)));
  setBackgroundColor(color);
  setOpaque(true);
  Label className=new Label(name,DecorationConstants.CLASS);
  className.setToolTip(new Label(name));
  className.setFont(DecorationConstants.classFont);
  add(className);
  new ClassFigureMover(this);
}
Program: 12099
Project: 12099
Buggy source:
public void addFigure(Figure figure){
  figure.setBackgroundColor(EntityFigure.entityColor);
  figure.setBorder(new CompoundBorder(new LineBorder(1),new MarginBorder(3,3,3,3)));
  add(figure);
}

Fixed version (ground truth):
public void addFigure(Figure figure){
  figure.setBackgroundColor(DecorationConstants.entityColor);
  figure.setBorder(new CompoundBorder(new LineBorder(1),new MarginBorder(3,3,3,3)));
  add(figure);
}
Program: 12100
Project: 12100
Buggy source:
public void mouseExited(MouseEvent me){
  List<JConnection> connections=figure.getOutgoingConnections();
  for (  JConnection connection : connections) {
    connection.setAlpha(null);
    connection.setLineWidth(1);
    Label l=connection.getLabel();
    if (l != null) {
      l.setFont(new Font(null,"String_Node_Str",10,SWT.BOLD));
      ConnectionLocator locator=connection.getLocator();
      locator.setRelativePosition(PositionConstants.CENTER);
      connection.add(l,locator);
    }
  }
}

Fixed version (ground truth):
public void mouseExited(MouseEvent me){
  List<JConnection> connections=figure.getOutgoingConnections();
  for (  JConnection connection : connections) {
    connection.setAlpha(null);
    connection.setLineWidth(1);
    Label l=connection.getLabel();
    if (l != null) {
      l.setFont(DecorationConstants.normalFont);
      ConnectionLocator locator=connection.getLocator();
      locator.setRelativePosition(PositionConstants.CENTER);
      connection.add(l,locator);
    }
  }
}
Program: 12101
Project: 12101
Buggy source:
public void mouseEntered(MouseEvent me){
  List<JConnection> connections=figure.getOutgoingConnections();
  for (  JConnection connection : connections) {
    connection.setLineWidth(3);
    Label l=connection.getLabel();
    if (l != null) {
      String fontStyle="String_Node_Str";
      ConnectionEndpointLocator locator=new ConnectionEndpointLocator(connection,true);
      if (connection.isWrite()) {
        locator.setUDistance(95);
        locator.setVDistance(0);
      }
 else {
        locator.setUDistance(42);
        locator.setVDistance(0);
      }
      l.setFont(new Font(null,fontStyle,14,SWT.BOLD));
      connection.add(l,locator);
    }
    PolygonDecoration decoration=new PolygonDecoration();
    decoration.setTemplate(PolygonDecoration.TRIANGLE_TIP);
    decoration.setSize(20,20);
    decoration.setBackgroundColor(connection.getForegroundColor());
    connection.setTargetDecoration(decoration);
  }
}

Fixed version (ground truth):
public void mouseEntered(MouseEvent me){
  List<JConnection> connections=figure.getOutgoingConnections();
  for (  JConnection connection : connections) {
    connection.setLineWidth(3);
    Label l=connection.getLabel();
    if (l != null) {
      ConnectionEndpointLocator locator=new ConnectionEndpointLocator(connection,true);
      if (connection.isWrite()) {
        locator.setUDistance(95);
        locator.setVDistance(0);
      }
 else {
        locator.setUDistance(42);
        locator.setVDistance(0);
      }
      l.setFont(DecorationConstants.highlightFont);
      connection.add(l,locator);
    }
    PolygonDecoration decoration=new PolygonDecoration();
    decoration.setTemplate(PolygonDecoration.TRIANGLE_TIP);
    decoration.setSize(20,20);
    decoration.setBackgroundColor(connection.getForegroundColor());
    connection.setTargetDecoration(decoration);
  }
}
Program: 12107
Project: 12107
Buggy source:
public MappingState(MappingState previous,PDGNodeMapping initialNodeMapping){
  this.nodeMappings=new LinkedHashSet<PDGNodeMapping>();
  this.edgeMappings=new LinkedHashSet<PDGEdgeMapping>();
  this.children=new ArrayList<MappingState>();
  if (previous != null) {
    nodeMappings.addAll(previous.nodeMappings);
    edgeMappings.addAll(previous.edgeMappings);
  }
  if (!containsAtLeastOneNodeInMappings(initialNodeMapping))   this.nodeMappings.add(initialNodeMapping);
  traverse(this,initialNodeMapping);
}

Fixed version (ground truth):
public MappingState(MappingState previous,PDGNodeMapping initialNodeMapping){
  this.nodeMappings=new LinkedHashSet<PDGNodeMapping>();
  this.edgeMappings=new LinkedHashSet<PDGEdgeMapping>();
  this.children=new ArrayList<MappingState>();
  if (previous != null) {
    nodeMappings.addAll(previous.nodeMappings);
    edgeMappings.addAll(previous.edgeMappings);
  }
  if (!containsAtLeastOneNodeInMappings(initialNodeMapping))   this.nodeMappings.add(initialNodeMapping);
  traverse(this,initialNodeMapping,new LinkedHashSet<PDGNode>(),new LinkedHashSet<PDGNode>());
}
Program: 12109
Project: 12109
Buggy source:
private boolean typeBindingMatch(ITypeBinding binding1,ITypeBinding binding2){
  if (binding1.isEqualTo(binding2))   return true;
  ITypeBinding superclass1=binding1.getSuperclass();
  ITypeBinding superclass2=binding2.getSuperclass();
  if (superclass1 != null && superclass2 != null && superclass1.isEqualTo(superclass2))   return true;
  return false;
}

Fixed version (ground truth):
private boolean typeBindingMatch(ITypeBinding binding1,ITypeBinding binding2){
  if (binding1.isEqualTo(binding2))   return true;
  ITypeBinding commonSuperType=commonSuperType(binding1,binding2);
  if (commonSuperType != null && !commonSuperType.getQualifiedName().equals("String_Node_Str"))   return true;
  return false;
}
Program: 12111
Project: 12111
Buggy source:
public boolean isCompatible(PDGNodeMapping nodeMapping){
  if (edgeG1.getClass() == edgeG2.getClass()) {
    if (edgeG1 instanceof PDGControlDependence) {
      return true;
    }
    if (edgeG1 instanceof PDGAbstractDataDependence) {
      AbstractVariable edgeG1Variable=((PDGAbstractDataDependence)edgeG1).getData();
      AbstractVariable edgeG2Variable=((PDGAbstractDataDependence)edgeG2).getData();
      CFGBranchNode edgeG1LoopNode=((PDGAbstractDataDependence)edgeG1).getLoop();
      CFGBranchNode edgeG2LoopNode=((PDGAbstractDataDependence)edgeG2).getLoop();
      if (equalData(edgeG1Variable,edgeG2Variable) || nodeMapping.matchingVariableDifference(edgeG1Variable,edgeG2Variable)) {
        if (edgeG1LoopNode == null && edgeG2LoopNode == null) {
          return true;
        }
 else         if (edgeG1LoopNode != null && edgeG2LoopNode != null) {
          ASTNodeMatcher matcher=new ASTNodeMatcher(nodeMapping.getTypeRoot1(),nodeMapping.getTypeRoot2());
          boolean nodeDiff=edgeG1LoopNode.getASTStatement().subtreeMatch(matcher,edgeG2LoopNode.getASTStatement());
          return nodeDiff;
        }
      }
    }
  }
  return false;
}

Fixed version (ground truth):
public boolean isCompatible(PDGNodeMapping nodeMapping){
  if (edgeG1.getClass() == edgeG2.getClass()) {
    if (edgeG1 instanceof PDGControlDependence) {
      return true;
    }
    if (edgeG1 instanceof PDGAbstractDataDependence) {
      AbstractVariable edgeG1Variable=((PDGAbstractDataDependence)edgeG1).getData();
      AbstractVariable edgeG2Variable=((PDGAbstractDataDependence)edgeG2).getData();
      CFGBranchNode edgeG1LoopNode=((PDGAbstractDataDependence)edgeG1).getLoop();
      CFGBranchNode edgeG2LoopNode=((PDGAbstractDataDependence)edgeG2).getLoop();
      if (equalData(edgeG1Variable,edgeG2Variable) || nodeMapping.matchingVariableDifference(edgeG1Variable,edgeG2Variable)) {
        if (edgeG1LoopNode == null && edgeG2LoopNode == null) {
          return true;
        }
 else         if (edgeG1LoopNode != null && edgeG2LoopNode != null) {
          ASTNodeMatcher astNodeMatcher=new ASTNodeMatcher(nodeMapping.getTypeRoot1(),nodeMapping.getTypeRoot2());
          boolean match=edgeG1LoopNode.getASTStatement().subtreeMatch(astNodeMatcher,edgeG2LoopNode.getASTStatement());
          return match && astNodeMatcher.isParameterizable();
        }
      }
    }
  }
  return false;
}
Program: 12116
Project: 12116
Buggy source:
public MappingState(PDGNodeMapping initialNodeMapping){
  this.nodeMappings=new LinkedHashSet<PDGNodeMapping>();
  this.edgeMappings=new LinkedHashSet<PDGEdgeMapping>();
  this.children=new ArrayList<MappingState>();
  this.nodeMappings.add(initialNodeMapping);
  traverse(this,initialNodeMapping);
}

Fixed version (ground truth):
public MappingState(MappingState previous,PDGNodeMapping initialNodeMapping){
  this.nodeMappings=new LinkedHashSet<PDGNodeMapping>();
  this.edgeMappings=new LinkedHashSet<PDGEdgeMapping>();
  this.children=new ArrayList<MappingState>();
  if (previous != null) {
    nodeMappings.addAll(previous.nodeMappings);
    edgeMappings.addAll(previous.edgeMappings);
  }
  if (!containsAtLeastOneNodeInMappings(initialNodeMapping))   this.nodeMappings.add(initialNodeMapping);
  traverse(this,initialNodeMapping);
}
Program: 12117
Project: 12117
Buggy source:
private void processPDGNodes(){
  Iterator<GraphNode> nodeIterator1=pdg1.getNodeIterator();
  while (nodeIterator1.hasNext()) {
    PDGNode node1=(PDGNode)nodeIterator1.next();
    Iterator<GraphNode> nodeIterator2=pdg2.getNodeIterator();
    while (nodeIterator2.hasNext()) {
      PDGNode node2=(PDGNode)nodeIterator2.next();
      ASTNodeMatcher astNodeMatcher=new ASTNodeMatcher();
      boolean match=node1.getASTStatement().subtreeMatch(astNodeMatcher,node2.getASTStatement());
      if (match) {
        PDGNodeMapping mapping=new PDGNodeMapping(node1,node2,astNodeMatcher.getDifferences());
        MappingState state=new MappingState(mapping);
        List<MappingState> maxStates=state.getMaximumCommonSubgraph();
        if (maximumState == null) {
          maximumState=maxStates.get(0);
        }
 else         if (maxStates.get(0).getSize() > maximumState.getSize()) {
          maximumState=maxStates.get(0);
        }
      }
    }
  }
}

Fixed version (ground truth):
private void processPDGNodes(){
  List<MappingState> finalStates=new ArrayList<MappingState>();
  Iterator<GraphNode> nodeIterator1=pdg1.getNodeIterator();
  while (nodeIterator1.hasNext()) {
    PDGNode node1=(PDGNode)nodeIterator1.next();
    Iterator<GraphNode> nodeIterator2=pdg2.getNodeIterator();
    List<MappingState> currentStates=new ArrayList<MappingState>();
    while (nodeIterator2.hasNext()) {
      PDGNode node2=(PDGNode)nodeIterator2.next();
      ASTNodeMatcher astNodeMatcher=new ASTNodeMatcher();
      boolean match=node1.getASTStatement().subtreeMatch(astNodeMatcher,node2.getASTStatement());
      if (match) {
        PDGNodeMapping mapping=new PDGNodeMapping(node1,node2,astNodeMatcher.getDifferences());
        if (finalStates.isEmpty()) {
          MappingState state=new MappingState(null,mapping);
          List<MappingState> maxStates=state.getMaximumCommonSubGraphs();
          for (          MappingState temp : maxStates) {
            if (!currentStates.contains(temp)) {
              currentStates.add(temp);
            }
          }
        }
 else {
          for (          MappingState previousState : finalStates) {
            MappingState state=new MappingState(previousState,mapping);
            List<MappingState> maxStates=state.getMaximumCommonSubGraphs();
            for (            MappingState temp : maxStates) {
              if (!currentStates.contains(temp)) {
                currentStates.add(temp);
              }
            }
          }
        }
      }
    }
    if (!currentStates.isEmpty())     finalStates=getMaximumStates(currentStates);
  }
  maximumStates=finalStates;
}
Program: 12118
Project: 12118
Buggy source:
public PDGMapper(PDG pdg1,PDG pdg2){
  this.pdg1=pdg1;
  this.pdg2=pdg2;
  processPDGNodes();
}

Fixed version (ground truth):
public PDGMapper(PDG pdg1,PDG pdg2){
  this.pdg1=pdg1;
  this.pdg2=pdg2;
  this.maximumStates=new ArrayList<MappingState>();
  processPDGNodes();
}
Program: 12119
Project: 12119
Buggy source:
public MappingState getMaximumState(){
  return maximumState;
}

Fixed version (ground truth):
public MappingState getMaximumState(){
  MappingState maximumState=null;
  if (maximumStates.size() == 1) {
    maximumState=maximumStates.get(0);
  }
 else {
    int minimum=maximumStates.get(0).getDifferenceCount();
    maximumState=maximumStates.get(0);
    for (int i=1; i < maximumStates.size(); i++) {
      MappingState currentState=maximumStates.get(i);
      if (currentState.getDifferenceCount() < minimum) {
        minimum=currentState.getDifferenceCount();
        maximumState=currentState;
      }
    }
  }
  return maximumState;
}
Program: 12123
Project: 12123
Buggy source:
private Assignment isParentAssignment(ASTNode node){
  if (node.getParent() instanceof Assignment) {
    Assignment assignment=(Assignment)node.getParent();
    if (assignment.getLeftHandSide().subtreeMatch(new ASTMatcher(),node)) {
      return assignment;
    }
 else {
      return null;
    }
  }
 else   if (node.getParent() instanceof MethodDeclaration) {
    return null;
  }
 else {
    return isParentAssignment(node.getParent());
  }
}

Fixed version (ground truth):
private Assignment isParentAssignment(ASTNode node){
  if (node.getParent() instanceof Assignment) {
    Assignment assignment=(Assignment)node.getParent();
    if (assignment.getLeftHandSide().subtreeMatch(new ASTMatcher(),node)) {
      return assignment;
    }
 else {
      return null;
    }
  }
 else   if (node.getParent() instanceof MethodDeclaration || node.getParent() instanceof ArrayAccess) {
    return null;
  }
 else {
    return isParentAssignment(node.getParent());
  }
}
Program: 12127
Project: 12127
Buggy source:
public boolean containsPlainVariable(PlainVariable variable){
  if (this.name.equals(variable.name))   return true;
  return rightPart.containsPlainVariable(variable);
}

Fixed version (ground truth):
public boolean containsPlainVariable(PlainVariable variable){
  if (this.name.equals(variable.name) || this.name.resolveBinding().isEqualTo(variable.name.resolveBinding()))   return true;
  return rightPart.containsPlainVariable(variable);
}
Program: 12128
Project: 12128
Buggy source:
public boolean equals(Object o){
  if (this == o) {
    return true;
  }
  if (o instanceof PlainVariable) {
    PlainVariable plain=(PlainVariable)o;
    return this.name.equals(plain.name);
  }
  return false;
}

Fixed version (ground truth):
public boolean equals(Object o){
  if (this == o) {
    return true;
  }
  if (o instanceof PlainVariable) {
    PlainVariable plain=(PlainVariable)o;
    if (this.name.equals(plain.name) || this.name.resolveBinding().isEqualTo(plain.name.resolveBinding()))     return true;
  }
  return false;
}
Program: 12129
Project: 12129
Buggy source:
public ASTSlice(PDGObjectSliceUnion pdgObjectSliceUnion){
  this.sourceMethodDeclaration=pdgObjectSliceUnion.getMethod().getMethodDeclaration();
  this.sourceTypeDeclaration=(TypeDeclaration)sourceMethodDeclaration.getParent();
  this.sliceNodes=pdgObjectSliceUnion.getSliceNodes();
  this.sliceStatements=new LinkedHashSet<Statement>();
  for (  PDGNode node : sliceNodes) {
    sliceStatements.add(node.getASTStatement());
  }
  this.removableStatements=new LinkedHashSet<Statement>();
  for (  PDGNode node : pdgObjectSliceUnion.getRemovableNodes()) {
    removableStatements.add(node.getASTStatement());
  }
  this.localVariableCriterion=pdgObjectSliceUnion.getObjectReference();
  this.passedParameters=new LinkedHashSet<VariableDeclaration>();
  for (  AbstractVariable variable : pdgObjectSliceUnion.getPassedParameters()) {
    passedParameters.add(variable.getName());
  }
  this.extractedMethodInvocationInsertionStatement=pdgObjectSliceUnion.getExtractedMethodInvocationInsertionNode().getASTStatement();
  this.extractedMethodName=localVariableCriterion.toString().replaceAll("String_Node_Str","String_Node_Str");
  this.declarationOfVariableCriterionBelongsToSliceNodes=pdgObjectSliceUnion.declarationOfObjectReferenceBelongsToSliceNodes();
  this.declarationOfVariableCriterionBelongsToRemovableNodes=pdgObjectSliceUnion.declarationOfObjectReferenceBelongsToRemovableNodes();
  this.iFile=pdgObjectSliceUnion.getIFile();
  this.boundaryBlock=pdgObjectSliceUnion.getBoundaryBlock();
}

Fixed version (ground truth):
public ASTSlice(PDGObjectSliceUnion pdgObjectSliceUnion){
  this.sourceMethodDeclaration=pdgObjectSliceUnion.getMethod().getMethodDeclaration();
  this.sourceTypeDeclaration=(TypeDeclaration)sourceMethodDeclaration.getParent();
  this.sliceNodes=pdgObjectSliceUnion.getSliceNodes();
  this.sliceStatements=new LinkedHashSet<Statement>();
  for (  PDGNode node : sliceNodes) {
    sliceStatements.add(node.getASTStatement());
  }
  this.removableStatements=new LinkedHashSet<Statement>();
  for (  PDGNode node : pdgObjectSliceUnion.getRemovableNodes()) {
    removableStatements.add(node.getASTStatement());
  }
  this.localVariableCriterion=pdgObjectSliceUnion.getObjectReference();
  this.passedParameters=new LinkedHashSet<VariableDeclaration>();
  for (  AbstractVariable variable : pdgObjectSliceUnion.getPassedParameters()) {
    passedParameters.add(variable.getName());
  }
  this.extractedMethodInvocationInsertionStatement=pdgObjectSliceUnion.getExtractedMethodInvocationInsertionNode().getASTStatement();
  this.extractedMethodName=localVariableCriterion.toString().replaceAll("String_Node_Str","String_Node_Str");
  this.declarationOfVariableCriterionBelongsToSliceNodes=pdgObjectSliceUnion.declarationOfObjectReferenceBelongsToSliceNodes();
  this.declarationOfVariableCriterionBelongsToRemovableNodes=pdgObjectSliceUnion.declarationOfObjectReferenceBelongsToRemovableNodes();
  this.iFile=pdgObjectSliceUnion.getIFile();
  this.boundaryBlock=pdgObjectSliceUnion.getBoundaryBlock();
  this.isObjectSlice=true;
}
Program: 12132
Project: 12132
Buggy source:
public void run(){
  IStructuredSelection selection=(IStructuredSelection)tableViewer.getSelection();
  TypeCheckElimination typeCheckElimination=(TypeCheckElimination)selection.getFirstElement();
  IFile sourceFile=typeCheckElimination.getTypeCheckIFile();
  String typeCheckMethodName=typeCheckElimination.toString();
  Statement typeCheckCodeFragment=typeCheckElimination.getTypeCheckCodeFragment();
  try {
    IJavaElement sourceJavaElement=JavaCore.create(sourceFile);
    ITextEditor sourceEditor=(ITextEditor)JavaUI.openInEditor(sourceJavaElement);
    AnnotationModel annotationModel=(AnnotationModel)sourceEditor.getDocumentProvider().getAnnotationModel(sourceEditor.getEditorInput());
    Iterator<Annotation> annotationIterator=annotationModel.getAnnotationIterator();
    while (annotationIterator.hasNext()) {
      Annotation currentAnnotation=annotationIterator.next();
      if (currentAnnotation.getType().equals("String_Node_Str")) {
        annotationModel.removeAnnotation(currentAnnotation);
      }
    }
    Annotation annotation=new Annotation("String_Node_Str",false,typeCheckMethodName);
    Position position=new Position(typeCheckCodeFragment.getStartPosition(),typeCheckCodeFragment.getLength());
    annotationModel.addAnnotation(annotation,position);
    sourceEditor.setHighlightRange(typeCheckCodeFragment.getStartPosition(),typeCheckCodeFragment.getLength(),true);
  }
 catch (  PartInitException e) {
    e.printStackTrace();
  }
catch (  JavaModelException e) {
    e.printStackTrace();
  }
}

Fixed version (ground truth):
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
  typeCheckEliminationResults=systemObject.generateTypeCheckEliminations(monitor);
}
Program: 12133
Project: 12133
Buggy source:
private TypeCheckElimination[] getTable(){
  if (selectedPackage != null)   new ASTReader(selectedPackage);
 else   new ASTReader(selectedProject);
  SystemObject systemObject=ASTReader.getSystemObject();
  typeCheckEliminationResults=systemObject.generateTypeCheckEliminations();
  List<TypeCheckElimination> typeCheckEliminations=typeCheckEliminationResults.getTypeCheckEliminations();
  TypeCheckElimination[] table=new TypeCheckElimination[typeCheckEliminations.size()];
  int i=0;
  for (  TypeCheckElimination typeCheckElimination : typeCheckEliminations) {
    table[i]=typeCheckElimination;
    i++;
  }
  return table;
}

Fixed version (ground truth):
private TypeCheckElimination[] getTable(){
  if (selectedPackage != null)   new ASTReader(selectedPackage);
 else   new ASTReader(selectedProject);
  final SystemObject systemObject=ASTReader.getSystemObject();
  IWorkbenchWindow window=getSite().getWorkbenchWindow();
  try {
    window.getWorkbench().getProgressService().run(true,true,new IRunnableWithProgress(){
      public void run(      IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
        typeCheckEliminationResults=systemObject.generateTypeCheckEliminations(monitor);
      }
    }
);
  }
 catch (  InvocationTargetException e) {
    e.printStackTrace();
  }
catch (  InterruptedException e) {
    e.printStackTrace();
  }
  List<TypeCheckElimination> typeCheckEliminations=typeCheckEliminationResults.getTypeCheckEliminations();
  TypeCheckElimination[] table=new TypeCheckElimination[typeCheckEliminations.size()];
  int i=0;
  for (  TypeCheckElimination typeCheckElimination : typeCheckEliminations) {
    table[i]=typeCheckElimination;
    i++;
  }
  return table;
}
Program: 12135
Project: 12135
Buggy source:
private void aliasSearch(PDGNode currentNode,boolean visitedFromLoopbackFlow,ReachingAliasSet reachingAliasSet){
  CFGNode currentCFGNode=currentNode.getCFGNode();
  for (  GraphEdge edge : currentCFGNode.outgoingEdges) {
    Flow flow=(Flow)edge;
    if (!visitedFromLoopbackFlow || (visitedFromLoopbackFlow && flow.isFalseControlFlow())) {
      CFGNode dstCFGNode=(CFGNode)flow.dst;
      PDGNode dstPDGNode=dstCFGNode.getPDGNode();
      ReachingAliasSet reachingAliasSetCopy=reachingAliasSet.copy();
      dstPDGNode.applyReachingAliasSet(reachingAliasSetCopy);
      dstPDGNode.updateReachingAliasSet(reachingAliasSetCopy);
      if (flow.isLoopbackFlow())       aliasSearch(dstPDGNode,true,reachingAliasSetCopy);
 else       aliasSearch(dstPDGNode,false,reachingAliasSetCopy);
    }
  }
}

Fixed version (ground truth):
private void aliasSearch(PDGNode currentNode,boolean visitedFromLoopbackFlow,ReachingAliasSet reachingAliasSet){
  CFGNode currentCFGNode=currentNode.getCFGNode();
  for (  GraphEdge edge : currentCFGNode.outgoingEdges) {
    Flow flow=(Flow)edge;
    if (!visitedFromLoopbackFlow || (visitedFromLoopbackFlow && flow.isFalseControlFlow())) {
      CFGNode srcCFGNode=(CFGNode)flow.src;
      CFGNode dstCFGNode=(CFGNode)flow.dst;
      PDGNode dstPDGNode=dstCFGNode.getPDGNode();
      ReachingAliasSet reachingAliasSetCopy=reachingAliasSet.copy();
      dstPDGNode.applyReachingAliasSet(reachingAliasSetCopy);
      dstPDGNode.updateReachingAliasSet(reachingAliasSetCopy);
      if (!(srcCFGNode instanceof CFGBranchDoLoopNode && flow.isTrueControlFlow())) {
        if (flow.isLoopbackFlow())         aliasSearch(dstPDGNode,true,reachingAliasSetCopy);
 else         aliasSearch(dstPDGNode,false,reachingAliasSetCopy);
      }
    }
  }
}