[Demonstration 1]

[Buggy Method]
@Override
protected InstrumentAssignmentArchitecture evolve(InstrumentAssignmentArchitecture child) {
    InstrumentAssignmentArchitecture arch = (InstrumentAssignmentArchitecture) child.copy();
    try {
        int[] orbitArray;
        if (orbit == -2) {
            orbitArray = allOrbits;
        } else {
            if (orbit == -1) {
                orbitArray = new int[] { pprng.nextInt(EOSSDatabase.getNumberOfOrbits()) };
            } else {
                orbitArray = new int[] { orbit };
            }
        }
        for (int orbitInd : orbitArray) {
            switch(mode) {
                //mode when we want specific orbit to instrument patterns
                case 0:
                    int[] instID = new int[instrument.length];
                    //case when instrument id is a wildcard
                    if (instrument[0] == -1) {
                        //select a random instrument for the orbit
                        instID[0] = pprng.nextInt(EOSSDatabase.getNumberOfInstruments());
                    } else {
                        instID = instrument;
                    }
                    //Case when we want to have instruments absent or separated
                    if (arg == 0) {
                        int removedInstCount = 0;
                        int maxRemovalAllowed;
                        if (orbit == -2 && instID.length > 1) {
                            //this would be case like separate2 or separate3
                            maxRemovalAllowed = instID.length - 1;
                        } else {
                            maxRemovalAllowed = EOSSDatabase.getNumberOfInstruments();
                        }
                        for (int index : instID) {
                            arch.removeInstrumentFromOrbit(index, orbitInd);
                            removedInstCount++;
                            if (removedInstCount >= maxRemovalAllowed) {
                                break;
                            }
                        }
                    } else {
                        //case when we want to have instruments present
                        //add all instruments from instID array
                        for (int index : instID) {
                            arch.addInstrumentToOrbit(index, orbitInd);
                        }
                    }
                    break;
                //mode when we want to match the number of orbits occupied
                case 1:
                    //case when there are more orbits occupied than the target value
                    if (arch.getNorbits() > arg) {
                        while (arch.getNorbits() > arg) {
                            Orbit[] occupiedOrbits = arch.getOccupiedOrbits();
                            Orbit orbitToRemove = occupiedOrbits[pprng.nextInt(occupiedOrbits.length)];
                            int orbitIndexToRemove = EOSSDatabase.findOrbitIndex(orbitToRemove);
                            ArrayList<Integer> instrumentsToRemove = arch.getInstrumentsInOrbit(orbitIndexToRemove);
                            for (Integer inst : instrumentsToRemove) {
                                arch.removeInstrumentFromOrbit(inst, orbitIndexToRemove);
                            }
                        }
                    } else if (arch.getNorbits() < arg) {
                        while (arch.getNorbits() < arg) {
                            Orbit[] emptyOrbits = arch.getEmptyOrbits();
                            Orbit orbitToAdd = emptyOrbits[pprng.nextInt(emptyOrbits.length)];
                            int orbitIndexToAdd = EOSSDatabase.findOrbitIndex(orbitToAdd);
                            int randInstToAdd = pprng.nextInt(EOSSDatabase.getNumberOfInstruments());
                            arch.addInstrumentToOrbit(randInstToAdd, orbitIndexToAdd);
                        }
                    }
                    break;
                //mode when we want to match the number of instruments used in a particular orbit
                case 2:
                    if (arch.getInstrumentsInOrbit(orbitInd).size() > arg) {
                        while (arch.getInstrumentsInOrbit(orbitInd).size() > arg) {
                            ArrayList<Integer> insts = arch.getInstrumentsInOrbit(orbitInd);
                            arch.removeInstrumentFromOrbit(insts.get(pprng.nextInt(insts.size())), orbitInd);
                        }
                    } else if (arch.getInstrumentsInOrbit(orbitInd).size() < arg) {
                        while (arch.getInstrumentsInOrbit(orbitInd).size() < arg) {
                            ArrayList<Integer> insts = arch.getInstrumentsInOrbit(orbitInd);
                            ArrayList<Integer> unassignedInst = new ArrayList<>(insts.size());
                            for (int i = 0; i < insts.size(); i++) {
                                unassignedInst.add(i);
                            }
                            unassignedInst.removeAll(insts);
                            arch.removeInstrumentFromOrbit(unassignedInst.get(pprng.nextInt(unassignedInst.size())), orbitInd);
                        }
                    }
                    break;
                default:
                    throw new UnsupportedOperationException(String.format("Expected mode to be {0,1,2}. Found %d", mode));
            }
        }
    } catch (Exception e) {
        System.err.println("");
    }
    return arch;
}

[Buggy Hunk]
arch.removeInstrumentFromOrbit(unassignedInst.get(pprng.nextInt(unassignedInst.size())), orbitInd);

[Patch]
arch.addInstrumentToOrbit(unassignedInst.get(pprng.nextInt(unassignedInst.size())), orbitInd);

[Demonstration 2]

[Buggy Method]
public static String compare(String stringData) {
    String result = "";
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date = null;
    try {
        date = simpleDateFormat.parse(stringData);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    long millisSecond = convertToMillisSecond(date);
    long currencyMillisSecond = System.currentTimeMillis();
    if (currencyMillisSecond > millisSecond) {
        long diff = currencyMillisSecond - millisSecond;
        long day = 86400000L;
        if (diff < day && getCurrentDayOfMonth() == getDateDayOfMonth(date)) {
            result = convertMillisSecondsToHourString(millisSecond);
        } else if (diff < (day * 2)) {
            result = "yesterday";
        } else {
            result = convertMillisSecondsToDateString(millisSecond);
        }
    }
    return result;
}

[Buggy Hunk]
} else if (diff < (day * 2)) {

[Patch]
} else if (diff < (day * 2) && getCurrentDayOfMonth() -1 == getDateDayOfMonth(date)) {

[Demonstration 3]

[Buggy Method]
public static Image getImageOfSymbol(int index) {
    if (symbolsImages == null) {
        try {
            symbolsImages = new Image[SYMBOLS];
            for (int i = 0; i < SYMBOLS; i++) {
                URL url = new URL("platform:/plugin/com.milkneko.mngefexamples.trollseditor/symbols/" + (i + 1) + ".png");
                InputStream inputStream = url.openConnection().getInputStream();
                symbolsImages[i] = new Image(null, inputStream);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return symbolsImages[index];
}

[Buggy Hunk]
URL url = new URL("platform:/plugin/com.milkneko.mngefexamples.trollseditor/symbols/" + (i + 1) + ".png" );

[Patch]
URL url = new URL("platform:/plugin/com.milkneko.mngefexamples.trollseditor/symbols/" + i + ".png");