nus-yam/ex-repair huggingface dataset:
Program: 62188
Project: 62188
Buggy source:
@Override public void translate(boolean isStatic,int scriptIndex,int classIndex,java.util.HashMap<Integer,GraphTargetItem> localRegs,Stack<GraphTargetItem> stack,java.util.Stack<GraphTargetItem> scopeStack,ConstantPool constants,AVM2Instruction ins,MethodInfo[] method_info,List<GraphTargetItem> output,com.jpexs.decompiler.flash.abc.types.MethodBody body,com.jpexs.decompiler.flash.abc.ABC abc,HashMap<Integer,String> localRegNames,List<String> fullyQualifiedNames){
  int regIndex=ins.operands[0];
  output.add(new IncLocalTreeItem(ins,regIndex));
  if (localRegs.containsKey(regIndex)) {
    localRegs.put(regIndex,new NotCompileTimeTreeItem(ins,new AddTreeItem(ins,localRegs.get(regIndex),new IntegerValueTreeItem(ins,new Long(1)))));
  }
 else {
    localRegs.put(regIndex,new AddTreeItem(ins,localRegs.get(regIndex),new IntegerValueTreeItem(ins,new Long(1))));
  }
}

Fixed version (ground truth):
@Override public void translate(boolean isStatic,int scriptIndex,int classIndex,java.util.HashMap<Integer,GraphTargetItem> localRegs,Stack<GraphTargetItem> stack,java.util.Stack<GraphTargetItem> scopeStack,ConstantPool constants,AVM2Instruction ins,MethodInfo[] method_info,List<GraphTargetItem> output,com.jpexs.decompiler.flash.abc.types.MethodBody body,com.jpexs.decompiler.flash.abc.ABC abc,HashMap<Integer,String> localRegNames,List<String> fullyQualifiedNames){
  int regIndex=ins.operands[0];
  output.add(new IncLocalTreeItem(ins,regIndex));
  if (localRegs.containsKey(regIndex)) {
    localRegs.put(regIndex,new NotCompileTimeTreeItem(ins,new AddTreeItem(ins,localRegs.get(regIndex),new IntegerValueTreeItem(ins,new Long(1)))));
  }
 else {
    localRegs.put(regIndex,new AddTreeItem(ins,new IntegerValueTreeItem(ins,new Long(0)),new IntegerValueTreeItem(ins,new Long(1))));
  }
}
Program: 62189
Project: 62189
Buggy source:
@Override public void translate(boolean isStatic,int scriptIndex,int classIndex,java.util.HashMap<Integer,GraphTargetItem> localRegs,Stack<GraphTargetItem> stack,java.util.Stack<GraphTargetItem> scopeStack,ConstantPool constants,AVM2Instruction ins,MethodInfo[] method_info,List<GraphTargetItem> output,com.jpexs.decompiler.flash.abc.types.MethodBody body,com.jpexs.decompiler.flash.abc.ABC abc,HashMap<Integer,String> localRegNames,List<String> fullyQualifiedNames){
  int regIndex=ins.operands[0];
  output.add(new IncLocalTreeItem(ins,regIndex));
  if (localRegs.containsKey(regIndex)) {
    localRegs.put(regIndex,new NotCompileTimeTreeItem(ins,new AddTreeItem(ins,localRegs.get(regIndex),new IntegerValueTreeItem(ins,new Long(1)))));
  }
 else {
    localRegs.put(regIndex,new AddTreeItem(ins,localRegs.get(regIndex),new IntegerValueTreeItem(ins,new Long(1))));
  }
}

Fixed version (ground truth):
@Override public void translate(boolean isStatic,int scriptIndex,int classIndex,java.util.HashMap<Integer,GraphTargetItem> localRegs,Stack<GraphTargetItem> stack,java.util.Stack<GraphTargetItem> scopeStack,ConstantPool constants,AVM2Instruction ins,MethodInfo[] method_info,List<GraphTargetItem> output,com.jpexs.decompiler.flash.abc.types.MethodBody body,com.jpexs.decompiler.flash.abc.ABC abc,HashMap<Integer,String> localRegNames,List<String> fullyQualifiedNames){
  int regIndex=ins.operands[0];
  output.add(new IncLocalTreeItem(ins,regIndex));
  if (localRegs.containsKey(regIndex)) {
    localRegs.put(regIndex,new NotCompileTimeTreeItem(ins,new AddTreeItem(ins,localRegs.get(regIndex),new IntegerValueTreeItem(ins,new Long(1)))));
  }
 else {
    localRegs.put(regIndex,new AddTreeItem(ins,new IntegerValueTreeItem(ins,new Long(0)),new IntegerValueTreeItem(ins,new Long(1))));
  }
}
Program: 62190
Project: 62190
Buggy source:
public ActionTry(long containerSWFPos,boolean ignoreNops,List<Label> labels,long address,FlasmLexer lexer,List<String> constantPool,int version) throws IOException, ParseException {
  super(0x8F,0);
  this.version=version;
  ASMParsedSymbol symb=lexer.yylex();
  if (symb.type == ASMParsedSymbol.TYPE_STRING) {
    catchInRegisterFlag=false;
    catchName=(String)symb.value;
  }
 else   if (symb.type == ASMParsedSymbol.TYPE_REGISTER) {
    catchRegister=(Integer)symb.value;
    catchInRegisterFlag=true;
  }
 else   if (symb.type == ASMParsedSymbol.TYPE_BLOCK_START) {
    return;
  }
 else {
    throw new ParseException("String_Node_Str",lexer.yyline());
  }
  lexBlockOpen(lexer);
}

