nus-yam/ex-repair huggingface dataset:
Program: 40379
Project: 40379
Buggy source:
protected static void dumpIR(CallGraph cg,boolean assertReachable) throws IOException {
  Set<IMethod> unreachable=HashSetFactory.make();
  IClassHierarchy cha=cg.getClassHierarchy();
  IClassLoader sourceLoader=cha.getLoader(EclipseProjectPath.SOURCE_REF);
  for (Iterator iter=sourceLoader.iterateAllClasses(); iter.hasNext(); ) {
    IClass clazz=(IClass)iter.next();
    Trace.println(clazz);
    if (clazz.isInterface())     continue;
    for (    IMethod m : clazz.getDeclaredMethods()) {
      if (m.isAbstract()) {
        Trace.println(m);
      }
 else {
        Iterator nodeIter=cg.getNodes(m.getReference()).iterator();
        if (!nodeIter.hasNext()) {
          Trace.println("String_Node_Str" + m.getReference() + "String_Node_Str");
          unreachable.add(m);
          continue;
        }
        CGNode node=(CGNode)nodeIter.next();
        Trace.println(node.getIR());
      }
    }
  }
  if (assertReachable) {
    Assert.assertTrue("String_Node_Str" + unreachable.toString(),unreachable.isEmpty());
  }
}

Fixed version (ground truth):
protected static void dumpIR(CallGraph cg,boolean assertReachable) throws IOException {
  Set<IMethod> unreachable=HashSetFactory.make();
  IClassHierarchy cha=cg.getClassHierarchy();
  IClassLoader sourceLoader=cha.getLoader(JavaSourceAnalysisScope.SOURCE);
  for (Iterator iter=sourceLoader.iterateAllClasses(); iter.hasNext(); ) {
    IClass clazz=(IClass)iter.next();
    Trace.println(clazz);
    if (clazz.isInterface())     continue;
    for (    IMethod m : clazz.getDeclaredMethods()) {
      if (m.isAbstract()) {
        Trace.println(m);
      }
 else {
        Iterator nodeIter=cg.getNodes(m.getReference()).iterator();
        if (!nodeIter.hasNext()) {
          Trace.println("String_Node_Str" + m.getReference() + "String_Node_Str");
          unreachable.add(m);
          continue;
        }
        CGNode node=(CGNode)nodeIter.next();
        Trace.println(node.getIR());
      }
    }
  }
  if (assertReachable) {
    Assert.assertTrue("String_Node_Str" + unreachable.toString(),unreachable.isEmpty());
  }
}
Program: 40380
Project: 40380
Buggy source:
private MethodReference getSliceRootReference(String className,String methodName,String methodDescriptor){
  TypeName clsName=TypeName.string2TypeName("String_Node_Str" + className.replace('.','/'));
  TypeReference clsRef=TypeReference.findOrCreate(EclipseProjectPath.SOURCE_REF,clsName);
  Atom nameAtom=Atom.findOrCreateUnicodeAtom(methodName);
  Descriptor descr=Descriptor.findOrCreateUTF8(methodDescriptor);
  return MethodReference.findOrCreate(clsRef,nameAtom,descr);
}

Fixed version (ground truth):
private MethodReference getSliceRootReference(String className,String methodName,String methodDescriptor){
  TypeName clsName=TypeName.string2TypeName("String_Node_Str" + className.replace('.','/'));
  TypeReference clsRef=TypeReference.findOrCreate(JavaSourceAnalysisScope.SOURCE,clsName);
  Atom nameAtom=Atom.findOrCreateUnicodeAtom(methodName);
  Descriptor descr=Descriptor.findOrCreateUTF8(methodDescriptor);
  return MethodReference.findOrCreate(clsRef,nameAtom,descr);
}
Program: 40381
Project: 40381
Buggy source:
protected Iterable<Entrypoint> makeDefaultEntrypoints(AnalysisScope scope,IClassHierarchy cha){
  return Util.makeMainEntrypoints(EclipseProjectPath.SOURCE_REF,cha);
}

Fixed version (ground truth):
protected Iterable<Entrypoint> makeDefaultEntrypoints(AnalysisScope scope,IClassHierarchy cha){
  return Util.makeMainEntrypoints(JavaSourceAnalysisScope.SOURCE,cha);
}
Program: 40382
Project: 40382
Buggy source:
public ClassLoaderReference getSourceLoader(){
  return getLoader(EclipseProjectPath.SOURCE);
}

Fixed version (ground truth):
public ClassLoaderReference getSourceLoader(){
  return SOURCE;
}
Program: 40383
Project: 40383
Buggy source:
public JavaSourceAnalysisScope(Collection<Language> languages){
  super(languages);
  initForJava();
  EclipseProjectPath.SOURCE_REF.setParent(getLoader(APPLICATION));
  getLoader(SYNTHETIC).setParent(EclipseProjectPath.SOURCE_REF);
  loadersByName.put(EclipseProjectPath.SOURCE,EclipseProjectPath.SOURCE_REF);
  setLoaderImpl(getLoader(SYNTHETIC),"String_Node_Str");
  setLoaderImpl(EclipseProjectPath.SOURCE_REF,"String_Node_Str");
}

Fixed version (ground truth):
public JavaSourceAnalysisScope(Collection<Language> languages){
  super(languages);
  initForJava();
  loadersByName.put(SOURCE.getName(),SOURCE);
  setLoaderImpl(getLoader(SYNTH_SOURCE.getName()),"String_Node_Str");
  setLoaderImpl(SOURCE,"String_Node_Str");
}
Program: 40384
Project: 40384
Buggy source:
public Iterator<T> iterator(){
  return new ArrayIterator<T>(entries);
}

Fixed version (ground truth):
public Iterator<T> iterator(){
  if (entries.length == 0) {
    return EmptyIterator.instance();
  }
  return new ArrayIterator<T>(entries);
}
Program: 40387
Project: 40387
Buggy source:
/** 
 * create a new field-element
 * @param fld - field element to serve as part of a path
 */
public FieldPathElement(IField fld){
  Assertions.precondition(fld != null,"String_Node_Str");
  this.fld=fld;
}

Fixed version (ground truth):
/** 
 * create a new field-element
 * @param fld - field element to serve as part of a path
 */
