#include <bits/stdc++.h>
using namespace std;

#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second

using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;

const double eps = 1e-10;

template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}

template<typename T>
vector<T> make_v(size_t a){return vector<T>(a);}

template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
  return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value!=0>::type
fill_v(U &u,const V... v){u=U(v...);}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value==0>::type
fill_v(U &u,const V... v){
  for(auto &e:u) fill_v<T>(e,v...);
}

class SA_IS {
private:
    std::string str;
    std::vector<int> sa;
    bool built = false;

    static inline bool is_lms(const std::vector<int>& is_l, size_t idx) {
        return idx > 0 && is_l[idx-1] && !is_l[idx];
    }

    void create_bin(const std::vector<int>& v, std::vector<int>& bin) {
        std::fill(bin.begin(), bin.end(), 0);
        for (auto& x : v) bin[x+1]++;
        for (int i = 1; i < bin.size(); i++) bin[i] += bin[i-1];
    }

    void set_lms(const std::vector<int>& v, std::vector<int>& sa, std::vector<int>& bin, const std::vector<int>& is_l) {
        for (int i = 0; i < v.size(); i++) {
            if (is_lms(is_l, i)) { sa[--bin[v[i]+1]] = i;}
        }
        for (int i = 0; i < v.size(); i++) {
            if (is_lms(is_l, i)) { bin[v[i]+1]++; }
        }
    }

    void induced_sort(const std::vector<int>& v, std::vector<int>& sa, size_t kind_num, std::vector<int>& bin, const std::vector<int>& is_l) {
        std::vector<int> cnt(kind_num+2, 0);
        for (int i = 0; i < v.size(); i++) {
            if (sa[i] <= 0 || !is_l[sa[i]-1]) continue;
            int kind = v[sa[i]-1];
            sa[bin[kind] + cnt[kind]++] = sa[i]-1;
        }
    }

    void reverse_induced_sort(const std::vector<int>& v, std::vector<int>& sa, std::vector<int>& bin, const std::vector<int>& is_l) {
        for (int i = v.size()-1; i > 0; i--) {
            if (sa[i] <= 0 || is_l[sa[i]-1]) continue;
            int kind = v[sa[i]-1];
            sa[--bin[kind+1]] = sa[i]-1;
        }
    }
public:
    SA_IS() : built(false) {}
    SA_IS(const std::string &str_) : str(str_) { build(); }
    SA_IS(std::string &&str_) : str(str_) { build(); }

    std::vector<int> build(const std::vector<int>& v, int kinds) {
        if (v.size() == 1) return std::vector<int>(1, 0);
        std::vector<int> bin(kinds+2, 0), is_l(v.size(), 0);
        std::vector<int> sa(v.size(), -1);

        for (int i = v.size()-2; i >= 0; i--) {
            is_l[i] = v[i] == v[i+1] ? is_l[i+1] : v[i] > v[i+1];
        }

        create_bin(v, bin);
        set_lms(v, sa, bin, is_l);
        induced_sort(v, sa, kinds, bin, is_l);
        reverse_induced_sort(v, sa, bin, is_l);

        std::vector<int> order(v.size());
        int cur = 0, prev = -1;
        for (int i = 0; i < v.size(); i++) if (is_lms(is_l, i)) order[i] = cur++;

        std::vector<int> next_v(cur);
        cur = -1;
        for (int i = 0; i < v.size(); i++) {
            if (!is_lms(is_l, sa[i])) continue;
            bool diff = false;
            for (int d = 0; d < v.size(); d++) {
                if (prev == -1 || v[sa[i]+d] != v[prev+d] || is_l[sa[i]+d] != is_l[prev+d]) {
                    diff = true;
                    break;
                }
                if (d > 0 && is_lms(is_l, sa[i]+d)) break;
            }
            if (diff) { cur++; prev = sa[i]; }
            next_v[order[sa[i]]] = cur;
        }

        std::vector<int> re_order(next_v.size());
        std::vector<int> next_sa = build(next_v, cur);
        std::fill(sa.begin(), sa.end(), -1);
        for (int i = 0; i < v.size(); i++) if (is_lms(is_l, i)) re_order[order[i]] = i;
        create_bin(v, bin);
        for (int i = next_sa.size()-1; i >= 0; i--) sa[--bin[v[re_order[next_sa[i]]]+1]] = re_order[next_sa[i]];
        create_bin(v, bin);
        induced_sort(v, sa, kinds, bin, is_l);
        reverse_induced_sort(v, sa, bin, is_l);

        return sa;
    }

