import java.io.*;
import java.util.Arrays;

/**
 * Created by dalt on 2018/4/2.
 */
public class CF955D {
    public static final int MOD = (int) (1e9 + 7);
    public static BlockReader input;
    public static PrintStream output;

    public static void main(String[] args) throws FileNotFoundException {

        init();

        solve();

        output.flush();
    }

    public static void init() throws FileNotFoundException {
        if (System.getProperty("ONLINE_JUDGE") == null) {
            input = new BlockReader(new FileInputStream("D:\\DataBase\\TESTCASE\\codeforces\\CF955D.in"));
            output = System.out;
        } else {
            input = new BlockReader(System.in);
            output = new PrintStream(new BufferedOutputStream(System.out), false);
        }
    }

    public static void solve() {
        int n = input.nextInteger();
        int m = input.nextInteger();
        int k = input.nextInteger();

        char[] s = new char[n];
        char[] t = new char[m];
        input.nextBlock(s, 0);
        input.nextBlock(t, 0);

        int p = Math.min(k, m);
        KAM prefixKAM = new KAM(p, t[0]);
        KAM suffixKAM = new KAM(p, t[m - 1]);
        for (int i = 1; i < p; i++) {
            prefixKAM.build(t[i]);
            suffixKAM.build(t[m - i - 1]);
        }

        if (k >= m) {
            prefixKAM.beginMatch();
            for (int i = 0; i < n; i++) {
                prefixKAM.match(s[i]);
                if (prefixKAM.matchLength == m) {
                    int start = i - k + 1;
                    int l = 0;
                    int r = Math.max(start, k);
                    output.println("Yes");
                    output.println(l + 1);
                    output.println(r + 1);
                    return;
                }
            }
        }

        prefixKAM.beginMatch();
        suffixKAM.beginMatch();
        int[] prefixRegistries = new int[p + 1];
        Arrays.fill(prefixRegistries, -1);
        int[] suffixRegistries = new int[p + 1];
        Arrays.fill(suffixRegistries, -1);
        for (int i = 0, until = k - 1; i < until; i++) {
            prefixKAM.match(s[i]);
            suffixKAM.match(s[n - i - 1]);
        }
        for (int i = k - 1; i < n; i++) {
            prefixKAM.match(s[i]);
            suffixKAM.match(s[n - i - 1]);
            addRegistry(prefixRegistries, prefixKAM, i);
            addRegistry(suffixRegistries, suffixKAM, n - i - 1);
        }

        for (int i = 1, until = p; i <= until; i++) {
            if (m - i > p) {
                continue;
            }
            if (prefixRegistries[i] != -1 && suffixRegistries[m - i] != -1 && prefixRegistries[i] < suffixRegistries[m - i]) {
                output.println("Yes");
                output.println(prefixRegistries[i] - k + 2);
                output.println(suffixRegistries[m - i] + 1);
                return;
            }
        }

        output.println("No");
        return;
    }

    public static void addRegistry(int[] registries, KAM kam, int id) {
        int match = kam.matchLength;
        while (match > 0 && registries[match] == -1) {
            registries[match] = id;
            match = kam.fail[match - 1];
        }
    }

    public static class KAM {
        int[] fail;
        char[] data;
        int buildLength;
        int matchLength;

        public KAM(int cap, char c) {
            fail = new int[cap + 1];
            data = new char[cap + 1];
            fail[0] = 0;
            data[0] = c;
            buildLength = 1;
        }

        public void beginMatch() {
            matchLength = 0;
        }

        public void build(char c) {
            data[buildLength] = c;
            fail[buildLength] = find(fail[buildLength - 1], c);
            buildLength++;
        }

        public int find(int curMatch, char c) {
            while (curMatch > 0 && data[curMatch] != c) {
                curMatch = fail[curMatch - 1];
            }
            return data[curMatch] == c ? curMatch + 1 : 0;
        }

        public void match(char c) {
            matchLength = find(matchLength, c);
        }
    }

    public static class BlockReader {
        static final int EOF = -1;
        InputStream is;
        byte[] dBuf;
        int dPos, dSize, next;
        StringBuilder builder = new StringBuilder();

        public BlockReader(InputStream is) {
            this(is, 4096);
        }

        public BlockReader(InputStream is, int bufSize) {
            this.is = is;
            dBuf = new byte[bufSize];
            next = nextByte();
        }

        public int nextByte() {
            while (dPos >= dSize) {
                if (dSize == -1) {
                    return EOF;
                }
                dPos = 0;
                try {
                    dSize = is.read(dBuf);
                } catch (Exception e) {
                }
            }
            return dBuf[dPos++];
        }

        public String nextBlock() {
            builder.setLength(0);
            skipBlank();
            while (next != EOF && !Character.isWhitespace(next)) {
                builder.append((char) next);
                next = nextByte();
            }
            return builder.toString();
        }

        public void skipBlank() {
            while (Character.isWhitespace(next)) {
                next = nextByte();
            }
        }

        public int nextInteger() {
            skipBlank();
            int ret = 0;
            boolean rev = false;
            if (next == '+' || next == '-') {
                rev = next == '-';
                next = nextByte();
            }
            while (next >= '0' && next <= '9') {
                ret = (ret << 3) + (ret << 1) + next - '0';
                next = nextByte();
            }
            return rev ? -ret : ret;
        }

        public long nextLong() {
            skipBlank();
            long ret = 0;
            boolean rev = false;
            if (next == '+' || next == '-') {
                rev = next == '-';
                next = nextByte();
            }
            while (next >= '0' && next <= '9') {
                ret = (ret << 3) + (ret << 1) + next - '0';
                next = nextByte();
            }
            return rev ? -ret : ret;
        }

        public int nextBlock(char[] data, int offset) {
            skipBlank();
            int index = offset;
            int bound = data.length;
            while (next != EOF && index < bound && !Character.isWhitespace(next)) {
                data[index++] = (char) next;
                next = nextByte();
            }
            return index - offset;
        }