public FieldPathElement(IField fld){
  if (fld == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.fld=fld;
}
Program: 40388
Project: 40388
Buggy source:
/** 
 * create a new anchor element
 * @param lpk -anchor element to serve as head of path
 */
public LocalPathElement(AbstractPointerKey lpk){
  this.lpk=lpk;
  if (Assertions.verifyAssertions) {
    Assertions._assert(lpk != null);
  }
}

Fixed version (ground truth):
/** 
 * create a new anchor element
 * @param lpk - anchor element to serve as head of path
 */
public LocalPathElement(AbstractPointerKey lpk){
  this.lpk=lpk;
  if (lpk == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
}
Program: 40389
Project: 40389
Buggy source:
protected HeapGraph(PointerAnalysis pa){
  this.pa=pa;
}

Fixed version (ground truth):
protected HeapGraph(PointerAnalysis pa){
  if (pa == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  this.pa=pa;
}
Program: 40390
Project: 40390
Buggy source:
public FieldImpl(IClass declaringClass,FieldReference canonicalRef,int accessFlags,Collection<Annotation> annotations){
  this.declaringClass=declaringClass;
  this.fieldRef=canonicalRef;
  this.accessFlags=accessFlags;
  this.annotations=annotations;
  if (Assertions.verifyAssertions) {
    Assertions._assert(declaringClass != null);
    Assertions._assert(fieldRef != null);
  }
}

Fixed version (ground truth):
public FieldImpl(IClass declaringClass,FieldReference canonicalRef,int accessFlags,Collection<Annotation> annotations){
  this.declaringClass=declaringClass;
  this.fieldRef=canonicalRef;
  this.accessFlags=accessFlags;
  this.annotations=annotations;
  if (declaringClass == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (fieldRef == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
}
Program: 40391
Project: 40391
Buggy source:
private void resolvePluginClassPath(IProject p) throws CoreException, IOException {
  BundleDescription bd=findModel(p).getBundleDescription();
  resolveBundleDescriptionClassPath(bd,Loader.APPLICATION);
}

Fixed version (ground truth):
private void resolvePluginClassPath(IProject p) throws CoreException, IOException {
  BundleDescription bd=findModel(p).getBundleDescription();
  if (bd == null) {
    throw new IllegalStateException("String_Node_Str" + p);
  }
  resolveBundleDescriptionClassPath(bd,Loader.APPLICATION);
}
Program: 40392
Project: 40392
Buggy source:
/** 
 * If file extension is not provided, use system default
 * @throws JavaModelException
 * @throws IOException
 */
private void resolveProjectClasspathEntries() throws JavaModelException, IOException {
  resolveClasspathEntries(project.getRawClasspath(),Loader.EXTENSION);
}

Fixed version (ground truth):
private void resolveProjectClasspathEntries() throws JavaModelException, IOException {
  resolveClasspathEntries(project.getRawClasspath(),Loader.EXTENSION);
}
Program: 40393
Project: 40393
Buggy source:
/** 
 * @return Collection of IClasses, representing the interfaces this class implements.
 */
protected Collection<IClass> computeAllInterfacesAsCollection() throws ClassHierarchyException {
  Collection<IClass> c=getDirectInterfaces();
  Set<IClass> result=HashSetFactory.make();
  for (Iterator<IClass> it=c.iterator(); it.hasNext(); ) {
    IClass klass=it.next();
    if (klass.isInterface()) {
      result.add(klass);
    }
 else {
      Warnings.add(ClassHierarchyWarning.create("String_Node_Str" + klass));
    }
  }
  for (Iterator<IClass> it=c.iterator(); it.hasNext(); ) {
    BytecodeClass I=(BytecodeClass)it.next();
    if (I.isInterface()) {
      result.addAll(I.computeAllInterfacesAsCollection());
    }
 else {
      Warnings.add(ClassHierarchyWarning.create("String_Node_Str" + I));
    }
  }
  IClass sup=null;
  try {
    sup=getSuperclass();
  }
 catch (  ClassHierarchyException e1) {
    Assertions.UNREACHABLE();
  }
  if (sup != null) {
    result.addAll(sup.getAllImplementedInterfaces());
  }
  return result;
}

Fixed version (ground truth):
/** 
 * @return Collection of IClasses, representing the interfaces this class implements.
 */
protected Collection<IClass> computeAllInterfacesAsCollection() throws ClassHierarchyException {
  Collection<IClass> c=getDirectInterfaces();
  Set<IClass> result=HashSetFactory.make();
  for (Iterator<IClass> it=c.iterator(); it.hasNext(); ) {
    IClass klass=it.next();
    if (klass.isInterface()) {
      result.add(klass);
    }
 else {
      Warnings.add(ClassHierarchyWarning.create("String_Node_Str" + klass));
    }
  }
  Set<IClass> last=null;
  do {
    last=HashSetFactory.make(result);
    for (    IClass i : last) {
      result.addAll(i.getDirectInterfaces());
    }
  }
 while (last.size() < result.size());
  IClass sup=null;
  try {
    sup=getSuperclass();
  }
 catch (  ClassHierarchyException e1) {
    Assertions.UNREACHABLE();
  }
  if (sup != null) {
    result.addAll(sup.getAllImplementedInterfaces());
  }
  return result;
}
Program: 40394
Project: 40394
Buggy source:
/** 
 * Method array2Set.
 * @param interfaces a set of class names
 * @return Set of all IClasses that can be loaded corresponding to the class names in the interfaces array; raise warnings ifclasses can not be loaded
 */
private Collection<IClass> array2IClassSet(ImmutableByteArray[] interfaces){
  ArrayList<IClass> result=new ArrayList<IClass>(interfaces.length);
  for (int i=0; i < interfaces.length; i++) {
    ImmutableByteArray name=interfaces[i];
    IClass klass=null;
    klass=loader.lookupClass(TypeName.findOrCreate(name));
    if (klass == null) {
      Warnings.add(ClassNotFoundWarning.create(name));
    }
 else {
      result.add(klass);
    }
  }
  return result;
}

Fixed version (ground truth):
/** 
 * @param interfaces a set of class names
 * @return Set of all IClasses that can be loaded corresponding to the class names in the interfaces array; raise warnings ifclasses can not be loaded
 */
private Collection<IClass> array2IClassSet(ImmutableByteArray[] interfaces){
  ArrayList<IClass> result=new ArrayList<IClass>(interfaces.length);
  for (int i=0; i < interfaces.length; i++) {
    ImmutableByteArray name=interfaces[i];
    IClass klass=null;
    klass=loader.lookupClass(TypeName.findOrCreate(name));
    if (klass == null) {
      Warnings.add(ClassNotFoundWarning.create(name));
    }
 else {
      result.add(klass);
    }
  }
  return result;
}
Program: 40395
Project: 40395
Buggy source:
private void populate(CGNode n){
  if (n.getMethod().isSynthetic()) {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    SyntheticMethod sm=(SyntheticMethod)n.getMethod();
    SSAInstruction[] statements=sm.getStatements();
    SSAMemoryAccessVisitor v=new SSAMemoryAccessVisitor(n);
    for (int i=0; i < statements.length; i++) {
      SSAInstruction s=statements[i];
      if (s != null) {
        v.setInstructionIndex(i);
        s.visit(v);
      }
    }
  }
 else {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    ShrikeCTMethod sm=(ShrikeCTMethod)n.getMethod();
    MemoryAccessVisitor v=new MemoryAccessVisitor(n.getMethod().getReference().getDeclaringClass().getClassLoader(),n);
    try {
      Instruction[] statements=sm.getInstructions();
      if (statements == null) {
        return;
      }
      if (DEBUG) {
        for (int i=0; i < statements.length; i++) {
          System.err.println(i + "String_Node_Str" + statements[i]);
        }
      }
      for (int i=0; i < statements.length; i++) {
        Instruction s=statements[i];
        if (s != null) {
          v.setInstructionIndex(i);
          s.visit(v);
        }
      }
    }
 catch (    InvalidClassFileException e) {
      e.printStackTrace();
      Assertions.UNREACHABLE();
    }
  }
}

Fixed version (ground truth):
private void populate(CGNode n){
  if (n.getMethod().isSynthetic()) {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    SSAInstruction[] statements=n.getIR().getInstructions();
    SSAMemoryAccessVisitor v=new SSAMemoryAccessVisitor(n);
    for (int i=0; i < statements.length; i++) {
      SSAInstruction s=statements[i];
      if (s != null) {
        v.setInstructionIndex(i);
        s.visit(v);
      }
    }
  }
 else {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    ShrikeCTMethod sm=(ShrikeCTMethod)n.getMethod();
    MemoryAccessVisitor v=new MemoryAccessVisitor(n.getMethod().getReference().getDeclaringClass().getClassLoader(),n);
    try {
      Instruction[] statements=sm.getInstructions();
      if (statements == null) {
        return;
      }
      if (DEBUG) {
        for (int i=0; i < statements.length; i++) {
          System.err.println(i + "String_Node_Str" + statements[i]);
        }
      }
      for (int i=0; i < statements.length; i++) {
        Instruction s=statements[i];
        if (s != null) {
          v.setInstructionIndex(i);
          s.visit(v);
        }
      }
    }
 catch (    InvalidClassFileException e) {
      e.printStackTrace();
      Assertions.UNREACHABLE();
    }
  }
}
Program: 40396
Project: 40396
Buggy source:
private void populate(CGNode n){
  if (n.getMethod().isSynthetic()) {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    SSAInstruction[] statements=n.getIR().getInstructions();
    SSAMemoryAccessVisitor v=new SSAMemoryAccessVisitor(n);
    for (int i=0; i < statements.length; i++) {
      SSAInstruction s=statements[i];
      if (s != null) {
        v.setInstructionIndex(i);
        s.visit(v);
      }
    }
  }
 else {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    ShrikeCTMethod sm=(ShrikeCTMethod)n.getMethod();
    MemoryAccessVisitor v=new MemoryAccessVisitor(n.getMethod().getReference().getDeclaringClass().getClassLoader(),n);
    try {
      Instruction[] statements=sm.getInstructions();
      if (statements == null) {
        return;
      }
      if (DEBUG) {
        for (int i=0; i < statements.length; i++) {
          System.err.println(i + "String_Node_Str" + statements[i]);
        }
      }
      for (int i=0; i < statements.length; i++) {
        Instruction s=statements[i];
        if (s != null) {
          v.setInstructionIndex(i);
          s.visit(v);
        }
      }
    }
 catch (    InvalidClassFileException e) {
      e.printStackTrace();
      Assertions.UNREACHABLE();
    }
  }
}

Fixed version (ground truth):
private void populate(CGNode n){
  if (ALWAYS_BUILD_IR || n.getMethod().isSynthetic()) {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    SSAInstruction[] statements=n.getIR().getInstructions();
    SSAMemoryAccessVisitor v=new SSAMemoryAccessVisitor(n);
    for (int i=0; i < statements.length; i++) {
      SSAInstruction s=statements[i];
      if (s != null) {
        v.setInstructionIndex(i);
        s.visit(v);
      }
    }
  }
 else {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    ShrikeCTMethod sm=(ShrikeCTMethod)n.getMethod();
    MemoryAccessVisitor v=new MemoryAccessVisitor(n.getMethod().getReference().getDeclaringClass().getClassLoader(),n);
    try {
      Instruction[] statements=sm.getInstructions();
      if (statements == null) {
        return;
      }
      if (DEBUG) {
        for (int i=0; i < statements.length; i++) {
          System.err.println(i + "String_Node_Str" + statements[i]);
        }
      }
      for (int i=0; i < statements.length; i++) {
        Instruction s=statements[i];
        if (s != null) {
          v.setInstructionIndex(i);
          s.visit(v);
        }
      }
    }
 catch (    InvalidClassFileException e) {
      e.printStackTrace();
      Assertions.UNREACHABLE();
    }
  }
}
Program: 40397
Project: 40397
Buggy source:
private void populate(CGNode n){
  if (ALWAYS_BUILD_IR || n.getMethod().isSynthetic()) {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    SSAInstruction[] statements=n.getIR().getInstructions();
    SSAMemoryAccessVisitor v=new SSAMemoryAccessVisitor(n);
    for (int i=0; i < statements.length; i++) {
      SSAInstruction s=statements[i];
      if (s != null) {
        v.setInstructionIndex(i);
        s.visit(v);
      }
    }
  }
 else {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    ShrikeCTMethod sm=(ShrikeCTMethod)n.getMethod();
    MemoryAccessVisitor v=new MemoryAccessVisitor(n.getMethod().getReference().getDeclaringClass().getClassLoader(),n);
    try {
      Instruction[] statements=sm.getInstructions();
      if (statements == null) {
        return;
      }
      if (DEBUG) {
        for (int i=0; i < statements.length; i++) {
          System.err.println(i + "String_Node_Str" + statements[i]);
        }
      }
      for (int i=0; i < statements.length; i++) {
        Instruction s=statements[i];
        if (s != null) {
          v.setInstructionIndex(i);
          s.visit(v);
        }
      }
    }
 catch (    InvalidClassFileException e) {
      e.printStackTrace();
      Assertions.UNREACHABLE();
    }
  }
}

Fixed version (ground truth):
private void populate(CGNode n){
  if (ALWAYS_BUILD_IR || n.getMethod().isSynthetic()) {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    IR ir=n.getIR();
    if (ir == null) {
      return;
    }
    SSAInstruction[] statements=ir.getInstructions();
    SSAMemoryAccessVisitor v=new SSAMemoryAccessVisitor(n);
    for (int i=0; i < statements.length; i++) {
      SSAInstruction s=statements[i];
      if (s != null) {
        v.setInstructionIndex(i);
        s.visit(v);
      }
    }
  }
 else {
    if (DEBUG) {
      System.err.println("String_Node_Str");
    }
    ShrikeCTMethod sm=(ShrikeCTMethod)n.getMethod();
    MemoryAccessVisitor v=new MemoryAccessVisitor(n.getMethod().getReference().getDeclaringClass().getClassLoader(),n);
    try {
      Instruction[] statements=sm.getInstructions();
      if (statements == null) {
        return;
      }
      if (DEBUG) {
        for (int i=0; i < statements.length; i++) {
          System.err.println(i + "String_Node_Str" + statements[i]);
        }
      }
      for (int i=0; i < statements.length; i++) {
        Instruction s=statements[i];
        if (s != null) {
          v.setInstructionIndex(i);
          s.visit(v);
        }
      }
    }
 catch (    InvalidClassFileException e) {
      e.printStackTrace();
      Assertions.UNREACHABLE();
    }
  }
}
Program: 40398
Project: 40398
Buggy source:
/** 
 * TODO: really shouldn't allow A to be null.
 */
public DelegatingSSAContextInterpreter(SSAContextInterpreter A,SSAContextInterpreter B){
  super(A,B);
  this.A=A;
  this.B=B;
  if (Assertions.verifyAssertions) {
    Assertions._assert(B != null,"String_Node_Str");
  }
}

Fixed version (ground truth):
/** 
 * neither A nor B should be null.
 */
public DelegatingSSAContextInterpreter(SSAContextInterpreter A,SSAContextInterpreter B){
  super(A,B);
  this.A=A;
  this.B=B;
  if (A == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (B == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
}
Program: 40399
Project: 40399
Buggy source:
public ZeroXCFABuilder(IClassHierarchy cha,AnalysisOptions options,AnalysisCache cache,ContextSelector appContextSelector,SSAContextInterpreter appContextInterpreter,ReflectionSpecification reflect,int instancePolicy){
  super(cha,options,cache,new DefaultPointerKeyFactory());
  ContextSelector def=new DefaultContextSelector();
  ContextSelector contextSelector=appContextSelector == null ? def : new DelegatingContextSelector(appContextSelector,def);
  setContextSelector(contextSelector);
  SSAContextInterpreter c=new DefaultSSAInterpreter(options,cache);
  c=new DelegatingSSAContextInterpreter(ReflectionContextInterpreter.createReflectionContextInterpreter(cha,options,getAnalysisCache(),reflect),c);
  SSAContextInterpreter contextInterpreter=new DelegatingSSAContextInterpreter(appContextInterpreter,c);
  setContextInterpreter(contextInterpreter);
  ZeroXInstanceKeys zik=makeInstanceKeys(cha,options,contextInterpreter,instancePolicy);
  setInstanceKeys(zik);
}

Fixed version (ground truth):
public ZeroXCFABuilder(IClassHierarchy cha,AnalysisOptions options,AnalysisCache cache,ContextSelector appContextSelector,SSAContextInterpreter appContextInterpreter,ReflectionSpecification reflect,int instancePolicy){
  super(cha,options,cache,new DefaultPointerKeyFactory());
  ContextSelector def=new DefaultContextSelector();
  ContextSelector contextSelector=appContextSelector == null ? def : new DelegatingContextSelector(appContextSelector,def);
  setContextSelector(contextSelector);
  SSAContextInterpreter c=new DefaultSSAInterpreter(options,cache);
  c=new DelegatingSSAContextInterpreter(ReflectionContextInterpreter.createReflectionContextInterpreter(cha,options,getAnalysisCache(),reflect),c);
  SSAContextInterpreter contextInterpreter=appContextInterpreter == null ? c : new DelegatingSSAContextInterpreter(appContextInterpreter,c);
  setContextInterpreter(contextInterpreter);
  ZeroXInstanceKeys zik=makeInstanceKeys(cha,options,contextInterpreter,instancePolicy);
  setInstanceKeys(zik);
}
Program: 40400
Project: 40400
Buggy source:
protected SSAContextInterpreter makeContextInterpreter(SSAContextInterpreter appContextInterpreter,ReflectionSpecification reflect){
  SSAContextInterpreter defI=new DefaultSSAInterpreter(getOptions(),getAnalysisCache());
  defI=new DelegatingSSAContextInterpreter(ReflectionContextInterpreter.createReflectionContextInterpreter(cha,getOptions(),getAnalysisCache(),reflect),defI);
  SSAContextInterpreter contextInterpreter=new DelegatingSSAContextInterpreter(appContextInterpreter,defI);
  return contextInterpreter;
}

Fixed version (ground truth):
protected SSAContextInterpreter makeContextInterpreter(SSAContextInterpreter appContextInterpreter,ReflectionSpecification reflect){
  SSAContextInterpreter defI=new DefaultSSAInterpreter(getOptions(),getAnalysisCache());
  defI=new DelegatingSSAContextInterpreter(ReflectionContextInterpreter.createReflectionContextInterpreter(cha,getOptions(),getAnalysisCache(),reflect),defI);
  SSAContextInterpreter contextInterpreter=appContextInterpreter == null ? defI : new DelegatingSSAContextInterpreter(appContextInterpreter,defI);
  return contextInterpreter;
}
Program: 40401
Project: 40401
Buggy source:
/** 
 * @param line a whitespace-delimited string of column names
 */
private void populateColumnHeadings(String line,Character delimiter){
  StringTokenizer st=new StringTokenizer(line,delimiter.toString());
  int nColumns=st.countTokens();
  for (int i=0; i < nColumns; i++) {
    columnHeadings.set(i,(String)st.nextElement());
  }
}

Fixed version (ground truth):
/** 
 * @param line a whitespace-delimited string of column names
 */
private void populateColumnHeadings(String line,Character delimiter){
  StringTokenizer st=delimiter == null ? new StringTokenizer(line) : new StringTokenizer(line,delimiter.toString());
  int nColumns=st.countTokens();
  for (int i=0; i < nColumns; i++) {
    columnHeadings.set(i,(String)st.nextElement());
  }
}
Program: 40402
Project: 40402
Buggy source:
private void populateRow(int row,String line,Character delimiter){
  StringTokenizer st=new StringTokenizer(line,delimiter.toString());
  int nColumns=st.countTokens();
  Assertions.productionAssertion(nColumns == getNumberOfColumns(),"String_Node_Str" + getNumberOfColumns() + "String_Node_Str"+ nColumns+ "String_Node_Str"+ row+ "String_Node_Str"+ line.length()+ "String_Node_Str"+ line);
  SimpleVector<String> r=new SimpleVector<String>();
  rows.add(row,r);
  for (int i=0; i < nColumns; i++) {
    r.set(i,(String)st.nextElement());
  }
}

Fixed version (ground truth):
private void populateRow(int row,String line,Character delimiter){
  StringTokenizer st=delimiter == null ? new StringTokenizer(line) : new StringTokenizer(line,delimiter.toString());
  int nColumns=st.countTokens();
  Assertions.productionAssertion(nColumns == getNumberOfColumns(),"String_Node_Str" + getNumberOfColumns() + "String_Node_Str"+ nColumns+ "String_Node_Str"+ row+ "String_Node_Str"+ line.length()+ "String_Node_Str"+ line);
  SimpleVector<String> r=new SimpleVector<String>();
  rows.add(row,r);
  for (int i=0; i < nColumns; i++) {
    r.set(i,(String)st.nextElement());
  }
}
Program: 40403
Project: 40403
Buggy source:
@Override public void addSeed(PathEdge<T> seed){
  unbalancedSeeds.add(Pair.make(seed.entry,seed.d1));
  super.addSeed(seed);
}

Fixed version (ground truth):
@Override public void addSeed(PathEdge<T> seed){
  if (getSeeds().contains(seed)) {
    return;
  }
  unbalancedSeeds.add(Pair.make(seed.entry,seed.d1));
  super.addSeed(seed);
}
Program: 40404
Project: 40404
Buggy source:
/** 
 * Spawn a process to execute the given command
 * @return an object representing the process
 * @throws WalaException
 * @throws IllegalArgumentException
 * @throws IOException
 */
protected Process spawnProcess(String cmd) throws IllegalArgumentException, IOException {
  if (cmd == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (logger != null) {
    logger.fine("String_Node_Str" + cmd);
  }
  String[] ev=getEnv() == null ? null : buildEnv(getEnv());
  Process p=Runtime.getRuntime().exec(cmd,ev,getWorkingDir());
  return p;
}

Fixed version (ground truth):
/** 
 * Spawn a process to execute the given command
 * @return an object representing the process
 * @throws WalaException
 * @throws IllegalArgumentException
 * @throws IOException
 */
protected Process spawnProcess(String cmd) throws IllegalArgumentException, IOException {
  if (cmd == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  System.out.println("String_Node_Str" + cmd);
  if (logger != null) {
    logger.fine("String_Node_Str" + cmd);
  }
  String[] ev=getEnv() == null ? null : buildEnv(getEnv());
  Process p=Runtime.getRuntime().exec(cmd,ev,getWorkingDir());
  return p;
}
Program: 40405
Project: 40405
Buggy source:
/** 
 * This is fragile.  Use with care.
 * @return a String representing the path to the wala.core plugin installation
 */
public static String getWalaCorePluginHome(){
  if (CorePlugin.getDefault() == null) {
    return null;
  }
  String install=Platform.getInstallLocation().getURL().getPath();
  Bundle b=Platform.getBundle("String_Node_Str");
  String l=b.getLocation();
  if (l.startsWith("String_Node_Str")) {
    l=l.replace("String_Node_Str","String_Node_Str");
  }
  return install + File.separator + l;
}

Fixed version (ground truth):
/** 
 * This is fragile.  Use with care.
 * @return a String representing the path to the wala.core plugin installation
 */
public static String getWalaCorePluginHome(){
  if (CorePlugin.getDefault() == null) {
    return null;
  }
  String install=Platform.getInstallLocation().getURL().getPath();
  Bundle b=Platform.getBundle("String_Node_Str");
  String l=b.getLocation();
  if (l.startsWith("String_Node_Str")) {
    l=l.replace("String_Node_Str","String_Node_Str");
  }
  if (l.startsWith("String_Node_Str")) {
    return l.replace("String_Node_Str","String_Node_Str");
  }
 else {
    return install + File.separator + l;
  }
}
Program: 40406
Project: 40406
Buggy source:
/** 
 * Return the unique receiver of an invocation of method on an object of type declaringClass
 * @param receiverClass type of receiver
 * @param selector method signature
 * @return Method resolved method abstraction
 * @throws IllegalArgumentException if receiverClass is null
 */
public IMethod resolveMethod(IClass receiverClass,Selector selector){
  if (receiverClass == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  IMethod result=findMethod(receiverClass,selector);
  if (result != null) {
    return result;
  }
 else {
    IClass superclass=null;
    try {
      superclass=receiverClass.getSuperclass();
    }
 catch (    ClassHierarchyException e) {
      Assertions.UNREACHABLE();
    }
    if (superclass == null) {
      if (DEBUG) {
        Trace.println("String_Node_Str" + selector + "String_Node_Str");
      }
      return null;
    }
 else {
      if (DEBUG) {
        Trace.println("String_Node_Str" + receiverClass + "String_Node_Str"+ superclass+ "String_Node_Str"+ selector);
      }
      return resolveMethod(superclass,selector);
    }
  }
}

Fixed version (ground truth):
/** 
 * Return the unique target of an invocation of method on an object of type declaringClass
 * @param receiverClass type of receiver
 * @param selector method signature
 * @return Method resolved method abstraction
 * @throws IllegalArgumentException if receiverClass is null
 */
public IMethod resolveMethod(IClass receiverClass,Selector selector){
  if (receiverClass == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  IMethod result=findMethod(receiverClass,selector);
  if (result != null) {
    return result;
  }
 else {
    IClass superclass=null;
    try {
      superclass=receiverClass.getSuperclass();
    }
 catch (    ClassHierarchyException e) {
      Assertions.UNREACHABLE();
    }
    if (superclass == null) {
      if (DEBUG) {
        Trace.println("String_Node_Str" + selector + "String_Node_Str");
      }
      return null;
    }
 else {
      if (DEBUG) {
        Trace.println("String_Node_Str" + receiverClass + "String_Node_Str"+ superclass+ "String_Node_Str"+ selector);
      }
      return resolveMethod(superclass,selector);
    }
  }
}
Program: 40407
Project: 40407
Buggy source:
/** 
 * Find the possible receivers of a call to a method reference
 * @param ref method reference
 * @return the set of IMethods that this call can resolve to.
 */
@SuppressWarnings("String_Node_Str") private Set<IMethod> findOrCreateTargetSet(IClass declaredClass,MethodReference ref){
  Map<MethodReference,Set<IMethod>> classCache=(Map<MethodReference,Set<IMethod>>)CacheReference.get(targetCache.get(declaredClass));
  if (classCache == null) {
    classCache=HashMapFactory.make(3);
    targetCache.put(declaredClass,CacheReference.make(classCache));
  }
  Set<IMethod> result=classCache.get(ref);
  if (result == null) {
    result=getPossibleTargets(declaredClass,ref);
    classCache.put(ref,result);
  }
  return result;
}

Fixed version (ground truth):
/** 
 * Find the possible targets of a call to a method reference
 * @param ref method reference
 * @return the set of IMethods that this call can resolve to.
 */
@SuppressWarnings("String_Node_Str") private Set<IMethod> findOrCreateTargetSet(IClass declaredClass,MethodReference ref){
  Map<MethodReference,Set<IMethod>> classCache=(Map<MethodReference,Set<IMethod>>)CacheReference.get(targetCache.get(declaredClass));
  if (classCache == null) {
    classCache=HashMapFactory.make(3);
    targetCache.put(declaredClass,CacheReference.make(classCache));
  }
  Set<IMethod> result=classCache.get(ref);
  if (result == null) {
    result=getPossibleTargets(declaredClass,ref);
    classCache.put(ref,result);
  }
  return result;
}
Program: 40408
Project: 40408
Buggy source:
/** 
 * Find the possible receivers of a call to a method reference where the receiver is of a certain type
 * @param receiverClass the class of the receiver
 * @param ref method reference
 * @return the set of IMethods that this call can resolve to.
 */
public Set<IMethod> getPossibleTargets(IClass receiverClass,MethodReference ref);

Fixed version (ground truth):
/** 
 * Find the possible targets of a call to a method reference where the receiver is of a certain type
 * @param receiverClass the class of the receiver
 * @param ref method reference
 * @return the set of IMethods that this call can resolve to.
 */
public Set<IMethod> getPossibleTargets(IClass receiverClass,MethodReference ref);
Program: 40410
Project: 40410
Buggy source:
/** 
 * don't call this unless you really know what you're doing
 */
public Operator getOperator(){
  if (opcode < OP_iand) {
    return Operator.values()[(opcode - OP_iadd) / 4];
  }
 else {
    return Operator.values()[(opcode - OP_iand) / 2];
  }
}

Fixed version (ground truth):
public Operator getOperator(){
  if (opcode < OP_iand) {
    return Operator.values()[(opcode - OP_iadd) / 4];
  }
 else {
    return Operator.values()[5 + (opcode - OP_iand) / 2];
  }
}
Program: 40413
Project: 40413
Buggy source:
public String getForInVar(String loopVarName,Node initExpr){
  this.loopVarName=loopVarName;
  this.forInVar="String_Node_Str" + counter++;
  this.forInInitExpr=initExpr;
  return forInVar;
}

Fixed version (ground truth):
public String getForInVar(Node initExpr){
  this.forInVar="String_Node_Str" + counter++;
  this.forInInitExpr=initExpr;
  return forInVar;
}
Program: 40414
Project: 40414
Buggy source:
public String getForInLoopVar(){
  Assertions._assert(loopVarName != null);
  return loopVarName;
}

Fixed version (ground truth):
public String getForInLoopVar(){
  return null;
}
Program: 40415
Project: 40415
Buggy source:
private CAstNode translateOpcode(int nodeType){
switch (nodeType) {
case Token.ADD:
    return CAstOperator.OP_ADD;
case Token.DIV:
  return CAstOperator.OP_DIV;
case Token.LSH:
return CAstOperator.OP_LSH;
case Token.MOD:
return CAstOperator.OP_MOD;
case Token.MUL:
return CAstOperator.OP_MUL;
case Token.RSH:
return CAstOperator.OP_RSH;
case Token.SUB:
return CAstOperator.OP_SUB;
case Token.URSH:
return CAstOperator.OP_URSH;
case Token.BITAND:
return CAstOperator.OP_BIT_AND;
case Token.EQ:
return CAstOperator.OP_EQ;
case Token.SHEQ:
return CAstOperator.OP_EQ;
case Token.IFEQ:
return CAstOperator.OP_EQ;
case Token.GE:
return CAstOperator.OP_GE;
case Token.GT:
return CAstOperator.OP_GT;
case Token.LE:
return CAstOperator.OP_LE;
case Token.LT:
return CAstOperator.OP_LT;
case Token.NE:
return CAstOperator.OP_NE;
case Token.SHNE:
return CAstOperator.OP_NE;
case Token.IFNE:
return CAstOperator.OP_NE;
case Token.BITNOT:
return CAstOperator.OP_BITNOT;
case Token.NOT:
return CAstOperator.OP_NOT;
default :
Assertions.UNREACHABLE();
return null;
}
}

Fixed version (ground truth):
private CAstNode translateOpcode(int nodeType){
switch (nodeType) {
case Token.ADD:
    return CAstOperator.OP_ADD;
case Token.DIV:
  return CAstOperator.OP_DIV;
case Token.LSH:
return CAstOperator.OP_LSH;
case Token.MOD:
return CAstOperator.OP_MOD;
case Token.MUL:
return CAstOperator.OP_MUL;
case Token.RSH:
return CAstOperator.OP_RSH;
case Token.SUB:
return CAstOperator.OP_SUB;
case Token.URSH:
return CAstOperator.OP_URSH;
case Token.BITAND:
return CAstOperator.OP_BIT_AND;
case Token.BITOR:
return CAstOperator.OP_BIT_OR;
case Token.BITXOR:
return CAstOperator.OP_BIT_XOR;
case Token.EQ:
return CAstOperator.OP_EQ;
case Token.SHEQ:
return CAstOperator.OP_EQ;
case Token.IFEQ:
return CAstOperator.OP_EQ;
case Token.GE:
return CAstOperator.OP_GE;
case Token.GT:
return CAstOperator.OP_GT;
case Token.LE:
return CAstOperator.OP_LE;
case Token.LT:
return CAstOperator.OP_LT;
case Token.NE:
return CAstOperator.OP_NE;
case Token.SHNE:
return CAstOperator.OP_NE;
case Token.IFNE:
return CAstOperator.OP_NE;
case Token.BITNOT:
return CAstOperator.OP_BITNOT;
case Token.NOT:
return CAstOperator.OP_NOT;
default :
Assertions.UNREACHABLE();
return null;
}
}
Program: 40416
Project: 40416
Buggy source:
private void init(Graph<T> G,Iterator<? extends T> nodes){
  this.G=G;
  if (G.getNumberOfNodes() == 0) {
    return;
  }
  while (nodes.hasNext()) {
    T o=nodes.next();
    if (!visited.contains(o)) {
      Q.add(o);
      visited.add(o);
    }
  }
  index=0;
  T current=Q.get(0);
  visitChildren(current);
}

Fixed version (ground truth):
private void init(Graph<T> G,Iterator<? extends T> nodes){
  this.G=G;
  if (G.getNumberOfNodes() == 0) {
    return;
  }
  while (nodes.hasNext()) {
    T o=nodes.next();
    if (!visited.contains(o)) {
      Q.add(o);
      visited.add(o);
    }
  }
  index=0;
  if (Q.size() > 0) {
    T current=Q.get(0);
    visitChildren(current);
  }
}
Program: 40418
Project: 40418
Buggy source:
/** 
 * Solely for optimization; return a Collection<TypeReference> representing the subclassesOfError kind of ugly. a better scheme?
 */
public Collection<TypeReference> getJavaLangErrorTypes(){
  if (subTypeRefsOfError == null) {
    computeSubClasses(TypeReference.JavaLangError);
    subTypeRefsOfError=HashSetFactory.make(subclassesOfError.size());
    for (Iterator it=subclassesOfError.iterator(); it.hasNext(); ) {
      IClass klass=(IClass)it.next();
      subTypeRefsOfError.add(klass.getReference());
    }
  }
  return Collections.unmodifiableCollection(subTypeRefsOfError);
}

Fixed version (ground truth):
/** 
 * Solely for optimization; return a Collection<TypeReference> representing the subclasses of Error kind of ugly. a better scheme?
 */
public Collection<TypeReference> getJavaLangErrorTypes(){
  if (subTypeRefsOfError == null) {
    computeSubClasses(TypeReference.JavaLangError);
    subTypeRefsOfError=HashSetFactory.make(subclassesOfError.size());
    for (Iterator it=subclassesOfError.iterator(); it.hasNext(); ) {
      IClass klass=(IClass)it.next();
      subTypeRefsOfError.add(klass.getReference());
    }
  }
  return Collections.unmodifiableCollection(subTypeRefsOfError);
}
Program: 40419
Project: 40419
Buggy source:
/** 
 * @param klass
 * @return the classes that immediately extend klass. if klass is an array class A[][]...[], we return array classesB[][]...[] (same dimensionality) where B is an immediate subclass of A. If A is primitive, we return the empty set.
 */
public Collection<IClass> getImmediateSubclasses(IClass klass){
  if (klass.isArrayClass()) {
    return getImmediateArraySubclasses(klass);
  }
  Function<Node,IClass> node2Class=new Function<Node,IClass>(){
    public IClass apply(    Node n){
      return n.klass;
    }
  }
;
  return Iterator2Collection.toCollection(new MapIterator<Node,IClass>(findNode(klass).children.iterator(),node2Class));
}

Fixed version (ground truth):
/** 
 * @param klass
 * @return the classes that immediately extend klass. if klass is an array class A[][]...[], we return array classes B[][]...[](same dimensionality) where B is an immediate subclass of A. If A is primitive, we return the empty set.
 */
public Collection<IClass> getImmediateSubclasses(IClass klass){
  if (klass.isArrayClass()) {
    return getImmediateArraySubclasses(klass);
  }
  Function<Node,IClass> node2Class=new Function<Node,IClass>(){
    public IClass apply(    Node n){
      return n.klass;
    }
  }
;
  return Iterator2Collection.toCollection(new MapIterator<Node,IClass>(findNode(klass).children.iterator(),node2Class));
}
Program: 40420
Project: 40420
Buggy source:
/** 
 * Return set of all subclasses of type in the Class Hierarchy TODO: Tune this implementation. Consider caching if necessary.
 */
public Collection<IClass> computeSubClasses(TypeReference type){
  IClass T=lookupClass(type);
  if (Assertions.verifyAssertions) {
    if (T == null) {
      Assertions._assert(T != null,"String_Node_Str" + type);
    }
  }
  if (T.getReference().equals(TypeReference.JavaLangError)) {
    if (subclassesOfError == null) {
      subclassesOfError=computeSubClassesInternal(T);
    }
    return subclassesOfError;
  }
 else {
    return computeSubClassesInternal(T);
  }
}

Fixed version (ground truth):
/** 
 * Return set of all subclasses of type in the Class Hierarchy TODO: Tune this implementation. Consider caching if necessary.
 */
public Collection<IClass> computeSubClasses(TypeReference type){
  IClass t=lookupClass(type);
  if (Assertions.verifyAssertions) {
    if (t == null) {
      Assertions._assert(t != null,"String_Node_Str" + type);
    }
  }
  if (t.getReference().equals(TypeReference.JavaLangError)) {
    if (subclassesOfError == null) {
      subclassesOfError=computeSubClassesInternal(t);
    }
    return subclassesOfError;
  }
 else   if (t.getReference().equals(TypeReference.JavaLangRuntimeException)) {
    if (runtimeExceptionClasses == null) {
      runtimeExceptionClasses=computeSubClassesInternal(t);
    }
    return runtimeExceptionClasses;
  }
 else {
    return computeSubClassesInternal(t);
  }
}
Program: 40421
Project: 40421
Buggy source:
/** 
 * @param klass
 * @return the number of classes that immediately extend klass. if klass is an array class A[][]...[], we returnnumber of immediate subclasses of A. If A is primitive, we return 0.
 */
public int getNumberOfImmediateSubclasses(IClass klass){
  if (klass.isArrayClass()) {
    IClass innermost=getInnermostTypeOfArrayClass(klass);
    return innermost == null ? 0 : getNumberOfImmediateSubclasses(innermost);
  }
  Node node=findNode(klass);
  return node.children.size();
}

Fixed version (ground truth):
/** 
 * @param klass
 * @return the number of classes that immediately extend klass. if klass is an array class A[][]...[], we return number ofimmediate subclasses of A. If A is primitive, we return 0.
 */
public int getNumberOfImmediateSubclasses(IClass klass){
  if (klass.isArrayClass()) {
    IClass innermost=getInnermostTypeOfArrayClass(klass);
    return innermost == null ? 0 : getNumberOfImmediateSubclasses(innermost);
  }
  Node node=findNode(klass);
  return node.children.size();
}
Program: 40422
Project: 40422
Buggy source:
/** 
 * Solely for optimization; return a Collection<TypeReference> representing the subclassesOfError kind of ugly. a better scheme?
 */
public Collection<TypeReference> getJavaLangErrorTypes();

Fixed version (ground truth):
/** 
 * Solely for optimization; return a Collection<TypeReference> representing the subclasses of Error kind of ugly. a better scheme?
 */
public Collection<TypeReference> getJavaLangErrorTypes();
Program: 40423
Project: 40423
Buggy source:
/** 
 * @return Collection<TypeReference>, set of exception types a call to adeclared target might throw.
 * @throws InvalidClassFileException 
 * @throws IllegalArgumentException  if target is null
 * @throws IllegalArgumentException  if cha is null
 */
public static Collection<TypeReference> inferInvokeExceptions(MethodReference target,IClassHierarchy cha) throws InvalidClassFileException {
  if (cha == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (target == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  ArrayList<TypeReference> set=new ArrayList<TypeReference>(runtimeExceptions);
  set.addAll(cha.getJavaLangErrorTypes());
  IClass klass=cha.lookupClass(target.getDeclaringClass());
  if (klass == null) {
    Warnings.add(MethodResolutionFailure.moderate(target));
  }
  if (klass != null) {
    IMethod M=klass.getMethod(target.getSelector());
    if (M == null) {
      Warnings.add(MethodResolutionFailure.severe(target));
    }
 else {
      TypeReference[] exceptionTypes=M.getDeclaredExceptions();
      if (exceptionTypes != null) {
        set.addAll(Arrays.asList(exceptionTypes));
      }
    }
  }
  return set;
}

Fixed version (ground truth):
/** 
 * @return Collection<TypeReference>, set of exception types a call to adeclared target might throw.
 * @throws InvalidClassFileException 
 * @throws IllegalArgumentException  if target is null
 * @throws IllegalArgumentException  if cha is null
 */
public static Collection<TypeReference> inferInvokeExceptions(MethodReference target,IClassHierarchy cha) throws InvalidClassFileException {
  if (cha == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  if (target == null) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  ArrayList<TypeReference> set=new ArrayList<TypeReference>(cha.getJavaLangRuntimeExceptionTypes());
  set.addAll(cha.getJavaLangErrorTypes());
  IClass klass=cha.lookupClass(target.getDeclaringClass());
  if (klass == null) {
    Warnings.add(MethodResolutionFailure.moderate(target));
  }
  if (klass != null) {
    IMethod M=klass.getMethod(target.getSelector());
    if (M == null) {
      Warnings.add(MethodResolutionFailure.severe(target));
    }
 else {
      TypeReference[] exceptionTypes=M.getDeclaredExceptions();
      if (exceptionTypes != null) {
        set.addAll(Arrays.asList(exceptionTypes));
      }
    }
  }
  return set;
}
Program: 40425
Project: 40425
Buggy source:
/** 
 * Propagate information for an "exit" edge to a caller return site [23] for each d5 s.t. <s_p,d2> -> <returnSite(c),d5> ..
 * @param edge the edge being processed
 * @param c a call site of edge.s_p
 * @param D4 set of d1 s.t. <c, d1> -> <edge.s_p, edge.d2> was recorded as call flow
 * @param entries the blocks in the supergraph that are entries for the procedure of c
 * @param retSite the return site being propagated to
 * @param retf the flow function
 */
private void propagateToReturnSiteWithBinaryFlowFunction(final PathEdge edge,final T c,final IntSet D4,final T[] entries,final T retSite,final IFlowFunction retf){
  D4.foreach(new IntSetAction(){
    public void act(    final int d4){
      final IntSet D5=computeBinaryFlow(d4,edge.d2,(IBinaryReturnFlowFunction)retf);
      if (D5 != null) {
        D5.foreach(new IntSetAction(){
          public void act(          final int d5){
            for (int i=0; i < entries.length; i++) {
              final T s_p=entries[i];
              if (DEBUG_LEVEL > 1) {
                System.err.println("String_Node_Str" + s_p);
              }
              IntSet D3=getInversePathEdges(s_p,c,d4);
              if (DEBUG_LEVEL > 1) {
                System.err.println("String_Node_Str" + D3);
              }
              if (D3 != null) {
                D3.foreach(new IntSetAction(){
                  public void act(                  int d3){
                    propagate(s_p,d3,retSite,d5);
                  }
                }
);
              }
            }
          }
        }
);
      }
    }
  }
);
}

Fixed version (ground truth):
/** 
 * Propagate information for an "exit" edge to a caller return site [23] for each d5 s.t. <s_p,d2> -> <returnSite(c),d5> ..
 * @param edge the edge being processed
 * @param c a call site of edge.s_p
 * @param D4 set of d1 s.t. <c, d1> -> <edge.s_p, edge.d2> was recorded as call flow
 * @param entries the blocks in the supergraph that are entries for the procedure of c
 * @param retSite the return site being propagated to
 * @param retf the flow function
 */
private void propagateToReturnSiteWithBinaryFlowFunction(final PathEdge edge,final T c,final IntSet D4,final T[] entries,final T retSite,final IFlowFunction retf){
  D4.foreach(new IntSetAction(){
    public void act(    final int d4){
      final IntSet D5=computeBinaryFlow(d4,edge.d2,(IBinaryReturnFlowFunction)retf);
      propToReturnSite(c,entries,retSite,d4,D5);
    }
  }
);
}