#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void ckmax(T& x, T y) {
  x = (y > x ? y : x);
}
template <typename T>
inline void ckmin(T& x, T y) {
  x = (y < x ? y : x);
}
namespace Fread {
const int SIZE = 1 << 21;
char buf[SIZE], *S, *T;
inline char getchar() {
  if (S == T) {
    T = (S = buf) + fread(buf, 1, SIZE, stdin);
    if (S == T) return '\n';
  }
  return *S++;
}
}  // namespace Fread
namespace Fwrite {
const int SIZE = 1 << 21;
char buf[SIZE], *S = buf, *T = buf + SIZE;
inline void flush() {
  fwrite(buf, 1, S - buf, stdout);
  S = buf;
}
inline void putchar(char c) {
  *S++ = c;
  if (S == T) flush();
}
struct NTR {
  ~NTR() { flush(); }
} ztr;
}  // namespace Fwrite
namespace Fastio {
struct Reader {
  template <typename T>
  Reader& operator>>(T& x) {
    char c = Fread ::getchar();
    T f = 1;
    while (c < '0' || c > '9') {
      if (c == '-') f = -1;
      c = Fread ::getchar();
    }
    x = 0;
    while (c >= '0' && c <= '9') {
      x = x * 10 + (c - '0');
      c = Fread ::getchar();
    }
    x *= f;
    return *this;
  }
  Reader& operator>>(char& c) {
    c = Fread ::getchar();
    while (c == '\n' || c == ' ') c = Fread ::getchar();
    return *this;
  }
  Reader& operator>>(char* str) {
    int len = 0;
    char c = Fread ::getchar();
    while (c == '\n' || c == ' ') c = Fread ::getchar();
    while (c != '\n' && c != ' ') {
      str[len++] = c;
      c = Fread ::getchar();
    }
    str[len] = '\0';
    return *this;
  }
  Reader() {}
} cin;
const char endl = '\n';
struct Writer {
  template <typename T>
  Writer& operator<<(T x) {
    if (x == 0) {
      Fwrite ::putchar('0');
      return *this;
    }
    if (x < 0) {
      Fwrite ::putchar('-');
      x = -x;
    }
    static int sta[45];
    int top = 0;
    while (x) {
      sta[++top] = x % 10;
      x /= 10;
    }
    while (top) {
      Fwrite ::putchar(sta[top] + '0');
      --top;
    }
    return *this;
  }
  Writer& operator<<(char c) {
    Fwrite ::putchar(c);
    return *this;
  }
  Writer& operator<<(char* str) {
    int cur = 0;
    while (str[cur]) Fwrite ::putchar(str[cur++]);
    return *this;
  }
  Writer& operator<<(const char* str) {
    int cur = 0;
    while (str[cur]) Fwrite ::putchar(str[cur++]);
    return *this;
  }
  Writer() {}
} cout;
}  // namespace Fastio
const int MAXN = 5e5;
const int LOG = 18;
const int INF = 1e9;
class KMP {
 public:
  int fail[MAXN + 5], match[MAXN + 5];
  void get_fail(const char* t, int m) {
    fail[1] = 0;
    for (int i = 2, j = 0; i <= m; ++i) {
      while (j && t[i] != t[j + 1]) j = fail[j];
      if (t[i] == t[j + 1]) ++j;
      fail[i] = j;
    }
  }
  void get_match(const char* s, const char* t, int n, int lim) {
    for (int i = 1, j = 0; i <= n; ++i) {
      while (j && (s[i] != t[j + 1] || j >= lim)) j = fail[j];
      if (s[i] == t[j + 1]) ++j;
      match[i] = j;
    }
  }
  KMP() {}
};
class Tree {
 public:
  struct EDGE {
    int nxt, to;
  } edge[MAXN * 2 + 5];
  int head[MAXN + 5], tot;
  inline void add_edge(int u, int v) {
    edge[++tot].nxt = head[u];
    edge[tot].to = v;
    head[u] = tot;
  }
  int fa[MAXN + 5], sz[MAXN + 5], son[MAXN + 5], dep[MAXN + 5];
  void dfs1(int u) {
    sz[u] = 1;
    for (int i = head[u]; i; i = edge[i].nxt) {
      int v = edge[i].to;
      if (v == fa[u]) continue;
      fa[v] = u;
      dep[v] = dep[u] + 1;
      dfs1(v);
      sz[u] += sz[v];
      if (!son[u] || sz[v] > sz[son[u]]) son[u] = v;
    }
  }
  int top[MAXN + 5], dfn[MAXN + 5], ofn[MAXN + 5], rev[MAXN + 5], cnt_dfn;
  void dfs2(int u, int t) {
    top[u] = t;
    dfn[u] = ++cnt_dfn;
    rev[cnt_dfn] = u;
    if (son[u]) dfs2(son[u], t);
    for (int i = head[u]; i; i = edge[i].nxt) {
      int v = edge[i].to;
      if (v == fa[u] || v == son[u]) continue;
      dfs2(v, v);
    }
    ofn[u] = cnt_dfn;
  }
  bool is_anc(int anc, int v) {
    return dfn[anc] <= dfn[v] && ofn[anc] >= dfn[v];
  }
  Tree() {}
};
class StaticRangeCover {
 private:
  int len;
  int fa[MAXN + 5], sz[MAXN + 5], mx[MAXN + 5], res[MAXN + 5];
  vector<pair<pair<int, int>, int> > vec;
  int get_fa(int u) { return (u == fa[u]) ? u : (fa[u] = get_fa(fa[u])); }
  void unite(int u, int v) {
    u = get_fa(u);
    v = get_fa(v);
    if (u != v) {
      if (sz[u] > sz[v]) swap(u, v);
      fa[u] = v;
      sz[v] += sz[u];
      mx[v] = max(mx[v], mx[u]);
    }
  }
  void jump_and_cover(int l, int r, int val) {
    for (int i = l; i <= r; ++i) {
      i = mx[get_fa(i)];
      if (i > r) {
        break;
      }
      res[i] = val;
      unite(i, r + 1);
    }
  }

