program P_I_2;

const
   { protože možností je různě mnoho a pole může obsahovat
     pouze stejně dlouhé řádky, je za poslední možností
     číslo 8, které slouží jako zarážka při jejich procházení }
   moznosti : array [0..7, 1..4] of integer = (
      ( 4, 1, 7, 8), { 000 -> 100, 001, 111 }
      ( 6, 0, 8, 8), { 001 -> 110, 000 }
      ( 5, 8, 8, 8), { 010 -> 101 }
      ( 4, 8, 8, 8), { 011 -> 100 }
      ( 3, 0, 8, 8), { 100 -> 011, 000 }
      ( 2, 8, 8, 8), { 101 -> 010 }
      ( 1, 8, 8, 8), { 110 -> 001 }
      ( 0, 8, 8, 8)  { 111 -> 000 }
   );

   MAXN = 10000000;

type TSloupecek = array [ 1..3 ] of boolean;

{ zakóduje sloupeček do binární soustavy }
function Zakoduj(var sloupecek : TSloupecek) : integer;
var
   kod : integer;
begin
   kod := 0;
   if sloupecek[1] then
      kod := kod + 1;
   if sloupecek[2] then
      kod := kod + 2;
   if sloupecek[3] then
      kod := kod + 4;

   Zakoduj := kod;
end;

var
   sloupecek : TSloupecek;    { hodnota true je na zakázaném políčku }
   N, K, L : longint;
   X, Y : longint;
   i, j : longint;

   pocty : array [ 1..2 ] of array [ 0..7 ] of longint;
   aktualni, pristi : integer;
   K1, K2, Mi : integer;

begin
   { načtení vstupu }
   readln(N, K, L);

   { zarážka, abychom zajistili, že žádná dlaždice nebude přečnívat ven z chodby }
   for j:=0 to 7 do begin
      pocty[1][j] := 0;
      pocty[2][j] := 0;
   end;

   aktualni:=1;
   pristi:=2;

   pocty[aktualni][7]:=1;

   if K > 0 then
      readln(X, Y);

   for j:=1 to N+1 do begin
      { za konec chodby umístíme zarážku, abychom zajistili, že žádná dlaždice
        nebude přečnívat ven z chodby }
      sloupecek[1]:=(j=N+1);
      sloupecek[2]:=(j=N+1);
      sloupecek[3]:=(j=N+1);

      while (K > 0) and (Y = j) do begin
         sloupecek[X] := true;
         dec(K);
         if K > 0 then
            readln(X, Y);
      end;

      K2:=Zakoduj(sloupecek);
      for K1:=0 to 7 do begin { pro všechny možné konfigurace sloupečku }
         i:=1;
         while moznosti[K1][i] < 8 do begin { pro všechny možnosti, jak jej pokrýt }
            Mi := moznosti[K1][i];
            if K2 and Mi = 0 then { pokud nenastane kolize se zakázaným políčkem }
               { aktualizujeme počet možností pro další sloupeček }
               pocty[pristi][K2 or Mi] :=
                  (pocty[pristi][K2 or Mi] + pocty[aktualni][K1]) mod L;
            inc(i);
         end;
      end;

      { příští sloupeček tabulky se stane aktuálním }
      aktualni:=pristi;
      pristi:=3-aktualni;

      { příští sloupeček vynulujeme }
      for i:=0 to 7 do
         pocty[pristi][i] := 0;
   end;

   { vypíšeme počet možností zcela pokryté chodby }
   writeln(pocty[aktualni][7]);
end.