762_C. Two strings_28682
You are given two strings a and b. You have to remove the minimum possible number of consecutive (standing one after another) characters from string b in such a way that it becomes a subsequence of string a. It can happen that you will not need to remove any characters at all, or maybe you will have to remove all of the characters from b and make it empty.

Subsequence of string s is any such string that can be obtained by erasing zero or more characters (not necessarily consecutive) from string s.

Input

The first line contains string a, and the second line — string b. Both of these strings are nonempty and consist of lowercase letters of English alphabet. The length of each string is no bigger than 105 characters.

Output

On the first line output a subsequence of string a, obtained from b by erasing the minimum number of consecutive characters.

If the answer consists of zero characters, output «-» (a minus sign).

Examples

Input

hi
bob


Output

-


Input

abca
accepted


Output

ac


Input

abacaba
abcdcba


Output

abcba

Note

In the first example strings a and b don't share any symbols, so the longest string that you can get is empty.

In the second example ac is a subsequence of a, and at the same time you can obtain it by erasing consecutive symbols cepted from string b.
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.ObjectInputStream.GetField;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.SortedSet;
import java.util.Stack;
import java.util.TreeMap;
import java.util.TreeSet;

public class Q21 {
	static int MOD = 1000000007;
	static boolean b[], c1 = false;
	static int m, bo, c, di;
	static ArrayList<Integer>[] amp;
	static ArrayList<Integer>[][] amp2;
	static int sum[], dist[];
	static long pow[], ans = 0;
	static int p = 10000, time = 0, p1 = -1, p2 = -1;
	static FasterScanner sc = new FasterScanner();
	static Queue<Integer> q = new LinkedList<>();
	static ArrayList<Pair>[] amp1;
	static int arr[];
	static ArrayList<Integer> parent = new ArrayList<>();
	static BufferedWriter log;
	static HashMap<Pair, Integer> hm;
	static HashSet<Integer> hs = new HashSet<>();
	static TreeMap<Integer, Pair> hsm;
	static Stack<Integer> s = new Stack<>();
	static Pair prr[];
	static Random r = new Random();
	static long dp[];

	public static void main(String[] args) throws IOException {
		log = new BufferedWriter(new OutputStreamWriter(System.out));
		String str1 = sc.nextLine(), str2 = sc.nextLine();
		int n = str1.length();
		int arr1[] = new int[str2.length()];
		int arr2[] = new int[str2.length()];
		Arrays.fill(arr1, 1000000);
		Arrays.fill(arr2, -1);
		int j = 0;
		int ans = Integer.MAX_VALUE / 2, ans2 = Integer.MAX_VALUE, temp11 = -1, temp12 = -1, temp1 = -1, temp2 = -1;
		for (int i = 0; i < n && j < str2.length(); i++) {
			if (str1.charAt(i) == str2.charAt(j)) {
				// System.out.println(i);
				arr1[j] = i;
				ans = str2.length() - j - 1;
				temp1 = 0;
				temp2 = j;
				j++;
			}
		}
		// for(int i = 0;i<str2.length();i++) System.out.print(arr1[i]+" ");
		j = str2.length() - 1;
		for (int i = n - 1; i >= 0 && j >= 0; i--) {
			if (str1.charAt(i) == str2.charAt(j)) {
				// System.out.println(i);
				arr2[j] = i;
				if (j < ans) {
					ans = j;
					temp1 = j;
					temp2 = str2.length() - 1;
				}
				j--;
			}
		}
		// for(int i = 0;i<str2.length();i++) System.out.print(arr2[i]+" ");
		// System.out.println(ans);
		for (int i = 0; i < n - 1 && i<str2.length()-1; i++) {
			if (arr1[i] >= 1000000)
				break;
			int y = Arrays.binarySearch(arr2, i + 1, str2.length() - 1,
					arr1[i] + 1);
			if (y < 0)
				y = -(y + 1);
			if (arr2[y] >= 0 && (y - 1 - i) < ans2) {
				
				if (arr2[y] > arr1[i]) {
					temp11 = i;
					ans2 = y - 1 - i;
					temp12 = y;
				}
			}
			// System.out.println(i+" "+y+" "+ans2);
		}
		// System.out.println(ans2);
		if (ans <= ans2) {
			if (ans == Integer.MAX_VALUE / 2)
				System.out.println("-");
			else {
				for (int i = temp1; i <= temp2; i++) {
					System.out.print(str2.charAt(i));
				}
			}
		} else {
			for (int i = 0; i <= temp11; i++) {
				System.out.print(str2.charAt(i));
			}
			for (int i = temp12; i <= str2.length() - 1; i++) {
				System.out.print(str2.charAt(i));
			}
		}
		log.close();
	}

