Problem: The deadline of Prof. Hachioji’s assignment is tomorrow. To complete the task, students have to copy pages of many reference books in the library.

All the reference books are in a storeroom and only the librarian is allowed to enter it. To obtain a copy of a reference book’s page, a student should ask the librarian to make it. The librarian brings books out of the storeroom and makes page copies according to the requests. The overall situation is shown in Figure 1.

Students queue up in front of the counter. Only a single book can be requested at a time. If a student has more requests, the student goes to the end of the queue after the request has been served.

In the storeroom, there are m desks D1, ... , Dm, and a shelf. They are placed in a line in this order, from the door to the back of the room. Up to c books can be put on each of the desks. If a student requests a book, the librarian enters the storeroom and looks for it on D1, ... , Dm in this order, and then on the shelf. After finding the book, the librarian takes it and gives a copy of a page to the student.

<image>

Then the librarian returns to the storeroom with the requested book, to put it on D1 according to the following procedure.

* If D1 is not full (in other words, the number of books on D1 < c), the librarian puts the requested book there.
* If D1 is full, the librarian
* temporarily puts the requested book on the non-full desk closest to the entrance or, in case all the desks are full, on the shelf,
* finds the book on D1 that has not been requested for the longest time (i.e. the least recently used book) and takes it,
* puts it on the non-full desk (except D1 ) closest to the entrance or, in case all the desks except D1 are full, on the shelf,
* takes the requested book from the temporary place,
* and finally puts it on D1 .



Your task is to write a program which simulates the behaviors of the students and the librarian, and evaluates the total cost of the overall process. Costs are associated with accessing a desk or the shelf, that is, putting/taking a book on/from it in the description above. The cost of an access is i for desk Di and m + 1 for the shelf. That is, an access to D1, ... , Dm , and the shelf costs 1, ... , m, and m + 1, respectively. Costs of other actions are ignored.

Initially, no books are put on desks. No new students appear after opening the library.



Input

The input consists of multiple datasets. The end of the input is indicated by a line containing three zeros separated by a space. It is not a dataset.

The format of each dataset is as follows.


m c n
k1
b11 . . . b1k1
.
.
.
kn
bn1 . . . bnkn


Here, all data items are positive integers. m is the number of desks not exceeding 10. c is the number of books allowed to put on a desk, which does not exceed 30. n is the number of students not exceeding 100. ki is the number of books requested by the i-th student, which does not exceed 50. bij is the ID number of the book requested by the i-th student on the j-th turn. No two books have the same ID number. Note that a student may request the same book more than once. bij is less than 100.

Here we show you an example of cost calculation for the following dataset.


3 1 2
3
60 61 62
2
70 60


In this dataset, there are 3 desks (D1, D2, D3 ). At most 1 book can be put on each desk. The number of students is 2. The first student requests 3 books of which IDs are 60, 61, and 62, respectively, and the second student 2 books of which IDs are 70 and 60, respectively.

The calculation of the cost for this dataset is done as follows. First, for the first request of the first student, the librarian takes the book 60 from the shelf and puts it on D1 and the first student goes to the end of the queue, costing 5. Next, for the first request of the second student, the librarian takes the book 70 from the shelf, puts it on D2, moves the book 60 from D1 to D3 , and finally moves the book 70 from D2 to D1 , costing 13. Similarly, the cost for the books 61, 60, and 62, are calculated as 14, 12, 14, respectively. Therefore, the total cost is 58.

Output

For each dataset, output the total cost of processing all the requests, in a separate line.

Example

Input

2 1 1
1
50
2 1 2
1
50
1
60
2 1 2
2
60 61
1
70
4 2 3
3
60 61 62
1
70
2
80 81
3 1 2
3
60 61 62
2
70 60
1 2 5
2
87 95
3
96 71 35
2
68 2
3
3 18 93
2
57 2
2 2 1
5
1 2 1 3 1
0 0 0


Output

4
16
28
68
58
98
23

Solution (in CPP):

Solution:
#include <iostream>
#include <iomanip>
#include <vector>
#include <array>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <tuple>
#include <cmath>
#include <algorithm>
#include <functional>
#include <numeric>
#include <cfloat>
#include <climits>
#include <cassert>
#include <random>
#include <fstream>

int main() {
	while (true) {
		int m, c, n; std::cin >> m >> c >> n; if (n == 0) break;
		std::vector<std::queue<int>> users(n);
		for (auto& u : users) {
			int k; std::cin >> k;
			for (auto i = 0; i < k; ++i) {
				int b; std::cin >> b;
				u.push(b);
			}
		}
		std::vector<int> current_book_position(100, m), recent_access(101, INT_MAX);
		std::set<int> first_desk;
		std::priority_queue<int, std::vector<int>, std::greater<int>> empty_space;
		for (auto i = 0; i <= m; ++i) empty_space.push(i);
		std::vector<int> desk_rest(m + 1, c); desk_rest.back() = INT_MAX;
		int sum_cost = 0;
		std::queue<int> user_in_row; for (auto i = 0; i < n; ++i) user_in_row.push(i);
		for (auto time = 0; !user_in_row.empty(); ++time) {
			const auto top = user_in_row.front(); user_in_row.pop();
			const auto ref = users[top].front(); users[top].pop();
			if (!users[top].empty()) user_in_row.push(top);
			const auto target_pos = current_book_position[ref];
			if (++desk_rest[target_pos] == 1) {
				empty_space.push(target_pos);
			}
			int cost = target_pos + 1;
			if (desk_rest[0] > 0) {
				cost += 1;
				if (--desk_rest[0] == 0) empty_space.pop();
			}
			else {
				const auto temp_area = empty_space.top();
				if (--desk_rest[temp_area] == 0) {
					empty_space.pop();
				}
				const auto most_least_ref = *std::min_element(first_desk.begin(), first_desk.end(), [&recent_access](int a, int b) {return recent_access[a] < recent_access[b]; });
				const auto escape_area = empty_space.top();
				if (--desk_rest[escape_area] == 0) {
					empty_space.pop();
				}
				if (++desk_rest[temp_area] == 1) {
					empty_space.push(temp_area);
				}
				cost += temp_area + 1 + 1 + escape_area + 1 + temp_area + 1 + 1;
				current_book_position[most_least_ref] = escape_area;
				first_desk.erase(most_least_ref);
			}
			current_book_position[ref] = 0;
			first_desk.insert(ref);
			recent_access[ref] = time;
			sum_cost += cost;
		}
		std::cout << sum_cost << '\n';
	}
}