[Demonstration 1]

[Buggy Method]
public int setHealth(int health) {
    this.health = health;
}

[Buggy Hunk]
public int setHealth(int health) {

[Patch]
public void setHealth(int health) {

[Demonstration 2]

[Buggy Method]
public Metadata deserealizateMetadata() {
    Metadata deserializedMetadata = null;
    try {
        FileInputStream inputFile = new FileInputStream(METADATA_PATH_TO_FILE);
        ObjectInputStream inputStream = new ObjectInputStream(inputFile);
        deserializedMetadata = (ArrayList<ArrayList<ArrayList<String>>>) inputStream.readObject();
        inputStream.close();
        inputFile.close();
    } catch (IOException e) {
        System.err.println("No se ha podido deserealizar el arbol, error: " + e.getMessage());
    } catch (ClassNotFoundException e) {
        System.err.println("No se ha podido deserealizar el arbol, error: " + e.getMessage());
    }
    return deserializedMetadata;
}

[Buggy Hunk]
deserializedMetadata= (ArrayList<ArrayList<ArrayList<String>>>) inputStream.readObject();

[Patch]
deserializedMetadata= (Metadata) inputStream.readObject();

[Demonstration 3]

[Buggy Method]
private MergedMinDiffs condense(MergedMinDiffs mmd, int n1, int n2) {
    Map<Integer, IntervalRangeSearch<Integer, Integer>> offsetMap = new HashMap<Integer, IntervalRangeSearch<Integer, Integer>>();
    TIntSet rmSet = new TIntHashSet();
    TIntIntMap collisionMap = new TIntIntHashMap();
    for (int i = 0; i < mmd.offsets.length; ++i) {
        int offset = mmd.offsets[i];
        int startI = mmd.getStartIMinusBlock(i);
        int stopI = mmd.stopIs[i];
        Integer key = Integer.valueOf(offset);
        IntervalRangeSearch<Integer, Integer> rt = offsetMap.get(key);
        if (rt == null) {
            rt = new IntervalRangeSearch<Integer, Integer>();
            offsetMap.put(key, rt);
        }
        Interval<Integer> interval = new Interval<Integer>(startI, stopI);
        Integer replaced = rt.put(interval, Integer.valueOf(i));
        log.info("i=" + i + " offset=" + offset + " store=" + interval + " tree.n=" + rt.size() + " inserted=" + (replaced == null));
        if (replaced != null) {
            // existing interval.  handle the merge
            int mergeIntoIdx = replaced.intValue();
            if (collisionMap.containsKey(mergeIntoIdx)) {
                mergeIntoIdx = collisionMap.get(mergeIntoIdx);
            }
            collisionMap.put(i, mergeIntoIdx);
            rmSet.add(i);
            log.info("merging " + i + " w/ index=" + mergeIntoIdx);
            /*                
                collision with "replaced" and "i"
                   - merge i with mmd[mergeIntoIdx]
                   - add i to rmSet
                   - create a pointer from i to mergeIntoIdx
                     so that the next collision can find
                     the original merge index
                */
            int mstartI = mmd.getStartIMinusBlock(mergeIntoIdx);
            int mstopI = mmd.stopIs[mergeIntoIdx];
            if (interval.min().intValue() <= mstartI) {
                if (interval.max() > mstopI) {
                    // interval is larger than current start to stop
                    mmd.stopIs[mergeIntoIdx] = mmd.stopIs[i];
                }
                // put back into format of startI and separate r
                mmd.startRs[mergeIntoIdx] = mmd.startRs[i];
                mmd.startIs[mergeIntoIdx] = mmd.startIs[i];
            } else if (interval.min() <= mstopI && (interval.max() > mstopI)) {
                mmd.stopIs[mergeIntoIdx] = mmd.stopIs[i];
            } else if (interval.min() >= mstartI && interval.max() <= mstopI) {
                // interval is within existing mmd1 interval
                // make sure it gets deleted
            }
        }
    }
    // TODO: the above doesn't merge adjacent, so need
    // one more pass through the indexes, but with
    // a query for adjacent pixel values
    if (rmSet.isEmpty()) {
        return mmd;
    }
    int nTot = mmd.offsets.length - rmSet.size();
    MergedMinDiffs mmdm = new MergedMinDiffs(nTot);
    int count = 0;
    for (int i = 0; i < mmd.offsets.length; ++i) {
        if (rmSet.contains(i)) {
            continue;
        }
        mmdm.offsets[count] = mmd.offsets[i];
        mmdm.startIs[count] = mmd.startIs[i];
        mmdm.startRs[count] = mmd.startRs[i];
        mmdm.stopIs[count] = mmd.stopIs[i];
        count++;
    }
    assert (count == nTot);
    log.fine("condensed " + rmSet.size() + " items");
    return mmdm;
}

[Buggy Hunk]
MergedMinDiffs mmdm = new MergedMinDiffs(nTot);

[Patch]
MergedMinDiffs mmdm = new MergedMinDiffs(nTot, n1);