	public static void recur2(int n, int m, int k) {
		if (k == 0 && n >= 0 && m >= 0) {
			ans++;
			return;
		}
		if (n < 0 || m < 0 || k <= 0)
			return;
		recur2(n - k, m, k - 1);
		recur2(n, m - k, k - 1);
	}

	public static void recur1(int n, int cnt) {
		if (n == 0 && cnt == 0) {
			ans = (ans + 1) % MOD;
		}
		if (cnt < 0)
			return;
		long temp = 0;
		for (int i = n - 1; i >= 0; i--) {
			if ((arr[n] - m) > arr[i])
				break;
			else
				recur1(i, cnt - 1);
		}
	}

	static class Pair implements Comparable<Pair> {
		long u;
		long v;

		public Pair() {

		}

		public Pair(long u, long v) {
			this.u = u;
			this.v = v;
		}

		public int hashCode() {
			int hu = (int) (u ^ (u >>> 32));
			int hv = (int) (v ^ (v >>> 32));
			return 31 * hu + hv;
		}

		public boolean equals(Object o) {
			Pair other = (Pair) o;
			return (u == other.u && v == other.v);
		}

		public int compareTo(Pair other) {
			return Long.compare(u, other.u) != 0 ? (Long.compare(u, other.u))
					: (Long.compare(v, other.v));
		}

		public String toString() {
			return "[u=" + u + ", v=" + v + "]";
		}
	}

	public static int getParent(int x, int parent[]) {
		while (parent[x] != x) {
			parent[x] = parent[parent[x]];
			x = parent[x];
		}
		return x;
	}

	public static void bfs(int x) {
		b[x] = true;
		q.add(x);
		while (!q.isEmpty()) {
			int y = q.poll();
			for (int i = 0; i < amp[y].size(); i++) {
				if (!b[amp[y].get(i)]) {
					q.add(amp[y].get(i));
					dist[amp[y].get(i)] = dist[y] + 1;
					b[amp[y].get(i)] = true;
				}
			}
		}
	}

	public static void seive(long n) {
		b = new boolean[(int) (n + 1)];
		Arrays.fill(b, true);
		b[0] = false;
		b[1] = false;
		for (int i = 2; i * i <= n; i++) {
			if (b[i]) {
				for (int p = 2 * i; p <= n; p += i) {
					b[p] = false;
				}
			}
		}
	}

	public static void buildGraph(int n) {
		for (int i = 0; i < n; i++) {
			int x = sc.nextInt(), y = sc.nextInt();
			amp[--x].add(--y);
			amp[y].add(x);
		}
	}

	public static void dfs(int x) {
		b[x] = true;
		for (int i = 0; i < amp[x].size(); i++) {
			if (!b[amp[x].get(i)]) {
				dfs(amp[x].get(i));
			}
			sum[amp[x].get(i)]++;
		}
	}

	public static void multiBfs() {
		// System.out.println(hs);
		while (!q.isEmpty()) {
			int x = q.poll();
			for (int e : amp[x]) {
				if (!b[e]) {
					q.add(e);
					b[e] = true;
					sum[e] = x;
				} else {
					if (!hs.contains(x) && e != sum[x]) {
						System.out.println("NO");
						System.exit(0);
					}
				}
			}
		}
	}

	public static void getCycle(int x) {
		b[x] = true;
		for (int e : amp[x]) {
			if (b[e]) {
				p2 = x;
				if (e != sum[x]) {
					p1 = e;
					c1 = true;
					return;
				}
			} else {
				sum[e] = x;
				// System.out.print(e+" ");
				getCycle(e);
				if (c1)
					return;
			}
		}
		if (c1)
			return;
	}

