#if 1
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <stack>
#include <array>
#include <deque>
#include <algorithm>
#include <utility>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <numeric>
#include <assert.h>
#include <bitset>
#include <memory>
#include <list>

auto& in = std::cin;
auto& out = std::cout;
#define all(C) std::begin(C), std::end(C)
const double PI = 3.141592653589793238462643383279502884197169399375105820974944;

struct Trie {
	std::unique_ptr<Trie> node[26] = {};//各アルファベットへの子のポインタ
	bool black=false;//この文字列の頂点が黒かどうか
	Trie() :node() {}
	void add(const char* str) {
		if (*str == '\0') {
			black = true;
			return;
		}
		int nxt = *str - 'a';
		if (!node[nxt]) {
			node[nxt] = std::make_unique<Trie>();
		}
		node[nxt]->add(str + 1);
	}
	//strを見つけて、最も浅い高さにいるblackな頂点の高さを返す
	//add("a")の時、search("a")は1を返す
	//ない場合は-1
	int search(const char* str) {
		if (black)
			return 0;
		if (*str == '\0')
			return -1;
		int nxt = *str - 'a';
		if (!node[nxt]) {
			return -1;
		}
		int res = node[nxt]->search(str + 1);
		if (res == -1)return -1;
		return res + 1;
	}
};


//http://odan3240.hatenablog.com/entry/2015/02/16/111938
struct RollingHash {
	typedef uint64_t int_type;
	typedef std::pair<int_type, int_type> hash_type;

	std::string str;
	int_type base1;
	int_type base2;
	int_type mod1;
	int_type mod2;
	std::vector<int_type> hash1;
	std::vector<int_type> hash2;
	std::vector<int_type> pow1;
	std::vector<int_type> pow2;

	RollingHash() : base1(1009), base2(3251), mod1(1000000007), mod2(1000000009), str(){}
	RollingHash(std::string s) : RollingHash() {
		init(std::move(s));
	}

	void init(std::string s) {
		str = std::move(s);
		int n = str.size();

		hash1.assign(n + 1, 0);
		hash2.assign(n + 1, 0);
		pow1.assign(n + 1, 1);
		pow2.assign(n + 1, 1);

		for (int i = 0; i < n; i++) {
			hash1[i + 1] = (hash1[i] + str[i]) * base1 % mod1;
			hash2[i + 1] = (hash2[i] + str[i]) * base2 % mod2;
			pow1[i + 1] = pow1[i] * base1 % mod1;
			pow2[i + 1] = pow2[i] * base2 % mod2;
		}
	}

	//[l,r)までのハッシュ値を返すよ
	hash_type getHash(int l, int r) {
		assert(l <= r);
		assert(0 <= l);
		assert(r <= (int)str.size());
		int_type t1 = ((hash1[r] - hash1[l] * pow1[r - l]) % mod1 + mod1) % mod1;
		int_type t2 = ((hash2[r] - hash2[l] * pow2[r - l]) % mod2 + mod2) % mod2;
		return std::make_pair(t1, t2);
	}
	//ハッシュ値の結合（使わない？）
	hash_type concat(hash_type h1, hash_type h2, int h2_len) {
		assert(0 <= h2_len);
		return std::make_pair((h1.first*pow1[h2_len] + h2.first) % mod1, (h1.second*pow2[h2_len] + h2.second) % mod2);
	}
};
//ハッシュが衝突しているか確認する
bool is_contact(RollingHash::hash_type h1, RollingHash::hash_type h2) {
	return h1 == h2;
}

Trie trie;
std::string S;
std::string S_rever;
std::vector<std::string> p_small;
//std::vector<std::string> p_large;
std::vector<RollingHash> p_RH;
int32_t N;
int32_t DP_[100010];
int32_t* DP = DP_+2;//[j]はjに*を入れたときの最小値
int main()
{
	using std::endl;
	in.sync_with_stdio(false);
	out.sync_with_stdio(false);
	in.tie(nullptr);
	out.tie(nullptr);

	in >> S >> N; S_rever = S; std::reverse(S_rever.begin(), S_rever.end());
	for (int32_t i = 0; i < N; i++)
	{
		std::string input;
		in >> input;
		if (input.size() <= 317) {
			p_small.emplace_back(std::move(input));
		}
		else {
			//p_large.emplace_back(std::move(input));
			p_RH.emplace_back(std::move(input));
		}
	}


	//小さいほうをとらい木に突っ込む
	for (auto& i : p_small)
	{
		std::reverse(i.begin(), i.end());
		trie.add(i.c_str());
	}

	RollingHash S_RH{ S };
	auto iter = S_rever.c_str() + S_rever.size()-1;
	int32_t ok_begin = -1;
	DP[-1] = 0;
	for (int32_t i = 0; i < S.size(); i++)
	{
		//i追加
		DP[i] = DP[ok_begin] + 1;

		//OKを移動
		int res = trie.search(iter);
		if (res == -1) {}
		else {
			ok_begin = std::max(ok_begin, i - res + 1);
		}
		--iter;

		for (auto& P : p_RH)
		{
			int size = P.str.size();
			if (i - size + 1 < 0) { continue; }
			auto bace = S_RH.getHash(i- size+1, i + 1);
			auto other = P.getHash(0, size);
			if (bace == other) {
				ok_begin = std::max(ok_begin, i - size + 1);
			}
		}

	}

	int32_t min_ = 10000000;
	for (int32_t i = ok_begin; i < (int)S.size(); i++)
	{
		min_ = std::min(min_, DP[i]);
	}
	out << min_ << endl;

	return 0;
}
#endif




Measured memory_bytes: 22984