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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.TreeSet;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.FileNotFoundException;
import java.util.List;
import java.io.Writer;
import java.io.BufferedReader;
import java.util.Comparator;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Asgar Javadov
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        private int revert(int zeroBased, int n) {
            return n - zeroBased;
        }

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            String s = in.next();
            String t = in.next();

            int[] zForward = StringUtils.zAlgorithm(t, s);

            StringBuilder sb = new StringBuilder();

            int[] zBack = StringUtils.zAlgorithm(sb.append(t).reverse().toString(), sb.delete(0, sb.length()).append(s).reverse().toString());

            if (k >= m) {
                for (int i = 0; i < n - k; ++i) {
                    if (zForward[i] >= m) {
                        if (Math.max(i + zForward[i], k) + k <= n) {
                            out.yes();
                            out.print(Math.max(i + zForward[i], k) - k + 1);
                            out.print(' ');
                            out.println(Math.max(i + zForward[i], k) + 1);
                            return;
                        } else if (Math.min(i, n - k) >= k) {
                            out.yes();
                            out.print(1);
                            out.space();
                            out.println(Math.min(i, n - k) + 1);
                            return;
                        }
                    } else if (zBack[i] >= m) {
                        if (Math.max(i + zBack[i], k) + k <= n) {
                            out.yes();
                            out.print(1);
                            out.space();
                            out.print(revert(Math.max(i + zBack[i], k) - 1, n));
                            return;
                        } else if (Math.min(i, n - k) >= k) {
                            out.yes();
                            out.print(revert(Math.min(i, n - k), n));
                            out.space();
                            out.print(revert(k - 1, n));
                            return;
                        }
                    }
                }
            }

            int[] b = getIndices(n, zBack, k, m);
            int[] f = getIndices(n, zForward, k, m);

            for (int x = 1; x <= m; ++x) {
                if (f[x] != -1 && b[m - x] != -1 && x <= k && m - x <= k) {
                    if (f[x] + x + b[m - x] + m - x <= n) {
                        out.yes();
                        out.print(f[x] + x - k + 1);
                        out.print(' ');
                        out.println(n - (b[m - x] + m - x) + 1);
                        return;
                    }
                }
            }

            out.no();
            return;
        }

        private int[] getIndices(int n, int[] zValue, int k, int m) {
            List<MathUtils.Pair> reverse = new ArrayList<>();
            for (int i = 0; i < zValue.length; ++i) {
                if (i + zValue[i] >= k) {
                    reverse.add(new MathUtils.Pair<>(zValue[i], i));
                }
            }

            Collections.sort(reverse, Comparator.reverseOrder());

            int[] b = new int[m + 1];

            Arrays.fill(b, -1);

            TreeSet<Integer> set = new TreeSet<>();
            for (int i = 0, x = m; x >= 0; --x) {
                MathUtils.Pair<Integer, Integer> tuple;
                while (i < reverse.size() && (tuple = reverse.get(i)).first >= x) {
                    set.add(tuple.second);
                    ++i;
                }
                Integer res = set.higher(k - x - 1);
                b[x] = res == null ? -1 : res;
            }
            return b;
        }
    }

    static class InputReader extends BufferedReader {
        StringTokenizer tokenizer;

        public InputReader(InputStream inputStream) {
            super(new InputStreamReader(inputStream), 32768);
        }

        public InputReader(String filename) {
            super(new InputStreamReader(Thread.currentThread().getContextClassLoader().getResourceAsStream(filename)));
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(readLine());
                } catch (IOException e) {
                    throw new RuntimeException();
                }
            }
            return tokenizer.nextToken();
        }

        public Integer nextInt() {
            return Integer.valueOf(next());
        }

    }

    static class OutputWriter extends PrintWriter {
        public OutputWriter(OutputStream outputStream) {
            super(outputStream);
        }

        public OutputWriter(Writer writer) {
            super(writer);
        }

        public OutputWriter(String filename) throws FileNotFoundException {
            super(filename);
        }

        public void yes() {
            println("Yes");
        }

        public void no() {
            println("No");
        }

        public void space() {
            print(' ');
        }

        public void close() {
            super.close();
        }

    }

    static class MathUtils {
        public static class Pair<K extends Comparable<K>, V> implements Comparable<MathUtils.Pair<K, V>> {
            public K first;
            public V second;

            public Pair(K first, V second) {
                this.first = first;
                this.second = second;
            }

            public int compareTo(MathUtils.Pair<K, V> o) {
                return first.compareTo(o.first);
            }

        }

    }

    static class StringUtils {
        public static char[] vowels = {'a', 'e', 'i', 'o', 'u'};
        private static boolean[] letters = new boolean[26];

        static {
            Arrays.fill(letters, true);
            for (char vowel : vowels)
                letters[vowel - 97] = false;
        }

        public static int[] zAlgorithm(char[] s) {
            int[] z = new int[s.length];

            for (int i = 1, L = 0, R = 0; i < s.length; ++i) {
                if (i < R) {
                    z[i] = Math.min(z[i - L], R - i + 1);
                }
                while (i + z[i] < s.length && s[z[i]] == s[i + z[i]]) {
                    z[i]++;
                }
                if (R < i + z[i] - 1) {
                    L = i;
                    R = i + z[i] - 1;
                }
            }

            return z;
        }

        public static int[] zAlgorithm(String pattern, String text) {
            int[] result = zAlgorithm(pattern + "#" + text);
            return Arrays.copyOfRange(result, pattern.length() + 1, pattern.length() + 1 + text.length());
        }

        public static int[] zAlgorithm(String s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}