	public static long count(long x, boolean b, long ans) {
		String str = Long.toString(x, 2);
		if (x == 1)
			return (ans + 1) % MOD;
		if (x == 0 && b)
			return (ans + 1) % MOD;
		else if (x == 0)
			return ans;
		if (str.length() > 1)
			ans = (long) ((ans + Math.pow(2, str.length() - 2) % MOD) % MOD);
		return count((long) (x - Math.pow(2, str.length() - 1)), !b, ans);
	}

	static boolean KMP(String pat, String txt) {
		int M = pat.length();
		int N = txt.length();

		// create lps[] that will hold the longest
		// prefix suffix values for pattern
		int lps[] = new int[M];
		int j = 0; // index for pat[]

		// Preprocess the pattern (calculate lps[]
		// array)
		computeLPSArray(pat, M, lps);

		int i = 0; // index for txt[]
		while (i < N) {
			if (pat.charAt(j) == txt.charAt(i)) {
				j++;
				i++;
			}
			if (j == M) {

				j = lps[j - 1];
				return true;
			}

			// mismatch after j matches
			else if (i < N && pat.charAt(j) != txt.charAt(i)) {
				// Do not match lps[0..lps[j-1]] characters,
				// they will match anyway
				if (j != 0)
					j = lps[j - 1];
				else
					i = i + 1;
			}
		}
		return false;
	}

	static void computeLPSArray(String pat, int M, int lps[]) {
		// length of the previous longest prefix suffix
		int len = 0;
		int i = 1;
		lps[0] = 0; // lps[0] is always 0

		// the loop calculates lps[i] for i = 1 to M-1
		while (i < M) {
			if (pat.charAt(i) == pat.charAt(len)) {
				len++;
				lps[i] = len;
				i++;
			} else // (pat[i] != pat[len])
			{
				// This is tricky. Consider the example.
				// AAACAAAA and i = 7. The idea is similar
				// to search step.
				if (len != 0) {
					len = lps[len - 1];

					// Also, note that we do not increment
					// i here
				} else // if (len == 0)
				{
					lps[i] = len;
					i++;
				}
			}
		}
	}

	static long power(long x, long y, long m) {
		if (y == 0)
			return 1;
		long p = power(x, y / 2, m) % m;
		p = (p * p) % m;

		return (y % 2 == 0) ? p : (x * p) % m;
	}

	private static void permutation(String prefix, String str) {
		int n = str.length();
		// if (n == 0) hs.add(prefix);
		// else {
		for (int i = 0; i < n; i++)
			permutation(prefix + str.charAt(i),
					str.substring(0, i) + str.substring(i + 1, n));
		// }
	}

	public static char give(char c1, char c2) {
		if (c1 != 'a' && c2 != 'a')
			return 'a';
		if (c1 != 'b' && c2 != 'b')
			return 'b';
		return 'c';
	}

	static class Graph {
		int vertex;
		long weight;
	}

	public static void buildTree(int n) {
		int arr[] = sc.nextIntArray(n);
		for (int i = 0; i < n; i++) {
			int x = arr[i] - 1;
			amp[i + 1].add(x);
			amp[x].add(i + 1);
		}
	}

	static class SegmentTree {
		long st[][];
		long lazy[];

		SegmentTree(int n) {
			int size = 4 * n;
			st = new long[size][3];
			lazy = new long[size];
			build(0, n - 1, 1);
		}

		long[] build(int ss, int se, int si) {
			if (ss == se) {
				st[si][0] = 1;
				st[si][1] = 1;
				st[si][2] = 1;
				return st[si];
			}
			int mid = (ss + se) / 2;
			long a1[] = build(ss, mid, si * 2), a2[] = build(mid + 1, se,
					si * 2 + 1);
			long ans[] = new long[3];
			if (arr[mid] < arr[mid + 1]) {
				ans[1] = Math.max(a2[1], Math.max(a1[1], a1[2] + a2[0]));
				if (a1[1] == (mid - ss + 1))
					ans[0] = ans[1];
				else
					ans[0] = a1[0];
				if (a2[2] == (se - mid))
					ans[2] = ans[1];
				else
					ans[2] = a2[2];
			} else {
				ans[1] = Math.max(a1[1], a2[1]);
				ans[0] = a1[0];
				ans[2] = a2[2];
			}
			st[si] = ans;
			return st[si];
		}