    void build() {
        str += '$';
        std::vector<int> v(str.size());
        for (int i = 0; i < str.size(); i++) v[i] = str[i];
        sa = build(v, *std::max_element(v.begin(), v.end()));
        sa = std::vector<int>(sa.begin()+1, sa.end());
        built = true;
        str = str.substr(0, str.size()-1);
    }

    const std::vector<int>& get_sa() {
        assert(built);
        return sa;
    }

    bool is_upper(const std::string& t, int s_idx) { // t > sa[si]
        int idx = 0; s_idx = sa[s_idx];
        while (s_idx+idx < sa.size() && idx < t.size()) {
            if (t[idx] > str[s_idx+idx]) return true;
            if (t[idx] < str[s_idx+idx]) return false;
            idx++;
        }
        return (idx < t.size() && s_idx + idx >= str.size());
    }

    int lower_bound(const std::string& t) {
        int l = -1, r = sa.size(), m;
        while (r - l > 1) {
            m = (l + r) >> 1;
            if (is_upper(t, m)) l = m;
            else r = m;
        }
        return r;
    }

    ::std::pair<int, int> bounds(std::string& t) {
        int l = lower_bound(t); t.back()++;
        int r = lower_bound(t); t.back()--;
        return ::std::pair<int, int>(l, r);
    }

    const int& operator[](const size_t& k) {
//        cout << k << endl;
//        assert(0 <= k && k < sa.size());
//        cout << "Ok" << sa[k] << endl;
        return sa[k];
    }

    const size_t size() { return str.size()-1; }
};

template<class MinDataStructure = std::vector<int>>
class LCP {
private:
    std::vector<int> lcp_, rank, sa;
    std::string str;
    MinDataStructure ds;

public:
    LCP() {}
    LCP(const std::string& str_, const std::vector<int>& sa_) : str(str_), sa(sa_) {
        build();
    }

    void build() {
        rank = std::vector<int>(str.size());
        lcp_ = std::vector<int>(sa.size());

        for (int i = 0; i < str.size(); i++) rank[sa[i]] = i;
        int h = 0;
        for (int i = 0; i < str.size(); i++) {
            if (rank[i] == sa.size()-1) continue;

            for (int j = sa[rank[i]+1]; i < str.size() && j < str.size() && str[i+h] == str[j+h]; h++);
            lcp_[rank[i]] = h;
            if (h > 0) h--;
        }

        ds = MinDataStructure(lcp_);
    }

    std::vector<int> get_lcp_vector() {
        return lcp_;
    }

    int lcp(int idx1, int idx2) { // lcp of A[idx1..] and A[idx2..]
//        assert(0 <= idx1 && idx1 < rank.size() && 0 <= idx2 && idx2 < rank.size());
        idx1 = rank[idx1]; idx2 = rank[idx2];
        if (idx1 > idx2) std::swap(idx1, idx2);
        return ds.query(idx1, idx2);
    }

    bool is_upper(const std::string& t, int s_idx, int& k) { // t > A[s_idx..]
        s_idx = sa[s_idx];
        while (k < t.size() && s_idx+k < str.size() && t[k] == str[s_idx+k]) k++;
        if (t.size() <= k) return false;
        if (str.size() <= s_idx+k) return true;
        return t[k] > str[s_idx+k];
    }

    int lower_bound(const std::string& t) {
        int l = -1, r = lcp_.size(), m_prev = (l + r) >> 1, m;
        int k = 0;
        (is_upper(t, m_prev, k) ? l : r) = m_prev;
        while (r - l > 1) {
            m = (l + r) >> 1;
            int k2 = lcp(sa[m_prev], sa[m]);
            if (k != k2) {
                if ((m_prev < m) ^ (k < k2)) r = m;
                else l = m;
            } else {
                if (is_upper(t, m, k)) l = m;
                else r = m;
                m_prev = m;
            }
        }
        return r;
    }

    std::pair<int, int> bounds(std::string& t) {
        int l = lower_bound(t); t.back()++;
        int r = lower_bound(t); t.back()--;
        return std::make_pair(l, r);
    }