        public boolean hasMore() {
            skipBlank();
            return next != EOF;
        }
    }
}


import java.io.BufferedReader;
// import java.io.FileInputStream;
// import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;

import static java.lang.Math.*;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;

public class Main {
    FastScanner in;
    PrintWriter out;

    int k;

    private void solve() throws IOException {
        int ss = in.nextInt(), ts = in.nextInt(), sss = ss + ts + 1, k = in.nextInt();
        this.k = k;
        String s = in.next();
        String t = in.next();

        int[] pi = pi((t + Character.toString('\0') + s).toCharArray());

        String sr = new StringBuilder(s).reverse().toString();
        String tr = new StringBuilder(t).reverse().toString();

        int[] pir = pi((tr + Character.toString('\0') + sr).toCharArray());

        HashMap<Integer, Integer> left = new HashMap<>();
        HashMap<Integer, Integer> right = new HashMap<>();

        for (int i = ts + 1; i < sss; i++) {
            if (i - ts >= k && pi[i] > 0 && !left.containsKey(pi[i])) {
                left.put(pi[i], i - ts);
            }
        }

        for (int i = ts + 1; i < sss; i++) {
            if (i - ts >= k && pir[i] > 0 && !right.containsKey(pir[i])) {
                right.put(pir[i], ss + 1 - (i - ts));
            }
        }

        for (int kl = 1, kr = ts - 1; kl < ts; kl++, kr--) {
            if (left.getOrDefault(kl, (int) 1e6) < right.getOrDefault(kr, -1)) {
                out.println("Yes");
                out.print((left.get(kl) - k + 1) + " " + (right.get(kr)));
                return;
            }
        }

        out.println("No");
    }

    int[] pi(char[] s) {
        int n = s.length, pi[] = new int[n];
        for (int i = 1, j = 0; i < n; i++) {
            while (j > 0 && s[i] != s[j])
                j = pi[j - 1];
            if (s[i] == s[j])
                j++;
            pi[i] = j;
            while (pi[i] > k)
                pi[i] = pi[pi[i] - 1];
        }
        return pi;
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next().replace(',', '.'));
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }
    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.io.BufferedReader;
// import java.io.FileInputStream;
// import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;

import static java.lang.Math.min;
import static java.lang.Math.sqrt;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;

public class Main {
    FastScanner in;
    PrintWriter out;

    private void solve() throws IOException {
        int ss = in.nextInt(), ts = in.nextInt(),
                sss = ss + ts + 1, k = in.nextInt();
        String s = in.next();
        String t = in.next();

        int[] pi = pi((t + "\0" + s).toCharArray(), k);

        for (int i = ts + 1; i < sss; i++) {
            if (pi[i] == ts) {
                out.println("Yes");
                int l = i - ts - ts, r = l + k;
                if (r + k > ss) {
                    l -= r + k - ss;
                    r = ss - k;
                }
                out.print((l + 1) + " " + (r + 1));
                return;
            }
        }

        String sr = new StringBuilder(s).reverse().toString();
        String tr = new StringBuilder(t).reverse().toString();

        int[] pir = pi((tr + "\0" + sr).toCharArray(), k);

        HashMap<Integer, Integer> left = new HashMap<>();
        HashMap<Integer, Integer> right = new HashMap<>();

        for (int i = ts + k; i < sss; i++) {
            for (int j = pi[i]; j > 0 && !left.containsKey(j); j = pi[j - 1]) {
                left.put(j, i - ts);
            }
        }

        for (int i = ts + k; i < sss; i++) {
            for (int j = pir[i]; j > 0 && !right.containsKey(j); j = pir[j - 1]) {
                right.put(j, ss + 1 - (i - ts));
            }
        }

        for (int kl = 1, kr = ts - 1; kl < ts; kl++, kr--) {
            if (left.getOrDefault(kl, (int) 1e6) < right.getOrDefault(kr, -1)) {
                out.println("Yes");
                out.print((left.get(kl) - k + 1) + " " + (right.get(kr)));
                return;
            }
        }

        out.println("No");
    }

    int[] pi(char[] s, int k) {
        int n = s.length, pi[] = new int[n];
        for (int i = 1, j = 0; i < n; i++) {
            while (j > 0 && s[i] != s[j])
                j = pi[j - 1];
            if (s[i] == s[j])
                j++;
            while (j > k)
                j = pi[j - 1];
            pi[i] = j;
        }
        return pi;
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next().replace(',', '.'));
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }
    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.io.BufferedReader;
// import java.io.FileInputStream;
// import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;

import static java.lang.Math.min;
import static java.lang.Math.sqrt;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;

public class Main {
    FastScanner in;
    PrintWriter out;

    int k;

    private void solve() throws IOException {
        int ss = in.nextInt(), ts = in.nextInt(), sss = ss + ts + 1, k = in.nextInt();
        this.k = k;
        String s = in.next();
        String t = in.next();

        int[] pi = pi((t + Character.toString('\0') + s).toCharArray());

        String sr = new StringBuilder(s).reverse().toString();
        String tr = new StringBuilder(t).reverse().toString();

        int[] pir = pi((tr + Character.toString('\0') + sr).toCharArray());

        HashMap<Integer, Integer> left = new HashMap<>();
        HashMap<Integer, Integer> right = new HashMap<>();

        left.put(0, k);
        for (int i = ts + 1; i < sss; i++) {
            if (i - ts >= k && pi[i] > 0 && !left.containsKey(pi[i])) {
                left.put(pi[i], i - ts);
                for (int j = pi[pi[i] - 1]; j > 0 && i - ts >= k && pi[j] > 0 && !left.containsKey(pi[j]); j = pi[j - 1]) {
                    left.put(pi[j], i - ts);
                }
            }
        }

        right.put(0, ss + 1 - k);
        for (int i = ts + 1; i < sss; i++) {
            if (i - ts >= k && pir[i] > 0 && !right.containsKey(pir[i])) {
                right.put(pir[i], ss + 1 - (i - ts));
                for (int j = pir[pir[i] - 1]; j > 0 && i - ts >= k && pi[j] > 0 && !right.containsKey(pi[j]); j = pi[j - 1]) {
                    right.put(pir[j], ss + 1 - (i - ts));
                }
            }
        }

        for (int kl = 0, kr = ts; kl <= ts; kl++, kr--) {
            if (left.getOrDefault(kl, (int) 1e6) < right.getOrDefault(kr, -1)) {
                out.println("Yes");
                out.print((left.get(kl) - k + 1) + " " + (right.get(kr)));
                return;
            }
        }

        out.println("No");
    }