		void update(int si, int ss, int se, int idx, int val) {
			if (ss == se) {
				arr[idx] += val;
			} else {
				int mid = (ss + se) / 2;
				if (ss <= idx && idx <= mid) {
					update(si * 2, ss, mid, idx, val);
				} else
					update(si * 2 + 1, mid + 1, se, idx, val);
				if (arr[mid] < arr[mid + 1]) {
					st[si][1] = Math.max(
							st[si * 2][1],
							Math.max(st[si * 2 + 1][1], st[si * 2][2]
									+ st[si * 2 + 1][0]));
					if (st[si * 2][1] == (mid - ss + 1))
						st[si][0] = st[si][1];
					else
						st[si][0] = st[si * 2][0];
					if (st[si * 2 + 1][1] == (se - mid))
						st[si][2] = st[si][1];
					else
						st[si][2] = st[si * 2 + 1][2];
				} else {
					st[si][1] = Math.max(st[si * 2][1], st[si * 2 + 1][1]);
					st[si][0] = st[si * 2][0];
					st[si][2] = st[si * 2 + 1][2];
				}
			}
		}

		/*
		 * void updateRange(int si, int ss, int se, int qs, int qe, int val){
		 * if(lazy[si]!=0){ st[si] = (se - ss + 1) - st[si]; if(ss!=se){
		 * lazy[si*2] ^= lazy[si]; lazy[si*2+1] ^= lazy[si]; } lazy[si] = 0; }
		 * if(ss>se || ss>qe || se<qs) return; if(ss>=qs && se<=qe){ st[si] =
		 * (se - ss + 1) - st[si]; if(ss!=se){ lazy[si*2+1] ^= val; lazy[si*2]
		 * ^= val; } return; } int mid = (ss+se)/2; updateRange(2*si, ss, mid,
		 * qs, qe, val); updateRange(2*si+1, mid+1, se, qs, qe, val); st[si] =
		 * st[si*2+1]+st[si*2]; } long queryRange(int si, int ss, int se, int
		 * qs, int qe){ //System.out.println(si +" "+ ss+ " "+ se+
		 * " "+qs+" "+qe); if(ss>se || ss>qe || qs>se){ return 0; }
		 * if(lazy[si]!=0){ st[si] = (se - ss + 1) - st[si]; if(ss!=se){
		 * lazy[si*2+1] ^= lazy[si]; lazy[si*2] ^= lazy[si]; } lazy[si] = 0; }
		 * if(ss>=qs && se<=qe) return st[si]; int mid = (ss+se)/2; return
		 * queryRange(2*si, ss, mid, qs, qe) + queryRange(2*si+1, mid+1, se, qs,
		 * qe); }
		 */
		long[] get(int qs, int qe, int ss, int se, int si) {
			if (qs <= ss && qe >= se) {
				return st[si];
			}
			int mid = (ss + se) / 2;
			if (qe <= mid)
				return get(qs, qe, ss, mid, si * 2);
			else if (qs > mid)
				return get(qs, qe, mid + 1, se, si * 2 + 1);
			long a1[] = get(qs, qe, ss, mid, si * 2), a2[] = get(qs, qe,
					mid + 1, se, si * 2 + 1);
			long ans[] = new long[3];
			if (arr[mid] < arr[mid + 1]) {
				ans[1] = Math.max(a2[1], Math.max(a1[1], a1[2] + a2[0]));
				if (a1[1] == (mid - ss + 1))
					ans[0] = ans[1];
				else
					ans[0] = a1[0];
				if (a2[2] == (se - mid))
					ans[2] = ans[1];
				else
					ans[2] = a2[2];
			} else {
				ans[1] = Math.max(a1[1], a2[1]);
				ans[0] = a1[0];
				ans[2] = a2[2];
			}
			return ans;
		}