Fixed version (ground truth):
public ActionTry(long containerSWFPos,boolean ignoreNops,List<Label> labels,long address,FlasmLexer lexer,List<String> constantPool,int version) throws IOException, ParseException {
  super(0x8F,0);
  this.version=version;
  ASMParsedSymbol symb=lexer.yylex();
  if (symb.type == ASMParsedSymbol.TYPE_STRING) {
    catchInRegisterFlag=false;
    catchName=(String)symb.value;
  }
 else   if (symb.type == ASMParsedSymbol.TYPE_REGISTER) {
    catchRegister=((RegisterNumber)symb.value).number;
    catchInRegisterFlag=true;
  }
 else   if (symb.type == ASMParsedSymbol.TYPE_BLOCK_START) {
    return;
  }
 else {
    throw new ParseException("String_Node_Str",lexer.yyline());
  }
  lexBlockOpen(lexer);
}
Program: 62191
Project: 62191
Buggy source:
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem target=stack.pop();
  GraphTargetItem lockCenter=stack.pop();
  GraphTargetItem constrain=stack.pop();
  boolean hasConstrains=true;
  if (constrain instanceof DirectValueTreeItem) {
    if (((DirectValueTreeItem)constrain).value instanceof Long) {
      if (((long)(Long)((DirectValueTreeItem)constrain).value) == 0) {
        hasConstrains=false;
      }
    }
    if (((DirectValueTreeItem)constrain).value instanceof Boolean) {
      if (((boolean)(Boolean)((DirectValueTreeItem)constrain).value) == false) {
        hasConstrains=false;
      }
    }
  }
  GraphTargetItem x1=null;
  GraphTargetItem y1=null;
  GraphTargetItem x2=null;
  GraphTargetItem y2=null;
  if (hasConstrains) {
    y2=stack.pop();
    x2=stack.pop();
    y1=stack.pop();
    x1=stack.pop();
  }
  output.add(new StartDragTreeItem(this,target,lockCenter,constrain,x1,y1,x2,y2));
}

Fixed version (ground truth):
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem target=stack.pop();
  GraphTargetItem lockCenter=stack.pop();
  GraphTargetItem constrain=stack.pop();
  boolean hasConstrains=true;
  if (constrain instanceof DirectValueTreeItem) {
    if (Double.compare(constrain.toNumber(),0) == 0) {
      hasConstrains=false;
    }
  }
  GraphTargetItem x1=null;
  GraphTargetItem y1=null;
  GraphTargetItem x2=null;
  GraphTargetItem y2=null;
  if (hasConstrains) {
    y2=stack.pop();
    x2=stack.pop();
    y1=stack.pop();
    x1=stack.pop();
  }
  output.add(new StartDragTreeItem(this,target,lockCenter,constrain,x1,y1,x2,y2));
}
Program: 62192
Project: 62192
Buggy source:
@Override public String toString(ConstantPool constants){
  boolean hasConstrains=true;
  if (constrain instanceof DirectValueTreeItem) {
    if (((DirectValueTreeItem)constrain).value instanceof Long) {
      if (((long)(Long)((DirectValueTreeItem)constrain).value) == 0) {
        hasConstrains=false;
      }
    }
    if (((DirectValueTreeItem)constrain).value instanceof Boolean) {
      if (((boolean)(Boolean)((DirectValueTreeItem)constrain).value) == false) {
        hasConstrains=false;
      }
    }
  }
  return hilight("String_Node_Str") + target.toString(constants) + hilight("String_Node_Str")+ lockCenter.toString(constants)+ (hasConstrains ? hilight("String_Node_Str") + x1.toString(constants) + hilight("String_Node_Str")+ y1.toString(constants)+ hilight("String_Node_Str")+ x2.toString(constants)+ hilight("String_Node_Str")+ y2.toString(constants) : "String_Node_Str")+ hilight("String_Node_Str");
}

Fixed version (ground truth):
@Override public String toString(ConstantPool constants){
  boolean hasConstrains=true;
  if (constrain instanceof DirectValueTreeItem) {
    if (Double.compare(constrain.toNumber(),0) == 0) {
      hasConstrains=false;
    }
  }
  return hilight("String_Node_Str") + target.toString(constants) + hilight("String_Node_Str")+ lockCenter.toString(constants)+ (hasConstrains ? hilight("String_Node_Str") + x1.toString(constants) + hilight("String_Node_Str")+ y1.toString(constants)+ hilight("String_Node_Str")+ x2.toString(constants)+ hilight("String_Node_Str")+ y2.toString(constants) : "String_Node_Str")+ hilight("String_Node_Str");
}
Program: 62193
Project: 62193
Buggy source:
@Override public void setImage(byte data[]){
  imageData=data;
  if (ImageTag.getImageFormat(data).equals("String_Node_Str")) {
    BufferedImage image=getImage(new ArrayList<Tag>());
    bitmapAlphaData=new byte[image.getWidth() * image.getHeight()];
    for (int i=0; i < bitmapAlphaData.length; i++) {
      bitmapAlphaData[i]=(byte)255;
    }
  }
 else {
    bitmapAlphaData=new byte[0];
  }
}

Fixed version (ground truth):
@Override public void setImage(byte data[]){
  imageData=data;
  if (ImageTag.getImageFormat(data).equals("String_Node_Str")) {
    BufferedImage image=getImage(new ArrayList<Tag>());
    byte ba[]=new byte[image.getWidth() * image.getHeight()];
    for (int i=0; i < ba.length; i++) {
      ba[i]=(byte)255;
    }
    ByteArrayOutputStream baos=new ByteArrayOutputStream();
    SWFOutputStream sos=new SWFOutputStream(baos,SWF.DEFAULT_VERSION);
    try {
      sos.writeBytesZlib(ba);
    }
 catch (    IOException ex) {
      Logger.getLogger(DefineBitsJPEG3Tag.class.getName()).log(Level.SEVERE,null,ex);
    }
    bitmapAlphaData=baos.toByteArray();
  }
 else {
    bitmapAlphaData=new byte[0];
  }
}
Program: 62194
Project: 62194
Buggy source:
@Override public void setImage(byte data[]){
  imageData=data;
  if (ImageTag.getImageFormat(data).equals("String_Node_Str")) {
    BufferedImage image=getImage(new ArrayList<Tag>());
    bitmapAlphaData=new byte[image.getWidth() * image.getHeight()];
    for (int i=0; i < bitmapAlphaData.length; i++) {
      bitmapAlphaData[i]=(byte)255;
    }
  }
 else {
    bitmapAlphaData=new byte[0];
  }
}

Fixed version (ground truth):
@Override public void setImage(byte data[]){
  imageData=data;
  if (ImageTag.getImageFormat(data).equals("String_Node_Str")) {
    BufferedImage image=getImage(new ArrayList<Tag>());
    byte ba[]=new byte[image.getWidth() * image.getHeight()];
    for (int i=0; i < ba.length; i++) {
      ba[i]=(byte)255;
    }
    ByteArrayOutputStream baos=new ByteArrayOutputStream();
    SWFOutputStream sos=new SWFOutputStream(baos,SWF.DEFAULT_VERSION);
    try {
      sos.writeBytesZlib(ba);
    }
 catch (    IOException ex) {
      Logger.getLogger(DefineBitsJPEG4Tag.class.getName()).log(Level.SEVERE,null,ex);
    }
    bitmapAlphaData=baos.toByteArray();
  }
 else {
    bitmapAlphaData=new byte[0];
  }
}
Program: 62198
Project: 62198
Buggy source:
public int removeTraps(){
  int rem=0;
  for (  MethodBody body : bodies) {
    rem+=body.removeTraps(constants,this);
  }
  return rem;
}

