program nesekmingas_skrydis_oro_balionu;
  { 108 u‘davinys }
  const MAX_N = 1000; { maksimalus daugiakampio virž–ni— skai‡ius }
        type taskas =  record
                         x, y: -1..1000;
                       end;
            daugiak = array [1..MAX_N] of taskas;

  function succ_v (i, n: integer): integer;
  begin
    if i = n
       then succ_v := 1
       else succ_v := i + 1
  end; { succ_v }

  function pred_v (i, n: integer): integer;
  begin
    if i = 1
       then pred_v := n
       else pred_v := i - 1
  end; { succ_v }

  function desine (t1, t2, t: taskas): boolean;
    { ar tažkas t yra dežin‚je ties‚s ižvestos per tažkus }
    { t1 ir t2 pus‚je. Ties‚s kryptis iž t1  t2 }
  begin
    desine := (t.x - t1.x) * (t2.y - t1.y) -
              (t.y - t1.y) * (t2.x - t1.x) > 0
  end; { desine }

  function lygiagr (t1, t2, t3, t4: taskas): boolean;
  { ar ties‚, ižvesta per tažkus t1 ir t2 lygiagreti tiesei }
  { ižvestai per kitus du tažkus }
  begin
    lygiagr := (t2.x - t1.x) * (t4.y - t3.y) =
               (t2.y - t1.y) * (t4.x - t3.x)
  end; { lygiagr }

  function priklauso (t1, t2, t: taskas): boolean;
  { ar tažkas t priklauso atkarpai, ižvestai per tažkus }
  { t1 ir t2 }
  begin
    priklauso := ((t.x - t1.x) * (t2.y - t1.y) -   { priklauso tiesei }
                 (t.y - t1.y) * (t2.x - t1.x) = 0) and
                 ((t1.x <= t.x) and (t.x <= t2.x) or  { ir atkarpai }
                  (t2.x <= t.x) and (t.x <= t2.x)) and
                 ((t1.y <= t.y) and (t.y <= t2.y) or
                  (t2.y <= t.y) and (t.y <= t2.y))
  end; { priklauso }

  function kerta (a1, a2, b1, b2: taskas): boolean;
  { ar atkarpa |a1, a2| kerta atkarp… |b1, b2| }
  { jei atkarpos n‚ra lygiagre‡ios }
  begin
    kerta :=  (desine (a1, a2, b1) <> desine (a1, a2, b2)) and
              (desine (b1, b2, a1) <> desine (b1, b2, a2)) and
              not priklauso (a1, a2, b1) and not priklauso (a1, a2, b2)
  end; { kerta }

  function virs (s1, s2: taskas; i, n: integer; v: daugiak): boolean;
  { tikrina, ar i-toji virž–n‚ priklauso spinduliui ir jei taip,  }
  { ar spindulys žioje virž–n‚je kerta (o ne lie‡ia) daugiakamp  }
  begin
    if priklauso (s1, s2, v[i]) { jei tažkas priklauso spinduliui }
       then virs := desine (s1, s2, v[succ_v(i, n)]) <>
                    desine (s1, s2, v[pred_v(i, n)])
       else virs := false
  end; { virž }

  function viduje (v: daugiak; n: integer; { daugiakampis }
                   t: taskas { keliautoj— koordinat‚s }): boolean;
    var i,
        kiek: integer;  { kiek briaun— kerta spindul }
        br1, br2, s1, s2: taskas;
        prikl: boolean; { ar tažkas priklauso daugiakampio briaunai }
  begin
    { patikrinsime, ar tažkas priklauso daugiakampio briaunai }
    prikl := false;
    for i :=  1 to n do
      prikl := prikl or priklauso (v[i], v[succ_v(i, n)], t);
    if prikl   { jei keliautojai nusileido ant sienos }
    then viduje := true
    else       { priežingu atveju }
      begin
        s1.x := -1; s1.y := -1; { spindulys tikrai ižeis u‘ daugiakampio }
        s2 := t;                { rib— }
        kiek := 0;
        for i := 1 to n do { skai‡iuosime kiek kražtini— kerta spindul }
          begin
            br1 := v[i];       { imame kit… briaun… }
            br2 := v[succ_v (i, n)];
            if not lygiagr (s1, s2, br1, br2){briauna nelygiagreti spinduliui}
               then if virs (s1, s2, i, n, v){spindulys kerta daug. virž–n‚je}
               or kerta (s1, s2, br1, br2)   { arba kerta briaun… }
                       then kiek := kiek + 1;
          end;
        viduje := kiek mod 2 = 1
      end
  end; { viduje }

  var f: text;
      i, n: integer;
      t: taskas;
      v: daugiak; { daugiakampio virž–n‚s }
begin
  assign (f, 'BAL.DAT');
  reset (f);
  read (f, n);
  readln (f, t.x, t.y);
  for i := 1 to n do   { perskaitome daugiakampio virž–nes }
    readln (f, v[i].x, v[i].y);
  close  (f);
  assign (f,  'BAL.REZ');
  rewrite (f);
  if viduje (v, n, t)
     then writeln (f, 'TAIP')
     else writeln (f, 'NE');
  close (f);
end.