		void print() {
			for (int i = 0; i < st.length; i++) {
				System.out.println(st[i][0] + " " + st[i][1] + " " + st[i][2]);
			}
			System.out.println();
		}
	}

	static int convert(int x) {
		int cnt = 0;
		String str = Integer.toBinaryString(x);
		// System.out.println(str);
		for (int i = 0; i < str.length(); i++) {
			if (str.charAt(i) == '1') {
				cnt++;
			}
		}
		int ans = (int) Math.pow(3, 6 - cnt);
		return ans;
	}

	static class Node2 {
		Node2 left = null;
		Node2 right = null;
		Node2 parent = null;
		int data;
	}

	static class BinarySearchTree {
		Node2 root = null;
		int height = 0;
		int max = 0;
		int cnt = 1;
		ArrayList<Integer> parent = new ArrayList<>();
		HashMap<Integer, Integer> hm = new HashMap<>();

		public void insert(int x) {
			Node2 n = new Node2();
			n.data = x;
			if (root == null) {
				root = n;
			} else {
				Node2 temp = root, temp2 = null;
				while (temp != null) {
					temp2 = temp;
					if (x > temp.data)
						temp = temp.right;
					else
						temp = temp.left;
				}
				if (x > temp2.data)
					temp2.right = n;
				else
					temp2.left = n;
				n.parent = temp2;
				parent.add(temp2.data);
			}
		}

		public Node2 getSomething(int x, int y, Node2 n) {
			if (n.data == x || n.data == y)
				return n;
			else if (n.data > x && n.data < y)
				return n;
			else if (n.data < x && n.data < y)
				return getSomething(x, y, n.right);
			else
				return getSomething(x, y, n.left);
		}

		public Node2 search(int x, Node2 n) {
			if (x == n.data) {
				max = Math.max(max, n.data);
				return n;
			}
			if (x > n.data) {
				max = Math.max(max, n.data);
				return search(x, n.right);
			} else {
				max = Math.max(max, n.data);
				return search(x, n.left);
			}
		}

		public int getHeight(Node2 n) {
			if (n == null)
				return 0;
			height = 1 + Math.max(getHeight(n.left), getHeight(n.right));
			return height;
		}
	}

	static long findDiff(long[] arr, long[] brr, int m) {
		int i = 0, j = 0;
		long fa = 1000000000000L;
		while (i < m && j < m) {
			long x = arr[i] - brr[j];
			if (x >= 0) {
				if (x < fa)
					fa = x;
				j++;
			} else {
				if ((-x) < fa)
					fa = -x;
				i++;
			}
		}
		return fa;
	}

	public static long max(long x, long y, long z) {
		if (x >= y && x >= z)
			return x;
		if (y >= x && y >= z)
			return y;
		return z;
	}

	static long modInverse(long a, long mOD2) {
		return power(a, mOD2 - 2, mOD2);
	}

	static long power2(long x, BigInteger y, long m) {
		long ans = 1;
		BigInteger two = new BigInteger("2");
		while (y.compareTo(BigInteger.ZERO) > 0) {
			if (y.getLowestSetBit() == y.bitCount()) {
				x = (x * x) % MOD;
				y = y.divide(two);
			} else {
				ans = (ans * x) % MOD;
				y = y.subtract(BigInteger.ONE);
			}
		}
		return ans;
	}

	static BigInteger power2(BigInteger x, BigInteger y, BigInteger m) {
		BigInteger ans = new BigInteger("1");
		BigInteger one = new BigInteger("1");
		BigInteger two = new BigInteger("2");
		BigInteger zero = new BigInteger("0");
		while (y.compareTo(zero) > 0) {
			// System.out.println(y);
			if (y.mod(two).equals(one)) {
				ans = ans.multiply(x).mod(m);
				y = y.subtract(one);
			} else {
				x = x.multiply(x).mod(m);
				y = y.divide(two);
			}
		}
		return ans;
	}

