class test
{
	public static void main(String[] args)
	{
		foititis[] pinakas = new foititis[7];

		pinakas[0] = new foititis("A Kappa", "A Kappa");
		pinakas[0].setAM(5);
		pinakas[0].setEtos(2014);
		pinakas[1] = new foititis("C Kappa", "C Kappa");
		pinakas[1].setAM(2);
		pinakas[1].setEtos(2015);
		pinakas[2] = new foititis("F Kappa", "F Kappa");
		pinakas[2].setAM(8);
		pinakas[2].setEtos(2009);
		pinakas[3] = new foititis("B Kappa6", "B Kappa");
		pinakas[3].setAM(15);
		pinakas[3].setEtos(2005);
		pinakas[4] = new foititis("D Kappa", "D Kappa");
		pinakas[4].setAM(1);
		pinakas[4].setEtos(2017);
		pinakas[5] = new foititis("E Kappa", "E Kappa");
		pinakas[5].setAM(24);
		pinakas[5].setEtos(2016);
		pinakas[6] = new foititis("G Kappa", "G Kappa");
		pinakas[6].setAM(20);
		pinakas[6].setEtos(2011);

		MyUtils.quickSort(pinakas, 0, pinakas.length - 1);

		for(int i = 0; i < pinakas.length; i++)
		{
			System.out.println(pinakas[i].getAm());
		}
	}
}

class foititis
{
	private String onoma;
	private String eponumo;
	private int am;
	private int etos;

	foititis(String onoma, String eponumo)
	{
		this.onoma = onoma;
		this.eponumo = eponumo;
	}

	public String getOnoma()
	{
		return onoma;
	}

	public String getEponumo()
	{
		return eponumo;
	}

	public int getAm()
	{
		return am;
	}

	public int getEtos()
	{
		return etos;
	}

	public void setAM(int am)
	{
		this.am = am;
	}

	public void setEtos(int etos)
	{
		this.etos = etos;
	}
}

class MyUtils
{
	public static void swap(foititis[] pinakas, int x, int y)
	{
		foititis temp = pinakas[x];
		pinakas[x] = pinakas[y];
		pinakas[y] = temp;
	}

	public static int partition(foititis[] pinakas, int f, int l)
	{
		int retValue = 0, lowerLimit = f, mid = (f + 1) / 2;

		swap(pinakas, f, mid);

		int pivot = pinakas[f].getAm();
		f++;

		while(f < l)
		{
			while(pinakas[f].getAm() <= pivot && f < l)
			{
				f++;
			}

			while(pinakas[l].getAm() >= pivot && f <= l)
			{
				l--;
			}

			if(f < l)
			{
				swap(pinakas, f, l);
			}
		}

		if(pivot > pinakas[f].getAm())
		{
			swap(pinakas, f, lowerLimit);
			retValue = f;
		}
		else
		{
			if(pivot >= pinakas[l].getAm())
			{
				swap(pinakas, l, lowerLimit);
				retValue = 1;
			}
		}

		return retValue;
	}

	/*public static int partition(foititis[] pinakas, int first, int last)
	{
		int pivot = pinakas[first].getAm(), low = first + 1, high = last;

		while(high > low)
		{
			while (low <= high && pinakas[low].getAm() <= pivot)
			{
				low++;
			}

			while (low <= high && pinakas[high].getAm() > pivot)
			{
				high--;
			}

			if(high > low)
			{
				swap(pinakas, high, low);
			}
		}

		while(high > first && pinakas[high].getAm() >= pivot)
		{
			high--;
		}

		if (pivot > pinakas[high].getAm())
		{
			swap(pinakas, first, high);

			return high;
		}
		else
		{
			return first;
		}
	}*/


	public static void quickSort(foititis[] pinakas, int f, int l)
	{
		//final int MIN = 5;

		if(/*l - f > 0*/ l > f)
        {
			/*if(l - f + 1 < MIN)
			{
				//other sort algo
			}
			else
			{*/

			int pivotIndex = partition(pinakas, f, l);
			quickSort(pinakas, f, pivotIndex - 1);
			quickSort(pinakas, pivotIndex + 1, l);
		}
	}
}