import java.util.*;
class Kolmnurk{ 
// autor: J.Kiho.                                          04.03.98
// HOIATUS! Autor ei vo~ta endale vastutust ei selles klassis 
//          leiduvate vigade, ebakohtade ega nendest kasutajatele 
//          po~hjustatud ebamugavuste ning kahjude eest. 

   // isendi andmed: ----------------------------
   
   /** Nurk.*/ 
   private float alpha, beta, gamma;
     
   /** Külg. Nurga alfa vastaskülg. */  
   private double a;
   
   /** Külg. Nurga beeta vastaskülg.*/ 
   private double b;
   
   /** Külg. Nurga gamma vastaskülg.*/ 
   private double c; 
   
   // konstruktorid: --------------------------
   
   /** 
    * Kolme küje järgi. 
    *
    *@param x külg
    *@param y külg
    *@param z külg 
    */
      Kolmnurk(double x, double y, double z){
      a = x; b = y; c = z; 
      nurgad();
   }
   
   /**
    * Kaatetite järgi. 
    *
    * @param kt1 kaatet
    * @param kt2 kaatet
    */
   Kolmnurk(double kt1, double kt2){
      a = kt1; b = kt2; 
      c = Math.sqrt(kt1*kt1 + kt2*kt2);
      nurgad();
   }
   
   /**
    * Kahe külje ja nendevahelise nurga järgi. 
    *
    * @param a külg
    * @param b külg
    * @param gamma nurk antud külgede vahel.
    */
   Kolmnurk(double a, double b, float gamma){
      this.a = a; this.b = b;  
      c =  Math.sqrt(a*a + b*b - 2*a*b*Math.cos(gamma));
      nurgad();
   }
   
   // klassimeetod ------------------------------------
   
   /**
    * Kontroll, kas antud kaks kolmnurka on sarnansed.
    * 
    *@param k1 kolmnurk
    *@param k2 kolmnurk
    *@return <code>true</code>, kui sarnased, 
    *	<code>false</code> - vastasel korral.
    */
    static boolean onSarnased(Kolmnurk k1, Kolmnurk k2){
	//ujupunktarvude vordlemiseks:
	final float  eps = 1f/(10000);
	
	float x1, y1, z1;
	x1 = Math.min(k1.alpha,Math.min(k1.beta, k1.gamma));
	z1 = Math.max(k1.alpha,Math.max(k1.beta, k1.gamma));
	y1 = k1.alpha + k1.beta + k1.gamma - x1 - z1;
	//k1 nurgad, x1<=y1<=z1
	
	float x2, y2, z2;
	x2 = Math.min(k2.alpha,Math.min(k2.beta, k1.gamma));
	z2 = Math.max(k2.alpha,Math.max(k2.beta, k1.gamma));
	y2 = k2.alpha + k2.beta + k2.gamma - x2 - z2;
	//k2 nurgad, x2<=y2<=z2
	
	return (Math.abs(x1-x2)<eps) && (Math.abs(y1-y2)<eps)
	 && (Math.abs(z1-z2)<eps);
   }// onSarnased
   
   // isendimeetodid: ---------------------------------------
   
    /**
    * Kolmnurga pindala arvutamine. Heroni valemiga.
    *
    * @return pindala &uuml;mardatult.
    */
   double pindala(){
      return 
	round(Math.sqrt(p()*(p() - a)*(p() - b)*(p() - c)));
   }
   
    /**
    * Kontroll, kas see kolmnurk on sarnane kolmnurgaga, mille 
    * k&uuml;jepikkused on 3, 4 ja 5.
    *
    *@return <code>true</code>, kui sarnased, 
    *	<code>false</code> - vastasel korral.
    */
   boolean onPyth(){
	return onSarnased(this, new Kolmnurk(3,4,5.0));
   }
    
   /**
    * Kolmnurk s&otilde;nena (k&uuml;ljed ja nurgad). 
    * Kolmnurga andmete tr&uuml;kikuju.
    */
   public String toString(){
      return "a="+round(a)+
	   "; b="+round(b)+
	   "; c="+round(c)+
	   "\n alfa="+kr(alpha)+
	    "; beeta="+kr(beta)+
	    "; gamma="+kr(gamma);     
   }
   
   // abimeetodid: --------------------------------- 
      
   /**
    * Nurgad k&uuml;lgede j&auml;gi.
    */
   private void nurgad(){// kylgede jargi
      double s = pindala();
      alpha = (float)Math.asin(2*s/b/c); 
      beta  = (float)Math.asin(2*s/a/c);
      gamma = (float)Math.asin(2*s/a/b);
      // voimalik nyrinurk uuesti:
      double pikim = Math.max(a, Math.max(b, c));
      if (a == pikim) alpha = (float)(Math.PI - gamma - beta);
       else
      if (b == pikim) beta  = (float)(Math.PI - gamma - alpha);
       else 
	              gamma = (float)(Math.PI - alpha - beta);
   }
   
   /**
    * Pool &uuml;mberm&otilde;&otilde;tu. 
    */
   private double p(){
      return (a + b + c)/2;
   }
   
    /**
     * L&uuml;hendada murdosa.
     *
     * @param x antud arv
     * @return l&uuml;hendatud murdosaga.
     */
    private double round(double x){
       double arv = 1000.0; //10 astmes (murdaosa kohtade arv) 
       return Math.round(x*arv)/arv;
    }
   
   /**
    * Radiaanid kraadideks.
    *
    * @param x nurk radiaanides
    * @return nurk t&auml;iskraadides
    */
   private int kr(float x){        
       return (int)Math.round(x*180/Math.PI);
   }
   
   // kylgede loendi organiseerimine: -----------------
   
   /**
    * Loendi, mis annab kolmnurga kyljed 
    * mittekahanevas j&auml;rjekorras
    */ 
   final class Loendi implements Enumeration{
       private int mitmes; // suuruselt mitmendat tahetakse
       private double[] x = new double[3]; // kyljed mittekahanevalt    
       // konstruktor, teeb loendi antud kolmnurga jaoks
       Loendi(Kolmnurk k){ 
	  mitmes = 0;
	  x[0] = Math.min(k.a, Math.min(k.b, k.c));
	  x[2] = Math.max(k.a, Math.max(k.b, k.c));
	  x[1] = k.a + k.b + k.c - x[0] - x[2];
       }//konstruktor
       public boolean hasMoreElements(){
	  return mitmes < 3;
       }
       public Object nextElement(){
	  return new Double(x[mitmes++]);
       }
   }//Loendi
   
   /**
    * Teeb selle kolmnurga k&uuml;lgede loendi.
    */
   Enumeration kyljed123(){
       return new Loendi(this);
   }
   
}//Kolmnurk