	static BigInteger power(BigInteger x, BigInteger y, BigInteger m) {
		if (y.equals(0))
			return (new BigInteger("1"));
		BigInteger p = power(x, y.divide(new BigInteger("2")), m).mod(m);
		p = (p.multiply(p)).mod(m);

		return (y.mod(new BigInteger("2")).equals(0)) ? p : (p.multiply(x))
				.mod(m);
	}

	static long d, x, y;

	public static void extendedEuclidian(long a, long b) {
		if (b == 0) {
			d = a;
			x = 1;
			y = 0;
		} else {
			extendedEuclidian(b, a % b);
			int temp = (int) x;
			x = y;
			y = temp - (a / b) * y;
		}
	}

	public static long gcd(long n, long m) {
		if (m != 0)
			return gcd(m, n % m);
		else
			return n;
	}

	public static class FasterScanner {
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = System.in.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n) {
			return nextIntArray(n, 0);
		}

		public int[] nextIntArray(int n, int off) {
			int[] arr = new int[n + off];
			for (int i = 0; i < n; i++) {
				arr[i + off] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) {
			return nextLongArray(n, 0);
		}

		public long[] nextLongArray(int n, int off) {
			long[] arr = new long[n + off];
			for (int i = 0; i < n; i++) {
				arr[i + off] = nextLong();
			}
			return arr;
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}
	}
}
hi
bob
 abca
accepted
 abacaba
abcdcba
 edbcd
d
 aa
zzaa
 aaaaaaaaaaaa
aaa
 aaaaaabbbbbbaaaaaa
aba
 a
aaa
 ab
aba
 aaaaaaaaa
a
 njtdhyqundyedsjyvy
ypjrs
 bacb
ccacacbacbccbbccccaccccccbcbabbbaababa
 caacacaacbaa
acbbbabacacac
 asdf
gasdf
 aaaabbbbaaaa
aba
 a
zazaa
 fdtffutxkujflswyddvhusfcook
kavkhnhphcvckogqqqqhdmgwjdfenzizrebefsbuhzzwhzvc
 az
aaazazaa
 abbcc
aca
 def
abcdef
 haddack
hack
 dedcbaa
dca
 aaa
aa
 bbacaabbaaa
acaabcaa
 abxzxzxzzaba
aba
 aba
a
 abab
ab
 aaxyaba
aaba
 abacaba
aa
 asdf
fasdf
 aaaaaaaaaaaaaaaaaaaa
aaaaaaaa
 npnkmawey
areakefvowledfriyjejqnnaeqheoh
 abcabbcbcccbccbbcc
acbcaabbbbcabbbaca
 bababsbs
abs
 aa
aaab
 aa
aaaa
 aaaaabbbaaaaa
aabbaa
 abcabc
abc
 abcde
fabcde
 aaaaabbbbbbaaaaaa
aba
 abbba
aba
 bacbcaacabbaacb
cbbaaccccbcaacacaabb
 aaaab
aab
 aaaaa
aaaa
 aaaaaaaaa
aaaa
 a
b
 ac
aacacaacbaaacbbbabacaca
 c
cbcbcbbacacacbccaaccbcabaaabbaaa
 bbbbaabbababbaaaaababbaaabbbbaaabbbababbbbabaabababaabaaabbbabababbbabababaababaaaaa
bbabaaaabaaaabbaaabbbabaaabaabbbababbbbbbbbbbabbababbaababbbaaabababababbbbaaababaaaaab
 lctsczqr
qvkp
 aa
a
 abc
ksdksdsdsnabc
 a
ab
 a
aaaaaaaaa
 b
abb
 ashfaniosafapisfasipfaspfaspfaspfapsfjpasfshvcmvncxmvnxcvnmcxvnmxcnvmcvxvnxmcvxcmvh
ashish
 acbc
cacacbac
 zhbt
ztjihmhebkrztefpwty
 aaaaaaa
aaa
 aaaaaaaaaaaa
aaaaaaaaaaaa
 b
cb
 aaeojkdyuilpdvyewjfrftkpcobhcumwlaoiocbfdtvjkhgda
mlmarpivirqbxcyhyerjoxlslyfzftrylpjyouypvk
 abcd
zzhabcd
 uglyqhkpruxoakm
cixxkpaaoodpuuh
 test
t
 baababaaaab
