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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

/**
 * @author Don Li
 */
public class Scissors2 {
    
    int INF = (int) 1e6;
    
    void solve() {
        int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
        char[] s = in.nextToken().toCharArray(), t = in.nextToken().toCharArray();
        
        int[] f = failure(t);
        int[] first = new int[m + 1];
        Arrays.fill(first, INF);
        for (int i = 0, j = 0; i < n; i++) {
            while (j > 0 && t[j] != s[i]) j = f[j];
            if (t[j] == s[i]) j++;
            if (first[j] == INF && i >= k - 1) first[j] = i;
            if (n - 1 - i >= k && Math.min(j, k) >= m) {
                out.println("Yes");
                out.printf("%d %d%n", Math.max(0, i - k + 1) + 1, n - k + 1);
                return;
            }
            if (j == m) j = f[j];
        }
        for (int i = m; i > 0; i--) {
            int j = f[i];
            first[j] = Math.min(first[j], first[i]);
        }
        
        reverse(t);
        f = failure(t);
        int[] last = new int[m + 1];
        Arrays.fill(last, -INF);
        for (int i = 0, j = 0; i < n; i++) {
            while (j > 0 && t[j] != s[n - 1 - i]) j = f[j];
            if (t[j] == s[n - 1 - i]) j++;
            if (last[j] == -INF && i >= k - 1) last[j] = n - 1 - i;
            if (n - 1 - i >= k && Math.min(j, k) >= m) {
                out.println("Yes");
                out.printf("%d %d%n", 1, Math.min(n - k, n - i - 1) + 1);
                return;
            }
            if (j == m) j = f[j];
        }
        for (int i = m; i > 0; i--) {
            int j = f[i];
            last[j] = Math.max(last[j], last[i]);
        }
        
        for (int i = 1; i < m; i++) {
            if (i <= k && m - i <= k && first[i] != INF && last[m - i] != -INF && first[i] < last[m - i]) {
                out.println("Yes");
                out.printf("%d %d%n", (first[i] - k + 1) + 1, last[m - i] + 1);
                return;
            }
        }
        out.println("No");
    }
    
    int[] failure(char[] s) {
        int n = s.length;
        int[] f = new int[n + 1];
        f[0] = f[1] = 0;
        for (int i = 2; i <= n; i++) {
            int j = f[i - 1];
            while (j > 0 && s[j] != s[i - 1]) j = f[j];
            f[i] = s[j] == s[i - 1] ? j + 1 : 0;
        }
        return f;
    }
    
    void reverse(char[] s) {
        for (int i = 0, j = s.length - 1; i < j; i++, j--) {
            char t = s[i]; s[i] = s[j]; s[j] = t;
        }
    }
    
    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new Scissors2().solve();
        out.close();
    }
    
    static FastScanner in;
    static PrintWriter out;
    
    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;
        
        public FastScanner(BufferedReader in) {
            this.in = in;
        }
        
        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        public int nextInt() {
            return Integer.parseInt(nextToken());
        }
        
        public long nextLong() {
            return Long.parseLong(nextToken());
        }
        
        public double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}