    int[] pi(char[] s) {
        int n = s.length, pi[] = new int[n];
        for (int i = 1, j = 0; i < n; i++) {
            while (j > 0 && s[i] != s[j])
                j = pi[j - 1];
            if (s[i] == s[j])
                j++;
            pi[i] = j;
            while (pi[i] > k)
                pi[i] = pi[pi[i] - 1];
        }
        return pi;
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next().replace(',', '.'));
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }
    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.io.BufferedReader;
// import java.io.FileInputStream;
// import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;

import static java.lang.Math.*;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;

public class Main {
    FastScanner in;
    PrintWriter out;

    int k;

    private void solve() throws IOException {
        int ss = in.nextInt(), ts = in.nextInt(), sss = ss + ts + 1, k = in.nextInt();
        this.k = k;
        String s = in.next();
        String t = in.next();

        int[] pi = pi((t + Character.toString('\0') + s).toCharArray());

        String sr = new StringBuilder(s).reverse().toString();
        String tr = new StringBuilder(t).reverse().toString();

        int[] pir = pi((tr + Character.toString('\0') + sr).toCharArray());

        HashMap<Integer, Integer> left = new HashMap<>();
        HashMap<Integer, Integer> right = new HashMap<>();

        for (int i = ts + 1; i < sss; i++) {
            if (i - ts >= k && pi[i] > 0 && !left.containsKey(pi[i])) {
                left.put(pi[i], i - ts);
                for (int j = pi[pi[i] - 1]; j > 0 && i - ts >= k && pi[j] > 0 && !left.containsKey(pi[j]); j = pi[j - 1]) {
                    left.put(pi[j], i - ts);
                }
            }
        }

        for (int i = ts + 1; i < sss; i++) {
            if (i - ts >= k && pir[i] > 0 && !right.containsKey(pir[i])) {
                right.put(pir[i], ss + 1 - (i - ts));
                for (int j = pir[pir[i] - 1]; j > 0 && i - ts >= k && pi[j] > 0 && !right.containsKey(pi[j]); j = pi[j - 1]) {
                    right.put(pir[j], ss + 1 - (i - ts));
                }
            }
        }

        for (int kl = 1, kr = ts - 1; kl < ts; kl++, kr--) {
            if (left.getOrDefault(kl, (int) 1e6) < right.getOrDefault(kr, -1)) {
                out.println("Yes");
                out.print((left.get(kl) - k + 1) + " " + (right.get(kr)));
                return;
            }
        }

        out.println("No");
    }

    int[] pi(char[] s) {
        int n = s.length, pi[] = new int[n];
        for (int i = 1, j = 0; i < n; i++) {
            while (j > 0 && s[i] != s[j])
                j = pi[j - 1];
            if (s[i] == s[j])
                j++;
            pi[i] = j;
            while (pi[i] > k)
                pi[i] = pi[pi[i] - 1];
        }
        return pi;
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next().replace(',', '.'));
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }
    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.io.BufferedReader;
// import java.io.FileInputStream;
// import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;

import static java.lang.Math.min;
import static java.lang.Math.sqrt;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;

public class Main {
    FastScanner in;
    PrintWriter out;

    int k;

    private void solve() throws IOException {
        int ss = in.nextInt(), ts = in.nextInt(), sss = ss + ts + 1, k = in.nextInt();
        this.k = k;
        String s = in.next();
        String t = in.next();

        int[] pi = pi((t + Character.toString('\0') + s).toCharArray());

        for (int i = ts + 1; i < sss; i++) {
            if (pi[i] == ts) {
                out.println("Yes");
                out.print("1 " + (k + 1));
                return;
            }
        }

        String sr = new StringBuilder(s).reverse().toString();
        String tr = new StringBuilder(t).reverse().toString();

        int[] pir = pi((tr + Character.toString('\0') + sr).toCharArray());

        HashMap<Integer, Integer> left = new HashMap<>();
        HashMap<Integer, Integer> right = new HashMap<>();

        for (int i = ts + 1; i < sss; i++) {
            if (i - ts >= k && pi[i] > 0 && !left.containsKey(pi[i])) {
                left.put(pi[i], i - ts);
                for (int j = pi[pi[i] - 1]; j > 0 && i - ts >= k && pi[j] > 0 && !left.containsKey(pi[j]); j = pi[j - 1]) {
                    left.put(pi[j], i - ts);
                }
            }
        }

        for (int i = ts + 1; i < sss; i++) {
            if (i - ts >= k && pir[i] > 0 && !right.containsKey(pir[i])) {
                right.put(pir[i], ss + 1 - (i - ts));
                for (int j = pir[pir[i] - 1]; j > 0 && i - ts >= k && pi[j] > 0 && !right.containsKey(pi[j]); j = pi[j - 1]) {
                    right.put(pir[j], ss + 1 - (i - ts));
                }
            }
        }

        for (int kl = 1, kr = ts - 1; kl < ts; kl++, kr--) {
            if (left.getOrDefault(kl, (int) 1e6) < right.getOrDefault(kr, -1)) {
                out.println("Yes");
                out.print((left.get(kl) - k + 1) + " " + (right.get(kr)));
                return;
            }
        }

        out.println("No");
    }

