#include <fstream>
#include <queue>
#include <vector>
#include <functional>

#define MAXPROCESSORS 100005
using namespace std;

ifstream f("fabrica.in");
ofstream g("fabrica.out");

struct HeapItem {
	int time;
	int execDuration;
	
	HeapItem() {
		time = execDuration = 0;
	}

	HeapItem(int gTime, int gExecDuration) {
		time = gTime;
		execDuration = gExecDuration;
	}
	
	bool operator <(const HeapItem &i) const {
		if (i.time == time) return i.execDuration < execDuration;
		return i.time < time;
	}

};

void readData(int *procA, int *procB, int &procACount, int &procBCount, int &cansCount) {
	//
	f >> cansCount >> procACount >> procBCount;
	for (int i = 0; i < procACount; i++) {
		f >> procA[i];
	}

	for (int i = 0; i < procBCount; i++) {
		f >> procB[i];
	}
}

int getMin(int m1, int m2) {
	return m1 < m2 ? m1 : m2;
}

void computeMinimumTimes(int *procA, int procACount, int *procB, int procBCount, int cansCount, int &procAMinTime, int &procBMinTime) {
	//
	priority_queue<HeapItem> procAHeap, procBHeap;
	
	for (int i = 0; i < procACount; i++) {
		procAHeap.push(HeapItem(0, procA[i]));
	}

	for (int i = 0; i < procBCount; i++) {
		procBHeap.push(HeapItem(0, procB[i]));
	}
	
	int forwardCans = 0;
	
	for (int i = 0; i < cansCount; i++) {
		//
		if (forwardCans) {
			forwardCans--;
			continue;
		}

		HeapItem first = procAHeap.top();
		procAHeap.pop();
		
		int diff = (procAHeap.top().time + procAHeap.top().execDuration) - first.time;
		int stepsForward = diff / first.execDuration + (diff % first.execDuration > 0 ? 1 : 0);
		stepsForward = stepsForward == 0 ? 1 : stepsForward;

		if (i + stepsForward > cansCount - 1) {
			stepsForward = cansCount - 1 - i;
		}

		first.time += ((stepsForward + 1) * first.execDuration);
		forwardCans += stepsForward;

		procAHeap.push(first);
	}
	
	while (procAHeap.size()) {
		procAMinTime = procAHeap.top().time;
		procAHeap.pop();
	}
	
}

int main() {
	//
	int procA[MAXPROCESSORS], procB[MAXPROCESSORS];
	int procACount, procBCount, cansCount, procAMinTime, procBMinTime;

	readData(procA, procB,  procACount, procBCount, cansCount);
	computeMinimumTimes(procA, procACount, procB, procBCount, cansCount, procAMinTime, procBMinTime);

	g << procAMinTime << " " << 0;
	return 0;
}