You've got string s, consisting of small English letters. Some of the English letters are good, the rest are bad.

A substring s[l...r] (1 ≤ l ≤ r ≤ |s|) of string s = s1s2...s|s| (where |s| is the length of string s) is string  slsl + 1...sr.

The substring s[l...r] is good, if among the letters  sl, sl + 1, ..., sr there are at most k bad ones (look at the sample's explanation to understand it more clear).

Your task is to find the number of distinct good substrings of the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their content is different, i.e. s[x...y] ≠ s[p...q].

Input

The first line of the input is the non-empty string s, consisting of small English letters, the string's length is at most 1500 characters.

The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the i-th character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.

The third line of the input consists a single integer k (0 ≤ k ≤ |s|) — the maximum acceptable number of bad characters in a good substring.

Output

Print a single integer — the number of distinct good substrings of string s.

Examples

Input

ababab
01000000000000000000000000
1


Output

5


Input

acbacbacaa
00000000000000000000000000
2


Output

8

Note

In the first example there are following good substrings: "a", "ab", "b", "ba", "bab".

In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb".
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897932384626;
const long long int MOD = 1000000000 + 7;
const int INF = 0x3f3f3f3f;
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
  cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
  const char *comma = strchr(names + 1, ',');
  cerr.write(names, comma - names) << " : " << arg1 << " | ";
  __f(comma + 1, args...);
}
long long int Nmul(long long int A, long long int B) {
  long long int ret = (long long int)((long long int)(A) * (long long int)(B));
  return ret;
}
long long int Mmul(long long int a, long long int b, long long int mod) {
  long long int c = Nmul(a, b);
  c %= mod;
  while (c < 0) {
    c += mod;
  };
  return c;
}
long long int Nadd(long long int A, long long int B) {
  long long int ret = (long long int)((long long int)(A) + (long long int)(B));
  return ret;
}
long long int Madd(long long int a, long long int b, long long int mod) {
  long long int c = Nadd(a, b);
  while (c >= mod) {
    c -= mod;
  };
  while (c < 0) {
    c += mod;
  };
  return c;
}
long long int Nsub(long long int A, long long int B) {
  long long int ret = (long long int)((long long int)(A) - (long long int)(B));
  return ret;
}
long long int Msub(long long int a, long long int b, long long int mod) {
  return Madd(a, mod - b, mod);
}
long long int Npow(long long int A, long long int p) {
  long long int ret = 1;
  while (p) {
    if (p & 1) {
      ret = (ret * A);
    }
    A = (A * A);
    p >>= 1;
  }
  return ret;
}
long long int Mpow(long long int a, long long int n, long long int b) {
  long long int res = 1;
  while (n) {
    if (n & 1) {
      res = Mmul(res, a, b);
    }
    a = Mmul(a, a, b);
    n >>= 1;
  }
  return Madd(res, 0, b);
}
long long int Ndiv(double A, double B, bool ud) {
  if (B) {
    double ret = (double)(A) / (double)(B);
    if (ud) return ceil(ret);
    return floor(ret);
  }
  return INF;
}
long long int Mdiv(long long int a, long long int b, long long int mod) {
  long long int ans = Mmul(a, Mpow(b, mod - 2, mod), mod);
  return ans;
}
int pre[1600 + 1];
int ans = 0;
int k;
string a, b;
struct trie {
  trie *child[27];
  bool is_word;
  trie *new_node() {
    trie *tmp = new trie;
    for (int i = 0; i < 26; i++) tmp->child[i] = NULL;
    tmp->is_word = 0;
    return tmp;
  }
  void addword(trie *root, int idx, int p) {
    trie *tmp = root;
    int ch, lmt;
    for (int i = idx; i < p; i++) {
      ch = (int)(a[i] - 'a');
      if (idx)
        lmt = pre[i] - pre[idx - 1];
      else
        lmt = pre[i];
      if (lmt <= k) {
        if (tmp->child[ch] == NULL) {
          ans++;
          tmp->child[ch] = new_node();
        }
        tmp = tmp->child[ch];
      } else
        return;
    }
  }
};
int main(int argc, char const *argv[]) {
  trie *root;
  root = root->new_node();
  cin >> a >> b >> k;
  for (int i = 0; i < a.size(); i++) {
    if (i) {
      pre[i] = pre[i - 1];
      if ((int)('1' - b[a[i] - 'a'])) pre[i] += 1;
    } else {
      if ((int)('1' - b[a[i] - 'a']))
        pre[i] = 1;
      else
        pre[i] = 0;
    }
  }
  int p = a.size();
  for (int i = 0; i < p; i++) {
    root->addword(root, i, p);
  }
  cout << ans << endl;
  return 0;
}
