#include <stdio.h>
#include <stdlib.h>
void swap (unsigned int *array, int first, int second);
int quickSortPartition(unsigned int *array, int from, int to);
void quickSort(unsigned int *array, int from, int to);

int main() {
	unsigned priceLimit, i = 0, sum = 0;
	unsigned long result = 0;
	unsigned *soups, *mains, *dess, *bav, *prices;
	int amounts[4], scanres;
	unsigned *arrays[4];	

	while (1) {

	scanres = scanf("%u %d %d %d %d", &priceLimit,  &amounts[0], &amounts[1], &amounts[2], &amounts[3]);
	scanres = scanres;	
	for (; i < 4; i++) {
		//printf("%d\n", amounts[i]);
		sum += amounts[i];
	}
	//printf("%d\n", priceLimit);
	sum += priceLimit;
	if (sum == 0) return 0;

	for (i = 0; i < 4; i++) {
		arrays[i] = malloc(sizeof(unsigned) * amounts[i]);
	}

	for (i = 0; i < 4; i++){
		unsigned *jmeno = arrays[i] + amounts[i];
		//printf("Array :%d\t", i);
		for (prices = arrays[i]; prices < jmeno; prices++) {
			scanres = scanf("%u", prices);
			//printf("%d", *prices);
		}
		//printf("\n");
	}

	

	unsigned *sMax = arrays[0] + amounts[0];
	unsigned *mMax = arrays[1] + amounts[1];
	unsigned *dMax = arrays[2] + amounts[2];
	unsigned *bMax = arrays[3] + amounts[3];

	quickSort(arrays[0], 0, amounts[0]-1);
	quickSort(arrays[1], 0, amounts[1]-1);
	quickSort(arrays[2], 0, amounts[2]-1);
	quickSort(arrays[3], 0, amounts[3]-1);
	sum = 0;
	for (soups = arrays[0]; soups < sMax; soups++) {
		sum += *soups;
		if (sum > priceLimit) {
			sum -= *soups;
			break;
		}
		for (mains = arrays[1]; mains < mMax; mains++) {
				sum += *mains;
				if (sum > priceLimit) {
					sum -= *mains;
					break;
				}
				for (dess = arrays[2]; dess < dMax; dess++) {
					sum += *dess;
					if (sum > priceLimit) {
						sum -= *dess;
						break;
					}
					for (bav = arrays[3]; bav < bMax; bav++) {
						sum += *bav;
						//printf("%d\n", sum);
						if (sum <= priceLimit) {
							result++;
						}
						sum -= *bav;
					}
					sum -= *dess;
				}
				sum -= *mains;
			}
		sum -= *soups;	
	}

	printf("%ld\n", result);

	for(i = 0; i < 4; i++) {
		free(arrays[i]);
	}

	result = 0;
	sum = 0;

	}

	free(arrays);
	return 0;
}

void swap (unsigned int *array, int first, int second) {
	int tmp = array[first];
	array[first] = array[second];
	array[second] = tmp;
}
int quickSortPartition(unsigned int *array, int from, int to) {
	int pivot = array[to];
	int lowerCounter = 0;
	int i = 0;
	for (i = from; i < to; ++i) {
		if (array[i] <= pivot) {
			swap(array, from + lowerCounter, i);
			++lowerCounter;
		}
	}
	swap(array, from + lowerCounter, to);
	return from + lowerCounter;
}

void quickSort(unsigned int *array, int from, int to) {
	if (from < to) {
		int pivotIndex = quickSortPartition(array, from, to);
		quickSort(array, from, pivotIndex - 1);
		quickSort(array, pivotIndex + 1, to);
	}
}