[Demonstration 1]

[Buggy Method]
public static void main(String[] args) {
    if (args.length == 0) {
        showHelp();
    } else if (args.length < 4) {
        showHelp();
    } else {
        File file = new File("features");
        ArrayList<String> inputLines = new ArrayList<>();
        String outputFile;
        String line;
        if (file.exists()) {
            inputLines = getFileContentsAsLines("features");
            outputFile = null;
            boolean result = false;
            String[] toLower = null;
            label115: for (int hasLabel = 0; hasLabel < inputLines.size(); ++hasLabel) {
                String cps = (String) inputLines.get(hasLabel);
                toLower = cps.split(" ");
                outputFile = toLower[0];
                result = Boolean.parseBoolean(toLower[1]);
                for (int seq = 0; seq < PARAMETER_NAMES.length; ++seq) {
                    line = PARAMETER_NAMES[seq];
                    if (outputFile.equalsIgnoreCase(line)) {
                        switch(seq) {
                            case 0:
                                SINGLE_WORD = result;
                                continue label115;
                            case 1:
                                TWO_CONSECUTIVE_WORDS = result;
                                continue label115;
                            case 2:
                                SINGLE_POS_TAG = result;
                                continue label115;
                            case 3:
                                TWO_CONSECUTIVE_POS_TAGS = result;
                                continue label115;
                            case 4:
                                THREE_CONSECUTIVE_POS_TAGS = result;
                                continue label115;
                            case 5:
                                SINGLE_POS_TAG_AND_SINGLE_WORD = result;
                                continue label115;
                            case 6:
                                TWO_CONSECUTIVE_POS_TAGS_AND_SINGLE_WORD = result;
                                continue label115;
                            case 7:
                                TWO_CONSECUTIVE_WORDS_AND_SINGLE_POS_TAG = result;
                            default:
                                continue label115;
                        }
                    }
                }
            }
        }
        inputLines = getFileContentsAsLines(args[1]);
        outputFile = args[2];
        StringBuilder var16 = new StringBuilder();
        boolean var17 = false;
        if (args.length > 3 && args[3].equalsIgnoreCase("tolower")) {
            var17 = true;
        }
        boolean var18 = false;
        if (args[0].equalsIgnoreCase("-lbl")) {
            var18 = true;
        }
        new Observation();
        Sequence var20 = new Sequence();
        line = null;
        for (int lineNumber = 0; lineNumber < inputLines.size(); ++lineNumber) {
            line = (String) inputLines.get(lineNumber);
            if (var17) {
                line = line.toLowerCase();
            }
            StringTokenizer tok = new StringTokenizer(line, " \t\r\n");
            int len = tok.countTokens();
            if (len <= 0) {
                if (var20.size() > 0) {
                    for (int var21 = 0; var21 < var20.size(); ++var21) {
                        try {
                            Observation var19 = getFeatures(var20, var21);
                            for (int e = 0; e < var19.size(); ++e) {
                                var16.append((String) var19.get(e)).append(' ');
                            }
                            if (var18 && ((Observation) var20.get(var21)).size() > 1) {
                                var16.append((String) ((Observation) var20.get(var21)).get(((Observation) var20.get(var21)).size() - 1));
                            }
                            var16.append('\n');
                        } catch (Exception var15) {
                            var15.printStackTrace();
                            System.out.println("Error in line number = " + lineNumber);
                            return;
                        }
                    }
                    var16.append('\n');
                }
                var20.clear();
            } else {
                Observation obsr = new Observation();
                while (tok.hasMoreTokens()) {
                    obsr.add(tok.nextToken());
                }
                var20.add(obsr);
            }
        }
        writeFileContentsFromString(outputFile, var16.toString());
    }
}

[Buggy Hunk]
System.out.println("Error in line number = " + lineNumber);

[Patch]
System.out.println("Error in line number = " + lineNumber + "(" + var21 + ") : " + line + StringUtils.join(var20));

[Demonstration 2]

[Buggy Method]
void play() throws IOException {
    do {
        userOutput.showMainMenu();
        OPTION_MENU OPTION = userInput.getOptionSelected();
        validateMainOption(OPTION);
    } while (!exit);
}

[Buggy Hunk]
void play() throws IOException {

[Patch]
void play() {

[Demonstration 3]

[Buggy Method]
@Override
public <TInput, TOutput> CommandResult<TOutput> execute(ServiceLocator locator, Serialization<TInput> input, Serialization<TOutput> output, TInput data, Principal principal) {
    if (data == null) {
        return CommandResult.badRequest("Data to persist not specified.");
    }
    Argument<TInput> arg;
    try {
        arg = input.deserialize(data, Argument.class, data.getClass());
    } catch (IOException e) {
        return CommandResult.badRequest(e.getMessage());
    }
    Optional<Class<?>> manifest = domainModel.find(arg.RootName);
    if (!manifest.isPresent()) {
        return CommandResult.badRequest("Couldn't find root type: " + arg.RootName);
    }
    if (!permissions.canAccess(manifest.get(), principal)) {
        return CommandResult.forbidden(arg.RootName);
    }
    if (arg.ToInsert == null && arg.ToUpdate == null && arg.ToDelete == null) {
        return CommandResult.badRequest("Data to persist not specified.");
    }
    List<AggregateRoot> insertData = null;
    List<Map.Entry<AggregateRoot, AggregateRoot>> updateData = null;
    List<AggregateRoot> deleteData = null;
    try {
        if (arg.ToInsert != null) {
            insertData = input.deserialize(arg.ToInsert, ArrayList.class, manifest.get());
        }
        if (arg.ToUpdate != null) {
            ArrayList<Pair> pairs = input.deserialize(arg.ToUpdate, ArrayList.class, Utils.makeGenericType(Pair.class, manifest.get()));
            if (pairs != null) {
                updateData = new ArrayList<>(pairs.size());
                for (Pair item : pairs) {
                    if (item.Value != null) {
                        updateData.add(new AbstractMap.SimpleEntry(item.Key, item.Value));
                    }
                }
                if (updateData.size() != pairs.size()) {
                    ArrayList<AggregateRoot> values = input.deserialize(arg.ToUpdate, ArrayList.class, manifest.get());
                    if (values != null) {
                        updateData = new ArrayList<>(values.size());
                        for (AggregateRoot item : values) {
                            updateData.add(new AbstractMap.SimpleEntry(null, item));
                        }
                    }
                }
            }
        }
        if (arg.ToDelete != null) {
            deleteData = input.deserialize(arg.ToDelete, ArrayList.class, manifest.get());
        }
    } catch (IOException e) {
        return CommandResult.badRequest("Error deserializing provided input for: " + arg.RootName + ". Reason: " + e.getMessage());
    }
    if ((insertData == null || insertData.size() == 0) && (updateData == null || updateData.size() == 0) && (updateData == null || updateData.size() == 0)) {
        return CommandResult.badRequest("Data not sent or deserialized unsuccessfully.");
    }
    PersistableRepository repository;
    try {
        repository = locator.resolve(PersistableRepository.class, manifest.get());
    } catch (ReflectiveOperationException e) {
        return CommandResult.badRequest("Error resolving repository for: " + arg.RootName + ". Reason: " + e.getMessage());
    }
    try {
        String[] uris = repository.persist(insertData, updateData, deleteData);
        return new CommandResult<>(output.serialize(uris), "Data persisted", 200);
    } catch (IOException ex) {
        return new CommandResult<>(null, ex.getMessage(), 409);
    }
}

[Buggy Hunk]
&& (updateData == null || updateData.size() == 0)) {

[Patch]
&& (deleteData == null || deleteData.size() == 0)) {