Fixed version (ground truth):
public int removeTraps(){
  int rem=0;
  for (int s=0; s < script_info.length; s++) {
    rem+=script_info[s].removeTraps(s,this);
  }
  return rem;
}
Program: 62199
Project: 62199
Buggy source:
public static int removeTraps(List localData,AVM2GraphSource code,int addr){
  HashMap<GraphSourceItem,AVM2Code.Decision> decisions=new HashMap<GraphSourceItem,AVM2Code.Decision>();
  removeTraps(false,false,localData,new Stack<GraphTargetItem>(),new ArrayList<GraphTargetItem>(),code,code.adr2pos(addr),0,new HashMap<Integer,Integer>(),new HashMap<Integer,HashMap<Integer,GraphTargetItem>>(),decisions);
  localData.set(2,new HashMap<Integer,GraphTargetItem>());
  return removeTraps(true,true,localData,new Stack<GraphTargetItem>(),new ArrayList<GraphTargetItem>(),code,code.adr2pos(addr),0,new HashMap<Integer,Integer>(),new HashMap<Integer,HashMap<Integer,GraphTargetItem>>(),decisions);
}

Fixed version (ground truth):
public static int removeTraps(List localData,AVM2GraphSource code,int addr){
  HashMap<GraphSourceItem,AVM2Code.Decision> decisions=new HashMap<GraphSourceItem,AVM2Code.Decision>();
  removeTraps(false,false,localData,new Stack<GraphTargetItem>(),new ArrayList<GraphTargetItem>(),code,code.adr2pos(addr),0,new HashMap<Integer,Integer>(),new HashMap<Integer,HashMap<Integer,GraphTargetItem>>(),decisions);
  localData.set(2,new HashMap<Integer,GraphTargetItem>());
  return removeTraps(true,false,localData,new Stack<GraphTargetItem>(),new ArrayList<GraphTargetItem>(),code,code.adr2pos(addr),0,new HashMap<Integer,Integer>(),new HashMap<Integer,HashMap<Integer,GraphTargetItem>>(),decisions);
}
Program: 62201
Project: 62201
Buggy source:
private boolean displayMethod(int pos,int methodIndex,String name,Trait trait){
  if (abc == null) {
    return false;
  }
  int bi=abc.findBodyIndex(methodIndex);
  if (bi == -1) {
    return false;
  }
  abcPanel.detailPanel.showCard(DetailPanel.METHOD_TRAIT_CARD,trait);
  if (reset || (abcPanel.detailPanel.methodTraitPanel.methodCodePanel.getBodyIndex() != bi)) {
    abcPanel.detailPanel.methodTraitPanel.methodCodePanel.setBodyIndex(bi,abc,name);
    abcPanel.detailPanel.methodTraitPanel.methodBodyParamsPanel.loadFromBody(abc.bodies[bi]);
    abcPanel.detailPanel.methodTraitPanel.methodInfoPanel.load(abc.bodies[bi].method_info,abc);
    abcPanel.detailPanel.setEditMode(false);
  }
  boolean success=false;
  for (  Highlighting h : highlights) {
    if ((pos >= h.startPos) && (pos < h.startPos + h.len)) {
      abcPanel.detailPanel.methodTraitPanel.methodCodePanel.hilighOffset(h.offset);
      success=true;
    }
  }
  return success;
}

Fixed version (ground truth):
private boolean displayMethod(int pos,int methodIndex,String name,Trait trait,boolean isStatic){
  if (abc == null) {
    return false;
  }
  int bi=abc.findBodyIndex(methodIndex);
  if (bi == -1) {
    return false;
  }
  abcPanel.detailPanel.showCard(DetailPanel.METHOD_TRAIT_CARD,trait);
  if (reset || (abcPanel.detailPanel.methodTraitPanel.methodCodePanel.getBodyIndex() != bi)) {
    abcPanel.detailPanel.methodTraitPanel.methodCodePanel.setBodyIndex(bi,abc,name);
    abcPanel.detailPanel.methodTraitPanel.methodBodyParamsPanel.loadFromBody(abc.bodies[bi]);
    abcPanel.detailPanel.methodTraitPanel.methodInfoPanel.load(abc.bodies[bi].method_info,abc);
    abcPanel.detailPanel.setEditMode(false);
    this.isStatic=isStatic;
  }
  boolean success=false;
  for (  Highlighting h : highlights) {
    if ((pos >= h.startPos) && (pos < h.startPos + h.len)) {
      abcPanel.detailPanel.methodTraitPanel.methodCodePanel.hilighOffset(h.offset);
      success=true;
    }
  }
  return success;
}
Program: 62202
Project: 62202
Buggy source:
public int removeTraps(ConstantPool constants,ABC abc){
  return code.removeTraps(constants,this,abc);
}

Fixed version (ground truth):
public int removeTraps(ConstantPool constants,ABC abc,int scriptIndex,int classIndex,boolean isStatic){
  return code.removeTraps(constants,this,abc,scriptIndex,classIndex,isStatic);
}
Program: 62203
Project: 62203
Buggy source:
public String toString(String path,boolean pcode,boolean isStatic,int scriptIndex,int classIndex,ABC abc,ConstantPool constants,MethodInfo method_info[],Stack<GraphTargetItem> scopeStack,boolean isStaticInitializer,boolean hilight,List<String> fullyQualifiedNames,Traits initTraits){
  String s="String_Node_Str";
  if (!Main.DO_DECOMPILE) {
    s="String_Node_Str";
    if (hilight) {
      s=Highlighting.hilighMethod(s,this.method_info);
    }
    return s;
  }
  if (pcode) {
    s+=code.toASMSource(constants,this,false);
  }
 else {
    AVM2Code deobfuscated=null;
    MethodBody b=(MethodBody)Helper.deepCopy(this);
    deobfuscated=b.code;
    deobfuscated.markMappedOffsets();
    if ((Boolean)Configuration.getConfig("String_Node_Str",true)) {
      deobfuscated.removeTraps(constants,b,abc);
    }
    try {
      s+=deobfuscated.toSource(path,isStatic,scriptIndex,classIndex,abc,constants,method_info,b,hilight,getLocalRegNames(abc),scopeStack,isStaticInitializer,fullyQualifiedNames,initTraits);
      s=s.trim();
      if (hilight) {
        s=Highlighting.hilighMethod(s,this.method_info);
      }
    }
 catch (    Exception ex) {
      ex.printStackTrace();
      s="String_Node_Str" + ex.toString();
    }
  }
  return s;
}

