#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 getMax(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(procA[i], procA[i]));
	}

	for (int i = 0; i < procBCount; i++) {
		procBHeap.push(HeapItem(procB[i], procB[i]));
	}
	
	int forwardCans = 0;
	procAMinTime = 0;

	for (int i = 0; i < cansCount; i++) {
		//
		if (forwardCans) {
			forwardCans--;
			continue;
		}

		HeapItem first = procAHeap.top();
		procAHeap.pop();
		
		int diff = procAHeap.top().time - first.time;
		int stepsForward = diff / first.execDuration;

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

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

		procAMinTime = getMax(procAMinTime, first.time - first.execDuration);
		procAHeap.push(first);
	}
	
}

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;
}