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.*;

/**
 * @author Don Li
 */
public class Scissors {
    
    void solve() {
        int n = in.nextInt(), m = in.nextInt(), k = in.nextInt();
        String s = in.nextToken(), t = in.nextToken();
        
        char[] s1 = (t + '#' + s).toCharArray();
        char[] s2 = (rev(t) + '#' + rev(s)).toCharArray();
        
        int[] z1 = z_function(s1);
        int[] z2 = z_function(s2);
        
        for (int i = 0; i < n; i++) {
            if (z1[m + 1 + i] == m) {
                int l = i, r = i + m - 1;
                while (r - l + 1 < 2 * k && l - 1 >= 0) l--;
                while (r - l + 1 < 2 * k && r + 1 < n) r++;
                out.println("Yes");
                out.printf("%d %d%n", l + 1, l + k + 1);
                return;
            }
        }
        
        Integer[] q1 = new Integer[n];
        Arrays.setAll(q1, i -> i);
        Arrays.sort(q1, Comparator.comparingInt(i -> -z1[m + 1 + i]));
        int[] leftmost = new int[m + 1];
        Arrays.fill(leftmost, -1);
        TreeSet<Integer> set = new TreeSet<>();
        for (int x = m - 1, p = 0; x >= 1; x--) {
            while (p < n && z1[m + 1 + q1[p]] >= x) {
                set.add(q1[p++]);
            }
            if (x == m) {
                set.first();
            }
            Integer i = set.ceiling(k - x);
            if (i != null && x <= k) leftmost[x] = i;
        }
        
        Integer[] q2 = new Integer[n];
        Arrays.setAll(q2, i -> i);
        Arrays.sort(q2, Comparator.comparingInt(i -> -z2[m + 1 + n - 1 - i]));
        int[] rightmost = new int[m + 1];
        Arrays.fill(rightmost, -1);
        set.clear();
        for (int x = m - 1, p = 0; x >= 1; x--) {
            while (p < n && z2[m + 1 + n - 1 - q2[p]] >= x) {
                set.add(q2[p++]);
            }
            Integer i = set.floor(n - k + x - 1);
            if (i != null && x <= k) rightmost[x] = i;
        }
        
        for (int x = 1; x <= m - 1; x++) {
            int i = leftmost[x], j = rightmost[m - x];
            if (i >= 0 && j >= 0 && j - i + 1 >= m) {
                out.println("Yes");
                out.printf("%d %d%n", (i + x - k) + 1, j + 1 - m + x + 1);
                return;
            }
        }
        out.println("No");
    }
    
    int[] z_function(char[] s) {
        int n = s.length;
        int[] z = new int[n];
        for (int i = 1, l = 0, r = 0; i < n; i++) {
            if (i <= r) z[i] = Math.min(z[i - l], r - i + 1);
            while (i + z[i] < n && s[i + z[i]] == s[z[i]]) z[i]++;
            if (i + z[i] - 1 > r) {
                l = i; r = i + z[i] - 1;
            }
        }
        return z;
    }
    
    String rev(String s) {
        return new StringBuilder(s).reverse().toString();
    }
    
    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new Scissors().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());
        }
    }
}