Fixed version (ground truth):
public String toString(String path,boolean pcode,boolean isStatic,int scriptIndex,int classIndex,ABC abc,ConstantPool constants,MethodInfo method_info[],Stack<GraphTargetItem> scopeStack,boolean isStaticInitializer,boolean hilight,List<String> fullyQualifiedNames,Traits initTraits){
  String s="String_Node_Str";
  if (!Main.DO_DECOMPILE) {
    s="String_Node_Str";
    if (hilight) {
      s=Highlighting.hilighMethod(s,this.method_info);
    }
    return s;
  }
  if (pcode) {
    s+=code.toASMSource(constants,this,false);
  }
 else {
    AVM2Code deobfuscated=null;
    MethodBody b=(MethodBody)Helper.deepCopy(this);
    deobfuscated=b.code;
    deobfuscated.markMappedOffsets();
    if ((Boolean)Configuration.getConfig("String_Node_Str",true)) {
      try {
        deobfuscated.removeTraps(constants,b,abc,scriptIndex,classIndex,isStatic);
      }
 catch (      Exception ex) {
        Logger.getLogger(MethodBody.class.getName()).log(Level.SEVERE,"String_Node_Str",ex);
      }
    }
    try {
      s+=deobfuscated.toSource(path,isStatic,scriptIndex,classIndex,abc,constants,method_info,b,hilight,getLocalRegNames(abc),scopeStack,isStaticInitializer,fullyQualifiedNames,initTraits);
      s=s.trim();
      if (hilight) {
        s=Highlighting.hilighMethod(s,this.method_info);
      }
    }
 catch (    Exception ex) {
      ex.printStackTrace();
      s="String_Node_Str" + ex.toString();
    }
  }
  return s;
}
Program: 62204
Project: 62204
Buggy source:
public boolean exportAS3Class(String className,String outdir,boolean isPcode) throws Exception {
  List<ABCContainerTag> abcTags=new ArrayList<ABCContainerTag>();
  for (  Tag t : tags) {
    if (t instanceof ABCContainerTag) {
      ABCContainerTag cnt=(ABCContainerTag)t;
      abcTags.add(cnt);
    }
  }
  for (int i=0; i < abcTags.size(); i++) {
    ABC abc=abcTags.get(i).getABC();
    int scriptIndex=abc.findScriptByPath(className);
    if (scriptIndex > -1) {
      String cnt="String_Node_Str";
      if (abc.script_info.length > 1) {
        cnt="String_Node_Str" + (i + 1) + "String_Node_Str"+ abc.script_info.length+ "String_Node_Str";
      }
      String path=abc.script_info[scriptIndex].getPath(abc);
      String packageName=path.substring(0,path.lastIndexOf("String_Node_Str"));
      if (packageName.equals("String_Node_Str")) {
        path=path.substring(1);
      }
      String exStr="String_Node_Str" + "String_Node_Str" + (i + 1) + "String_Node_Str"+ abcTags.size()+ "String_Node_Str"+ cnt+ path+ "String_Node_Str";
      informListeners("String_Node_Str",exStr);
      abc.script_info[scriptIndex].export(abc,abcTags,outdir,isPcode);
      return true;
    }
  }
  return false;
}

Fixed version (ground truth):
public boolean exportAS3Class(String className,String outdir,boolean isPcode) throws Exception {
  List<ABCContainerTag> abcTags=new ArrayList<ABCContainerTag>();
  for (  Tag t : tags) {
    if (t instanceof ABCContainerTag) {
      ABCContainerTag cnt=(ABCContainerTag)t;
      abcTags.add(cnt);
    }
  }
  for (int i=0; i < abcTags.size(); i++) {
    ABC abc=abcTags.get(i).getABC();
    int scriptIndex=abc.findScriptByPath(className);
    if (scriptIndex > -1) {
      String cnt="String_Node_Str";
      if (abc.script_info.length > 1) {
        cnt="String_Node_Str" + (i + 1) + "String_Node_Str"+ abc.script_info.length+ "String_Node_Str";
      }
      String path=abc.script_info[scriptIndex].getPath(abc);
      String packageName=path.substring(0,path.lastIndexOf("String_Node_Str"));
      if (packageName.equals("String_Node_Str")) {
        path=path.substring(1);
      }
      String exStr="String_Node_Str" + "String_Node_Str" + (i + 1) + "String_Node_Str"+ abcTags.size()+ "String_Node_Str"+ cnt+ path+ "String_Node_Str";
      informListeners("String_Node_Str",exStr);
      abc.script_info[scriptIndex].export(abc,abcTags,outdir,isPcode,scriptIndex);
      return true;
    }
  }
  return false;
}
Program: 62205
Project: 62205
Buggy source:
public void export(String directory,boolean pcode,List<ABCContainerTag> abcList,String abcStr) throws IOException {
  for (int i=0; i < script_info.length; i++) {
    String path=script_info[i].getPath(this);
    String packageName=path.substring(0,path.lastIndexOf("String_Node_Str"));
    if (packageName.equals("String_Node_Str")) {
      path=path.substring(1);
    }
    String cnt="String_Node_Str";
    if (script_info.length > 1) {
      cnt="String_Node_Str" + (i + 1) + "String_Node_Str"+ script_info.length+ "String_Node_Str";
    }
    String exStr="String_Node_Str" + abcStr + cnt+ path+ "String_Node_Str";
    informListeners("String_Node_Str",exStr);
    script_info[i].export(this,abcList,directory,pcode);
  }
}

Fixed version (ground truth):
public void export(String directory,boolean pcode,List<ABCContainerTag> abcList,String abcStr) throws IOException {
  for (int i=0; i < script_info.length; i++) {
    String path=script_info[i].getPath(this);
    String packageName=path.substring(0,path.lastIndexOf("String_Node_Str"));
    if (packageName.equals("String_Node_Str")) {
      path=path.substring(1);
    }
    String cnt="String_Node_Str";
    if (script_info.length > 1) {
      cnt="String_Node_Str" + (i + 1) + "String_Node_Str"+ script_info.length+ "String_Node_Str";
    }
    String exStr="String_Node_Str" + abcStr + cnt+ path+ "String_Node_Str";
    informListeners("String_Node_Str",exStr);
    script_info[i].export(this,abcList,directory,pcode,i);
  }
}
Program: 62208
Project: 62208
Buggy source:
public AVM2Graph(AVM2Code code,ABC abc,MethodBody body,boolean isStatic,int classIndex,HashMap<Integer,GraphTargetItem> localRegs,Stack<GraphTargetItem> scopeStack,HashMap<Integer,String> localRegNames,List<String> fullyQualifiedNames){
  super(new AVM2GraphSource(code,isStatic,classIndex,localRegs,scopeStack,abc,body,localRegNames,fullyQualifiedNames),body.getExceptionEntries());
  this.code=code;
  this.abc=abc;
  this.body=body;
}