 public:
  void build(int _len) {
    len = _len;
    for (int i = 1; i <= len + 1; ++i) {
      fa[i] = i;
      sz[i] = 1;
      mx[i] = i;
      res[i] = INF;
    }
  }
  void range_cover(int l, int r, int v) {
    vec.push_back(make_pair(make_pair(l, r), v));
  }
  void get_res(int* _res) {
    for (int i = ((int)(vec).size()) - 1; i >= 0; --i) {
      jump_and_cover(vec[i].first.first, vec[i].first.second, vec[i].second);
    }
    for (int i = 1; i <= len; ++i) {
      _res[i] = res[i];
    }
  }
  StaticRangeCover() {}
};
class RangeMinQuery {
 private:
  int _log2[MAXN + 5];
  pair<int, int> st[MAXN + 5][LOG + 1];

 public:
  void build(int* a, int n) {
    _log2[0] = -1;
    for (int i = 1; i <= n; ++i) {
      _log2[i] = _log2[i >> 1] + 1;
      st[i][0] = make_pair(a[i], i);
    }
    for (int j = 1; j <= LOG; ++j) {
      for (int i = 1; i + (1 << (j - 1)) <= n; ++i) {
        st[i][j] = min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
      }
    }
  }
  pair<int, int> rmq(int l, int r) {
    int k = _log2[r - l + 1];
    return min(st[l][k], st[r - (1 << k) + 1][k]);
  }
  int rmq_val(int l, int r) { return rmq(l, r).first; }
  int rmq_pos(int l, int r) { return rmq(l, r).second; }
  RangeMinQuery() {}
};
int n, m, K;
char s[MAXN + 5], t[MAXN + 5];
KMP kmp, kmp_rev;
Tree tree, tree_rev;
StaticRangeCover DSU;
RangeMinQuery RMQ;
void cover_anc(int u, int tim) {
  while (u) {
    int l = tree.dfn[tree.top[u]], r = tree.dfn[u];
    DSU.range_cover(l, r, tim);
    u = tree.fa[tree.top[u]];
  }
}
int first_cov_tim[MAXN + 5];
int arr[MAXN + 5];
void query_anc(int u, int tim) {
  while (u) {
    int l = tree_rev.dfn[tree_rev.top[u]], r = tree_rev.dfn[u];
    if (RMQ.rmq_val(l, r) < tim) {
      Fastio ::cout << "Yes" << Fastio ::endl;
      int x = tree_rev.rev[RMQ.rmq_pos(l, r)] - 1;
      for (int i = K; i < tim; ++i) {
        int v = kmp.match[i];
        if (v != 0 && tree.is_anc(x, v)) {
          Fastio ::cout << i - K + 1 << " " << tim << Fastio ::endl;
          exit(0);
        }
      }
      assert(0);
    }
    u = tree_rev.fa[tree_rev.top[u]];
  }
}
int main() {
  Fastio ::cin >> n >> m >> K;
  Fastio ::cin >> (s + 1);
  Fastio ::cin >> (t + 1);
  kmp.get_fail(t, m);
  kmp.get_match(s, t, n, min(m, K));
  reverse(s + 1, s + n + 1);
  reverse(t + 1, t + m + 1);
  kmp_rev.get_fail(t, m);
  kmp_rev.get_match(s, t, n, min(m, K));
  if (m <= K) {
    for (int i = m; i <= n - K; ++i) {
      if (kmp.match[i] == m) {
        Fastio ::cout << "Yes" << Fastio ::endl;
        Fastio ::cout << max(1, i - K + 1) << " " << n - K + 1 << Fastio ::endl;
        return 0;
      }
    }
    for (int i = K + 1; i <= n - m + 1; ++i) {
      if (kmp_rev.match[n - i + 1] == m) {
        Fastio ::cout << "Yes" << Fastio ::endl;
        Fastio ::cout << 1 << " " << min(i, n - K + 1) << Fastio ::endl;
        return 0;
      }
    }
  }
  for (int i = 2; i <= m; ++i) {
    if (kmp.fail[i]) {
      tree.add_edge(kmp.fail[i], i);
    }
    if (kmp_rev.fail[i]) {
      tree_rev.add_edge(m - kmp_rev.fail[i] + 1, m - i + 1);
    }
  }
  for (int i = 1; i <= m; ++i) {
    if (!tree.fa[i]) {
      tree.dfs1(i);
      tree.dfs2(i, i);
    }
  }
  for (int i = m; i >= 1; --i) {
    if (!tree_rev.fa[i]) {
      tree_rev.dfs1(i);
      tree_rev.dfs2(i, i);
    }
  }
  DSU.build(m);
  for (int i = n - K; i >= K; --i) {
    if (kmp.match[i] != 0) {
      int u = kmp.match[i];
      cover_anc(u, i);
    }
  }
  DSU.get_res(first_cov_tim);
  for (int i = 1; i <= m; ++i) {
    if (tree_rev.rev[i] != 1) {
      arr[i] = first_cov_tim[tree.dfn[tree_rev.rev[i] - 1]];
    }
  }
  RMQ.build(arr, m);
  for (int i = K + 1; i <= n - K + 1; ++i) {
    if (kmp_rev.match[n - i + 1] != 0) {
      int u = m - kmp_rev.match[n - i + 1] + 1;
      assert(u != 1);
      query_anc(u, i);
    }
  }
  Fastio ::cout << "No" << Fastio ::endl;
  return 0;
}
