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;
void re(int& x);
template <class T, class... Ts>
void re(T& t, Ts&... ts);
void pr(int x);
void pr(const char* x);
void ps();
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts);
vector<int> pi(const string& s) {
  vector<int> p(s.size());
  for (int i = 1; i < s.size(); i++) {
    int g = p[i - 1];
    while (g && s[i] != s[g]) g = p[g - 1];
    p[i] = g + (s[i] == s[g]);
  }
  return p;
}
int n, m, k;
bool foundent = false;
void match(const string& s, const string& pat, int* fi) {
  vector<int> p = pi(pat + '\0' + s), res;
  int delta = (int)p.size() - (int)s.size();
  for (int i = delta; i < p.size(); i++) {
    if (i >= delta + k - 1)
      fi[p[i]] = min(fi[p[i]], i - delta);
    else if (p[i] == (int)(pat).size())
      foundent = true;
  }
  for (int i = (int)(pat).size(); i > 0; i--) {
    fi[p[i - 1]] = min(fi[p[i - 1]], fi[i]);
  }
}
char ss[610000];
char tt[610000];
int file[610000];
int firi[610000];
void solve() {
  re(n, m, k);
  scanf("%s %s", ss, tt);
  string s = ss, t = tt;
  for (int i = 0; i <= s.size(); i++) file[i] = firi[i] = 1000000000;
  match(s, t, file);
  reverse((s).begin(), (s).end());
  reverse((t).begin(), (t).end());
  match(s, t, firi);
  for (int i = 0; i <= k; i++)
    if (0 <= (int)(t).size() - i && (int)(t).size() - i <= k) {
      if (file[i] < (n - 1 - firi[(int)(t).size() - i])) {
        ps("Yes");
        ps(file[i] - k + 2, n - firi[(int)(t).size() - i]);
        return;
      }
    }
  if (foundent) {
    ps("Yes");
    ps(1, n - k + 1);
    return;
  }
  ps("No");
}
int main() { solve(); }
void re(int& x) { scanf("%d", &x); }
template <class T, class... Ts>
void re(T& t, Ts&... ts) {
  re(t);
  re(ts...);
}
void pr(int x) { printf("%d", x); }
void pr(const char* x) { printf("%s", x); }
void ps() { pr("\n"); }
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts) {
  pr(t);
  if (sizeof...(ts)) pr(" ");
  ps(ts...);
}
