Jenya has recently acquired quite a useful tool — k-scissors for cutting strings. They are generally used for cutting out two non-intersecting substrings of length k from an arbitrary string s (its length should be at least 2·k in order to perform this operation) and concatenating them afterwards (preserving the initial order). For example, with the help of 2-scissors you can cut ab and de out of abcde and concatenate them into abde, but not ab and bc since they're intersecting.

It's a nice idea to test this tool before using it in practice. After looking through the papers, Jenya came up with two strings s and t. His question is whether it is possible to apply his scissors to string s such that the resulting concatenation contains t as a substring?

Input

The first line contains three integers n, m, k (2 ≤ m ≤ 2·k ≤ n ≤ 5·105) — length of s, length of t and the aforementioned scissors' parameter correspondingly.

The next two lines feature s and t consisting of lowercase latin letters.

Output

If there is no answer, print «No». 

Otherwise print «Yes» and two integers L and R denoting the indexes where cutted substrings start (1-indexed). If there are several possible answers, output any.

Examples

Input

7 4 3
baabaab
aaaa


Output

Yes
1 5


Input

6 3 2
cbcbcb
bcc


Output

Yes
2 5


Input

7 5 3
aabbaaa
aaaaa


Output

No

Note

In the first sample case you can cut out two substrings starting at 1 and 5. The resulting string baaaab contains aaaa as a substring.

In the second sample case the resulting string is bccb.
#include <bits/stdc++.h>
using namespace std;
const int mod = (1e9) + 7;
const double eps = 1e-9;
const int siz = 5e5 + 5, siz2 = 1e5 + 5;
int n, m, k, mn[siz], mx[siz], pref[siz], suff[siz], tree1[siz * 4],
    tree2[siz * 4];
char s[siz], t[siz];
vector<int> zf(string &s) {
  int n = s.size();
  vector<int> z(n);
  int l = 0, r = 0;
  for (int i = 1; i < n; i++) {
    if (i > r) {
      if (s[i] != s[0]) {
        z[i] = 0;
      } else {
        l = i;
        z[i] = 1;
        while (l + z[i] < n && s[z[i]] == s[l + z[i]]) {
          z[i]++;
        }
        r = l + z[i] - 1;
      }
    } else {
      int k = i - l;
      if (z[k] < r - i + 1) {
        z[i] = z[k];
      } else {
        z[i] = r - i + 1;
        l = i;
        while (l + z[i] < n && s[z[i]] == s[l + z[i]]) {
          z[i]++;
        }
        r = l + z[i] - 1;
      }
    }
  }
  return z;
}
void build(int node, int s, int e) {
  if (s == e) {
    tree1[node] = pref[s];
    tree2[node] = suff[s];
    return;
  }
  int mid = (s + e) / 2;
  build(node * 2, s, mid);
  build(node * 2 + 1, mid + 1, e);
  tree1[node] = max(tree1[node * 2], tree1[node * 2 + 1]);
  tree2[node] = max(tree2[node * 2], tree2[node * 2 + 1]);
}
int query1(int node, int s, int e, int l, int v) {
  if (tree1[node] < v || e < l) return -1;
  if (s == e) return s;
  int mid = (s + e) / 2;
  int val = query1(node * 2, s, mid, l, v);
  if (val != -1) return val;
  return query1(node * 2 + 1, mid + 1, e, l, v);
}
int query2(int node, int s, int e, int r, int v) {
  if (tree2[node] < v || s > r) return -1;
  if (s == e) return s;
  int mid = (s + e) / 2;
  int val = query2(node * 2 + 1, mid + 1, e, r, v);
  if (val != -1) return val;
  return query2(node * 2, s, mid, r, v);
}
int main() {
  scanf("%d%d%d%s%s", &n, &m, &k, s, t);
  string ss(s), ts(t);
  string s1 = ts + "#" + ss;
  reverse(ss.begin(), ss.end());
  reverse(ts.begin(), ts.end());
  string s2 = ts + "#" + ss;
  vector<int> z1 = zf(s1), z2 = zf(s2);
  int sz = z1.size();
  for (int i = m + 1; i < sz; i++) {
    pref[i - m - 1] = z1[i];
    suff[n - (i - m - 1) - 1] = z2[i];
  }
  build(1, 0, n - 1);
  for (int i = 1; i < m; i++) {
    mn[i] = query1(1, 0, n - 1, max(k - i, 0), i);
    mx[i] = query2(1, 0, n - 1, min(n - k + i - 1, n - 1), i);
  }
  for (int i = 1; i < m; i++) {
    if (mn[i] == -1 || mx[m - i] == -1 || i > k || m - i > k ||
        mn[i] + i - 1 >= mx[m - i] - (m - i) + 1)
      continue;
    printf("Yes\n%d %d\n", mn[i] + i - k + 1, mx[m - i] - (m - i) + 2);
    return 0;
  }
  if (m <= k) {
    for (int i = 0; i < n; i++) {
      if (pref[i] == m) {
        int l = i, r = min(n - 1, i + k - 1);
        if (r - i + 1 < k) {
          l -= k - (r - i + 1);
        }
        if (l > k) {
          printf("Yes\n1 %d\n", l + 1);
          return 0;
        }
        r = i;
        l = max(0, i - k + 1);
        if (r - i + 1 < k) {
          r += k - (r - i + 1);
        }
        if (l + 1 < n - k) {
          printf("Yes\n%d %d\n", l + 1, n - k + 1);
          return 0;
        }
      }
    }
  }
  printf("No\n");
  return 0;
}
