program lobio_ieskojimas;
  { 131 u‘davinys }
  const D = 4; { labirinto dydis }
  type  labirintas = array [1..D, 1..D] of
           record
             t: char;     { laukelio tipas }
             nr: integer; { laukelio numeris }
             buta_s,          { ar pakli–ta Ť langelŤ savarankižkai }
             buta_n: boolean; { ar pakli–ta Ť langelŤ savarankižkai }
           end;
        siena = record
                  kuri, { su kuria ižorine siena lie‡iasi }
                  n1, n2: integer;  { kuriuos stulpelius (eilutes) skiria }
                end;
        sienos = array [1..D, 1..D, 1..D, 1..D] of boolean;

   procedure form_sienas (s2, s3: siena; var s: sienos);
   { suformuoja sienas }
     var y, x, u, v, i, kryptis: integer;
   begin
     for y := 1 to D do
       for x := 1 to D do
         for u := 1 to D do
           for v := 1 to D do
               s[y, x, u, v] := false;
     for i := 1 to 5 do
       begin
         if i <= 2  { prie kurios labirinto sienos glaud‘iasi ži siena }
            then kryptis := s2.kuri
            else kryptis := s3.kuri;
         if i in [1, 3] { randame stulpelŤ (eilutŠ) }
            then if (kryptis = 1) or (kryptis = 4)
                    then y := 1
                    else y := 4
            else if (kryptis in [1, 4]) and (i in [2, 4]) or
                    (kryptis in [2, 3]) and (i = 5)
                    then y := 2
                    else y := 3;
         if (kryptis = 1) or (kryptis = 3)
            then if i <= 2
                    then s[y, s2.n1, y, s2.n2] := true
                    else s[y, s3.n1, y, s3.n2] := true
            else if i <= 2
                   then s[s2.n1, y, s2.n2, y] := true
                   else s[s3.n1, y, s3.n2, y] := true;
       end;
     for y := 1 to D do
       for x := 1 to D do
         for u := 1 to D do
           for v := 1 to D do
               if s[y, x, u, v]
                  then s[u, v, y, x] := true
   end; { form_sienas }

   procedure nebuta (y, x: integer; var l: labirintas);
   { pa‘ymi, kad neb–ta nei viename labirinto laukelyje, }
   { ižskyrus laukelŤ su koordinat‚mis y, x }
     var i, j: integer;
   begin
    for i := 1 to D do
      for j := 1 to D do
        begin
          l[i, j].buta_s := false;
          l[i, j].buta_n := false;
        end;
    l[y, x].buta_s := true;
   end; { neb–ta }

  function ejimai (l: labirintas; { labirintas }
                   iejim_y, iejim_x: integer; { i‚jimas }
                   s2, s3: siena { sienos }): integer;
  { randa lobŤ ir ižeina iž labirinto }
    var dx, dy: array [1..4] of -1..1; { iž laukelio einama keturiomis }
                                       { kryptimis }
        min: integer;  { minmalus ‚jim— skai‡ius }
        s: sienos;
    { visi žie kintamieji global–s rekursinei proced–rai eiti }

   procedure rasti (y, x: integer; var kur_y, kur_x: integer);
   { raanda langelŤ Ť kurŤ mus permeta (nuneža) iž langelio (y, x) }
     var tipas: char;
         ska, u, v: integer;
   begin
     { rasime Ť kokio tipo langelŤ mue perkels }
     if l[y, x].t = 'D'
        then tipas := 'D'
        else if (l[y, x].nr <= 2)
                then tipas := 'U'
                else tipas := '’';
     { rasime koks bus to langelio numeris }
     if tipas = 'D'
        then if l[y, x].nr <= 2
                then ska := l[y, x].nr + 1
                else ska := 1
        else if tipas = '’'
                then ska := 1
                else ska := l[y, x].nr + 3;
     { rasime t… langelŤ }
     for u := 1 to D do
       for v := 1 to D do
         if (l[u, v].t = tipas) and (l[u, v].nr = ska)
            then begin
                   kur_y := u; kur_x := v;
                 end;
   end; { rasti }

    procedure eiti (y, x,   { langelio koordinat‚s }
                    sprogm, { turim— sprogmen— kiekis }
                    ej: integer; { padaryt— ‚jim— skai‡ius }
                    rasta,  { ar rastas lobis }
                    pats: boolean; { ar pats at‚jo Ť langelŤ }
                    var min: integer { minimalus ‚jim— skai‡ius });
    { rekursin‚ proced–ra, vaikž‡iojanti po labirint… }
      var k, u, v, kur_y, kur_x: integer;
          lab: labirintas;
          sprogo: boolean;
    begin
      if (y = iejim_y) and (x = iejim_x) and rasta
      then begin  { radome lobŤ ir pasiek‚me iž‚jim… }
             if min > ej
                then min := ej;
             exit;
           end;
     if (l[y, x].t in ['U', 'D']) and pats
     then begin { jei iž žio laukelio mus nunež(permes) Ť kit… }
            rasti (y, x, kur_y, kur_x);
            if not l[kur_y, kur_x].buta_n { jei jame neb–ta }
            then begin
                   l[kur_y, kur_x].buta_n := true;
                   eiti (kur_y, kur_x, sprogm, ej, rasta, false, min);
                   l[kur_y, kur_x].buta_n := false
                 end;
          end
     else begin { eisime visomis keturiomis kryptimis }
           if l[y, x].t = 'L' { jei pasiek‚me lobŤ }
              then begin
                     lab := l;      { Ťsimename aplankytus laukelius }
                     rasta := true; { radome lobŤ }
                     nebuta (y, x, l); { v‚l galime visur vaikž‡ioti }
                   end;
           for k := 1 to 4 do
             begin
               u := y + dy[k]; { paeiname atitinkama kryptimi }
               v := x + dx[k];
               if (u in [1..D]) and (v in [1..D]) and (ej+1 < min)
                  { jei langelis priklauso labirintui ir verta eiti }
               then if not l[u, v].buta_s { jei nebuvome žiame langelyje }
                    then begin
                           { gal reikia sprogdinti sien… }
                           sprogo := s[y, x, u, v];
                           if sprogo { jei reikia sprogdinti }
                           then begin
                                  sprogm := sprogm - 1;
                                  s[y, x, u, v] := false;
                                  ej := ej + 1;
                                end;
                           if sprogm >= 0 { jei u‘teko sprogmen— }
                           then begin
                                  l[u, v].buta_s := true;
                                  eiti (u, v, sprogm, ej+1, rasta, true, min);
                                  l[u, v].buta_s := false;
                                end;
                          if sprogo { grŤ‘tame per ‘ingsnŤ atgal }
                          then begin
                                 sprogm := sprogm + 1;
                                 s[y, x, u, v] := true;
                                 ej := ej - 1;
                               end;
                         end;
             end;
           if l[y, x].t = 'L' { jei buvome radŠ lobŤ }
           then begin
                  l := lab;  { atstatome buvusi… labirinto pad‚tŤ }
                  rasta := false; { lobio v‚l neturime }
                end;
       end;
    end; { eiti }

    var  i, j: integer;
  begin
    { apibr‚‘iame ‚jimo kryptis }
    dy[1] := 0;  dx[1] := 1;
    dy[2] := 0;  dx[2] := -1;
    dy[3] := 1;  dx[3] := 0;
    dy[4] := -1; dx[4] := 0;
    { nei viename laukelyje dar neb–ta }
    nebuta (iejim_y, iejim_x, l);
    min := maxint; { minimalus ‚jim— skai‡ius }
    { suformuojame sienas }
    form_sienas (s2, s3, s);
    eiti (iejim_y, iejim_x, 2, 1, false, true, min);
    ejimai := min + 1;   { iž‚jimas iž labirinto taip pat yra ‚jimas }
  end; { ‚jimai }

  var f: text;
      iejim_x, iejim_y: integer;
      i, xx, yy: integer;
      l: labirintas;
      s2, s3: siena;
begin
  assign (f, 'LABIR.DAT');
  reset (f);
  readln (f, iejim_x, iejim_y);  { perskaitomos Ť‚jimo koordinat‚s }
  for i := 1 to D * D do
    begin
      readln (f, yy, xx);
      case i of  { nustatomas laukelio tipas }
        1:      l[xx, yy].t := 'P';
        2..6:   l[xx, yy].t := 'U';
        7:      l[xx, yy].t := '’';
        8..12:  l[xx, yy].t := 'S';
        13..15: l[xx, yy].t := 'D';
        16:     l[xx, yy].t := 'L';
      end;
      case i of  { nustatomas laukelio numeris }
        2, 13: l[xx, yy].nr := 1;
        3, 14: l[xx, yy].nr := 2;
        4, 15: l[xx, yy].nr := 3;
        5:     l[xx, yy].nr := 4;
        6:     l[xx, yy].nr := 5;
        else   l[xx, yy].nr := 1;
      end;
    end;
  readln (f, s2.kuri, s2.n1, s2.n2);
  readln (f, s3.kuri, s3.n1, s3.n2);
  close (f);
  writeln (ejimai(l, iejim_y, iejim_x, s2, s3));
end.