public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    char[] input = br.readLine().toCharArray();

    LinkedList<Character> list = new LinkedList<>();
    for (char c : input) {
        list.add(c);
    }

    ListIterator<Character> it = list.listIterator();
    while (it.hasNext()) {
        it.next();
    }

    int n = Integer.parseInt(br.readLine());

    while (n-- > 0) {
        String command = br.readLine();

        switch (command) {
            case "L" :
                if (it.hasPrevious()) {
                    it.previous();
                }
                break;
            case "D" :
                if (it.hasNext()) {
                    it.next();
                }
                break;
            case "B" :
                if (it.hasPrevious() && !list.isEmpty()) {
                    it.previous();
                    it.remove();
                }
                break;
            default:
                it.add(command.charAt(2));
                break;
        }
    }

    StringBuilder sb = new StringBuilder();
    for (char c : list) {
        sb.append(c);
    }

    System.out.println(sb);
}

case "B" :
        if (it.hasPrevious() && !list.isEmpty()) {
            it.previous();
            it.remove();
        }
        break;

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    int[] nm = convertStringArrayToIntegerArray(br.readLine().split(" "));
    int n = nm[0];
    int m = nm[1];

    boolean[][] graph = new boolean[n+1][n+1];
    while (m-- > 0) {
        int[] xy = convertStringArrayToIntegerArray(br.readLine().split(" "));

        graph[xy[0]][xy[1]] = true;
        graph[xy[1]][xy[0]] = true;
    }

    int answer = 0;

    boolean[] isVisit = new boolean[n+1];
    for (int i = 1; i < graph.length; i++) {
        if (!isVisit[i]) {
            answer += bfs(isVisit, graph, i);
        }
    }

    System.out.println(answer);
}

private static int[] convertStringArrayToIntegerArray(String[] args) {
    int[] array = new int[args.length];
    int i = 0;
    for (String str : args) {
        array[i++] = Integer.parseInt(str);
    }

    return array;
}

private static int bfs(boolean[] isVisit, boolean[][] graph,int startIndex) {
    Queue<Integer> queue = new LinkedList<>();
    queue.offer(startIndex);
    isVisit[startIndex] = true;

    while (!queue.isEmpty()) {
        int x = queue.poll();

        for (int i = 1; i < isVisit.length; i++) {
            if (isVisit[i]) {
                continue;
            }

            if (graph[x][i]) {
                queue.offer(i);
                isVisit[i] = true;
            }
        }
    }

    return 1;
}

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int n = Integer.parseInt(br.readLine());
    br.readLine();

    int answer = solution(n, br.readLine());

    System.out.println(answer);
}

public static int solution(int n, String target) {
    int answer = 0;

    char[] s = target.toCharArray();
    char[] targetString = getTargetString(n).toCharArray();
    int[] fail = failFunction(targetString);

    int start = 0;
    int m = 0;

    while (start <= s.length - targetString.length) {
        if (m < targetString.length && s[start + m] == targetString[m]) {
            ++m;
            if (m == targetString.length) {
                answer++;
            }
        } else {
            if  (m == 0) {
                start++;
            } else {
                start += (m - fail[m - 1]);
                m = fail[m - 1];
            }
        }
    }

    return answer;
}

private static String getTargetString(int n) {
    StringBuilder sb = new StringBuilder();
    sb.append("I");

    while (n-- > 0) {
        sb.append("OI");
    }
    return sb.toString();
}

private static int[] failFunction(char[] target) {
    int n = target.length;
    int[] fail = new int[n];

    int start = 1;
    int m = 0;

    while (start + m < n) {
        if (target[start + m] == target[m]) {
            m++;
            fail[start + m - 1] = m;
        } else {
            if (m == 0) {
                start++;
            } else {
                start += (m - fail[m - 1]);
                m = fail[m - 1];
            }
        }
    }

    return fail;
}

private static int[] failFunction(char[] target) {
    int n = target.length;
    int[] fail = new int[n];

    int start = 1;
    int m = 0;

    while (start + m < n) {
        if (target[start + m] == target[m]) {
            m++;
            fail[start + m - 1] = m;
        } else {
            if (m == 0) {
                start++;
            } else {
                start += (m - fail[m - 1]);
                m = fail[m - 1];
            }
        }
    }

    return fail;
}

