[Demonstration 1]

[Buggy Method]
private boolean isUnchecked(CtTypeReference<?> throwable) {
    Class<?> throwableClass = throwable.getActualClass();
    if (RuntimeException.class.isAssignableFrom(throwableClass) | Error.class.isAssignableFrom(throwableClass)) {
        return true;
    }
    return false;
}

[Buggy Hunk]
if(RuntimeException.class.isAssignableFrom(throwableClass) | Error.class.isAssignableFrom(throwableClass)){

[Patch]
if(RuntimeException.class.isAssignableFrom(throwableClass) || Error.class.isAssignableFrom(throwableClass)){

[Demonstration 2]

[Buggy Method]
public String saveAsString() throws YAMLNotInitializedException {
    StringBuilder yamlString = new StringBuilder();
    int writeCount = getLogicalLineCount();
    String writeLine;
    String inlineKey = "";
    boolean inline = false;
    for (int i = 0; i < writeCount; i++) {
        writeLine = getLogicalLine(i);
        if (inline && writeLine.startsWith("inline." + inlineKey)) {
            continue;
        }
        inline = false;
        yamlString.append("\n");
        if (writeLine.startsWith("group.")) {
            writeLine = writeLine.substring(6);
            yamlString.append(getIndentation(writeLine));
            yamlString.append(getWriteKey(writeLine)).append(':');
        } else if (writeLine.startsWith("inline.")) {
            inline = true;
            writeLine = writeLine.substring(7);
            inlineKey = writeLine.substring(0, writeLine.lastIndexOf('.'));
            try {
                List<String> list = getStringList(inlineKey, null);
                int listSize = list == null ? 0 : list.size();
                if (i + listSize < writeCount && !getLogicalLine(i + listSize + 1).startsWith("inline." + inlineKey)) {
                    yamlString.append(inlineKey).append(": [");
                    yamlString.append(getWriteValue(inlineKey + ".0"));
                    for (int j = 1; j < listSize; j++) {
                        yamlString.append(", ");
                        yamlString.append(getWriteValue(inlineKey + '.' + j));
                    }
                    yamlString.append("]");
                    i += listSize - 1;
                } else {
                    yamlString.append(inlineKey).append(": {");
                    yamlString.append(getKeyValuePair(writeLine, false));
                    while (i < writeCount) {
                        writeLine = getLogicalLine(++i);
                        if (writeLine.startsWith("inline." + inlineKey)) {
                            yamlString.append(", ");
                            yamlString.append(getKeyValuePair(writeLine.substring(7), false));
                        } else {
                            break;
                        }
                    }
                    --i;
                    yamlString.append("}");
                }
                if (list != null) {
                    list.clear();
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        } else if (writeLine.startsWith("key.")) {
            writeLine = writeLine.substring(4);
            yamlString.append(getKeyValuePair(writeLine, true));
        } else {
            yamlString.append(writeLine);
        }
    }
    return yamlString.toString().substring(1);
}

[Buggy Hunk]
if (i + listSize < writeCount && !getLogicalLine(i + listSize + 1).startsWith("inline." + inlineKey))

[Patch]
if ((i + listSize < writeCount && !getLogicalLine(i + listSize + 1).startsWith("inline." + inlineKey)) || (i + listSize >= writeCount))

[Demonstration 3]

[Buggy Method]
public static Object generateDefaultValue(Class<?> type) {
    try {
        if (Integer.class.isAssignableFrom(type)) {
            return type.getConstructor(int.class).newInstance(0);
        } else if (Short.class.isAssignableFrom(type)) {
            return type.getConstructor(short.class).newInstance((short) 0);
        } else if (Long.class.isAssignableFrom(type)) {
            return type.getConstructor(long.class).newInstance(0);
        } else if (Float.class.isAssignableFrom(type)) {
            return type.getConstructor(float.class).newInstance(0);
        } else if (Double.class.isAssignableFrom(type)) {
            return type.getConstructor(double.class).newInstance(0);
        } else if (Boolean.class.isAssignableFrom(type)) {
            return type.getConstructor(boolean.class).newInstance(false);
        } else if (Character.class.isAssignableFrom(type)) {
            return type.getConstructor(char.class).newInstance('\u0000');
        } else if (Byte.class.isAssignableFrom(type)) {
            return type.getConstructor(byte.class).newInstance((byte) 0);
        } else {
            return type.newInstance();
        }
    } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
        return null;
    }
}

[Buggy Hunk]
catch(InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e)

[Patch]
catch(InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException exception)