[Demonstration 1]

[Buggy Method]
private void addStateInfo(Subdivision subdivision, final ContainerRequestContext containerRequestContext) {
    if (Strings.isNullOrEmpty(subdivision.getName()))
        containerRequestContext.getHeaders().putSingle(MaxMindHeaders.X_STATE, subdivision.getName());
}

[Buggy Hunk]
if (Strings.isNullOrEmpty(subdivision.getName()))

[Patch]
if (!Strings.isNullOrEmpty(subdivision.getName()))

[Demonstration 2]

[Buggy Method]
public static LinkedList<String> getArgsFromText(String text) {
    final LinkedList<String> args = new LinkedList<>();
    final Pattern p = Pattern.compile("([\"'])(?:(?=(\\\\?))\\2.)*?\\1|([^\\s]+)");
    final Matcher m = p.matcher(text);
    while (m.find()) {
        String s = m.group();
        if (s.startsWith("\'") || s.startsWith("\""))
            s = s.substring(1, s.length() - 1);
        args.add(s.toLowerCase());
    }
    return args;
}

[Buggy Hunk]
args.add(s.toLowerCase());

[Patch]
args.add(s);

[Demonstration 3]

[Buggy Method]
private static Node getLustreNode(AgreeNode agreeNode, String nodePrefix, boolean monolithic) {
    List<VarDecl> inputs = new ArrayList<>();
    List<VarDecl> locals = new ArrayList<>();
    List<Equation> equations = new ArrayList<>();
    List<Expr> assertions = new ArrayList<>();
    Expr assumeConjExpr = new BoolExpr(true);
    int i = 0;
    for (AgreeStatement statement : agreeNode.assumptions) {
        String inputName = assumeSuffix + i++;
        inputs.add(new AgreeVar(inputName, NamedType.BOOL, statement.reference, agreeNode.compInst));
        IdExpr assumeId = new IdExpr(inputName);
        assertions.add(new BinaryExpr(assumeId, BinaryOp.EQUAL, statement.expr));
        assumeConjExpr = new BinaryExpr(assumeId, BinaryOp.AND, assumeConjExpr);
    }
    int j = 0;
    if (monolithic) {
        for (AgreeStatement statement : agreeNode.lemmas) {
            String inputName = lemmaSuffix + j++;
            inputs.add(new AgreeVar(inputName, NamedType.BOOL, statement.reference, agreeNode.compInst));
            IdExpr lemmaId = new IdExpr(inputName);
            assertions.add(new BinaryExpr(lemmaId, BinaryOp.EQUAL, statement.expr));
        }
    }
    String assumeHistName = assumeSuffix + "__HIST";
    String assumeConjName = assumeSuffix + "__CONJ";
    IdExpr assumeHistId = new IdExpr(assumeHistName);
    IdExpr assumeConjId = new IdExpr(assumeConjName);
    locals.add(new VarDecl(assumeHistName, NamedType.BOOL));
    locals.add(new VarDecl(assumeConjName, NamedType.BOOL));
    equations.add(new Equation(assumeConjId, assumeConjExpr));
    equations.add(getHist(assumeHistId, assumeConjId));
    Expr guarConjExpr = new BoolExpr(true);
    for (AgreeStatement statement : agreeNode.guarantees) {
        guarConjExpr = new BinaryExpr(statement.expr, BinaryOp.AND, guarConjExpr);
    }
    if (monolithic) {
        for (AgreeStatement statement : agreeNode.lemmas) {
            guarConjExpr = new BinaryExpr(statement.expr, BinaryOp.AND, guarConjExpr);
        }
    }
    assertions.add(new BinaryExpr(assumeHistId, BinaryOp.IMPLIES, guarConjExpr));
    //we only add the assertions of an agreenode if we are performing
    //monolithic verification. However, we should add EQ statements
    //with left hand sides which part of the agreeNode assertions
    for (AgreeStatement statement : agreeNode.assertions) {
        if (monolithic || statement.reference instanceof EqStatement || statement.reference instanceof PropertyStatement) {
            if (!monolithic) {
                EObject container = statement.reference.eContainer();
                while (!(container instanceof ComponentClassifier)) {
                    container = container.eContainer();
                }
                if (container instanceof ComponentImplementation) {
                    //throw away eqs and property statements in the implementation
                    continue;
                }
            }
            assertions.add(statement.expr);
        }
    }
    Expr assertExpr = new BoolExpr(true);
    for (Expr expr : assertions) {
        assertExpr = new BinaryExpr(expr, BinaryOp.AND, assertExpr);
    }
    String outputName = "__ASSERT";
    List<VarDecl> outputs = new ArrayList<>();
    outputs.add(new VarDecl(outputName, NamedType.BOOL));
    equations.add(new Equation(new IdExpr(outputName), assertExpr));
    //gather the remaining inputs
    for (AgreeVar var : agreeNode.inputs) {
        inputs.add(var);
    }
    for (AgreeVar var : agreeNode.outputs) {
        inputs.add(var);
    }
    return new Node(nodePrefix + agreeNode.id, inputs, outputs, locals, equations);
}

[Buggy Hunk]
private static Node getLustreNode(AgreeNode agreeNode, String nodePrefix, boolean monolithic){

[Patch]
protected static Node getLustreNode(AgreeNode agreeNode, String nodePrefix, boolean monolithic){