#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <iostream>
#include <queue>
#include <list>
#include <stack>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define REP(i,a,n) for(int i=(a); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define FOR(it,c) for(__typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
typedef long long ll;
class AhoCorasick {

  struct Node {
    std::map<char,Node> child;
    std::vector<size_t> pattern;
    Node* failure;
    Node():failure(NULL){}
  };
  Node root;

  void clear_tree(){
    root.child.clear();
    root.pattern.clear();
  }

  void generate_trie(const std::vector<std::string>& patterns){
    size_t n = patterns.size();

    for(size_t i=0; i<n; i++){
      Node* t = &root;
      for(size_t j=0; j<patterns[i].length(); j++){
        t = &(t->child[patterns[i][j]]);
      }
      t->pattern.push_back(i);
    }
  }

  void add_failure_edge(){
    std::queue<Node*> que;
    que.push(&root);

    while(!que.empty()){
      Node* t = que.front(); que.pop();
      std::map<char,Node>::iterator itr = t->child.begin();

      for(; itr != t->child.end(); ++itr){
        que.push(&(itr->second));
        char c = itr->first;
        Node* node = &(itr->second);

        Node* anode = t->failure;
        while(anode != NULL && anode->child.count(c)==0) anode = anode->failure;

        if(anode == NULL){
          node->failure = &root;
        }else{
          node->failure = &(anode->child[c]);
        }

        for(size_t i=0; i<node->failure->pattern.size(); i++){
          node->pattern.push_back(node->failure->pattern[i]);
        }
        
        std::vector<size_t>(node->pattern).swap(node->pattern);

      }
    }
  }

  void make_PMA(const std::vector<std::string>& patterns){
    clear_tree();
    generate_trie(patterns);
    add_failure_edge();
  }
  
public:
  AhoCorasick(const std::vector<std::string>& patterns){
    make_PMA(patterns);
  }

  std::vector< std::pair<size_t,size_t> > find(const std::string& text){
    std::vector< std::pair<size_t,size_t> > ret;
    Node* node = &root;
    
    for(size_t i=0; i<text.length(); i++){
      while(node != NULL && node->child.count(text[i])==0) node = node->failure;

      if(node == NULL) node = &root;
      else node = &(node->child[text[i]]);

      for(size_t j=0; j<node->pattern.size(); j++){
        size_t e = i;
        size_t pi = node->pattern[j];
        ret.push_back(std::make_pair(e,pi));
      }
    }
    return ret;
  }
};

int main(){
  ios::sync_with_stdio(false);
  string S;
  cin >> S;
  int M;
  cin >> M;
  vector<string> v;
  rep(i,M){
    string tmp;
    cin >> tmp;
    v.push_back(tmp);
  }

  AhoCorasick ac(v);
  vector< pair<size_t,size_t> > ret = ac.find(S);

  cout << ret.size() << endl;
  
  return 0;
}