import java.util.*;

/** This class represents fractions of form n/d where n and d are long integer
 * numbers. Basic operations and arithmetics for fractions are provided.
 */
public class Lfraction implements Comparable<Lfraction> {
   public static long gcd(long a, long b) {
      return b == 0 ? a : gcd(b, a % b);
   }


   public long numerator;
   public long denominator;

   /** Main method. Different tests. */
   public static void main (String[] param) {
    // TODO!!! Your debugging tests here
   }


   /** Constructor.
    * @param a numerator
    * @param b denominator > 0
    */
   public Lfraction (long a, long b) {
      numerator = a;
      denominator = Math.abs(b);
      if (b == 0)
         throw new RuntimeException("Сannot be divided by 0");
   }

   /** Public method to access the numerator field.
    * @return numerator
    */
   public long getNumerator() {
      return numerator;
   }

   /** Public method to access the denominator field.
    * @return denominator
    */
   public long getDenominator() {
      return denominator;
   }

   /** Conversion to string.
    * @return string representation of the fraction
    */
   @Override
   public String toString() {
      if (getDenominator()==1)
         return getNumerator()+"";
      else
         return getNumerator()+"/"+getDenominator();
   }

   /** Equality test.
    * @param m second fraction
    * @return true if fractions this and m are equal
    */
   @Override
   public boolean equals (Object m) {
      return compareTo((Lfraction)m) == 0;
   }

   /** Hashcode has to be equal for equal fractions.
    * @return hashcode
    */
   @Override
   public int hashCode() {
      return Objects.hash(getNumerator(), getDenominator());
   }

   /** Sum of fractions.
    * @param m second addend
    * @return this+m
    */
   public Lfraction plus (Lfraction m) {
      long a = getNumerator() * m.getDenominator() +
              getDenominator() * m.getNumerator();
      long b = getDenominator() * m.getDenominator();
      return new Lfraction(a, b);
   }

   /** Multiplication of fractions.
    * @param m second factor
    * @return this*m
    */



   public Lfraction times (Lfraction m) {
      long a = getNumerator() * m.getNumerator();
      long b = getDenominator() * m.getDenominator();
      long gcd = gcd(a, b);
      return new Lfraction((a / gcd),(b / gcd));
   }


   /** Inverse of the fraction. n/d becomes d/n.
    * @return inverse of this fraction: 1/this
    */
   public Lfraction inverse() {
      if (numerator < 0) {
         return new Lfraction(-denominator, -numerator);
      }
      return new Lfraction(denominator, numerator);
   }

   /** Opposite of the fraction. n/d becomes -n/d.
    * @return opposite of this fraction: -this
    */
   public Lfraction opposite() {
      return new Lfraction(-numerator, denominator);
   }

   /** Difference of fractions.
    * @param m subtrahend
    * @return this-m
    */
   public Lfraction minus (Lfraction m) {
      long a = getNumerator() * m.getDenominator() - getDenominator() * m.getNumerator();
      long b = getDenominator() * m.getDenominator();
      return new Lfraction(a, b);
   }

   /** Quotient of fractions.
    * @param m divisor
    * @return this/m
    */
   public Lfraction divideBy (Lfraction m) {
         long a = getNumerator() *  m.getDenominator() ;
         long b = getDenominator() * m.getNumerator();
         long gcd = gcd(a, b);
         return new Lfraction((a / gcd),(b / gcd));
   }

   /** Comparision of fractions.
    * @param m second fraction
    * @return -1 if this < m; 0 if this==m; 1 if this > m
    */
   @Override
   public int compareTo (Lfraction m) {
      if (minus(m).getNumerator() > 0)
         return 1;
      else if (minus(m).getNumerator() < 0)
         return -1;
      else
         return 0;
   }



   /** Clone of the fraction.
    * @return new fraction equal to this
    */
   @Override
   public Object clone()
           throws CloneNotSupportedException {
      return new Lfraction(getNumerator(), getDenominator());
   }

   /** Integer part of the (improper) fraction.
    * @return integer part of this fraction
    */
   public long integerPart() {
      return (int)toDouble();
   }

   /** Extract fraction part of the (improper) fraction
    * (a proper fraction without the integer part).
    * @return fraction part of this fraction
    */
   public Lfraction fractionPart() {
      int part = (int) (numerator / denominator);
      return new Lfraction(numerator - (part * denominator), denominator);
   }

   /** Approximate value of the fraction.
    * @return numeric value of this fraction
    */
   public double toDouble() {
      return numerator * 1.0 / denominator;
   }

   /** Double value f presented as a fraction with denominator d > 0.
    * @param f real number
    * @param d positive denominator for the result
    * @return f as an approximate fraction of form n/d
    */
   public static Lfraction toLfraction (double f, long d) {
      long nominator = Math.round(Math.round(f*10*d)/10);
      return new Lfraction(nominator, d);
   }

   /** Conversion from string to the fraction. Accepts strings of form
    * that is defined by the toString method.
    * @param s string form (as produced by toString) of the fraction
    * @return fraction represented by s
    */
   public static Lfraction valueOf (String s) {
      if (s.isEmpty())
         throw new RuntimeException("Input is empty");

      String[] numbers = s.split("/");

      if (numbers.length != 2)
         throw new RuntimeException("The entered word must contain exactly two numbers, the input contains: \"" + s + "\"");
      return new Lfraction(Long.parseLong(numbers[0]), Long.parseLong(numbers[1]));
   }
}