#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <deque>

class MatchTree
{
public:
	template <typename Iter>
	void insert(Iter _begin, Iter _end, int _cell)
	{
		Node *node = &root;
		while (_begin != _end) {
			auto tmp = node->links.find(*_begin);
			if (tmp == node->links.end()) {
				node = node->links[*_begin] = new Node();
			} else {
				node = tmp->second;
			}
			if (node->cells.empty() || node->cells.back() != _cell) {
				node->cells.push_back(_cell);
			}
			++_begin;
		}
		node->word_end = _cell;
	}

	template <typename Iter>
	bool match(Iter _begin, Iter _end, std::vector<int> *&_out)
	{
		Node *node = &root;
		while (_begin != _end) {
			auto tmp = node->links.find(*_begin);
			if (tmp == node->links.end()) {
				return false;
			}
			node = tmp->second;
			++_begin;
		}
		_out = &node->cells;
		return true;
	}

	// Returns -1 on fail.
	template <typename Iter>
	int exact_match(Iter _begin, Iter _end)
	{
		Node *node = &root;
		while (_begin != _end) {
			auto tmp = node->links.find(*_begin);
			if (tmp == node->links.end()) {
				return -1;
			}
			node = tmp->second;
			++_begin;
		}
		return node->word_end;
	}

	template <typename Iter>
	void erase(Iter _begin, Iter _end)
	{
		erase_r(_begin, _end, &root);
	}

	template <typename Iter>
	std::vector<std::pair<int, int>> exact_matches(Iter _begin, Iter _end)
	{
		std::vector<std::pair<int, int>> result;
		int idx = 1;
		Node *node = &root;
		while (_begin != _end) {
			auto tmp = node->links.find(*_begin);
			if (tmp == node->links.end()) {
				return result;
			}
			node = tmp->second;
			if (node->word_end != -1) {
				result.emplace_back(idx, node->word_end);
			}
			++_begin; ++idx;
		}
		return result;
	}

private:
	struct Node
	{
		std::unordered_map<int, Node*> links;
		std::vector<int> cells;
		int word_end = -1;
	};

	template <typename Iter>
	void erase_r(Iter _begin, Iter _end, Node *_node)
	{
		if (_begin == _end) return;
		auto tmp = _node->links.find(*_begin);
		erase_r(_begin + 1, _end, tmp->second);
		if (tmp->second->links.empty()) {
			delete tmp->second;
			_node->links.erase(tmp);
		}
	}

	Node root;
};

MatchTree prefix, suffix, midfix, repeat;
int max_l = 0;

std::vector<std::deque<int>> all_right_seq(std::deque<int>::iterator _begin, std::deque<int>::iterator _end)
{
	std::vector<std::deque<int>> result;
	if (_begin == _end) {
		return result;
	}

	auto matches = prefix.exact_matches(_begin, _end);
	for (auto &&m : matches) {
		if (_begin + m.first == _end) {
			result.push_back({ m.second });
		}
		auto rest = all_right_seq(_begin + m.first, _end);
		for (auto &&r : rest) {
			r.insert(r.begin(), m.second);
			result.push_back(r);
		}
	}
	if (matches.empty()) {
		std::vector<int> *out;
		if (prefix.match(_begin, _end, out)) {
			for (auto &&c : *out) {
				result.push_back({ c });
			}
		}
	}

	return result;
}


std::vector<std::deque<int>> all_sequences(std::deque<int>::iterator _begin, std::deque<int>::iterator _end)
{
	std::vector<std::deque<int>> result;
	if (_begin == _end) {
		return result;
	}

	int len = _end - _begin;
	if (len <= max_l) {
		std::vector<int> *out;
		if (midfix.match(_begin, _end, out)) {
			for (auto &&i : *out) {
				result.push_back({ i });
			}
		}
	}

	std::vector<int> *out;
	std::deque<int>::reverse_iterator rbegin(_end);
	std::deque<int>::reverse_iterator rend(_begin);
	int diff = _end - _begin;
	for (int off = 1; off <= diff; ++off) {
		if (suffix.match(rend - off, rend, out)) {
			auto rest = all_right_seq(_begin + off, _end);
			if (rest.empty()) continue;
			for (auto &&r : rest) {
				for (auto &&c : *out) {
					result.push_back({ c });
					result.back().insert(result.back().end(), r.begin(), r.end());
				}
			}
		}
	}

	return result;
}


int main()
{
	int n, m;
	std::cin >> n >> m;
	
	std::deque<int> seq(1000);
	for (int i = 1; i <= n; ++i) {
		int l; std::cin >> l;
		for (int j = 0; j < l; ++j) {
			std::cin >> seq[j];
		}
		prefix.insert(seq.begin(), seq.begin() + l, i);
		suffix.insert(std::deque<int>::reverse_iterator(seq.begin() + l), std::deque<int>::reverse_iterator(seq.begin()), i);
		for (int j = 0; j < l; ++j) {
			midfix.insert(seq.begin() + j, seq.begin() + l, i);
		}
		if (max_l < l) {
			max_l = l;
		}
	}

	for (int i = 0; i < m; ++i) {
		std::cin >> seq[i];
	}
	seq.resize(m);

	std::vector<std::deque<int>> vv1, vv2;
	std::vector<std::deque<int>> *sequences = &vv1, *seq_swap = &vv2;

	int minutes = 1;
	*sequences = std::vector<std::deque<int>>{ seq };
	while (!sequences->empty() || !seq_swap->empty()) {
		while (!sequences->empty()) {
			auto top = sequences->back();
			sequences->pop_back();
			if (top.size() == 1 && top[0] == 1) {
				std::cout << minutes << std::endl;
				return 0;
			}
			if (top.empty()) continue;
			if (repeat.exact_match(top.begin(), top.end()) != -1) continue;
			repeat.insert(top.begin(), top.end(), 0);

			auto all_seq = all_sequences(top.begin(), top.end());
			seq_swap->insert(seq_swap->end(), all_seq.begin(), all_seq.end());
		}
		std::swap(sequences, seq_swap);
		++minutes;
	}

	std::cout << (-1) << std::endl;

	return 0;
}