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>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast", "-funroll-loops", "-fdelete-null-pointer-checks")
#pragma GCC target("ssse3", "sse3", "sse2", "sse", "avx2", "avx")
using std::max;
using std::min;
using std::pair;
using std::reverse;
using std::vector;
const int MAXN = 5e5 + 20;
namespace MyIO {
const int MAXB = 1 << 18;
char gbuf[MAXB], *ps = gbuf, *pt = gbuf;
char pbuf[MAXB + 1], *pp = pbuf;
struct Flusher {
  ~Flusher() { fwrite(pbuf, 1, pp - pbuf, stdout); }
} flusher;
inline char Getchar() {
  if (ps == pt) {
    ps = gbuf;
    pt = gbuf + fread(gbuf, 1, MAXB, stdin);
  }
  return (ps == pt) ? EOF : *ps++;
}
inline void Putchar(const char &ch) {
  if (pp == pbuf + MAXB) {
    pp = pbuf;
    fwrite(pbuf, 1, MAXB, stdout);
  }
  *pp++ = ch;
}
}  // namespace MyIO
int read() {
  int x = 0;
  char c = MyIO::Getchar();
  bool f = 0;
  while (c < '0' || c > '9')
    (c == '-') ? f = 1, c = MyIO::Getchar() : c = MyIO::Getchar();
  while (c >= '0' && c <= '9')
    x = (x << 1) + (x << 3) + (48 ^ c), c = MyIO::Getchar();
  return (f) ? -x : x;
}
void write(const int &x) {
  if (x / 10) write(x / 10);
  MyIO::Putchar('0' + x % 10);
}
struct string {
  char data[MAXN];
  int len;
  int size() const { return len; }
  void reverse() { std::reverse(data, data + len); }
  char &operator[](const int &index) { return data[index]; }
  char operator[](const int &index) const { return data[index]; }
};
void read_string(string &s) {
  char ch = MyIO::Getchar();
  while (ch < 'a' && ch > 'z') ch = MyIO::Getchar();
  s.len = 0;
  while (ch >= 'a' && ch <= 'z') s[s.len++] = ch, ch = MyIO::Getchar();
}
void z_algorithm(const string &s1, const string &s2, vector<int> &z,
                 const vector<int> &z_s2, const int &z_limit) {
  const int n1 = s1.size(), n2 = min((int)s2.size(), z_limit);
  while (z[0] < n2 && s1[z[0]] == s2[z[0]]) ++z[0];
  for (int i = 1, l = 0, r = 0; i < n1; ++i) {
    if (i < r) z[i] = min(r - i, z_s2[i - l]);
    while (z[i] < n2 && i + z[i] < n1 && s1[i + z[i]] == s2[z[i]]) ++z[i];
    if (r < i + z[i]) l = i, r = i + z[i];
  }
}
struct disjoint_set {
  vector<int> fa;
  disjoint_set(const int &n) {
    fa.resize(n);
    for (int i = 0; i < n; ++i) fa[i] = i;
  }
  int get_fa(const int &x) {
    if (fa[x] == x)
      return x;
    else
      return fa[x] = get_fa(fa[x]);
  }
  void merge(int x, int y) {
    x = get_fa(x), y = get_fa(y);
    fa[x] = y;
  }
};
void print_vector(const vector<int> &qaq) {
  static int CNT = 0;
  printf("CNT:%d\n", CNT++);
  puts("----------------");
  for (int j : qaq) write(j), MyIO::Putchar(' ');
  puts("\n----------------");
}
int main() {
  int n = read(), m = read(), k = read();
  string s, t;
  read_string(s), read_string(t);
  vector<int> z_pre(n, 0), z_suf(n, 0), z_t(m, 0);
  z_algorithm(t, t, z_t, z_t, k);
  z_algorithm(s, t, z_pre, z_t, k);
  s.reverse(), t.reverse();
  z_t.assign(m, 0);
  z_algorithm(t, t, z_t, z_t, k);
  z_algorithm(s, t, z_suf, z_t, k);
  reverse(z_suf.begin(), z_suf.end());
  auto Ans = [&](const int &t1, const int &s2) {
    if (t1 == -1)
      MyIO::Putchar('N'), MyIO::Putchar('o');
    else {
      MyIO::Putchar('Y'), MyIO::Putchar('e'), MyIO::Putchar('s'),
          MyIO::Putchar('\n');
      write(t1 - k + 1 + 1), MyIO::Putchar(' '), write(s2 + 1);
    }
    return 0;
  };
  if (m <= k)
    for (int i = 0; i < n; ++i)
      if (z_pre[i] == m) {
        int start_L = max(0, (i + z_pre[i] - 1) - k + 1), start_R = start_L + k;
        int start_R2 = min(i, (n - 1) - k + 1),
            start_L2 = (start_R2 - 1) - k + 1;
        if (start_R + k - 1 <= n - 1)
          return Ans(start_L + k - 1, start_R);
        else if (start_L2 >= 0)
          return Ans(start_L2 + k - 1, start_R2);
      }
  vector<vector<pair<int, int> > > oper(n);
  for (int i = 0; i < n; ++i) {
    int l = max(1, i - min(i, (n - 1) - k + 1) + 1), r = z_suf[i];
    if (l <= r) oper[i].push_back(pair<int, int>(l, r));
  }
  vector<int> mx(n + 1, -1);
  disjoint_set DS(n + 1);
  auto modify = [&](const int &l, const int &r, const int &val) {
    for (int i = DS.get_fa(l); i <= r; DS.merge(i, i + 1), i = DS.get_fa(i)) {
      if (mx[i] == -1) mx[i] = val;
    }
  };
  for (int x = n - 1; x >= 0; --x)
    for (pair<int, int> i : oper[x]) modify(i.first, i.second, x);
  vector<int> arr;
  arr.reserve(n);
  for (int i = 0; i < n; ++i) {
    if ((i + z_pre[i] - 1) >= k && z_pre[i] <= k && m - z_pre[i] <= k)
      if (mx[m - z_pre[i]] != -1 &&
          mx[m - z_pre[i]] - (m - z_pre[i]) + 1 > i + z_pre[i] - 1)
        return Ans(i + z_pre[i] - 1, mx[m - z_pre[i]] - (m - z_pre[i]) + 1);
    if (i <= k - 1 && i + z_pre[i] - 1 >= k - 1) arr.push_back(k - 1 - i + 1);
  }
  for (int z : arr)
    if (z <= k && m - z <= k)
      if (mx[m - z] != -1 && mx[m - z] - (m - z) + 1 > k - 1)
        return Ans(k - 1, mx[m - z] - (m - z) + 1);
  return Ans(-1, -1);
}
