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>
const int MAXN = 500002;
class hash {
 public:
  static const int mul1 = 233;
  static const int mod1 = 10007;
  static const unsigned long long mul2 = 990523;
  static int po1[600000];
  static unsigned long long po2[600000];
  static void init() {
    po1[0] = po2[0] = 1;
    for (int i = 1; i <= MAXN; i++) {
      po1[i] = po1[i - 1] * mul1 % mod1;
      po2[i] = po2[i - 1] * mul2;
    }
  }
  int v1;
  unsigned long long v2;
  int length;
  hash() {
    v1 = 0;
    v2 = 0;
    length = 0;
  }
  hash(const int &v1, const unsigned long long &v2, const int &length) {
    this->v1 = v1;
    this->v2 = v2;
    this->length = length;
  }
};
int hash::po1[600000];
unsigned long long hash::po2[600000];
bool operator==(const hash &h1, const hash &h2) {
  return h1.v1 == h2.v1 && h1.v2 == h2.v2;
}
hash operator+(const hash &h, const char &c) {
  return hash((h.v1 * hash::mul1 + c) % hash::mod1, h.v2 * hash::mul2 + c,
              h.length + 1);
}
hash operator-(const hash &h1, const hash &h2) {
  int l = h1.length - h2.length;
  return hash(
      ((h1.v1 - h2.v1 * hash::po1[l]) % hash::mod1 + hash::mod1) % hash::mod1,
      h1.v2 - h2.v2 * hash::po2[l], l);
}
char s[600000];
char t[600000];
hash hs[600000];
hash ht[600000];
int pre[600000];
int suf[600000];
int main() {
  int n, m, k;
  hash::init();
  memset(pre, -1, sizeof(pre));
  memset(suf, -1, sizeof(suf));
  scanf("%d %d %d", &n, &m, &k);
  scanf("%s", s + 1);
  scanf("%s", t + 1);
  for (int i = 1; i <= n; i++) {
    hs[i] = hs[i - 1] + s[i];
  }
  for (int i = 1; i <= m; i++) {
    ht[i] = ht[i - 1] + t[i];
  }
  int first = 0, end = 1;
  for (int i = 1; i <= m && i <= k; i++) {
    if ((hs[k] - hs[k - i]) == ht[i]) {
      if (first == 0) {
        first = i;
      }
      end = i;
      pre[i] = k;
    }
  }
  int curpos = k;
  for (int i = 1; i <= first; i++) {
    while (curpos <= n) {
      if ((hs[curpos] - hs[curpos - i]) == ht[i]) {
        break;
      }
      curpos++;
    }
    if (curpos <= n) {
      pre[i] = curpos;
    } else {
      break;
    }
  }
  curpos = k;
  for (int i = end; i <= m && i <= k; i++) {
    while (curpos <= n) {
      if ((hs[curpos] - hs[curpos - i]) == ht[i]) {
        break;
      }
      curpos++;
    }
    if (curpos <= n) {
      pre[i] = curpos;
    } else {
      break;
    }
  }
  first = m + 1, end = m;
  for (int i = m; i >= 1 && i >= m - k + 1; i--) {
    if ((hs[n - k + 1 + (m - i + 1) - 1] - hs[n - k]) == (ht[m] - ht[i - 1])) {
      if (first == m + 1) {
        first = i;
      }
      end = i;
      suf[i] = n - k + 1;
    }
  }
  curpos = n - k + 1;
  for (int i = m; i >= first; i--) {
    while (curpos >= 1) {
      if ((hs[curpos + (m - i)] - hs[curpos - 1]) == (ht[m] - ht[i - 1])) {
        break;
      }
      curpos--;
    }
    if (curpos >= 1) {
      suf[i] = curpos;
    } else {
      break;
    }
  }
  curpos = n - k + 1;
  for (int i = end; i >= 1 && i >= m - k + 1; i--) {
    while (curpos >= 1) {
      if ((hs[curpos + (m - i)] - hs[curpos - 1]) == (ht[m] - ht[i - 1])) {
        break;
      }
      curpos--;
    }
    if (curpos >= 1) {
      suf[i] = curpos;
    } else {
      break;
    }
  }
  bool have = false;
  int ans1, ans2;
  for (int i = 1; i < m; i++) {
    if (pre[i] != -1 && suf[i + 1] != -1) {
      if (pre[i] < suf[i + 1]) {
        have = true;
        ans1 = pre[i] - k + 1;
        ans2 = suf[i + 1];
        break;
      }
    }
  }
  if (!have && m <= k) {
    for (int i = 1; i + m - 1 <= n; i++) {
      if ((hs[i + m - 1] - hs[i - 1]) == (ht[m])) {
        have = true;
        if (i + m - 1 <= 2 * k) {
          ans1 = 1;
          ans2 = k + 1;
        } else {
          ans1 = i + m - 2 * k;
          ans2 = i + m - k;
        }
        break;
      }
    }
  }
  if (have) {
    puts("Yes");
    printf("%d %d", ans1, ans2);
  } else {
    puts("No");
  }
  return 0;
}
