program kvadratine_saknis;
  { 100 u‘davinys }
  const SK_ILG = 90; { maksimalus skai‡iaus ilgis }
  type didelis = array [1..SK_ILG] of 0..9;

  procedure suma (n: integer; sk1, sk2: didelis; var sum: didelis);
  { sudeda du teigiamus didelius skai‡ius, turin‡ius iki n skaitmen— }
    var perk, tarp, i: integer;
  begin
    perk := 0;              { perk‚limas }
    for i := n downto 1 do  { pradedama nuo paskutiniojo skaitmens }
      begin
        tarp := sk1[i] + sk2[i] + perk;
        sum[i] := tarp mod 10;
        perk := tarp div 10;
      end;
  end; { suma }

  procedure div2 (n: integer; sk: didelis; var dalmuo: didelis);
  { dalmuo := sk div 2; sk turi iki n skaitmen— }
    var i: integer;
  begin
    dalmuo[n] := sk[n] div 2;
    for i := n-1 downto 1 do
      begin
        dalmuo[i] := sk[i] div 2;
        if sk[i] mod 2 = 1
           then dalmuo[i+1] := dalmuo[i+1] + 5;
      end;
  end; { suma }

   procedure sandauga (n: integer; sk1, sk2 : didelis; var san :didelis);
   { san := sk1 * sk2, kai daugikliai turi iki n skaitmen— }
   var i, j, k,laik,  tarpinis : integer;
   begin
     for i := n downto 1 do
       san[i] := 0;
     for i := n downto 1 do     { kiekvien… skaitmenŤ }
       for j := n downto 1 do   { dauginame iž antrojo skai‡iaus }
         begin
           k := j + i - n;
           tarpinis := sk1[i] * sk2[j];
           while tarpinis <> 0 do  { tarpinŠ sandaug… pridedame prie }
             begin                 { turimos }
               laik := san[k];
               san[k] := (san[k] + tarpinis) mod 10;
               tarpinis := (laik + tarpinis) div 10;
               k := k - 1;
             end
         end;
  end; { sandauga }

  function maziau (n: integer; sk1, sk2: didelis): boolean;
  { ar sk1 < sk2, kai skai‡iai turi iki n skaitmen—  }
    var i: integer;
  begin
    i := 1;
    while (i < n) and (sk1[i] = sk2[i]) do
      i := i + 1;
    maziau := sk1[i] < sk2[i];
  end; { maziau }

  procedure saknis (n: integer; { x skaitmen— skai‡ius + 1 }
                    x: didelis; { didelis skai‡ius }
                    var galima: boolean; { ar galima ižtraukti žaknŤ }
                    var rez: didelis  { žaknis });
    var sk,   { skaitmen— skai‡ius iežkomoje žaknyje }
        i: integer;
        a, b, ab, { intervalo r‚‘iai ir vidurio tažkas }
        a_plius_1, a_plius_b, vienas,
        xx: didelis;  { vidurio tažkas, pakeltas kvadratu }
  begin
    for i := 1 to n-1 do
      vienas[i] := 0;
    vienas[n] := 1;                { a := 1                            }
    sk := (n - 2) div 2 + 1;       { randame žaknies skaitmen— skai‡i— }
    for i := n downto 1 do         { sudarome interval…                }
      begin                        { a := 1000...000;                  }
        a[i] := 0;                 { b := 9999...999;                  }
        if i >= n - sk + 1
           then b[i] := 9
           else b[i] := 0;
      end;
    a[n - sk + 1] := 1;
    sandauga (n, a, a, xx);
    if maziau (n, xx, x) or maziau (n, x, xx)       { jei a n‚ra žaknis     }
    then begin
           suma (n, a, vienas, a_plius_1);          { sudarome a_plius_1    }
           while maziau (n, a_plius_1, b) do        { while b - a > 1 do    }
             begin
               suma (n, a, b, a_plius_b);           { a_plius_b := a + b    }
               div2 (n, a_plius_b, ab);             { ab := a_plius_b div 2 }
               sandauga (n, ab, ab, xx);            { xx := ab * ab         }
               if maziau (n, xx, x)                 { if xx < x             }
                  then a := ab                      {    then a := xx       }
                  else b := ab;                     {    else b := xx       }
               suma (n, a, vienas, a_plius_1)       { a_plius_1 := a + 1    }
             end
         end
    else b := a;  { jei a yra žaknis }
    sandauga (n, b, b, xx);                {  xx := ab * ab        }
    galima := not maziau (n, xx, x) and not maziau (n, x, xx);
    if galima
       then rez := b;
  end; { žaknis }

  var f: text;
      i, j, n: integer;
      x, rez: didelis;
      galima: boolean;
      c: char;
begin
  assign (f, 'SAKNIS.DAT');
  reset (f);
  readln (f, n);
  x[1] := 0;         { traukiant žaknŤ teks dirbti su skai‡iais }
  n:= n + 1;         { turin‡iais iki n+1 skaitmens, tod‚l skai‡i— }
  for i := 2 to n do { patraukiame per vien… pozicij… Ť dežinŠ }
    begin
      read (f, c);
      x[i] := ord(c) - ord('0');
    end;
  close (f);
  saknis (n, x, galima, rez);
  assign (f, 'SAKNIS.REZ');  { spausdinami rezultatai }
  rewrite (f);
  if not galima
     then writeln (f, 'NEGALIMA')
     else begin
            i := 1;
            while rez[i] = 0 do
              i := i + 1;
            for j := i to n do
              write (f, rez[j])
           end;
  close (f);
end.