[Demonstration 1]

[Buggy Method]
public static String scrypt(String passwd, int N, int r, int p) {
    try {
        byte[] salt = new byte[16];
        SecureRandom.getInstance("SHA1PRNG").nextBytes(salt);
        byte[] derived = SCrypt.scrypt(passwd.getBytes("UTF-8"), salt, N, r, p, 28);
        String params = Long.toString(log2(N) << 16L | r << 8 | p, 16);
        StringBuilder sb = new StringBuilder((salt.length + derived.length) * 2);
        sb.append("$s0$").append(params).append('$');
        sb.append(encode(salt)).append('$');
        sb.append(encode(derived));
        return sb.toString();
    } catch (UnsupportedEncodingException e) {
        throw new IllegalStateException("JVM doesn't support UTF-8?");
    } catch (GeneralSecurityException e) {
        throw new IllegalStateException("JVM doesn't support SHA1PRNG or HMAC_SHA256?");
    }
}

[Buggy Hunk]
byte[] derived = SCrypt.scrypt(passwd.getBytes("UTF-8"), salt, N, r, p, 28);

[Patch]
byte[] derived = SCrypt.scrypt(passwd.getBytes("UTF-8"), salt, N, r, p, HASH_LENGTH);

[Demonstration 2]

[Buggy Method]
public Span[] sentPosDetect(String s) {
    List<Span> sentences = new ArrayList<Span>();
    int start = 0;
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        if (c == '\n' || c == '\r') {
            if (start - i > 0) {
                Span span = new Span(start, i).trim(s);
                if (span.length() > 0) {
                    sentences.add(span);
                }
                start = i + 1;
            }
        }
    }
    if (s.length() - start > 0) {
        Span span = new Span(start, s.length()).trim(s);
        if (span.length() > 0) {
            sentences.add(span);
        }
    }
    return sentences.toArray(new Span[sentences.size()]);
}

[Buggy Hunk]
if (start - i > 0) {

[Patch]
if (i - start > 0) {

[Demonstration 3]

[Buggy Method]
public Verifier v(byte[] I, byte[] P, byte[] salt) {
    Verifier verifier = new Verifier();
    this.mHash.reset();
    this.mHash.update(I);
    this.mHash.update(":".getBytes(Charset.forName("UTF-8")));
    this.mHash.update(P);
    byte[] tempHash = mHash.digest();
    mHash.reset();
    mHash.update(salt);
    mHash.update(tempHash);
    BigInteger hashResult = new BigInteger(mHash.digest());
    BigInteger verifierResult = mG.modPow(hashResult, mPrime);
    String verifierString = verifierResult.toString(16);
    if (verifierString.length() % 2 == 1)
        verifierString = "0" + verifierResult.toString(16);
    verifier.setVerifier(verifierString);
    verifier.setSalt(new BigInteger(salt).toString(16));
    return verifier;
}

[Buggy Hunk]
verifier.setSalt(new BigInteger(salt).toString(16));

[Patch]
verifier.setSalt(Hex.encode(salt));