program teiginys_apie_statuji_trikampi;
  { 60 u‘davinys }

  procedure sukeisti (var x, y : integer);
   { Sukei‡ia dviej— kintam—j— reikžmes vietomis }
   var tarp : integer;
  begin
    tarp := x;
    x := y;
    y := tarp;
  end;

  function saknis (x : integer) : integer;
    { nat–rini— skai‡i— kvadratin‚ žaknis }
    var a, b, { intervalas }
        ab,   { vienas iž naujo intervalo r‚‘i— }
        xx : integer;
  begin
    a := 1;  b := x + 1; { pradinis intervalas }
    while b - a > 1 do
      begin
        ab := (a + b) div 2;  { intervalas dalijamas pusiau }
        xx := x div ab;
        if xx >= ab then a := ab
                    else b := ab
     end;
   saknis := a
  end;

    procedure iesk_a (var a : integer; b, c : integer;
                      var teig_b : boolean);
      { iežko sprendinio, kai ne‘inomas vienas skai‡ius }
      { b <= c }
      var t1, t2, a1 : integer;
    begin
      { gal b–t tr–kstamas skai‡ius yra ‘ambin‚ }
      t1 := b * b + c * c;
      a1 := saknis (t1);
      if a1 * a1 = t1 { jei radome sprendin }
         then teig_b := true
         else begin
                t2 := c * c - b * b;
                a1 := saknis (t2);
                teig_b := a1 * a1 = t2
              end;
      if teig_b then a := a1;
    end;

    procedure iesk_ab (var a, b : integer; c : integer;
                       var teig_b : boolean);
    { iežko sprendinio, kai ne‘inomi du skai‡iai }
      var aa, bb, { gautas, bet ne‘inia, ar optimalus rezultatas }
          a1, b1 : integer;
    begin
      aa := 0; bb := 0;            { dar neradome nei vieno sprendinio }
      b1 := 0;
      while  b1 < c do { gal turima kražt. yra trikampio stri‘ain‚... }
        begin
          b1 := b1 + 1;
          iesk_a (a1, b1, c, teig_b);
          if teig_b             { jei radome sprendin  }
             then if  a1 < c    { ir jis optimalus }
                      then begin
                              a := a1; b := b1;
                              exit;
                           end
                      else if aa = 0 { neaižku, ar optimalus, bet sminti  }
                             then begin                          { reikia  }
                                    aa := a1; bb := b1;
                                  end;
         end;  { while }
      { Jei iki žios vietos radome sprendin, tai jis tikrai optimalus }
      if teig_b
         then  begin
                 a := aa; b := bb;
               end
         else begin  { iežkome toliau, galb–t ‘inomas skai‡ius yra }
                     { trikampio statinis }
                 while not teig_b and (sqr(b1) - sqr(c) <= sqr(b1 - 1)) do
                   begin
                      b1 := b1 + 1;
                      iesk_a (a1, c, b1, teig_b);
                   end;
                 if teig_b { jei radome }
                    then begin
                           a := a1; b := b1;
                          end;
               end { else }
    end;

  procedure iesk_abc (var a, b, c : integer; var teig_b : boolean);
    { iežko sprendinio, kai ne‘inomi visi skai‡iai }
  begin
    c := 0;
    teig_b := false;
    while not teig_b do   { ciklas baigsis, nes tikrai ‘inome, }
      begin               { kad sprendinys egzistuoja }
        c := c + 1;
        iesk_ab (a, b, c, teig_b);
      end;
  end;


  procedure trikampis ( var a, b, c : integer; { trikampio kražt. ilgiai }
                        var teig_a, teig_b, teig_c : boolean
                        { ar teisingi atitinkami teiginiai } );
     var nez : integer; { ne‘inom— kražtini— skai‡ius }
  begin
    { kiek kražtini— ne‘inome }
    nez := ord(a = 0) + ord(b = 0) + ord(c = 0);
    { bus patogiau, jei kražtini— ilgius surikuosime did‚jimo tvarka }
    if a > b then sukeisti (a, b);
    if a > c then sukeisti (a, c);
    if b > c then sukeisti (b, c);
    if nez = 0 { jei ‘inome visus skai‡ius }
      then begin
             teig_a := (a * a + b * b = c * c);
             teig_c := not teig_a;
           end
      else begin
             teig_a := false;
             teig_c := false;
             case nez of { tiek skai‡i— yra ne‘inoma }
               1 : iesk_a (a, b, c, teig_b);
               2 : iesk_ab (a, b, c, teig_b);
               3 : iesk_abc (a, b, c, teig_b);
             end;
           end;
  end;

  var a, b, c : integer;             { trikampio kražtini— ilgiai }
      teig_a, teig_b, teig_c : boolean; { ar teisingi teiginiai }
begin
  writeln ('­veskite tris neneigiamus sveikuosius skai‡ius : ');
  readln (a, b, c);
  trikampis (a, b, c, teig_a, teig_b, teig_c);
  if teig_a
       then writeln ('Teiginys yra teisingas')
    else if teig_c
       then writeln ('Teiginys yra klaidingas')
    else if not teig_b
       then writeln ('Teiginys negali b–ti teisingas')
    else begin
           writeln ('Teiginys gali b–ti teisingas');
           writeln (a, ' ', b, ' ', c);
         end;
end.


