//author: Marco Happenhofer
//e-Mail: marco.happenhofer@aon.at
//Ma-Nr : 0125932
//Bsp-Nr: 3055

import eprog.*;
import java.util.*;
import java.math.*;

public class Rgb extends EprogIO	{
	static class Point_3D{
		//Klasse 3D Punkt speziell für eine Farbkonvertierung.
		//3 Variablen, je eine für ein Achse;
		private int r,g,b;	//Die Farben rot grün blau;
		//Konstructor
		Point_3D(int rot, int gruen, int blau)	{
			r=rot;	g=gruen;	b=blau;
			}

		Point_3D()	{
			r=0;	g=0;	b=0;
			}

		//Funktionen
		public int Farbe(char welche)	{
		//Auslesen einer Farbe
			int ausgabe;
			switch ((int)welche)	{
				case 114:	//114 steht für r
					ausgabe= r;	break;
				case 103:	//103 steht für g
					ausgabe= g;	break;
				case 98:	//98 steht für b
					ausgabe= b;	break;
				default:	//Fehlerausgabe falls eine falsche Farbe angegeben wurde
					ausgabe= -1;
				}
			return ausgabe;
			}

		public void setze(char welche,int Wert)	{
		//Setzen einer Farbe
			switch ((int)welche)	{
				case 114:	//114 steht für r
					r=Wert;	break;
				case 103:	//103 steht für g
					g=Wert;	break;
				case 98:	//98 steht für b
					b=Wert;	break;
				}
			}
		public void mod(Point_3D konv)	{
		//modelliert aus den Punkt die Koordinaten für die RGB Konversion
		//zB: 100 100 100 in das 7/7/3 System ==> 73,73,85
			  double temp,pr,pg,pb;
			  int zw;
			  pr=konv.Farbe('r');
			  pg=konv.Farbe('g');
			  pb=konv.Farbe('b');
							/*	Information zur Berechnung
							die Koordinate von dem angegebenen Punkt werden in das andere System umgerechnet.
							Also mit (7/255) multiplizieren. Wenn man nun davon den ganzahligen Wert nimmt (
							also abrundet) so erhält man die Farbe im neuen System. Bei der Aufgabe ist dies
							aber uninteressant. Interessant ist jedoch der kleinste Punkt vom alten System
							der im gleichen neuem System ist. Also mit (255/7) multiplizieren. */

			  //modellieren der Farbe rot

			  	zw=(int)((pr*7)/255);
			  	temp=(double)zw;
			   	temp=Math.round((temp*255)/7);
			  r= (int) temp;

			  //modellieren der Farbe grün

			  	zw=(int)((pg*7)/255);
			  	temp=(double)zw;
			   	temp=Math.round((temp*255)/7);
			  g= (int) temp;

			  //modellieren der Farbe blau

			  	zw=(int)((pb*3)/255);
			  	temp=(double)zw;
			   	temp=Math.round((temp*255)/3);
			  b= (int) temp;
			}
	}

