Jenya has recently acquired quite a useful tool — k-scissors for cutting strings. They are generally used for cutting out two non-intersecting substrings of length k from an arbitrary string s (its length should be at least 2·k in order to perform this operation) and concatenating them afterwards (preserving the initial order). For example, with the help of 2-scissors you can cut ab and de out of abcde and concatenate them into abde, but not ab and bc since they're intersecting.

It's a nice idea to test this tool before using it in practice. After looking through the papers, Jenya came up with two strings s and t. His question is whether it is possible to apply his scissors to string s such that the resulting concatenation contains t as a substring?

Input

The first line contains three integers n, m, k (2 ≤ m ≤ 2·k ≤ n ≤ 5·105) — length of s, length of t and the aforementioned scissors' parameter correspondingly.

The next two lines feature s and t consisting of lowercase latin letters.

Output

If there is no answer, print «No». 

Otherwise print «Yes» and two integers L and R denoting the indexes where cutted substrings start (1-indexed). If there are several possible answers, output any.

Examples

Input

7 4 3
baabaab
aaaa


Output

Yes
1 5


Input

6 3 2
cbcbcb
bcc


Output

Yes
2 5


Input

7 5 3
aabbaaa
aaaaa


Output

No

Note

In the first sample case you can cut out two substrings starting at 1 and 5. The resulting string baaaab contains aaaa as a substring.

In the second sample case the resulting string is bccb.
import java.io.*;
import java.util.*;

public class D implements Runnable{
	public static void main (String[] args) {new Thread(null, new D(), "_cf", 1 << 28).start();}

	public void run() {
//		try { new TestGenerator(); } catch (Exception e) {}
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		System.err.println("Go!");

		int n = fs.nextInt();
		int m = fs.nextInt();
		int k = fs.nextInt();
		String s1 = fs.next(), s2 = fs.next();

//		System.out.println("Brute " + brute(s1, s2, k) + "\n");

		int[] z1 = getZ((s2+"#"+s1).toCharArray());
		int[] z2 = getZ((reverse(s2)+"#"+reverse(s1)).toCharArray());
		z1 = Arrays.copyOfRange(z1, m + 1, z1.length);
		z2 = Arrays.copyOfRange(z2, m + 1, z2.length);

		//		System.out.println(Arrays.toString(z1));
		//		System.out.println(Arrays.toString(z2));

		int[] left = new int[k + 1];
		Num[] a = new Num[n]; for(int i = 0; i < n; i++) a[i] = new Num(z1[i], i); Arrays.sort(a);
		left = get(a, k);

		int[] right = new int[k + 1];
		a = new Num[n]; for(int i = 0; i < n; i++) a[i] = new Num(z2[i], i); Arrays.sort(a);
		right = get(a, k);

		//		System.out.println(Arrays.toString(left));
		//		System.out.println(Arrays.toString(right));


		for(int i = 0; i < n; i++) {
			if(z1[i] == m) {
				if(i + k + k <= n) {
					System.out.printf("Yes\n%d %d\n", i+1, i + k + 1);
					return;
				}
				else if(i - k >= 0 && i + k <= n) {
					System.out.printf("Yes\n%d %d\n", i-k+1, i + 1);
					return;
				}
				else {
					int end = Math.min(n - 1, i + k);
					int ridx = end - k;
					int lidx = ridx - k;
					if(lidx >= 0 && ridx < n) {
						System.out.printf("Yes\n%d %d\n", lidx+1, ridx+1);
						return;
					}
				}
			}
		}

		for(int tk = 1; tk <= Math.min(m-1, k); tk++) {
			if(left[tk] == -1 || m - tk > k || right[m-tk] == -1) continue;
			int lidx = left[tk]; lidx -= (k - tk);
			int alt = m - tk;
			int ridx = n - right[alt] - 1; ridx -= alt-1;
			if(lidx + k > ridx) continue;
			if(lidx < 0 || ridx < 0) continue;
			if(lidx > n || ridx > n) continue;

			System.out.printf("Yes\n%d %d\n", lidx+1, ridx+1);
			return;
		}


		System.out.println("No");

		out.close();
	}

	int[] get(Num[] a, int k) {
		int[] left = new int[k + 1];
		TreeSet<Integer> set = new TreeSet<>();
		for(int x = k, ptr = 0; x > 0; x--) {
			while(ptr < a.length && a[ptr].z >= x) {
				if(a[ptr].idx + x >= k) set.add(a[ptr].idx);
				ptr++;
			}
			if(set.isEmpty()) left[x] = -1;
			else {
				Integer hi = set.ceiling(k - x);
				if(hi == null) left[x] = -1;
				else left[x] = hi;
			}
		}
		return left;
	}

	boolean brute(String s, String t, int k) {
		for(int i = 0; i + k <= s.length(); i++) {
			for(int j = i + k; j + k <= s.length(); j++) {
				String s1 = s.substring(i, i + k);
				String s2 = s.substring(j, j + k);
				if((s1+s2).contains(t)) {
					System.out.println((s1+s2));
					System.out.println((i+1) + " , " + (j+1));
					return true;
				}
			}
		}
		return false;
	}

	String reverse(String s) { return new StringBuilder(s).reverse().toString(); }

	void reverse(int[] a) {
		int n = a.length;
		for(int i = 0; i < n / 2; i++) {
			int t = a[i];
			a[i] = a[n - i - 1];
			a[n - i - 1] = t;
		}
	}

	int[] getZ (char[] a) {
		int[] z = new int[a.length];
		int left = 0, right = 0; //left and right bounds for my z box
		for(int k = 1; k < a.length; k++) {
			if(k > right) {
				//we have to do actual comparisons here
				left = right = k;
				while(right < a.length && a[right] == a[right - left]) {
					//while my right pointer is matching the prefix of the string
					right++;
				}
				z[k] = right - left; //the length that was matched
				right--;
			}
			else {
				//reuse values because k lies inside my z box
				int k1 = k - left; //the position that we can reuse
				if(z[k1] < right - k + 1) {
					//the z value for this previous position can't get any more matches so just copy it.
					z[k] = z[k1];
				}
				else {
					//we have to check to see if there are more matches
					left = k;
					while(right < a.length && a[right] == a[right - left]) {
						right++;
					}
					z[k] = right - left;
					right--;
				}
			}
		}
		return z;
	}

	class Num implements Comparable<Num> {
		int z, idx;
		Num(int zz, int i) { z = zz; idx = i; }
		public int compareTo(Num n) { return Integer.compare(n.z, z); }
		public String toString() { return "Idx " + idx + " Z " + z; }
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;
		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
//				br = new BufferedReader(new FileReader("testdata.out"));
				st = new StringTokenizer("");
			} catch (Exception e){e.printStackTrace();}
		}
		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}
		public int nextInt() {return Integer.parseInt(next());}
		public long nextLong() {return Long.parseLong(next());}
		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			try {line = br.readLine();}
			catch (Exception e) {e.printStackTrace();}
			return line;
		}
		public Integer[] nextIntegerArray(int n) {
			Integer[] a = new Integer[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}
		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}
		public char[] nextCharArray() {return nextLine().toCharArray();}
	}

}