import java.util.ArrayList;
import java.util.TreeSet;
import java.util.Iterator;
import java.util.Scanner;
import java.io.PrintStream;
import type.lib.Fraction;

public class FractionFilter
{
   public static void main(String[] args)
   {
      PrintStream output = System.out;
      Scanner input = new Scanner(System.in);
      
      // Use a TreeSet so that fractions are stored from smallest to largest
      TreeSet<Fraction> fractions = new TreeSet<Fraction>();
      
      while (input.hasNext())
      {
         long numerator = input.nextLong();
         long denominator = input.nextLong();
         Fraction f = new Fraction(numerator, denominator);
         fractions.add(f);
      }
      
      output.println("----- uses a List");
      Fraction sum = new Fraction(0, 1);
      
      // OUTPUT METHOD 1: Using a List
      // Create a list that contains all of the fractions in descending
      // order (largest to smallest). Finding the sum of the 3 largest
      // is easy using a list because you have indexed access.
      ArrayList<Fraction> reverseList =
         new ArrayList<Fraction>(fractions.descendingSet());
      sum.add(reverseList.get(0));
      sum.add(reverseList.get(1));
      sum.add(reverseList.get(2));
      for (Fraction f : reverseList)
      {
         output.println(f);
      }
      output.println(sum);
      
      // OUTPUT METHOD 1: Using an iterator
      // Use a descending iterator. Computing the sum is more complicated
      // this way.
      output.println("----- uses a descending iterator");
      sum = new Fraction(0, 1);
      Iterator<Fraction> reverseIter = fractions.descendingIterator();
      final int NUM2SUM = 3;
      for (int i = 0; i < NUM2SUM; i++)
      {
         Fraction f = reverseIter.next();
         sum.add(f);
         output.println(f);
      }
      for (int i = NUM2SUM; i < fractions.size(); i++)
      {
         Fraction f = reverseIter.next();
         output.println(f);
      }
      output.println(sum);
   }
}