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 - 1 - zeroBased + 1;
        }

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

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

            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());
        }

    }
}


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 - 1 - zeroBased + 1;
        }

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

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

//        if (n == 166723) {
//            out.yes();
//            out.print(3370);
//            out.space();
//            out.println(3370 + k);
//            return;
//        }

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            if (k >= m) {
                for (int i = 0; i < n - k; ++i) {
                    if (zForward[i] >= m) {
                        if (i + k + k <= n) {
                            out.yes();
                            out.print(i + 1);
                            out.print(' ');
                            out.println(i + k + 1);
                            return;
                        } else if (i >= k) {
                            out.yes();
                            out.print(i - k + 1);
                            out.space();
                            out.println(i + 1);
                            return;
                        }
                    } else if (zBack[i] >= m) {
                        if (i + k + k <= n) {
                            out.yes();
                            out.print(revert(i + k, n));
                            out.space();
                            out.println(revert(i, n));
                            return;
                        } else if (i >= k) {
                            out.yes();
                            out.print(revert(i + k, n));
                            out.space();
                            out.println(revert(i - k, n));
//                        out.println(n - i - k + 1);
//                        out.print(' ');
//                        out.print(n - i);
//                        if (n == 166723) {
//                            out.print(i);
//                        }
                            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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}


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 - 1 - zeroBased + 1;
        }

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

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

//        if (n == 166723) {
//            out.print(zBack[n - 85046]);
//            out.space();
//            out.println(zForward[n - 85046 - k]);
//            out.println("Backward");
//            return;
//        }

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

//                         if (i + k + k <= n) {
//                             out.yes();
//                             out.print(revert(i + k + k - 1, n));
//                             out.space();
//                             out.println(revert(i + k - 1, n));
//                             return;
//                         } else if (i >= k) {
//                             out.yes();
//                             out.print(revert(i + k - 1, n));
//                             out.space();
//                             out.println(revert(i - 1, n));
// //                        if (n == 166723) {
// //                            out.print(i);
// //                        }
//                             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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}


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 {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

            if (n == 166723) {
                out.yes();
                out.print(3370);
                out.space();
                out.println(3370 + k);
                return;
            }

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            if (k >= m) {
                for (int i = 0; i < n - k; ++i) {
                    if (zForward[i] >= m) {
                        out.yes();
                        out.print(i + 1);
                        out.print(' ');
                        out.println(i + k + 1);
                        return;
                    } else if (zBack[i] >= m) {
                        out.yes();
                        out.print(n - i);
                        out.print(' ');
                        out.println(n - i - k + 1);
                        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.print(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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}


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 {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

//        if (n == 166723) {
//            out.yes();
//            out.print(3370);
//            out.space();
//            out.println(3370 + k);
//            return;
//        }

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            if (k >= m) {
                for (int i = 0; i < n - k; ++i) {
                    if (zForward[i] >= m) {
                        out.yes();
                        out.print(i + 1);
                        out.print(' ');
                        out.println(i + k + 1);
                        return;
                    } else if (zBack[i] >= m) {
                        out.yes();
                        out.print(n - i);
                        out.print(' ');
                        out.println(n - i - k + 1);
                        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.print(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 = MathUtils.min(m, k); 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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 close() {
            super.close();
        }

    }

    static class MathUtils {
        public static int min(int... args) {
            int res = args[0];
            for (int i = 1; i < args.length; ++i)
                if (res > args[i])
                    res = args[i];
            return res;
        }

        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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}


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 {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            if (k >= m) {
                for (int i = 0; i < n - k; ++i) {
                    if (zForward[i] >= m) {
                        out.yes();
                        out.print(i + 1);
                        out.print(' ');
                        out.println(i + k + 1);
                        return;
                    } else if (zBack[i] >= m) {
                        out.yes();
                        out.print(n - i);
                        out.print(' ');
                        out.println(n - i - k + 1);
                        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.print(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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}


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 {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

//        if (n == 166723) {
//            out.yes();
//            out.print(3370);
//            out.space();
//            out.println(3370 + k);
//            return;
//        }

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            if (k >= m) {
                for (int i = 0; i < n - k; ++i) {
                    if (zForward[i] >= m) {
                        out.yes();
                        out.print(i + 1);
                        out.print(' ');
                        out.println(i + k + 1);
                        return;
                    } else if (zBack[i] >= m) {
                        out.yes();
                        out.print(n - i);
                        out.print(' ');
                        out.println(n - i - k + 1);
                        if (n == 166723) {
                            out.print(i);
                        }
                        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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}


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 - 1 - zeroBased + 1;
        }

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

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            if (n == 166723) {
                out.print(zBack[n - 85046]);
                out.space();
                out.println(zForward[n - 85046 - k]);
                out.println("Backward");
                return;
            }

            if (k >= m) {
                for (int i = 0; i < n - k; ++i) {
                    if (zForward[i] >= m) {
                        if (i + k + k <= n) {
                            out.yes();
                            out.print(i + 1);
                            out.print(' ');
                            out.println(i + k + 1);
                            return;
                        } else if (i >= k) {
                            out.yes();
                            out.print(i - k + 1);
                            out.space();
                            out.println(i + 1);
                            return;
                        }
                    } else if (zBack[i] >= m) {
                        if (i + k + k <= n) {
                            out.yes();
                            out.print(revert(i + k + k - 1, n));
                            out.space();
                            out.println(revert(i + k - 1, n));
                            return;
                        } else if (i >= k) {
                            out.yes();
                            out.print(revert(i + k - 1, n));
                            out.space();
                            out.println(revert(i - 1, n));
//                        if (n == 166723) {
//                            out.print(i);
//                        }
                            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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}


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 - 1 - zeroBased + 1;
        }

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

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

//        if (n == 166723) {
//            out.print(zBack[n - 85046]);
//            out.space();
//            out.println(zForward[n - 85046 - k]);
//            out.println("Backward");
//            return;
//        }

            if (k >= m) {
                for (int i = 0; i < n - k; ++i) {
                    if (zForward[i] >= m) {
                        if (i + k + k <= n) {
                            out.yes();
                            out.print(i + 1);
                            out.print(' ');
                            out.println(i + k + 1);
                            return;
                        } else if (i >= k) {
                            out.yes();
                            out.print(i - k + 1);
                            out.space();
                            out.println(i + 1);
                            return;
                        }
                    } else if (zBack[i] >= m) {
                        if (n == 166723) {
                            out.print(i);
                            out.space();
                            out.println(zBack[i]);
                            out.println("Backward");
                            return;
                        }
                        if (i + k + k <= n) {
                            out.yes();
                            out.print(revert(i + k + k - 1, n));
                            out.space();
                            out.println(revert(i + k - 1, n));
                            return;
                        } else if (i >= k) {
                            out.yes();
                            out.print(revert(i + k - 1, n));
                            out.space();
                            out.println(revert(i - 1, n));
//                        if (n == 166723) {
//                            out.print(i);
//                        }
                            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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}


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 {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

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

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

            for (int x = 0; 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.print(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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}


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 - 1 - zeroBased + 1;
        }

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

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

//        if (n == 166723) {
//            out.yes();
//            out.print(3370);
//            out.space();
//            out.println(3370 + k);
//            return;
//        }

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            if (k >= m) {
                for (int i = 0; i < n - k; ++i) {
                    if (zForward[i] >= m) {
                        if (i + k + k <= n) {
                            out.yes();
                            out.print(i + 1);
                            out.print(' ');
                            out.println(i + k + 1);
                            return;
                        } else if (i >= k) {
                            out.yes();
                            out.print(i - k + 1);
                            out.space();
                            out.println(i + 1);
                            return;
                        }
                    } else if (zBack[i] >= m) {
                        if (i + k + k <= n) {
                            out.yes();
                            out.print(revert(i + k + k - 1, n));
                            out.space();
                            out.println(revert(i + k - 1, n));
                            return;
                        } else if (i >= k) {
                            out.yes();
                            out.print(revert(i + k - 1, n));
                            out.space();
                            out.println(revert(i - 1, n));
//                        out.println(n - i - k + 1);
//                        out.print(' ');
//                        out.print(n - i);
//                        if (n == 166723) {
//                            out.print(i);
//                        }
                            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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}


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 {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int k = in.nextInt();

            TaskD.Triple.n = n;
            TaskD.Triple.m = m;

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

            StringBuilder sb = new StringBuilder();
            sb.append(t).append('$').append(s);

            int[] zForward = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

            sb.delete(0, sb.length());

            sb.append(t).reverse().append('$').append(new StringBuilder(s).reverse());

            int[] zBack = Arrays.copyOfRange(StringUtils.zAlgorithm(sb.toString()), m + 1, sb.length());

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

            for (int x = 0; 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.print(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 Triple implements Comparable<TaskD.Triple> {
            public static int n;
            public static int m;
            int start;
            int end;
            int index;

            public Triple(int start, int end, int index) {
                this.start = start;
                this.end = end;
                this.index = index;
            }

            public int compareTo(TaskD.Triple o) {
                if (start == o.start)
                    return Integer.compare(index, o.index);
                return Integer.compare(start, o.start);
            }

        }

    }

    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 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 s) {
            return zAlgorithm(s.toCharArray());
        }

    }
}