#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;

const int var = 26;	// the number of charactor
int trans(char c) {
	return c - 'a';
}

struct node {
	node *fail;
	vector<node*> next;
	vector<int> ok;
	node() : fail(nullptr), next(var, nullptr) {}
};

node* getnext(node* p, char c) {
	while (p->next[trans(c)] == nullptr) p = p->fail;
	return p->next[trans(c)];
}

class Aho_Corasick {
	vector<int> unite(const vector<int>& a, const vector<int>& b) {
		vector<int> res;
		set_union(a.begin(), a.end(), b.begin(), b.end(), back_inserter(res));
		return res;
	}
	int K;
	node *root;
public:
	Aho_Corasick(const vector<string>& Ts) : K(Ts.size()), root(new node) {
		node *now;
		root->fail = root;
		for (int i = 0; i < K; i++) {
			auto &T = Ts[i];
			now = root;
			for (auto c : T) {
				if (now->next[trans(c)] == nullptr) {
					now->next[trans(c)] = new node;
				}
				now = now->next[trans(c)];
			}
			now->ok.push_back(i);
		}
		queue<node*> q;
		for (int i = 0; i < var; i++) {
			if (root->next[i] == nullptr) {
				root->next[i] = root;
			}
			else {
				root->next[i]->fail = root;
				q.push(root->next[i]);
			}
		}
		while (!q.empty()) {
			now = q.front(); q.pop();
			for (int i = 0; i < var; i++) {
				if (now->next[i] != nullptr) {
					node *nx = now->fail;
					while (nx->next[i] == nullptr) {
						nx = nx->fail;
					}
					now->next[i]->fail = nx->next[i];
					now->next[i]->ok = unite(now->next[i]->ok, nx->next[i]->ok);
					q.push(now->next[i]);
				}
			}
		}
	}
	node* getroot() const {
		return root;
	}
	vector<int> count(const string& S) const {
		vector<int> res(K);
		node *now = root;
		for (auto c : S) {
			now = getnext(now, c);
			for (auto k : now->ok) res[k]++;
		}
		return res;
	}
};

int main()
{
	string S;
	cin >> S;
	int n = S.size();
	int N;
	cin >> N;
	vector<string> ps(N);
	for (int i = 0; i < N; i++) {
		cin >> ps[i];
	}
	sort(ps.begin(), ps.end(), [](const string& a, const string& b) {
		return a.size() < b.size();
	});
	Aho_Corasick ac(ps);
	auto it = ac.getroot();
	vector<pii> vs;
	for (int i = 0; i < n; i++) {
		it = getnext(it, S[i]);
		if (!it->ok.empty()) {
			vs.emplace_back(i + 1 - ps[it->ok[0]].size(), i + 1);
		}
	}
	sort(vs.begin(), vs.end());
	vs.emplace_back(1e9, 0);
	priority_queue<int,vector<int>,greater<int>> q;
	int p = 0;
	int res = 0;
	for (int i = 0; i < n; i++) {
		while (vs[p].first == i) {
			q.push(vs[p].second);
			p++;
		}
		if (!q.empty() && q.top() == i + 1) {
			res++;
			q = priority_queue<int, vector<int>, greater<int>>();
		}
	}
	cout << res << endl;
	return 0;
}