Fixed version (ground truth):
public AVM2Graph(AVM2Code code,ABC abc,MethodBody body,boolean isStatic,int scriptIndex,int classIndex,HashMap<Integer,GraphTargetItem> localRegs,Stack<GraphTargetItem> scopeStack,HashMap<Integer,String> localRegNames,List<String> fullyQualifiedNames){
  super(new AVM2GraphSource(code,isStatic,scriptIndex,classIndex,localRegs,scopeStack,abc,body,localRegNames,fullyQualifiedNames),body.getExceptionEntries());
  this.code=code;
  this.abc=abc;
  this.body=body;
}
Program: 62209
Project: 62209
Buggy source:
public static List<GraphTargetItem> translateViaGraph(String path,AVM2Code code,ABC abc,MethodBody body,boolean isStatic,int classIndex,HashMap<Integer,GraphTargetItem> localRegs,Stack<GraphTargetItem> scopeStack,HashMap<Integer,String> localRegNames,List<String> fullyQualifiedNames){
  AVM2Graph g=new AVM2Graph(code,abc,body,isStatic,classIndex,localRegs,scopeStack,localRegNames,fullyQualifiedNames);
  List<GraphPart> allParts=new ArrayList<GraphPart>();
  for (  GraphPart head : g.heads) {
    populateParts(head,allParts);
  }
  List localData=new ArrayList();
  localData.add((Boolean)isStatic);
  localData.add((Integer)classIndex);
  localData.add(localRegs);
  localData.add(scopeStack);
  localData.add(abc.constants);
  localData.add(abc.method_info);
  localData.add(body);
  localData.add(abc);
  localData.add(localRegNames);
  localData.add(fullyQualifiedNames);
  localData.add(new ArrayList<ABCException>());
  localData.add(new ArrayList<Integer>());
  localData.add(new ArrayList<Integer>());
  return g.translate(localData);
}

Fixed version (ground truth):
public static List<GraphTargetItem> translateViaGraph(String path,AVM2Code code,ABC abc,MethodBody body,boolean isStatic,int scriptIndex,int classIndex,HashMap<Integer,GraphTargetItem> localRegs,Stack<GraphTargetItem> scopeStack,HashMap<Integer,String> localRegNames,List<String> fullyQualifiedNames){
  AVM2Graph g=new AVM2Graph(code,abc,body,isStatic,scriptIndex,classIndex,localRegs,scopeStack,localRegNames,fullyQualifiedNames);
  List<GraphPart> allParts=new ArrayList<GraphPart>();
  for (  GraphPart head : g.heads) {
    populateParts(head,allParts);
  }
  List localData=new ArrayList();
  localData.add((Boolean)isStatic);
  localData.add((Integer)classIndex);
  localData.add(localRegs);
  localData.add(scopeStack);
  localData.add(abc.constants);
  localData.add(abc.method_info);
  localData.add(body);
  localData.add(abc);
  localData.add(localRegNames);
  localData.add(fullyQualifiedNames);
  localData.add(new ArrayList<ABCException>());
  localData.add(new ArrayList<Integer>());
  localData.add(new ArrayList<Integer>());
  localData.add((Integer)scriptIndex);
  return g.translate(localData);
}
Program: 62210
Project: 62210
Buggy source:
@Override public void translate(boolean isStatic,int classIndex,java.util.HashMap<Integer,GraphTargetItem> localRegs,Stack<GraphTargetItem> stack,java.util.Stack<GraphTargetItem> scopeStack,ConstantPool constants,AVM2Instruction ins,MethodInfo[] method_info,List<GraphTargetItem> output,com.jpexs.decompiler.flash.abc.types.MethodBody body,com.jpexs.decompiler.flash.abc.ABC abc,HashMap<Integer,String> localRegNames,List<String> fullyQualifiedNames){
  stack.push(new BooleanTreeItem(ins,Boolean.TRUE));
}

Fixed version (ground truth):
@Override public void translate(boolean isStatic,int classIndex,java.util.HashMap<Integer,GraphTargetItem> localRegs,Stack<GraphTargetItem> stack,java.util.Stack<GraphTargetItem> scopeStack,ConstantPool constants,AVM2Instruction ins,MethodInfo[] method_info,List<GraphTargetItem> output,com.jpexs.decompiler.flash.abc.types.MethodBody body,com.jpexs.decompiler.flash.abc.ABC abc,HashMap<Integer,String> localRegNames,List<String> fullyQualifiedNames){
}
Program: 62212
Project: 62212
Buggy source:
private void decompileMethod(String methodName,String expectedResult,boolean isStatic){
  int bodyIndex=abc.findMethodBodyByName(clsIndex,methodName);
  assertTrue(bodyIndex > -1);
  String actualResult=abc.bodies[bodyIndex].toString(methodName,false,isStatic,clsIndex,abc,abc.constants,abc.method_info,new Stack<GraphTargetItem>(),false,false,new ArrayList<String>(),abc.instance_info[clsIndex].instance_traits);
  actualResult=actualResult.replaceAll("String_Node_Str","String_Node_Str");
  expectedResult=expectedResult.replaceAll("String_Node_Str","String_Node_Str");
  assertEquals(expectedResult,actualResult);
}

Fixed version (ground truth):
private void decompileMethod(String methodName,String expectedResult,boolean isStatic){
  int bodyIndex=abc.findMethodBodyByName(clsIndex,methodName);
  assertTrue(bodyIndex > -1);
  String actualResult=abc.bodies[bodyIndex].toString(methodName,false,isStatic,clsIndex,abc,abc.constants,abc.method_info,new Stack<GraphTargetItem>(),false,false,new ArrayList<String>(),abc.instance_info[clsIndex].instance_traits);
  actualResult=actualResult.replaceAll("String_Node_Str","String_Node_Str");
  expectedResult=expectedResult.replaceAll("String_Node_Str","String_Node_Str");
  assertEquals(actualResult,expectedResult);
}
Program: 62213
Project: 62213
Buggy source:
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem name=stack.pop();
  GraphTargetItem computedVal=variables.get(Highlighting.stripHilights(name.toStringNoQuotes(null)));
  GetVariableTreeItem gvt=new GetVariableTreeItem(this,name);
  gvt.setComputedValue(computedVal);
  stack.push(gvt);
}