	static class wurfel	{
		//Klasse Würfel besteht aus 8 3D Punkten die bei der Installierung 0
		//und bei dem Konstruktor wird der erste Punkt auf den Punkt der
		//übergeben wurde gesetzt.
		private Point_3D farb_konv [] ={new Point_3D(),new Point_3D(),new Point_3D(),new Point_3D(),new Point_3D(),new Point_3D(),new Point_3D(),new Point_3D()};
		//Abstände die gefragt sind
		private double abstand []={0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
		//Konstruktor
		wurfel(Point_3D kleinster)	{
			farb_konv[0].setze('r',kleinster.Farbe('r'));
			farb_konv[0].setze('g',kleinster.Farbe('g'));
			farb_konv[0].setze('b',kleinster.Farbe('b'));
			alle();
			}

		//Funktionen
		public String Punkt(int welcher)	{
		//Gibt einen bestimmten Punkt aus. von 0 bis 7
			String Ausgabe;
			Ausgabe =String.valueOf(farb_konv[welcher].Farbe('r'))+ " "+String.valueOf(farb_konv[welcher].Farbe('g'))+" "+String.valueOf(farb_konv[welcher].Farbe('b'));
			return Ausgabe;
			}

		public void alle ()	{
		//mit dieser Methode werden alle anderen 7 3D Punkte aufgrund der vorgegebenen Abmessungen
		//gesetzt. Das heißt der erste Punkt ist der Grundstein für das Quader. Die Abmessung sind bekannt
		// mit (255/7) bzw (255/3)
			int i;
			double temp;
			//setzt den ursprünglichen Punkt auf das neue System.
			farb_konv[0].setze('r',(farb_konv[0].Farbe('r')*7)/255);
			farb_konv[0].setze('g',(farb_konv[0].Farbe('g')*7)/255);
			farb_konv[0].setze('b',(farb_konv[0].Farbe('b')*3)/255);
			//setzt die anderen Punkte auf den Ausgangspunkt und addiert die nötigen punkte hinzu
			for (i=1;i<8;i++)	{
				farb_konv[i].setze('r',farb_konv[0].Farbe('r'));
				farb_konv[i].setze('g',farb_konv[0].Farbe('g'));
				farb_konv[i].setze('b',farb_konv[0].Farbe('b'));
				if (i>3)	farb_konv[i].setze('r',farb_konv[0].Farbe('r')+1);
				if (i==1 ||	i==2 ||i==5 ||	i==6) farb_konv[i].setze('g',farb_konv[0].Farbe('g')+1);
				if (i==3 ||	i==2 ||i==7 ||	i==6) farb_konv[i].setze('b',farb_konv[0].Farbe('b')+1);
				}
			//setzt die Punkte vom neuen System ins alte zurück
			for (i=0;i<8;i++)	{
				temp=(double) farb_konv[i].Farbe('r');
				temp=Math.round((temp*255)/7);
					farb_konv[i].setze('r',(int)temp);
				temp=(double) farb_konv[i].Farbe('g');
				temp=Math.round((temp*255)/7);
					farb_konv[i].setze('g',(int)temp);
				temp=(double) farb_konv[i].Farbe('b');
				temp=Math.round((temp*255)/3);
					farb_konv[i].setze('b',(int)temp);
				}
			}

		public void einheits(Point_3D Angabe)	{
		//Diese Methode berechnet alle Abstände von den Eckpunkten zu den angegebenen Punkt.
			int i;
			double l1,l2,l3,l4;
			double summe=0;
			//Berechnung erfolgt mittels Phytagoras
			//Summe speichert die gesamten Längen um später alle Abstände auf die Einheitslänge zu bringen
			for (i = 0;i<8;i++)	{
				l1=(double) (farb_konv[i].Farbe('r')-Angabe.Farbe('r'));
				l2=(double) (farb_konv[i].Farbe('g')-Angabe.Farbe('g'));
				l3=(double) (farb_konv[i].Farbe('b')-Angabe.Farbe('b'));
				l4=Math.sqrt(Math.pow(l2,2)+Math.pow(l3,2));
				abstand[i]=Math.sqrt(Math.pow(l4,2)+Math.pow(l1,2));
				summe=summe+abstand[i];
				}
			//Alle Abstände auf die Einheitslänge bringen
			for (i = 0;i<8;i++)	{
				abstand[i]=abstand[i]/summe;
				}
			}

		public double abstaende (int welche)	{
		//Gibt den Abstand eines gewissen Punktes zurück
			return abstand[welche];
			}
		private void quicksort (int l, int r)	{
		//Quicksort sortiert alle Abstände der größe nach
			int i,j;
			double v,temp;
			if (r>l)
				{v=abstand[r];	i=l-1;	j=r;
				for(;;)
					{while  (i<r && abstand[++i]<v);
					 while  (j>l && abstand[--j]>v);
				     if (i>=j) break;
				     temp=abstand[j];
				     abstand[j]=abstand[i];
				     abstand[i]=temp;
				     }
				temp=abstand[r];
				abstand[r]=abstand[i];
				abstand[i]=temp;
				quicksort(l,i-1);
				quicksort(i+1,r);
				}
			}
	}


//***********************************************************************
//***********************************************************************
//**************H*A*U*P*T*P*R*O*G*R*A*M*M********************************
//***********************************************************************
//***********************************************************************

	public static void main (String args[]) throws EprogException	{
		int i,r=0,g=0,b=0;
		//Eingabe der 3 Farbwerte
		try{
			r=EprogIO.readInt();
			g=EprogIO.readInt();
			b=EprogIO.readInt();
			}
		catch (EprogException e)	{
					//Bei Ausnahmnefehlern ....
					println("?");
					System.exit(0);
					}
		//Werte im gültigen Bereich
		if (r<0 || r>255 || g<0 || g>255 || b<0 || b>255)	{
					println("FALSCHE EINGABE");
					System.exit(0);
					}
		//einen 3D Punkt erstellen
		Point_3D erster = new Point_3D();
		//einen 3D Punkt erschaffen mit den Eingaben
		Point_3D zweiter = new Point_3D(r,g,b);
		//Punkt 1 so modellieren das er ihn die Maske paßt
		erster.mod(zweiter);
		//Einen Würfel aus Punkt 2 erschaffen
		wurfel W6 = new wurfel(zweiter);
		//Längen auf den zweiten Punkt berechnen
		W6.einheits(zweiter);
		//Längen sortieren
		W6.quicksort(0,7);
		//Daten ausgeben
		for (i=0;i<8;i++)	{
			printFixed(W6.abstaende(i));
			print(" ");
			}
		println("");
	}
}