public static int solution(int n, String target) {
    int answer = 0;

    char[] s = target.toCharArray();
    char[] targetString = getTargetString(n).toCharArray();
    int[] fail = failFunction(targetString);

    int start = 0;
    int m = 0;

    while (start <= s.length - targetString.length) {
        if (m < targetString.length && s[start + m] == targetString[m]) {
            ++m;
            if (m == targetString.length) {
                answer++;
            }
        } else {
            if  (m == 0) {
                start++;
            } else {
                start += (m - fail[m - 1]);
                m = fail[m - 1];
            }
        }
    }

    return answer;
}

assertEquals(4, test.solution(1, "OOIOIOIOIIOII"));
assertEquals(6, test.solution(2, "OOIOIIOIOIOIOIOIOIOIOOIOI"));
assertEquals(7, test.solution(1, "IOIOIOIOIOIOIOI"));

public static void main(String[] args) throws IOException {
    try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {

        int amount = Integer.parseInt(br.readLine());

        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < amount; i++) {
            list.add(Integer.parseInt(br.readLine()));
        }

        Collections.sort(list);

        StringBuilder sb = new StringBuilder();
        for (int i : list) {
            sb.append(i).append("\n");
        }

        System.out.println(sb);
    }
}

...

    static final class LegacyMergeSort {
        private static final boolean userRequested =
            java.security.AccessController.doPrivileged(
                new sun.security.action.GetBooleanAction(
                    "java.util.Arrays.useLegacyMergeSort")).booleanValue();
    }

...

public String solution(String m, String[] musicinfos) {
    String answer = "(None)";

    m = getSharpReplace(m);

    int maxPlayTime = 0;

    for (String music : musicinfos) {
        String[] info = music.split(",");

        int playTimeToMinute = getPlayTime(info[0], info[1]);
        String melody = getMelody(playTimeToMinute, info[3]);

        if (melody.contains(m)) {
            if (maxPlayTime < playTimeToMinute) {
                answer = info[2];
                maxPlayTime = playTimeToMinute;
            }
        }
    }

    return answer;
}

private String getSharpReplace(String arg) {
    return arg.replace("C#", "1")
            .replace("D#", "2")
            .replace("E#", "3")
            .replace("F#", "4")
            .replace("G#", "5")
            .replace("A#", "6");
}

private int getPlayTime(String start, String end) {
    LocalTime startTime = convertLocalTime(start);
    LocalTime endTime = convertLocalTime(end);

    LocalTime playTime = endTime.minusHours(startTime.getHour()).minusMinutes(startTime.getMinute());

    return playTime.getHour() * 60 + playTime.getMinute();
}

private LocalTime convertLocalTime(String time) {
    String[] hourAndMinute = time.split(":");

    return LocalTime.of(Integer.parseInt(hourAndMinute[0]), Integer.parseInt(hourAndMinute[1]), 0);
}

private String getMelody(int playtime, String melody) {
    String sharpReplaceMelody = getSharpReplace(melody);
    StringBuilder sb = new StringBuilder();

    char[] array = sharpReplaceMelody.toCharArray();
    for (int i = 0; i < playtime; i++) {
        sb.append(array[i % sharpReplaceMelody.length()]);
    }

    return sb.toString();
}

assertEquals("HELLO", test.solution("ABCDEFG", new String[] {"12:00,12:14,HELLO,CDEFGAB", "13:00,13:05,WORLD,ABCDEF"}));
assertEquals("FOO", test.solution("CC#BCC#BCC#BCC#B", new String[] {"03:00,03:30,FOO,CC#B", "04:00,04:08,BAR,CC#BCC#BCC#B"}));
assertEquals("WORLD", test.solution("ABC", new String[] {"12:00,12:14,HELLO,C#DEFGAB", "13:00,13:05,WORLD,ABCDEF"}));
assertEquals("(None)", test.solution("CDEFGAC", new String[] {"12:00,12:06,HELLO,CDEFGA"}));
assertEquals("FOO", test.solution("CCB", new String[] {"03:00,03:10,FOO,CCB#CCB", "04:00,04:08,BAR,ABC"}));

