/**/ /*
    题意：给出A,B串，问最小代价将B变为A的子串，代价不能超过LIM
           A<=10^6, B<=1000,LIM<=30

   经典编辑距离方程为
        dp[i,j] = min( dp[i-1,j-1]+(A[i]!=B[j]) , dp[i-1,j]+1 , dp[i,j-1]+1)
        dp[0,0]=0
   O(nm)
   现在允许B是A的子串，只需初始化时 dp[i,0] = 0 即可 但还是O(nm)

   由于要求代价<=LIM，所以打算对于会超过这个代价的dp[i,j]不去计算
   这样子平均复杂度为O(n*LIM)

   用一个last记录上一行最后需要计算的合法位置
   由于dp[i,j]相邻元素相差不超过1，最好的情况是dp[i,last+1] = LIM，这时dp[i-1,last] = LIM
   而dp[i,last+2],dp[i,last+3]等肯定会大于LIM！！
   所以对于当前行，我们只需计算到last+1即可！！

   由此得到算法：（有点像归纳）
   初始时last = LIM  因为dp[0,LIM] = LIM
   对于当前行，只需计算到last+1处即可
   若dp[now,last]>LIM  再调整一下

   启示：平常要计算整个n*m的表
          现在只计算每一行的前面一些元素，因为后面的那些代价会超过LIM！
*/
#include < cstdio >
#include < cstring >
#include < algorithm >

using   namespace  std;

inline  int  min( int  a, int  b) {return a<b?a:b;}

const   int  MAXN  =   1000010 ;

 char  A[MAXN],B[ 1010 ];
 int  dp[ 2 ][ 1010 ];

 int  main()
 {
    //freopen("in","r",stdin);
    int lim;
    while(~scanf("%s%s",A+1,B+1))
    {
        scanf("%d",&lim);
        //dp[i,j] = min{ dp[i-1,j]+1 , dp[i,j-1]+1 , dp[i-1,j-1]+(A[i]!=B[j]) }
        //dp[i,0] = 0
        //ans = min{ dp[i,len] }
        for(int j=0;j<=lim;j++)dp[0][j] = j;
        int len = strlen(B+1);
        int ans = lim+1,last = min(lim,len);//last记录上一次最后计算的位置 当前最多计算的位置为last+1
        int pre = 0,now = 1;
        for(int i=1,j;A[i];i++)
        {
            dp[now][0] = 0;
            for(j=1;j<=last;j++)
            {
                dp[now][j] = min(dp[pre][j],dp[now][j-1])+1;
                dp[now][j] = min(dp[now][j],dp[pre][j-1]+(A[i]!=B[j]));
            }
            //j = last+1
            dp[now][j] = min(dp[now][j-1]+1,dp[pre][j-1]+(A[i]!=B[j]));
            if(j>=len)ans = min(ans,dp[now][len]);
            last = min(len,last+1);
            while(dp[now][last]>lim)last--;            
            swap(pre,now);            
        }
        printf("%d\n",ans>lim?-1:ans);
    }
    return 0;
}