[Demonstration 1]

[Buggy Method]
public void handleTokens(String program, boolean debug) {
    code = program;
    if (program.equalsIgnoreCase("easter egg")) {
        o_O();
        return;
    }
    finish = false;
    StringBuilder token = new StringBuilder();
    String integer = "";
    char[] chars = program.toCharArray();
    StringBuilder sb = new StringBuilder();
    boolean in = false;
    for (int i = 0; i < chars.length; i++) {
        if (chars[i] == '(') {
            in = true;
        } else if (chars[i] == ')') {
            in = false;
        }
        if (!in) {
            String s = String.valueOf(chars[i]);
            for (Map.Entry<String, String> entry : replace.entrySet()) {
                if (s.contains(entry.getKey())) {
                    s = s.replace(entry.getKey(), entry.getValue());
                    break;
                }
            }
            sb.append(s);
        } else {
            sb.append(chars[i]);
        }
    }
    program = sb.toString();
    if (program.contains("-")) {
        String[] sides = program.split("-", 2);
        handleTokens(sides[0]);
        Object pop = stack.pop();
        if (pop.equals(new VarInteger(0)) || (pop instanceof IntList && !((IntList) pop).contains(new VarInteger(1)))) {
            stack.push(new VarInteger(0));
            return;
        }
        program = sides[1];
    }
    if (debug) {
        System.out.println("program >> " + program);
    }
    chars = program.toCharArray();
    for (int i = 0; i < chars.length; i++) {
        char c = chars[i];
        token.append(c);
        String str = token.toString();
        if (debug) {
            System.out.println("current >> " + str);
        }
        if (Util.isInteger(str)) {
            integer = str;
        } else if (!integer.isEmpty()) {
            stack.push(new VarInteger(new BigInteger(integer)));
            integer = "";
            token.setLength(0);
            token.append(c);
        }
        str = token.toString();
        if (tokens.containsKey(str)) {
            handleToken(str);
            token.setLength(0);
        } else if (manipulator.containsKey(str)) {
            token.setLength(0);
            NStack ns = manipulator.get(str).manipulator(stack, this);
            NStack newStack = new NStack(input);
            for (Object o : ns) {
                newStack.push(o);
            }
            stack = newStack;
        } else if (special.containsKey(str)) {
            token.setLength(0);
            int k = i + 1;
            int push = 0;
            for (; k < chars.length; k++) {
                String at = String.valueOf(chars[k]);
                if (special.containsKey(at) && !(special.get(str) instanceof Base255)) {
                    push++;
                }
                if (at.equals(")")) {
                    push--;
                    if (push < 0) {
                        break;
                    }
                } else if (at.equals("}") && !(special.get(str) instanceof Base255)) {
                    break;
                }
                token.append(chars[k]);
            }
            i = k;
            handleSpecial(str, token.toString());
            token.setLength(0);
        } else if (twoToken.containsKey(str)) {
            token.setLength(0);
            int k = i + 1;
            sb = new StringBuilder();
            for (; k < chars.length; k++) {
                sb.append(chars[k]);
                if (tokens.containsKey(sb.toString())) {
                    TwoToken tt = twoToken.get(str);
                    stack = tt.twoToken(stack, sb.toString(), this);
                    break;
                }
            }
            i = k;
        } else if (twoChar.containsKey(str)) {
            StringBuilder theChar = new StringBuilder();
            List<String> codePage = Arrays.asList(Util.getCodepage());
            do {
                i++;
                theChar.append(chars[i]);
            } while ((!codePage.contains(theChar.toString())));
            stack = twoChar.get(str).twoChar(stack, theChar.toString(), this);
            token.setLength(0);
        }
        if (debug) {
            System.out.println("stack >> " + stack);
        }
        if (finish || finishSilent) {
            break;
        }
    }
    if (!integer.isEmpty()) {
        stack.push(new VarInteger(new BigInteger(integer)));
    }
}

[Buggy Hunk]
handleTokens(sides[0]);

[Patch]
handleTokens(sides[0], debug);

[Demonstration 2]

[Buggy Method]
public String getUserPassword(String email) {
    Result<Record> result = create.select().from(USER).fetch();
    for (Record r : result) {
        System.out.print("Is " + r.getValue(USER.EMAIL).toString() + " the same as " + email + "? ");
        if (r.getValue(USER.EMAIL).toString().compareTo(email) == 0)
            return r.getValue(USER.PASSWORD).toString();
        System.out.print("No... ");
    }
    return null;
}

[Buggy Hunk]
System.out.print("No... ");

[Patch]
System.out.println("No... ");

[Demonstration 3]

[Buggy Method]
public Stack<GoPiece[][]> getPositions() {
    return positions;
}

[Buggy Hunk]
public Stack<GoPiece[][]> getPositions()

[Patch]
public Stack<Point> getPositions()