#include <iostream>
#include <cstdio>
#include <string>
#include <sstream>

#include <vector>
#include <deque>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <functional>
#include <algorithm>

using namespace std;

typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ulonglong;

typedef vector<uint>::iterator iter;

bool hasInput();
void readInput();
void calculate();
void writeOutput();
void reset();

uint N = 0;
vector<uint> list1, list2, list3;
set<uint> set1, set2, set3;
ulonglong result = 0;

int main(int argc, char **argv) {
	list1.reserve(150000);
	list2.reserve(150000);
	list3.reserve(150000);
	while (true) {
		reset();
		if (!hasInput())
			break;
		readInput();
		calculate();
		writeOutput();
	}
	return 0;
}

void reset() {
	N = 0;
	result = 0;
	list1.clear();
	list2.clear();
	list3.clear();
	set1.clear();
	set2.clear();
	set3.clear();
}

bool hasInput() {
	cin >> N;
	return N > 0;
}

void readInput() {
	uint num;
	for (uint i = 0; i < N; ++i) {
		cin >> num;
		list1.push_back(num);
	}
	for (uint i = 0; i < N; ++i) {
		cin >> num;
		list2.push_back(num);
	}
	for (uint i = 0; i < N; ++i) {
		cin >> num;
		list3.push_back(num);
	}
}

uint indexof(vector<uint>& vec, uint val) {
	return find(vec.begin(), vec.end(), val) - vec.begin();
}

void calculate() {
	result = 0;
	for (uint num = 1; num <= N; ++num) {
		set1.clear();
		iter iter1 = find(list1.begin(), list1.end(), num);
		++iter1;
		for (; iter1 != list1.end(); ++iter1)
			set1.insert(*iter1);
		if (set1.size() == 0)
			continue;

		set2.clear();
		iter iter2 = find(list2.begin(), list2.end(), num);
		++iter2;
		for (; iter2 != list2.end(); ++iter2)
			if (set1.find(*iter2) != set1.end())
				set2.insert(*iter2);
		if (set2.size() == 0)
			continue;

		set3.clear();
		iter iter3 = find(list3.begin(), list3.end(), num);
		++iter3;
		for (; iter3 != list3.end(); ++iter3)
			if (set2.find(*iter3) != set2.end())
				set3.insert(*iter3);
		result += set3.size();
	}
}

void writeOutput() {
	cout << result << endl;
}