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?
The first line contains three integers *n*, *m*, *k* (2 ≤ *m* ≤ 2·*k* ≤ *n* ≤ 5·10<sup class="upper-index">5</sup>) — 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.
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.
7 4 3
baabaab
aaaa
Yes
1 5
6 3 2
cbcbcb
bcc
Yes
2 5
7 5 3
aabbaaa
aaaaa
No
16 6 4
abcdcadbbbcacdca
dcadbc
Yes
4 10
81 5 3
acbbcccbcbcbbbabaabbbcbacbaabbabaacccaaaaaabbbaacbaabcbcacbbacacbaaaaccbbcacbbcba
cbbab
Yes
1 30
12 3 4
dbcbabbbdcbb
bba
No
18 3 4
dcdbdbadddbddbbccc
bba
Yes
1 6
7 3 3
aaabbaa
aaa
Yes
1 4
8 3 4
bcbaaaax
bcb
Yes
1 5
30 17 9
dbcdcdcdbddaabcbdcdbdacaddcdbc
bcdcdcdbdabcbdcdb
Yes
2 13
25 7 12
bbabaabbabbabbbabbabaabba
babaabb
Yes
2 14
28 14 9
deaeeabadeaecbebddaeaedebbdd
badeaecbeaeaed
Yes
7 19
12 8 4
aaaaabbbaaab
aaaaaaaa
No
2 2 1
ab
aa
No
2 2 1
aa
aa
Yes
1 2
4 3 2
aaba
aaa
No
4 2 2
acba
aa
No
27 13 12
baababbabbbbaaaabaabbbbaaaa
baababbabbbba
Yes
1 13
27 11 9
bbaabababaaaabbbbabaababaab
abababaabab
Yes
2 17
7 3 2
aabcbaa
aaa
Yes
1 6
import sys 
input = sys.stdin.buffer.readline 

def partial(s):
    g, pi = 0, [0] * len(s)
    for i in range(1, len(s)):
        while g and (s[g] != s[i]):
            g = pi[g - 1]
        pi[i] = g = g + (s[g] == s[i])

    return pi
s ='alert?balbertb'

def process(k, S, T):
    n = len(S)
    m = len(T)
    S1 = T+"?"+S
    A1 = partial(S1)
    A1 = A1[m+1:]
    S2 = T[::-1]+"?"+S[::-1]
    B1 = partial(S2)
    B1 = B1[m+1:]
    B1 = B1[::-1]
    prefix_find = [None for i in range(k+1)]
    suffix_find = [None for i in range(k+1)]
    for i in range(n):
        pi = A1[i]
        if pi <= k and prefix_find[pi] is None:
            prefix_find[pi] = i
    for i in range(n-1, -1, -1):
        si = B1[i]
        if si <= k and suffix_find[si] is None:
            suffix_find[si] = i 
    for i in range(1, k+1):
        if prefix_find[i] is not None and m-i <= k and suffix_find[m-i] is not None:
            i2 = prefix_find[i]
            i1 = i2-i+1
            j1 = suffix_find[m-i]
            j2 = j1+m-i-1 
            if i2-k+1 >= 0 and j1+k-1 <= n-1:
                l1, r1 = i2-k+1, i2 
                l2, r2 = j1, j1+k-1 
                if r1 < l2:
                    sys.stdout.write('Yes\n')
                    sys.stdout.write(f'{l1+1} {l2+1}\n')
                    return 
    sys.stdout.write('No\n')
    return
            
            
            
    

n, m, k = [int(x) for x in input().split()]
S = input().decode().strip()
T = input().decode().strip()
process(k, S, T)