Fixed version (ground truth):
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem name=stack.pop();
  GraphTargetItem computedVal=variables.get(Highlighting.stripHilights(name.toStringNoQuotes((ConstantPool)null)));
  GetVariableTreeItem gvt=new GetVariableTreeItem(this,name);
  gvt.setComputedValue(computedVal);
  stack.push(gvt);
}
Program: 62214
Project: 62214
Buggy source:
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem value=stack.pop();
  GraphTargetItem name=stack.pop();
  SetVariableTreeItem svt=new SetVariableTreeItem(this,name,value);
  variables.put(Highlighting.stripHilights(name.toStringNoQuotes(null)),value);
  output.add(svt);
}

Fixed version (ground truth):
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem value=stack.pop();
  GraphTargetItem name=stack.pop();
  SetVariableTreeItem svt=new SetVariableTreeItem(this,name,value);
  variables.put(Highlighting.stripHilights(name.toStringNoQuotes((ConstantPool)null)),value);
  output.add(svt);
}
Program: 62215
Project: 62215
Buggy source:
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem functionName=stack.pop();
  long numArgs=popLong(stack);
  List<GraphTargetItem> args=new ArrayList<GraphTargetItem>();
  for (long l=0; l < numArgs; l++) {
    args.add(stack.pop());
  }
  CallFunctionTreeItem cft=new CallFunctionTreeItem(this,functionName,args);
  cft.calculatedFunction=functions.get(Highlighting.stripHilights(functionName.toStringNoQuotes(null)));
  stack.push(cft);
}

Fixed version (ground truth):
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem functionName=stack.pop();
  long numArgs=popLong(stack);
  List<GraphTargetItem> args=new ArrayList<GraphTargetItem>();
  for (long l=0; l < numArgs; l++) {
    args.add(stack.pop());
  }
  CallFunctionTreeItem cft=new CallFunctionTreeItem(this,functionName,args);
  cft.calculatedFunction=functions.get(Highlighting.stripHilights(functionName.toStringNoQuotes((ConstantPool)null)));
  stack.push(cft);
}
Program: 62216
Project: 62216
Buggy source:
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem value=stack.pop();
  GraphTargetItem name=stack.pop();
  variables.put(Highlighting.stripHilights(name.toStringNoQuotes(null)),value);
  output.add(new DefineLocalTreeItem(this,name,value));
}

Fixed version (ground truth):
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem value=stack.pop();
  GraphTargetItem name=stack.pop();
  variables.put(Highlighting.stripHilights(name.toStringNoQuotes((ConstantPool)null)),value);
  output.add(new DefineLocalTreeItem(this,name,value));
}
Program: 62218
Project: 62218
Buggy source:
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem name=stack.pop();
  GraphTargetItem computedVal=variables.get(Highlighting.stripHilights(name.toStringNoQuotes()));
  GetVariableTreeItem gvt=new GetVariableTreeItem(this,name);
  gvt.setComputedValue(computedVal);
  stack.push(gvt);
}

Fixed version (ground truth):
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem name=stack.pop();
  GraphTargetItem computedVal=variables.get(Highlighting.stripHilights(name.toStringNoQuotes(null)));
  GetVariableTreeItem gvt=new GetVariableTreeItem(this,name);
  gvt.setComputedValue(computedVal);
  stack.push(gvt);
}
Program: 62219
Project: 62219
Buggy source:
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem value=stack.pop();
  GraphTargetItem name=stack.pop();
  SetVariableTreeItem svt=new SetVariableTreeItem(this,name,value);
  variables.put(Highlighting.stripHilights(name.toStringNoQuotes(regNames,variables)),value);
  output.add(svt);
}

Fixed version (ground truth):
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem value=stack.pop();
  GraphTargetItem name=stack.pop();
  SetVariableTreeItem svt=new SetVariableTreeItem(this,name,value);
  variables.put(Highlighting.stripHilights(name.toStringNoQuotes(null)),value);
  output.add(svt);
}
Program: 62220
Project: 62220
Buggy source:
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem functionName=stack.pop();
  long numArgs=popLong(stack);
  List<GraphTargetItem> args=new ArrayList<GraphTargetItem>();
  for (long l=0; l < numArgs; l++) {
    args.add(stack.pop());
  }
  CallFunctionTreeItem cft=new CallFunctionTreeItem(this,functionName,args);
  cft.calculatedFunction=functions.get(Highlighting.stripHilights(functionName.toStringNoQuotes(variables,functions)));
  stack.push(cft);
}

Fixed version (ground truth):
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem functionName=stack.pop();
  long numArgs=popLong(stack);
  List<GraphTargetItem> args=new ArrayList<GraphTargetItem>();
  for (long l=0; l < numArgs; l++) {
    args.add(stack.pop());
  }
  CallFunctionTreeItem cft=new CallFunctionTreeItem(this,functionName,args);
  cft.calculatedFunction=functions.get(Highlighting.stripHilights(functionName.toStringNoQuotes(null)));
  stack.push(cft);
}
Program: 62221
Project: 62221
Buggy source:
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem value=stack.pop();
  GraphTargetItem name=stack.pop();
  variables.put(Highlighting.stripHilights(name.toStringNoQuotes(regNames,variables,functions)),value);
  output.add(new DefineLocalTreeItem(this,name,value));
}

Fixed version (ground truth):
@Override public void translate(Stack<GraphTargetItem> stack,List<GraphTargetItem> output,java.util.HashMap<Integer,String> regNames,HashMap<String,GraphTargetItem> variables,HashMap<String,GraphTargetItem> functions){
  GraphTargetItem value=stack.pop();
  GraphTargetItem name=stack.pop();
  variables.put(Highlighting.stripHilights(name.toStringNoQuotes(null)),value);
  output.add(new DefineLocalTreeItem(this,name,value));
}
Program: 62222
Project: 62222
Buggy source:
public static void stopWork(){
  working=false;
  if (abcMainFrame != null) {
    abcMainFrame.setStatus("String_Node_Str");
  }
  if (actionMainFrame != null) {
    actionMainFrame.setStatus("String_Node_Str");
  }
}

