[Demonstration 1]

[Buggy Method]
static AlchemyGenerator<Double> createGeneratorFor(GenerateDouble annotation) {
    checkNotNull(annotation, "missing annotation");
    Type type = annotation.value();
    checkNotNull(type, "@GenerateDouble missing value");
    if (type == RANGE) {
        double min = annotation.min();
        double max = annotation.max();
        checkThat(min < max, "@GenerateDouble: min must be less than max");
        return doubles(min, max);
    }
    //Cover remaining cases
    switch(type) {
        case POSITIVE:
            return positiveDoubles();
        case NEGATIVE:
            return doubles(-Double.MAX_VALUE, 0);
        default:
            return doubles(-Double.MAX_VALUE, Double.MAX_VALUE);
    }
}

[Buggy Hunk]
return doubles(-Double.MAX_VALUE, 0);

[Patch]
return doubles(-Double.MAX_VALUE, -Double.MAX_VALUE);

[Demonstration 2]

[Buggy Method]
public static Pair<List<ResourceList>, List<ResourceList>> getParetoCurve(List<ResourceList> resources) {
    List<ResourceList> paretoCurve = new ArrayList();
    List<ResourceList> remaining = new ArrayList();
    double limitTime = Double.MAX_VALUE;
    // sort the list of ResourceList by cost
    Collections.sort(resources, new Comparator<ResourceList>() {

        // returns 1 if r2 before r1 and -1 otherwise
        @Override
        public int compare(ResourceList r1, ResourceList r2) {
            return r2.getFullCost() < r1.getFullCost() ? 1 : -1;
        }
    });
    // for all remaining pairs
    for (ResourceList resource : resources) {
        double execTime = resource.getMaxTime();
        // if second argument is less than or equal to the limit
        if (execTime <= limitTime) {
            // add to the curve and set it as the new limit
            paretoCurve.add(resource);
            limitTime = execTime;
        } else
            remaining.add(resource);
    }
    return new Pair(paretoCurve, remaining);
}

[Buggy Hunk]
double limitTime = Double.MAX_VALUE;

[Patch]
double limitTime = Double.POSITIVE_INFINITY;

[Demonstration 3]

[Buggy Method]
@Override
public void onTouch(int x, int y) {
    if (firstMove) {
        if (players[counter % 2] instanceof HumanPlayer && !resolveFirstMove(x, y))
            return;
    }
    firstMove = false;
    Point temp = players[counter % 2].resolveMove(new Point(y, x));
    Log.v("temp", temp.x + " " + temp.y);
    if (!temp.equals(inValid)) {
        if (selectedPiece.getRank() > 0 && temp.equals(players[counter % 2].getSumoPushPoint())) {
            sumoChain = players[counter % 2].getSumoChain();
            switch(counter % 2) {
                case PLAYER_TWO:
                    resolveSumoPushP1();
                    break;
                case PLAYER_ONE:
                    resolveSumoPushP2();
                    break;
            }
            counter++;
        } else
            board.move(new Point(selectedPiece.getY(), selectedPiece.getX()), temp);
        counter++;
        //find next piece
        Point winPoint = GameLogic.win(board);
        if (!winPoint.equals(-1, -1)) {
            Piece winPiece = board.getTile(winPoint.y, winPoint.x).getPiece();
            int winPlayer = winPiece.getOwner();
            score[winPlayer] += scores[winPiece.getRank()];
            win = winPlayer;
            gameBoardView.updateScore(score);
            board.rankUp(winPiece.getY(), winPiece.getX());
        } else {
            win = -1;
        }
        resolveNormalMove(temp.y, temp.x);
        if (win != -1) {
            Log.v("game", "somebody has won");
            counter = win;
            //if it's a player, just return and wait for swipe
            //if ai,
            if (players[counter % 2] instanceof AIPlayer) {
                onSwipeLeft();
                Point A = players[counter % 2].selectPiece(board);
                selectedPiece = board.getTile(A.x, A.y).getPiece();
                availMoves = players[counter % 2].calcMoves(board, selectedPiece);
                onTouch(-1, -1);
            } else
                return;
        } else {
            if (players[counter % 2] instanceof AIPlayer && win == -1)
                onTouch(-1, -1);
        }
    }
}

[Buggy Hunk]
Piece winPiece = board.getTile(winPoint.y, winPoint.x).getPiece();

[Patch]
Piece winPiece = board.getTile(winPoint.x, winPoint.y).getPiece();