{*************************************************************************
 *                                                                       *
 *                       Pogromcy Algorytmów 2004                        *
 *                                                                       *
 *   Rozwiązanie zadania: Zbrodnia na Piccadilly Circus                  *
 *   Plik:                pic.pas                                        *
 *   Autor:               Michał Adamaszek                               *
 *************************************************************************}


(* Rozwiazanie zadania Picadilly
   Michal Adamaszek, 2003.09.28
   
   Szkic rozw:
   
   Normujemy przedzialy aby miescily sie w [p;k]. Wyznaczamy minimalna
   i maksymalna liczbe przedzialow wchodzacych w ich sume na osi rzeczywistej.
   Sortujemy konce przedzialow. Zamiatamy i wyznaczamy min i max.
   
   Zlozonosc:
   
   O(n^2) (sortowanie przez wybor)
   
   Pamiec:
   
   O(n)
   
*)

const 
    MAX_N = 5000;	

(* Poczatek / koniec przedzialu  *)
    _BG = 0;
    _EN = 1;
    
(* Punkt w czasie *)
type TTimePt = record
    t: longint;	(* Czas *)
    be: byte;	(* Poczatek czy koniec przedz. *)
end;


(* Zmienne programu *)
var
    n: integer;
    n_real: integer;	(* Liczba faktycznie istotnych przedzialow *)
    bg, en: longint;		(* Poczatek i koniec sledzenia *)
    pt: array[0..2 * MAX_N] of TTimePt;	(* Pocz, konce przedzialow *)

    i, j, k: integer;	(* Sortowanie *)
    tmp_pt: TTimePt;
        
(* Funkcja wczytujaca dane *)
procedure input;
var 
    i: integer;
    x, y: longint;
begin        
    (* Podstawowe parametry *)
    read(bg, en, n);
    n_real := 0;
        
    for i := 0 to n - 1 do begin
	read(x, y);
	(* Dopasowujemy przedzial do (bg, en) *)
	if bg > x then x := bg;
	if en < y then y := en;
	(* Sprawdzimy czy przedzial jest istotny *)
	if x <= y then begin
	    pt[n_real].t := x;
	    pt[n_real].be := _BG;
	    inc(n_real);
	    (* Wstawiamy tylko konce < (ostro) en *)
	    if y < en then begin
    		pt[n_real].t := y;
		pt[n_real].be := _EN;
		inc(n_real);
	    end;
	end;
    end;
end;

(* Obliczenie wyniku dla posortowanej tablicy pt *)
procedure calcresult; 
var
    min_sol, max_sol: integer;	(* Wyniki *)
    curr: integer;		(* Chwilowy wynik *)
    i, k, pt_bg, pt_en: integer;
    stop: boolean;
begin
    curr := 0;
    i := 0; 
    min_sol := n_real;
    max_sol := 0;
    
    (* Przechodzimy wszystkie punkty *)
    while i < n_real do begin
	k := i;
	pt_bg := 0;
	pt_en := 0;
	stop := false;
	(* Zliczamy poczatki i konce w danym punkcie *)
	while (i < n_real) and (not stop) do begin 
	    if pt[i].t = pt[k].t then begin
		if pt[i].be = _BG then inc(pt_bg)
		else inc(pt_en);
		inc(i);
	    end
	    else stop := true;
	end;
	(* Uaktualniamy max, min *)
	if curr + pt_bg > max_sol then max_sol := curr + pt_bg;
	if curr + pt_bg - pt_en < min_sol then min_sol := curr + pt_bg - pt_en;
	curr := curr + pt_bg - pt_en;
    end;
    
    (* Zapisanie wyniku *)
    writeln(min_sol - 1, ' ', max_sol - 1);
end;

(* Program glowny *)
begin

    input;
    
    (* Dodamy jeszcze poczatek przedzialu (bg, en), potem od wyniku odejmiemy 1 *)
    pt[n_real].t := bg; 
    pt[n_real].be := _BG; 
    inc(n_real);

    (* Sortowanie *)
    for i := 0 to n_real - 1 do begin
	k := i;
	for j := i + 1 to n_real - 1 do begin    
	    if pt[j].t < pt[k].t then k := j;
	end;
	(* Zamiana *)
	tmp_pt := pt[k];
	pt[k] := pt[i];
	pt[i] := tmp_pt;
    end;

    calcresult;
    
end.