Fixed version (ground truth):
public static void stopWork(){
  working=false;
  if (abcMainFrame != null) {
    abcMainFrame.setStatus("String_Node_Str");
  }
  if (actionMainFrame != null) {
    actionMainFrame.setStatus("String_Node_Str");
  }
  if (loadingDialog != null) {
    loadingDialog.setDetail("String_Node_Str");
  }
}
Program: 62223
Project: 62223
Buggy source:
public static void startWork(String name){
  working=true;
  if (abcMainFrame != null) {
    abcMainFrame.setStatus(name);
  }
  if (actionMainFrame != null) {
    actionMainFrame.setStatus(name);
  }
  if (Main.isCommandLineMode()) {
    System.out.println(name);
  }
}

Fixed version (ground truth):
public static void startWork(String name){
  working=true;
  if (abcMainFrame != null) {
    abcMainFrame.setStatus(name);
  }
  if (actionMainFrame != null) {
    actionMainFrame.setStatus(name);
  }
  if (loadingDialog != null) {
    loadingDialog.setDetail(name);
  }
  if (Main.isCommandLineMode()) {
    System.out.println(name);
  }
}
Program: 62224
Project: 62224
Buggy source:
@Override protected Object doInBackground() throws Exception {
  try {
    swf=parseSWF(Main.file);
    FileInputStream fis=new FileInputStream(file);
    DEBUG_COPY=true;
    ByteArrayOutputStream baos=new ByteArrayOutputStream();
    try {
      swf.saveTo(baos);
    }
 catch (    NotSameException nse) {
      Logger.getLogger(Main.class.getName()).log(Level.FINE,null,nse);
      JOptionPane.showMessageDialog(null,"String_Node_Str");
    }
    DEBUG_COPY=false;
  }
 catch (  Exception ex) {
    Logger.getLogger(Main.class.getName()).log(Level.SEVERE,null,ex);
    JOptionPane.showMessageDialog(null,"String_Node_Str");
    loadingDialog.setVisible(false);
    return false;
  }
  List<Tag> listAbc=new ArrayList<Tag>();
  for (  Tag t : swf.tags) {
    if (t instanceof DoABCTag) {
      listAbc.add(t);
    }
  }
  if (false) {
    JOptionPane.showMessageDialog(null,"String_Node_Str");
    loadingDialog.setVisible(false);
    if (!openFileDialog()) {
      System.exit(0);
    }
  }
 else {
    if (listAbc.size() > 0) {
      List<DoABCTag> listAbc2=new ArrayList<DoABCTag>();
      for (      Tag tag : listAbc) {
        listAbc2.add((DoABCTag)tag);
      }
      abcMainFrame=new com.jpexs.asdec.abc.gui.MainFrame(listAbc2);
      abcMainFrame.display();
    }
 else {
      actionMainFrame=new com.jpexs.asdec.action.gui.MainFrame(swf.tags);
      actionMainFrame.display();
    }
  }
  loadingDialog.setVisible(false);
  return true;
}

Fixed version (ground truth):
@Override protected Object doInBackground() throws Exception {
  try {
    Main.startWork("String_Node_Str");
    swf=parseSWF(Main.file);
    FileInputStream fis=new FileInputStream(file);
    DEBUG_COPY=true;
    ByteArrayOutputStream baos=new ByteArrayOutputStream();
    try {
      swf.saveTo(baos);
    }
 catch (    NotSameException nse) {
      Logger.getLogger(Main.class.getName()).log(Level.FINE,null,nse);
      JOptionPane.showMessageDialog(null,"String_Node_Str");
    }
    DEBUG_COPY=false;
  }
 catch (  Exception ex) {
    Logger.getLogger(Main.class.getName()).log(Level.SEVERE,null,ex);
    JOptionPane.showMessageDialog(null,"String_Node_Str");
    loadingDialog.setVisible(false);
    return false;
  }
  List<Tag> listAbc=new ArrayList<Tag>();
  for (  Tag t : swf.tags) {
    if (t instanceof DoABCTag) {
      listAbc.add(t);
    }
  }
  if (false) {
    JOptionPane.showMessageDialog(null,"String_Node_Str");
    loadingDialog.setVisible(false);
    if (!openFileDialog()) {
      System.exit(0);
    }
  }
 else {
    if (listAbc.size() > 0) {
      List<DoABCTag> listAbc2=new ArrayList<DoABCTag>();
      for (      Tag tag : listAbc) {
        listAbc2.add((DoABCTag)tag);
      }
      abcMainFrame=new com.jpexs.asdec.abc.gui.MainFrame(listAbc2);
      abcMainFrame.display();
    }
 else {
      actionMainFrame=new com.jpexs.asdec.action.gui.MainFrame(swf.tags);
      actionMainFrame.display();
    }
  }
  loadingDialog.setVisible(false);
  return true;
}
Program: 62225
Project: 62225
Buggy source:
private void clearTemporaryRegisters(List<TreeItem> output){
  for (int i=0; i < output.size(); i++) {
    if (output.get(i) instanceof SetLocalTreeItem) {
      if (isKilled(((SetLocalTreeItem)output.get(i)).regIndex,0,code.size() - 1)) {
        output.remove(i);
        i--;
      }
    }
  }
}

Fixed version (ground truth):
public void clearTemporaryRegisters(List<TreeItem> output){
  for (int i=0; i < output.size(); i++) {
    if (output.get(i) instanceof SetLocalTreeItem) {
      if (isKilled(((SetLocalTreeItem)output.get(i)).regIndex,0,code.size() - 1)) {
        output.remove(i);
        i--;
      }
    }
 else     if (output.get(i) instanceof WithTreeItem) {
      clearTemporaryRegisters(((WithTreeItem)output.get(i)).items);
    }
  }
}
Program: 62227
Project: 62227
Buggy source:
public String getPath(ABC abc){
  for (  Trait t : traits.traits) {
    Multiname name=t.getName(abc);
    Namespace ns=name.getNamespace(abc.constants);
    if (ns.kind == Namespace.KIND_PACKAGE) {
      return ns.getName(abc.constants) + "String_Node_Str" + name.getName(abc.constants,new ArrayList<String>());
    }
  }
  return "String_Node_Str";
}

Fixed version (ground truth):
public String getPath(ABC abc){
  for (  Trait t : traits.traits) {
    Multiname name=t.getName(abc);
    Namespace ns=name.getNamespace(abc.constants);
    if ((ns.kind == Namespace.KIND_PACKAGE) || (ns.kind == Namespace.KIND_PACKAGE_INTERNAL)) {
      return ns.getName(abc.constants) + "String_Node_Str" + name.getName(abc.constants,new ArrayList<String>());
    }
  }
  return "String_Node_Str";
}
Program: 62228
Project: 62228
Buggy source:
/** 
 * Constructor
 */