    int[] pi(char[] s) {
        int n = s.length, pi[] = new int[n];
        for (int i = 1, j = 0; i < n; i++) {
            while (j > 0 && s[i] != s[j])
                j = pi[j - 1];
            if (s[i] == s[j])
                j++;
            pi[i] = j;
            while (pi[i] > k)
                pi[i] = pi[pi[i] - 1];
        }
        return pi;
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

        int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        long nextLong() throws IOException {
            return Long.parseLong(next());
        }

        double nextDouble() throws IOException {
            return Double.parseDouble(next().replace(',', '.'));
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }
    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

    public static void main(String[] args) throws IOException {
        new Main().run();
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.stream.IntStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.stream.Stream;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author prakharjain
 */
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);
        _955D solver = new _955D();
        solver.solve(1, in, out);
        out.close();
    }

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

            int k = in.nextInt();

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

            Kmp<Character> kmp1 = new Kmp<Character>(
                    s.chars().mapToObj(c -> (char) c).toArray(Character[]::new), t.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp1.fail();
            kmp1.matches(k);
            kmp1.can();

            String sr = new StringBuilder(s).reverse().toString();
            String tr = new StringBuilder(t).reverse().toString();

            Kmp<Character> kmp2 = new Kmp<Character>(
                    sr.chars().mapToObj(c -> (char) c).toArray(Character[]::new), tr.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp2.fail();
            kmp2.matches(k);
            kmp2.can();

            for (int i = 0; i <= m; i++) {
                int lai = kmp1.ans[i];

                int rai = kmp2.ans[m - i];

                if (i > k || m - i > k)
                    continue;

                int raia = n - 1 - rai;

                if (i == m) {
                    if (lai < k - 1) {
                        lai = k - 1;
                    }
                    raia = n - k;
                } else if (m - i == m) {
                    lai = 0;
                    if (raia > n - k) {
                        raia = n - k;
                    }
                }
                if (lai < raia && lai - k + 1 >= 0 && raia + k - 1 < n) {

                    out.println("Yes");
                    out.print(lai + 1 - k + 1);
                    out.print(" ");
                    out.print(raia + 1);

                    return;
                }
            }

            out.println("No");
        }

        class Kmp<T extends Comparable<T>> {
            T[] s;
            T[] p;
            int n;
            int m;
            int[] f;
            int[] ans;
            int[] ansi;

            public Kmp(T[] s, T[] p) {
                super();
                this.s = s;
                this.p = p;
                this.n = s.length;
                this.m = p.length;
                this.f = new int[m];
                this.ans = new int[n + 1];
                for (int i = 1; i <= n; i++)
                    this.ans[i] = n;
                this.ansi = new int[n];
            }

            void fail() {
                f[0] = -1;

                for (int i = 1; i < m; i++) {
                    int c = f[i - 1];

                    f[i] = -1;
                    while (c > -1) {
                        if (p[c + 1].equals(p[i])) {
                            f[i] = c + 1;
                            break;
                        } else {
                            c = f[c];
                        }
                    }

                    if (f[i] == -1) {
                        if (p[0].equals(p[i])) {
                            f[i] = 0;
                        }
                    }
                }
            }

            int matches(int k) {

                int matches = 0;

                int j = 0;
                for (int i = 0; i < n; i++) {
                    if (s[i].equals(p[j])) {
                        j++;
                        if (ans[j] == n && i >= k - 1) {
                            ans[j] = i;
                        }
                        if (j == m) {
                            if (ans[j] == n) {
                                ans[j] = i;
                            }
                            matches++;
                            j = f[j - 1] + 1;
                        }
                    } else {
                        while (j > 0 && !p[j].equals(s[i])) {
                            j = f[j - 1] + 1;
                        }

                        if (p[j].equals(s[i])) {
                            j++;
                            if (ans[j] == n && i >= k - 1) {
                                ans[j] = i;
                            }
                        }
                    }
                }

                return matches;
            }

            void can() {
                boolean[] vis = new boolean[m + 1];

                for (int i = m; i > 0; i--) {
                    if (!vis[i]) {
                        int p = i;
                        vis[p] = true;
                        int c = f[p - 1] + 1;
                        while (c > 0) {
                            ans[c] = Math.min(ans[p], ans[c]);
                            vis[c] = true;
                            p = c;
                            c = f[p - 1] + 1;
                        }
                    }
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public String next() {
            return nextString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

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

        public void print(int i) {
            writer.print(i);
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.stream.IntStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.stream.Stream;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author prakharjain
 */
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);
        _955D solver = new _955D();
        solver.solve(1, in, out);
        out.close();
    }

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

            int k = in.nextInt();

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

            Kmp<Character> kmp1 = new Kmp<Character>(
                    s.chars().mapToObj(c -> (char) c).toArray(Character[]::new), t.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp1.fail();
            kmp1.matches(k);
            kmp1.can();

            String sr = new StringBuilder(s).reverse().toString();
            String tr = new StringBuilder(t).reverse().toString();

            Kmp<Character> kmp2 = new Kmp<Character>(
                    sr.chars().mapToObj(c -> (char) c).toArray(Character[]::new), tr.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp2.fail();
            kmp2.matches(k);
            kmp2.can();

            for (int i = 0; i <= m; i++) {
                int lai = kmp1.ans[i];

                int rai = kmp2.ans[m - i];

                if (i > k || m - i > k)
                    continue;

                int raia = n - 1 - rai;

                if (lai < raia && lai - k + 1 >= 0 && raia + k - 1 < n) {

                    out.println("Yes");
                    out.print(lai + 1 - k + 1);
                    out.print(" ");
                    out.print(raia + 1);

                    return;
                }
            }

            out.println("No");
        }

        class Kmp<T extends Comparable<T>> {
            T[] s;
            T[] p;
            int n;
            int m;
            int[] f;
            int[] ans;
            int[] ansi;

            public Kmp(T[] s, T[] p) {
                super();
                this.s = s;
                this.p = p;
                this.n = s.length;
                this.m = p.length;
                this.f = new int[m];
                this.ans = new int[n + 1];
                for (int i = 1; i <= n; i++)
                    this.ans[i] = n;
                this.ansi = new int[n];
            }

            void fail() {
                f[0] = -1;

                for (int i = 1; i < m; i++) {
                    int c = f[i - 1];

                    f[i] = -1;
                    while (c > -1) {
                        if (p[c + 1].equals(p[i])) {
                            f[i] = c + 1;
                            break;
                        } else {
                            c = f[c];
                        }
                    }

                    if (f[i] == -1) {
                        if (p[0].equals(p[i])) {
                            f[i] = 0;
                        }
                    }
                }
            }

            int matches(int k) {

                int matches = 0;

                int j = 0;
                for (int i = 0; i < n; i++) {
                    if (s[i].equals(p[j])) {
                        j++;
                        if (ans[j] == n && i >= k - 1) {
                            ans[j] = i;
                        }
                        if (j == m) {
                            matches++;
                            j = f[j - 1] + 1;
                        }
                    } else {
                        while (j > 0 && !p[j].equals(s[i])) {
                            j = f[j - 1] + 1;
                        }

                        if (p[j].equals(s[i])) {
                            j++;
                            if (ans[j] == n && i >= k - 1) {
                                ans[j] = i;
                            }
                        }
                    }
                }

                return matches;
            }

            void can() {
                boolean[] vis = new boolean[m];

                for (int i = m - 1; i >= 0; i--) {
                    if (!vis[i]) {
                        int p = i;
                        vis[p] = true;
                        int c = f[p];
                        while (c > 0) {
                            ans[c] = Math.min(ans[p], ans[c]);
                            vis[c] = true;
                            p = c;
                            c = f[p];
                        }
                    }
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public String next() {
            return nextString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

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

        public void print(int i) {
            writer.print(i);
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.stream.IntStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.stream.Stream;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author prakharjain
 */
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);
        _955D solver = new _955D();
        solver.solve(1, in, out);
        out.close();
    }

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

            int k = in.nextInt();

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

            Kmp<Character> kmp1 = new Kmp<Character>(
                    s.chars().mapToObj(c -> (char) c).toArray(Character[]::new), t.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp1.fail();
            kmp1.matches(k);
            kmp1.can();

            String sr = new StringBuilder(s).reverse().toString();
            String tr = new StringBuilder(t).reverse().toString();

            Kmp<Character> kmp2 = new Kmp<Character>(
                    sr.chars().mapToObj(c -> (char) c).toArray(Character[]::new), tr.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp2.fail();
            kmp2.matches(k);
            kmp2.can();

            for (int i = 0; i <= m; i++) {
                int lai = kmp1.ans[i];

                int rai = kmp2.ans[m - i];

                if (i > k || m - i > k)
                    continue;

                int raia = n - 1 - rai;

                if (i == m) {
                    raia = n - k;
                } else if (m - i == m) {
                    lai = 0;
                }
                if (lai < raia && lai - k + 1 >= 0 && raia + k - 1 < n) {

                    out.println("Yes");
                    out.print(lai + 1 - k + 1);
                    out.print(" ");
                    out.print(raia + 1);

                    return;
                }
            }

            out.println("No");
        }

        class Kmp<T extends Comparable<T>> {
            T[] s;
            T[] p;
            int n;
            int m;
            int[] f;
            int[] ans;
            int[] ansi;

            public Kmp(T[] s, T[] p) {
                super();
                this.s = s;
                this.p = p;
                this.n = s.length;
                this.m = p.length;
                this.f = new int[m];
                this.ans = new int[n + 1];
                for (int i = 1; i <= n; i++)
                    this.ans[i] = n;
                this.ansi = new int[n];
            }

            void fail() {
                f[0] = -1;

                for (int i = 1; i < m; i++) {
                    int c = f[i - 1];

                    f[i] = -1;
                    while (c > -1) {
                        if (p[c + 1].equals(p[i])) {
                            f[i] = c + 1;
                            break;
                        } else {
                            c = f[c];
                        }
                    }

                    if (f[i] == -1) {
                        if (p[0].equals(p[i])) {
                            f[i] = 0;
                        }
                    }
                }
            }

            int matches(int k) {

                int matches = 0;

                int j = 0;
                for (int i = 0; i < n; i++) {
                    if (s[i].equals(p[j])) {
                        j++;
                        if (ans[j] == n && i >= k - 1) {
                            ans[j] = i;
                        }
                        if (j == m) {
                            matches++;
                            j = f[j - 1] + 1;
                        }
                    } else {
                        while (j > 0 && !p[j].equals(s[i])) {
                            j = f[j - 1] + 1;
                        }

                        if (p[j].equals(s[i])) {
                            j++;
                            if (ans[j] == n && i >= k - 1) {
                                ans[j] = i;
                            }
                        }
                    }
                }

                return matches;
            }

            void can() {
                boolean[] vis = new boolean[m + 1];

                for (int i = m; i > 0; i--) {
                    if (!vis[i]) {
                        int p = i;
                        vis[p] = true;
                        int c = f[p - 1] + 1;
                        while (c > 0) {
                            ans[c] = Math.min(ans[p], ans[c]);
                            vis[c] = true;
                            p = c;
                            c = f[p - 1] + 1;
                        }
                    }
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public String next() {
            return nextString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

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

        public void print(int i) {
            writer.print(i);
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.stream.IntStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.stream.Stream;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author prakharjain
 */
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);
        _955D solver = new _955D();
        solver.solve(1, in, out);
        out.close();
    }

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

            int k = in.nextInt();

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

            Kmp<Character> kmp1 = new Kmp<Character>(
                    s.chars().mapToObj(c -> (char) c).toArray(Character[]::new), t.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp1.fail();
            kmp1.matches(k);
            kmp1.can();

            String sr = new StringBuilder(s).reverse().toString();
            String tr = new StringBuilder(t).reverse().toString();

            Kmp<Character> kmp2 = new Kmp<Character>(
                    sr.chars().mapToObj(c -> (char) c).toArray(Character[]::new), tr.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp2.fail();
            kmp2.matches(k);
            kmp2.can();

            for (int i = 0; i <= m; i++) {
                int lai = kmp1.ans[i];

                int rai = kmp2.ans[m - i];

                if (i > k || m - i > k)
                    continue;

                int raia = n - 1 - rai;

                if (i == k) {
                    raia = n - k;
                } else if (m - i == k) {
                    lai = 0;
                }
                if (lai < raia && lai - k + 1 >= 0 && raia + k - 1 < n) {

                    out.println("Yes");
                    out.print(lai + 1 - k + 1);
                    out.print(" ");
                    out.print(raia + 1);

                    return;
                }
            }

            out.println("No");
        }

        class Kmp<T extends Comparable<T>> {
            T[] s;
            T[] p;
            int n;
            int m;
            int[] f;
            int[] ans;
            int[] ansi;

            public Kmp(T[] s, T[] p) {
                super();
                this.s = s;
                this.p = p;
                this.n = s.length;
                this.m = p.length;
                this.f = new int[m];
                this.ans = new int[n + 1];
                for (int i = 1; i <= n; i++)
                    this.ans[i] = n;
                this.ansi = new int[n];
            }

            void fail() {
                f[0] = -1;

                for (int i = 1; i < m; i++) {
                    int c = f[i - 1];

                    f[i] = -1;
                    while (c > -1) {
                        if (p[c + 1].equals(p[i])) {
                            f[i] = c + 1;
                            break;
                        } else {
                            c = f[c];
                        }
                    }

                    if (f[i] == -1) {
                        if (p[0].equals(p[i])) {
                            f[i] = 0;
                        }
                    }
                }
            }

            int matches(int k) {

                int matches = 0;

                int j = 0;
                for (int i = 0; i < n; i++) {
                    if (s[i].equals(p[j])) {
                        j++;
                        if (ans[j] == n && i >= k - 1) {
                            ans[j] = i;
                        }
                        if (j == m) {
                            matches++;
                            j = f[j - 1] + 1;
                        }
                    } else {
                        while (j > 0 && !p[j].equals(s[i])) {
                            j = f[j - 1] + 1;
                        }

                        if (p[j].equals(s[i])) {
                            j++;
                            if (ans[j] == n && i >= k - 1) {
                                ans[j] = i;
                            }
                        }
                    }
                }

                return matches;
            }

            void can() {
                boolean[] vis = new boolean[m + 1];

                for (int i = m; i > 0; i--) {
                    if (!vis[i]) {
                        int p = i;
                        vis[p] = true;
                        int c = f[p - 1] + 1;
                        while (c > 0) {
                            ans[c] = Math.min(ans[p], ans[c]);
                            vis[c] = true;
                            p = c;
                            c = f[p - 1] + 1;
                        }
                    }
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public String next() {
            return nextString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

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

        public void print(int i) {
            writer.print(i);
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.stream.IntStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.stream.Stream;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author prakharjain
 */
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);
        _955D solver = new _955D();
        solver.solve(1, in, out);
        out.close();
    }

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

            int k = in.nextInt();

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

            Kmp<Character> kmp1 = new Kmp<Character>(
                    s.chars().mapToObj(c -> (char) c).toArray(Character[]::new), t.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp1.fail();
            kmp1.matches(k);
            kmp1.can();

            String sr = new StringBuilder(s).reverse().toString();
            String tr = new StringBuilder(t).reverse().toString();

            Kmp<Character> kmp2 = new Kmp<Character>(
                    sr.chars().mapToObj(c -> (char) c).toArray(Character[]::new), tr.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp2.fail();
            kmp2.matches(k);
            kmp2.can();

            for (int i = 0; i <= m; i++) {
                int lai = kmp1.ans[i];

                int rai = kmp2.ans[m - i];

                if (i > k || m - i > k)
                    continue;

                int raia = n - 1 - rai;

                if (i == m && lai != n) {
                    lai = Math.max(k - 1, kmp1.sa);
                    raia = n - k;
                } else if (m - i == m && rai != n) {
                    lai = 0;
                    raia = Math.min(n - 1 - kmp2.sa, n - k);
                }
                if (lai < raia && lai - k + 1 >= 0 && raia + k - 1 < n) {

                    out.println("Yes");
                    out.print(lai + 1 - k + 1);
                    out.print(" ");
                    out.print(raia + 1);

                    return;
                }
            }

            out.println("No");
        }

        class Kmp<T extends Comparable<T>> {
            T[] s;
            T[] p;
            int n;
            int m;
            int[] f;
            int[] ans;
            int[] ansi;
            int sa;

            public Kmp(T[] s, T[] p) {
                super();
                this.s = s;
                this.p = p;
                this.n = s.length;
                this.m = p.length;
                this.f = new int[m];
                this.ans = new int[n + 1];
                for (int i = 1; i <= n; i++)
                    this.ans[i] = n;
                this.ansi = new int[n];
            }

            void fail() {
                f[0] = -1;

                for (int i = 1; i < m; i++) {
                    int c = f[i - 1];

                    f[i] = -1;
                    while (c > -1) {
                        if (p[c + 1].equals(p[i])) {
                            f[i] = c + 1;
                            break;
                        } else {
                            c = f[c];
                        }
                    }

                    if (f[i] == -1) {
                        if (p[0].equals(p[i])) {
                            f[i] = 0;
                        }
                    }
                }
            }

            int matches(int k) {

                int matches = 0;

                int j = 0;
                for (int i = 0; i < n; i++) {
                    if (s[i].equals(p[j])) {
                        j++;
                        if (ans[j] == n && i >= k - 1) {
                            ans[j] = i;
                        }
                        if (j == m) {
                            if (sa == n) {
                                sa = i;
                            }
                            matches++;
                            j = f[j - 1] + 1;
                        }
                    } else {
                        while (j > 0 && !p[j].equals(s[i])) {
                            j = f[j - 1] + 1;
                        }

                        if (p[j].equals(s[i])) {
                            j++;
                            if (ans[j] == n && i >= k - 1) {
                                ans[j] = i;
                            }
                        }
                    }
                }

                return matches;
            }

            void can() {
                boolean[] vis = new boolean[m + 1];

                for (int i = m; i > 0; i--) {
                    if (!vis[i]) {
                        int p = i;
                        vis[p] = true;
                        int c = f[p - 1] + 1;
                        while (c > 0) {
                            ans[c] = Math.min(ans[p], ans[c]);
                            vis[c] = true;
                            p = c;
                            c = f[p - 1] + 1;
                        }
                    }
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public String next() {
            return nextString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

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

        public void print(int i) {
            writer.print(i);
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.stream.IntStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.stream.Stream;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author prakharjain
 */
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);
        _955D solver = new _955D();
        solver.solve(1, in, out);
        out.close();
    }

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

            int k = in.nextInt();

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

            Kmp<Character> kmp1 = new Kmp<Character>(
                    s.chars().mapToObj(c -> (char) c).toArray(Character[]::new), t.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp1.fail();
            kmp1.matches(k);
            kmp1.can();

            String sr = new StringBuilder(s).reverse().toString();
            String tr = new StringBuilder(t).reverse().toString();

            Kmp<Character> kmp2 = new Kmp<Character>(
                    sr.chars().mapToObj(c -> (char) c).toArray(Character[]::new), tr.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp2.fail();
            kmp2.matches(k);
            kmp2.can();

            for (int i = 0; i <= m; i++) {
                int lai = kmp1.ans[i];

                int rai = kmp2.ans[m - i];

                if (i > k || m - i > k)
                    continue;

                int raia = n - 1 - rai;

                if (i == m && kmp1.sa != n) {
                    lai = Math.max(k - 1, kmp1.sa);
                    raia = n - k;
                } else if (m - i == m && kmp2.sa != n) {
                    lai = k - 1;
                    raia = Math.min(n - 1 - kmp2.sa, n - k);
                }
                if (lai < raia && lai - k + 1 >= 0 && raia + k - 1 < n) {

                    out.println("Yes");
                    out.print(lai + 1 - k + 1);
                    out.print(" ");
                    out.print(raia + 1);

                    return;
                }
            }

            out.println("No");
        }

        class Kmp<T extends Comparable<T>> {
            T[] s;
            T[] p;
            int n;
            int m;
            int[] f;
            int[] ans;
            int[] ansi;
            int sa;

            public Kmp(T[] s, T[] p) {
                super();
                this.s = s;
                this.p = p;
                this.n = s.length;
                this.m = p.length;
                this.f = new int[m];
                this.ans = new int[n + 1];
                for (int i = 1; i <= n; i++)
                    this.ans[i] = n;
                this.ansi = new int[n];
                this.sa = n;
            }

            void fail() {
                f[0] = -1;

                for (int i = 1; i < m; i++) {
                    int c = f[i - 1];

                    f[i] = -1;
                    while (c > -1) {
                        if (p[c + 1].equals(p[i])) {
                            f[i] = c + 1;
                            break;
                        } else {
                            c = f[c];
                        }
                    }

                    if (f[i] == -1) {
                        if (p[0].equals(p[i])) {
                            f[i] = 0;
                        }
                    }
                }
            }

            int matches(int k) {

                int matches = 0;

                int j = 0;
                for (int i = 0; i < n; i++) {
                    if (s[i].equals(p[j])) {
                        j++;
                        if (ans[j] == n && i >= k - 1) {
                            ans[j] = i;
                        }
                        if (j == m) {
                            if (sa == n) {
                                sa = i;
                            }
                            matches++;
                            j = f[j - 1] + 1;
                        }
                    } else {
                        while (j > 0 && !p[j].equals(s[i])) {
                            j = f[j - 1] + 1;
                        }

                        if (p[j].equals(s[i])) {
                            j++;
                            if (ans[j] == n && i >= k - 1) {
                                ans[j] = i;
                            }
                        }
                    }
                }

                return matches;
            }

            void can() {
                boolean[] vis = new boolean[m + 1];

                for (int i = m; i > 0; i--) {
                    if (!vis[i]) {
                        int p = i;
                        vis[p] = true;
                        int c = f[p - 1] + 1;
                        while (c > 0) {
                            ans[c] = Math.min(ans[p], ans[c]);
                            vis[c] = true;
                            p = c;
                            c = f[p - 1] + 1;
                        }
                    }
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public String next() {
            return nextString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

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

        public void print(int i) {
            writer.print(i);
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.stream.IntStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.stream.Stream;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author prakharjain
 */
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);
        _955D solver = new _955D();
        solver.solve(1, in, out);
        out.close();
    }

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

            int k = in.nextInt();

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

            Kmp<Character> kmp1 = new Kmp<Character>(
                    s.chars().mapToObj(c -> (char) c).toArray(Character[]::new), t.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp1.fail();
            kmp1.matches(k);
            kmp1.can();

            String sr = new StringBuilder(s).reverse().toString();
            String tr = new StringBuilder(t).reverse().toString();

            Kmp<Character> kmp2 = new Kmp<Character>(
                    sr.chars().mapToObj(c -> (char) c).toArray(Character[]::new), tr.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp2.fail();
            kmp2.matches(k);
            kmp2.can();

            for (int i = 0; i <= m; i++) {
                int lai = kmp1.ans[i];

                int rai = kmp2.ans[m - i];

                if (i > k || m - i > k)
                    continue;

                int raia = n - 1 - rai;

                if (i >= m) {
                    raia = n - k;
                } else if (m - i >= m) {
                    lai = 0;
                }
                if (lai < raia && lai - k + 1 >= 0 && raia + k - 1 < n) {

                    out.println("Yes");
                    out.print(lai + 1 - k + 1);
                    out.print(" ");
                    out.print(raia + 1);

                    return;
                }
            }

            out.println("No");
        }

        class Kmp<T extends Comparable<T>> {
            T[] s;
            T[] p;
            int n;
            int m;
            int[] f;
            int[] ans;
            int[] ansi;

            public Kmp(T[] s, T[] p) {
                super();
                this.s = s;
                this.p = p;
                this.n = s.length;
                this.m = p.length;
                this.f = new int[m];
                this.ans = new int[n + 1];
                for (int i = 1; i <= n; i++)
                    this.ans[i] = n;
                this.ansi = new int[n];
            }

            void fail() {
                f[0] = -1;

                for (int i = 1; i < m; i++) {
                    int c = f[i - 1];

                    f[i] = -1;
                    while (c > -1) {
                        if (p[c + 1].equals(p[i])) {
                            f[i] = c + 1;
                            break;
                        } else {
                            c = f[c];
                        }
                    }

                    if (f[i] == -1) {
                        if (p[0].equals(p[i])) {
                            f[i] = 0;
                        }
                    }
                }
            }

            int matches(int k) {

                int matches = 0;

                int j = 0;
                for (int i = 0; i < n; i++) {
                    if (s[i].equals(p[j])) {
                        j++;
                        if (ans[j] == n && i >= k - 1) {
                            ans[j] = i;
                        }
                        if (j == m) {
                            matches++;
                            j = f[j - 1] + 1;
                        }
                    } else {
                        while (j > 0 && !p[j].equals(s[i])) {
                            j = f[j - 1] + 1;
                        }

                        if (p[j].equals(s[i])) {
                            j++;
                            if (ans[j] == n && i >= k - 1) {
                                ans[j] = i;
                            }
                        }
                    }
                }

                return matches;
            }

            void can() {
                boolean[] vis = new boolean[m + 1];

                for (int i = m; i > 0; i--) {
                    if (!vis[i]) {
                        int p = i;
                        vis[p] = true;
                        int c = f[p - 1] + 1;
                        while (c > 0) {
                            ans[c] = Math.min(ans[p], ans[c]);
                            vis[c] = true;
                            p = c;
                            c = f[p - 1] + 1;
                        }
                    }
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public String next() {
            return nextString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

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

        public void print(int i) {
            writer.print(i);
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.stream.IntStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.stream.Stream;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author prakharjain
 */
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);
        _955D solver = new _955D();
        solver.solve(1, in, out);
        out.close();
    }

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

            int k = in.nextInt();

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

            Kmp<Character> kmp1 = new Kmp<Character>(
                    s.chars().mapToObj(c -> (char) c).toArray(Character[]::new), t.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp1.fail();
            kmp1.matches(k);
            kmp1.can();

            String sr = new StringBuilder(s).reverse().toString();
            String tr = new StringBuilder(t).reverse().toString();

            Kmp<Character> kmp2 = new Kmp<Character>(
                    sr.chars().mapToObj(c -> (char) c).toArray(Character[]::new), tr.chars().mapToObj(c -> (char) c).toArray(Character[]::new));

            kmp2.fail();
            kmp2.matches(k);
            kmp2.can();

            for (int i = 0; i <= m; i++) {
                int lai = kmp1.ans[i];

                int rai = kmp2.ans[m - i];

                if (i > k || m - i > k)
                    continue;

                int raia = n - 1 - rai;

                if (i == m && lai != n) {
                    if (lai < k - 1) {
                        lai = k - 1;
                    }
                    raia = n - k;
                } else if (m - i == m && rai != n) {
                    lai = 0;
                    if (raia > n - k) {
                        raia = n - k;
                    }
                }
                if (lai < raia && lai - k + 1 >= 0 && raia + k - 1 < n) {

                    out.println("Yes");
                    out.print(lai + 1 - k + 1);
                    out.print(" ");
                    out.print(raia + 1);

                    return;
                }
            }

            out.println("No");
        }

        class Kmp<T extends Comparable<T>> {
            T[] s;
            T[] p;
            int n;
            int m;
            int[] f;
            int[] ans;
            int[] ansi;

            public Kmp(T[] s, T[] p) {
                super();
                this.s = s;
                this.p = p;
                this.n = s.length;
                this.m = p.length;
                this.f = new int[m];
                this.ans = new int[n + 1];
                for (int i = 1; i <= n; i++)
                    this.ans[i] = n;
                this.ansi = new int[n];
            }

            void fail() {
                f[0] = -1;

                for (int i = 1; i < m; i++) {
                    int c = f[i - 1];

                    f[i] = -1;
                    while (c > -1) {
                        if (p[c + 1].equals(p[i])) {
                            f[i] = c + 1;
                            break;
                        } else {
                            c = f[c];
                        }
                    }

                    if (f[i] == -1) {
                        if (p[0].equals(p[i])) {
                            f[i] = 0;
                        }
                    }
                }
            }

            int matches(int k) {

                int matches = 0;

                int j = 0;
                for (int i = 0; i < n; i++) {
                    if (s[i].equals(p[j])) {
                        j++;
                        if (ans[j] == n && i >= k - 1) {
                            ans[j] = i;
                        }
                        if (j == m) {
                            if (ans[j] == n) {
                                ans[j] = i;
                            }
                            matches++;
                            j = f[j - 1] + 1;
                        }
                    } else {
                        while (j > 0 && !p[j].equals(s[i])) {
                            j = f[j - 1] + 1;
                        }

                        if (p[j].equals(s[i])) {
                            j++;
                            if (ans[j] == n && i >= k - 1) {
                                ans[j] = i;
                            }
                        }
                    }
                }

                return matches;
            }

            void can() {
                boolean[] vis = new boolean[m + 1];

                for (int i = m; i > 0; i--) {
                    if (!vis[i]) {
                        int p = i;
                        vis[p] = true;
                        int c = f[p - 1] + 1;
                        while (c > 0) {
                            ans[c] = Math.min(ans[p], ans[c]);
                            vis[c] = true;
                            p = c;
                            c = f[p - 1] + 1;
                        }
                    }
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public String next() {
            return nextString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

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

        public void print(int i) {
            writer.print(i);
        }

    }
}