    const int operator[](int k) {
        return lcp_[k];
    }

    const int rank_(int k) {
        return rank[k];
    }
};

template<class ValueMonoid, int HEIGHT = 20> // HEIGHT is log size
class SparseTable {
private:
    using value_structure = ValueMonoid;
    using value_type = typename value_structure::value_type;
    using size_type = std::uint32_t;

    size_type size_;
    std::array<std::vector<value_type>, HEIGHT> table;
public:
    SparseTable() : size_(0) {}
    SparseTable(const std::vector<value_type>& v) : size_(v.size()) {
        table[0] = v;
        for (size_type i = 1, w = 1; i < HEIGHT; i++, w *= 2) {
            table[i].resize(size_, value_structure::identity());
            for (size_type j = 0; j < size_; j++) {
                if (j + w < size_) table[i][j] = value_structure::operation(table[i-1][j], table[i-1][j+w]);
                else table[i][j] = table[i-1][j];
            }
        }
    }

    static inline size_type log2(size_type x) {
        if (x == 0) return 0;
        return size_type(31) ^ __builtin_clz(x);
    }

    value_type query(size_type l, size_type r) {
        if (r <= l) return value_structure::identity();
        size_type k = log2(r - l);
        return value_structure::operation(table[k][l], table[k][r-(size_type(1) << k)]);
    }
};

class lcp_monoid {
public:
    using value_type = int;
    static value_type identity() { return INF; }
    static value_type operation(const value_type& l, const value_type& r) {
        return min(l, r);
    }
};

int main(void){
	cin.tie(0);
	ios::sync_with_stdio(false);
	string S, T;
	int64 k;
	cin >> S >> T >> k;
	string S_T = S + "$" + T;
	SA_IS sa(S_T);
	LCP<SparseTable<lcp_monoid>> lcp(S_T, sa.get_sa());
	vector<int> is_S(S_T.size(), 1);
	REP(i, T.size()) {
	    is_S[lcp.rank_(i + 1 + S.size())] = 0;
	}
	SparseTable<lcp_monoid> con_T(is_S);
	vector<int64> dp(S.size()+2, 0);
	dp[0] = 1;
	dp[1] = -1;
//	REP(i, S_T.size()+1) {
//	    cout << S_T.substr(sa[i], S_T.size()-sa[i]+1) << endl;
//	}

	auto ok = [&](int64 idx, int64 k) {
	    idx = lcp.rank_(idx);
        int64 l = idx, r = S_T.size(), m;
        while (r - l > 1) {
            m = (l + r) >> 1;
//            cout << idx << " " << sa[idx] << " " << m << " " << sa[m] << endl;
            if (lcp.lcp(sa[idx], sa[m]) >= k) {
                l = m;
            } else {
                r = m;
            }
        }
        int64 rr = l;
        l = -1; r = idx;
        while (r -l > 1) {
            m = (l + r) >> 1;
            if (lcp.lcp(sa[idx], sa[m]) >= k) {
                r = m;
            } else {
                l = m;
            }
        }
        int64 ll = r;
        return (con_T.query(ll, rr+1) == 0);
	};

	auto match_len = [&](int64 idx) {
	    idx = lcp.rank_(idx);
        int64 l = idx, r = S_T.size(), m;
        while (r - l > 1) {
            m = (l + r) >> 1;
            if (con_T.query(idx, m+1) == 0) {
                r = m;
            } else {
                l = m;
            }
        }
        int64 res = lcp.lcp(sa[idx], sa[r]);
//        cout << idx << " " << r << " ";
        l = 0; r = idx;
        while (r - l > 1) {
            m = (l + r) >> 1;
            if (con_T.query(m, idx+1) == 0) {
                l = m;
            } else {
                r = m;
            }
        }
        chmax(res, lcp.lcp(sa[idx], sa[l]));
//        cout << l << " " << res << endl;
        return res;
	};

//    cout << ok(0, 3) << endl;
	REP(i, S.size()) {
	    dp[i+1] += dp[i];
	    if (dp[i] == 0) continue;
	    int64 ret = match_len(i);
	    if (ret >= k) {
	        dp[i+k]++;
	        dp[i+ret+1]--;
	    }
	}
	if (dp[S.size()]) {
	    cout << "Yes" << endl;
	} else {
	    cout << "No" << endl;
	}
}



Measured memory_bytes: 75344