public String[] solution(String[] files) {

    List<File> fileList = new ArrayList<>();
    for (int i = 0; i < files.length; i++) {
        char[] array = files[i].toCharArray();

        String originName = files[i];
        String head = "";
        Integer number = 0;

        boolean isString = true;
        int numberStartIndex = 0;
        for (int j = 0; j < array.length; j++) {
            if (isString && isNumber(array[j])) {
                head = new String(array, 0, j).toUpperCase();
                numberStartIndex = j;
                isString = false;
                continue;
            }

            if (!isString && !isNumber(array[j])) {
                number = Integer.parseInt(new String(array, numberStartIndex, j - numberStartIndex));
                isString = true;
                break;
            }
        }

        if (!isString) {
            number = Integer.parseInt(new String(array, numberStartIndex, array.length - numberStartIndex));
        }

        fileList.add(new File(originName, head, number, i));
    }

    sort(fileList);

    return fileList.stream()
            .map(File::getOriginName)
            .toArray(String[]::new);
}

private void sort(List<File> fileList) {
    fileList.sort((f1, f2) -> {
        if (f1.head.compareTo(f2.head) != 0) {
            return f1.head.compareTo(f2.head);
        } else if (f1.number.compareTo(f2.number) != 0) {
            return f1.number.compareTo(f2.number);
        } else {
            return f1.index.compareTo(f2.index);
        }
    });
}

private boolean isNumber(char ch) {
    return (48 <= ch && ch <= 57);
}

static class File {
    private final String originName;
    private final String head;
    private final Integer number;
    private final Integer index;

    public File(String originName, String head, Integer number, Integer index) {
        this.originName = originName;
        this.head = head;
        this.number = number;
        this.index = index;
    }

    public String getOriginName() {
        return this.originName;
    }

    public String getHead() {
        return this.head;
    }

    public Integer getNumber() {
        return this.number;
    }

    public Integer getIndex() {
        return this.index;
    }
}

return fileList.stream()
        .sorted(Comparator.comparing(File::getHead)
        .thenComparing(Comparator.comparing(File::getNumber)
        .thenComparing(File::getIndex)))
        .map(File::getOriginName)
        .toArray(String[]::new);

assertArrayEquals(new String[] {"img1.png", "IMG01.GIF", "img02.png", "img2.JPG", "img10.png", "img12.png"}, test.solution(new String[] {"img12.png", "img10.png", "img02.png", "img1.png", "IMG01.GIF", "img2.JPG"}));
assertArrayEquals(new String[] {"A-10 Thunderbolt II", "B-50 Superfortress", "F-5 Freedom Fighter", "F-14 Tomcat"}, test.solution(new String[] {"F-5 Freedom Fighter", "B-50 Superfortress", "A-10 Thunderbolt II", "F-14 Tomcat"}));
assertArrayEquals(new String[] {"img100.p2ng", "img202.png123"}, test.solution(new String[] {"img202.png123", "img100.p2ng"}));
assertArrayEquals(new String[] {"foo010bar020.zip", "foo010bar030.zip"}, test.solution(new String[] {"foo010bar020.zip", "foo010bar030.zip"}));
assertArrayEquals(new String[] {"F-15", "F-17", "F-22"}, test.solution(new String[] {"F-22", "F-17", "F-15"}));

private static final int ASCII = 32;
private static final char EMPTY = ' ';

public int solution(int m, int n, String[] board) {
    int answer = 0;
    char[][] charBoard = convertStringArrayToCharArray(m, n, board);

    while (true) {
        boolean isEnd = box(charBoard);

        if (isEnd) {
            break;
        }

        answer += delete(charBoard);
    }

    return answer;
}

public char[][] convertStringArrayToCharArray(int m, int n, String[] board) {
    char[][] charBoard = new char[m][n];

    int i = 0;
    for (String str : board) {
        char[] toChar = str.toCharArray();
        charBoard[i] = toChar;
        ++i;
    }

    return charBoard;
}