public LoadingDialog(){
  setResizable(false);
  setTitle(Main.shortApplicationVerName);
  setSize(300,150);
  setLayout(new BorderLayout());
  loadingPanel=new LoadingPanel(50,50);
  loadingPanel.setPreferredSize(new Dimension(100,100));
  add(loadingPanel,BorderLayout.WEST);
  add(loadingLabel,BorderLayout.CENTER);
  View.centerScreen(this);
  View.setWindowIcon(this);
  loadingLabel.setHorizontalAlignment(SwingConstants.LEFT);
  addWindowListener(new WindowAdapter(){
    @Override public void windowClosing(    WindowEvent e){
      System.exit(0);
    }
  }
);
}

Fixed version (ground truth):
/** 
 * Constructor
 */
public LoadingDialog(){
  setResizable(false);
  setTitle(Main.shortApplicationVerName);
  setSize(250,150);
  setLayout(new BorderLayout());
  loadingPanel=new LoadingPanel(50,50);
  loadingPanel.setPreferredSize(new Dimension(100,100));
  add(loadingPanel,BorderLayout.WEST);
  add(loadingLabel,BorderLayout.CENTER);
  View.centerScreen(this);
  View.setWindowIcon(this);
  loadingLabel.setHorizontalAlignment(SwingConstants.LEFT);
  addWindowListener(new WindowAdapter(){
    @Override public void windowClosing(    WindowEvent e){
      System.exit(0);
    }
  }
);
}
Program: 62229
Project: 62229
Buggy source:
public String getParamStr(ConstantPool constants,MethodBody body,ABC abc){
  HashMap<Integer,String> localRegNames=new HashMap<Integer,String>();
  if (body != null) {
    localRegNames=body.code.getLocalRegNamesFromDebug(abc);
  }
  String paramStr="String_Node_Str";
  for (int i=0; i < param_types.length; i++) {
    if (i > 0) {
      paramStr+="String_Node_Str";
    }
    if (!localRegNames.isEmpty()) {
      paramStr+=localRegNames.get(i + 1);
    }
 else     if ((paramNames.length > i) && (paramNames[i] != 0) && Main.PARAM_NAMES_ENABLE) {
      paramStr+=constants.constant_string[paramNames[i]];
    }
 else {
      paramStr+="String_Node_Str" + (i + 1);
    }
    paramStr+="String_Node_Str";
    if (param_types[i] == 0) {
      paramStr+="String_Node_Str";
    }
 else {
      paramStr+=constants.constant_multiname[param_types[i]].getName(constants);
    }
    if (optional != null) {
      if (i >= param_types.length - optional.length) {
        paramStr+="String_Node_Str" + optional[i - (param_types.length - optional.length)].toString(constants);
      }
    }
  }
  if (flagNeed_rest()) {
    paramStr+="String_Node_Str";
    if (!localRegNames.isEmpty()) {
      paramStr+=localRegNames.get(param_types.length + 1);
    }
 else {
      paramStr+="String_Node_Str";
    }
  }
  return paramStr;
}

Fixed version (ground truth):
public String getParamStr(ConstantPool constants,MethodBody body,ABC abc){
  HashMap<Integer,String> localRegNames=new HashMap<Integer,String>();
  if (body != null) {
    localRegNames=body.code.getLocalRegNamesFromDebug(abc);
  }
  String paramStr="String_Node_Str";
  for (int i=0; i < param_types.length; i++) {
    if (i > 0) {
      paramStr+="String_Node_Str";
    }
    if (!localRegNames.isEmpty()) {
      paramStr+=localRegNames.get(i + 1);
    }
 else     if ((paramNames.length > i) && (paramNames[i] != 0) && Main.PARAM_NAMES_ENABLE) {
      paramStr+=constants.constant_string[paramNames[i]];
    }
 else {
      paramStr+="String_Node_Str" + (i + 1);
    }
    paramStr+="String_Node_Str";
    if (param_types[i] == 0) {
      paramStr+="String_Node_Str";
    }
 else {
      paramStr+=constants.constant_multiname[param_types[i]].getName(constants);
    }
    if (optional != null) {
      if (i >= param_types.length - optional.length) {
        paramStr+="String_Node_Str" + optional[i - (param_types.length - optional.length)].toString(constants);
      }
    }
  }
  if (flagNeed_rest()) {
    if ((param_types != null) && (param_types.length > 0)) {
      paramStr+="String_Node_Str";
    }
    paramStr+="String_Node_Str";
    if (!localRegNames.isEmpty()) {
      paramStr+=localRegNames.get(param_types.length + 1);
    }
 else {
      paramStr+="String_Node_Str";
    }
  }
  return paramStr;
}
Program: 62230
Project: 62230
Buggy source:
protected RedisVersion getRedisVersion(){
  String info=jedis.info();
  String[] infos=info.split("String_Node_Str");
  String version=null;
  for (int i=0; i < infos.length; i++) {
    if (infos[i].startsWith("String_Node_Str")) {
      String[] versionInfo=infos[i].split("String_Node_Str");
      version=versionInfo[1];
      break;
    }
  }
  if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_3_0;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_2_8;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_2_6;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_2_4;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_2_2;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_2_0;
 else   return RedisVersion.REDIS_1_0;
}

Fixed version (ground truth):
protected RedisVersion getRedisVersion(){
  String info=jedis.info();
  String[] infos=info.split("String_Node_Str");
  String version=null;
  for (int i=0; i < infos.length; i++) {
    if (infos[i].startsWith("String_Node_Str")) {
      String[] versionInfo=infos[i].split("String_Node_Str");
      version=versionInfo[1];
      break;
    }
  }
  if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_3_0;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_2_8;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_2_6;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_2_4;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_2_2;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_2_0;
 else   if (version.startsWith("String_Node_Str"))   return RedisVersion.REDIS_1_0;
 else   return RedisVersion.UNKNOWN;
}
Program: 62231
Project: 62231
Buggy source:
@Override public RedisVersion getSupportVersion(){
  return RedisVersion.REDIS_1_0;
}

Fixed version (ground truth):
@Override public RedisVersion getSupportVersion(){
  if (second != -1)   return RedisVersion.REDIS_1_0;
 else   return RedisVersion.REDIS_2_2;
}