baababbbbbbb
 a
a
 ofih
ihfsdf
 gkvubrvpbhsfiuyha
ihotmn
 abba
aba
 abcd
faaaabbbbccccdddeda
 accac
baacccbcccabaabbcacbbcccacbaabaaac
 aaa
aaaaa
 hddddddack
hackyz
 ababbbbbbbbbbbb
abbbbb
 babababbaaabb
abbab
 ccccabccbb
cbbabcc
 ba
bb
 aa
aa
 lo
euhaqdhhzlnkmqnakgwzuhurqlpmdm
 bbaabb
ab
 aac
aaa
 ddbcd
d
 aa
zyaa
 aaaaabaaa
a
 njtdhyqundyedsjyvy
ypjqs
 babb
ccacacbacbccbbccccaccccccbcbabbbaababa
 caacacaacbaa
cacacababbbca
 asdf
gatdf
 b
zazaa
 koocfsuhvddywslfjukxtufftdf
kavkhnhphcvckogqqqqhdmgwjdfenzizrebefsbuhzzwhzvc
 fed
abcdef
 eedcbaa
dca
 bbacabbbaaa
acaabcaa
 baba
ab
 aaxyaba
baaa
 fsda
fasdf
 abcabbcbcccbccbbcc
acabbbacbbbbaacbca
 bababsbs
asb
 abcde
edcbaf
 aaaabbabbbbaaaaaa
aba
 bcaabbacaacbcab
cbbaaccccbcaacacaabb
 b
b
 c
cbcbcbbacacacbccaaccccabaaabbaaa
 bbbbaabbababbaaaaababbaaabbbbaaabbbababbbbabaabababaabaaabbbabababbbabababaababaaaaa
bbabaaaabaaaabbaaabbbabaaabaabbbababbbbbbbbbbabbababbaababbbaaabababaaabbbbaaababaaaaab
 rqzcstcl
qvkp
 ashfaniosafapisfasipfaspfaspfaspfapsfjpasfshvcmvncxmvnxcvnmcxvnmxcnvmcvxvnxmcvxcmvh
asgish
 acbc
bacacbac
 zhbt
ztjihmhebjrztefpwty
 adghkjvtdfbcoioalwmuchbocpktfrfjweyvdpliuydkjoeaa
mlmarpivirqbxcyhyerjoxlslyfzftrylpjyouypvk
 mkaoxurpkhqylgu
cixxkpaaoodpuuh
 tset
t
 baabaaaabab
baababbbbbbb
 ofih
ihfsef
 aaaaaabbbbbbaaaaaa
aca
 a{
aaazazaa
 bbbcc
aca
 abxzxzxzzaba
aca
 aca
a
 abacaca
aa
 npnkeawmy
areakefvowledfriyjejqnnaeqheoh
 ba
aaaa
 aaaaa
aab
 ad
aacacaacbaaacbbbabacaca
 a
ba
 a
aaaabaaaa
 b
acb
 aaaaaaa
baa
 b
bb
 abcd
dcbahzz

- ac abcba d aa aaa aba a ab a ys ba aacacac asdf aba a kvc a ac def hack dca aa acaabaa aba a ab aaba aa asdf aaaaaaaa a acbc abs aa aa aabbaa abc abcde aba aba cbcaabb aab aaaa aaaa - a c bbbbbbbabbababbaababbbaaabababababbbbaaababaaaaab q a abc a a b ashish ac zt aaa aaaaaaaaaaaa b ouypvk abcd uh t baababb a ih ih aba a aac aaa hack abbbbb abbab cabcc b aa - ab aa d
 aa
 a
 jqs
 ba
 cacacabaa
 df
 -
 kc
 f
 dca
 acaaaa
 ab
 aaa
 fa
 acabbb
 asb
 e
 aba
 cbbacaabb
 b
 c
 bbbbbbbabbababbaababbbaaabababaaabbbbaaababaaaaab
 q
 asish
 ac
 zt
 mpvk
 uh
 t
 baababb
 ih
 aa
 a
 -
 aa
 a
 aa
 a
 a
 aa
 a
 a
 a
 b
 aa
 b
 d