public char toLowerCase(char value) {
    return (char) ((value >= 65 && value <= 90) ? (value + ASCII) : value);
}

public boolean box(char[][] charBoard) {
    boolean isEnd = true;

    for (int i = 0; i < charBoard.length; i++) {
        for (int j = 0; j < charBoard[i].length; j++) {
            if (validation(i, j, charBoard)) {
                char value = toLowerCase(charBoard[i][j]);
                charBoard[i][j] = value;
                charBoard[i][j+1] = value;
                charBoard[i+1][j] = value;
                charBoard[i+1][j+1] = value;

                isEnd = false;
            }
        }
    }

    return isEnd;
}

private boolean validation(int i, int j, char[][] charBoard) {
    if ((i + 1) == charBoard.length || (j + 1) == charBoard[0].length) {
        return false;
    }
    char position = toLowerCase(charBoard[i][j]);

    if (position == EMPTY) {
        return false;
    }

    char moveX = toLowerCase(charBoard[i][j+1]);
    char moveY = toLowerCase(charBoard[i+1][j]);
    char moveXY = toLowerCase(charBoard[i+1][j+1]);

    if (position != moveX) {
        return false;
    }

    if (position != moveY) {
        return false;
    }

    if (position != moveXY) {
        return false;
    }

    return true;
}

private int delete(char[][] charBoard) {
    int answer = 0;

    for (int i = 0; i < charBoard.length; i++) {
        for (int j = 0; j < charBoard[i].length; j++) {
            if (charBoard[i][j] == EMPTY) {
                continue;
            }

            if (charBoard[i][j] >= 97 && charBoard[i][j] <= 122) {
                if (i != 0) {
                    for (int k = i; k > 0; k--) {
                        charBoard[k][j] = charBoard[k-1][j];
                        charBoard[k-1][j] = EMPTY;
                    }
                } else {
                    charBoard[i][j] = EMPTY;
                }

                ++answer;
            }
        }
    }

    return answer;
}

assertEquals(14, test.solution(4,5, new String[] {"CCBDE", "AAADE", "AAABF", "CCBBF"}));
assertEquals(15, test.solution(6,6, new String[] {"TTTANT", "RRFACC", "RRRFCC", "TRRRAA", "TTMMMF", "TMMTTJ"}));
assertEquals(14, test.solution(4,5, new String[] {"AAAAA","AUUUA","AUUAA","AAAAA"}));
assertEquals(4, test.solution(2,2, new String[] {"AA","AA"}));
assertEquals(0, test.solution(2,2, new String[] {"AA","AB"}));
assertEquals(4, test.solution(3,2, new String[] {"AA","AA", "AB"}));
assertEquals(8, test.solution(4,2, new String[] {"CC","AA", "AA", "CC"}));
assertEquals(12, test.solution(6,2, new String[] {"DD", "CC", "AA", "AA", "CC", "DD"}));
assertEquals(8, test.solution(8,2, new String[] {"FF", "AA", "CC", "AA", "AA", "CC", "DD", "FF"}));
assertEquals(8, test.solution(6,2, new String[] {"AA", "AA", "CC", "AA", "AA", "DD"}));
assertEquals(8, test.solution(4,4, new String[] {"ABCD", "BACE", "BCDD", "BCDD"}));
assertEquals(27, test.solution(8,9, new String[] {"ABCDADFDA", "ABDFQWERF", "WKDNFNRIT", "AKAKWODCJ", "AKAKWODCJ", "KKKKKKKKK", "KKKKKKKKK", "KKKKKKKKK"}));
assertEquals(15, test.solution(4,5, new String[] {"AAAAA", "AAAAU", "AAAUU", "UUUUU"}));
assertEquals(24, test.solution(5,6, new String[] {"AAAAAA", "BBAATB", "BBAATB", "JJJTAA", "JJJTAA"}));
assertEquals(32, test.solution(6,6, new String[] {"AABBEE", "AAAEEE", "VAAEEV", "AABBEE", "AACCEE", "VVCCEE"}));