import std.string;
template Zero (T) {
  T zero () {
    return T.init;
  }
  T one () {
    return zero()+1;
  }
}
template Zero(T:float) {
  T zero() {
    return 0;
  }
  T one () {
    return zero()+1;
  }
}
template Zero(T:double) {
  T zero() {
    return 0;
  }
  T one () {
    return zero()+1;
  }
}
template Zero(T:real) {
  T zero() {
    return 0;
  }
  T one () {
    return zero()+1;
  }
}
struct BigRational(T, int rat) {
 private:
  T n;
  T d;
  static T int_gcd_recurse (T less, T more) {
    T zero = Zero!(T).zero();
    T amb = more%less;
    if (amb==zero) {
      return less;
    }
    return int_gcd_recurse(amb,less);
  }
  static T int_abs (T a) {
    T zero = Zero!(T).zero();
    return a<zero?-a:a;
  }
  static T int_gcd (T aa,  T bb) {
    T a = int_abs(aa);
    T b = int_abs(bb);
    return int_gcd_recurse(a<b?a:b,a<b?b:a);
  }
  BigRational InternalRationalize() {
    if (rat!=0)
      return Rationalize();
    return *this;
  }
 public:
  static BigRational opCall (BigRational r) {
    return BigRational(r.n,r.d);
  }
  static BigRational opCall (T nn, T dd) {
    BigRational r;
    r.n=nn;
    r.d=dd;
    return r;
  }
  static BigRational opCall () {
    BigRational r;
    return r;
  }
  BigRational Rationalize() {
    T k = int_gcd(n,d);
    n=n/k;
    d=d/k;
    return *this;
  }
  BigRational opNeg() {
    return BigRational(-n,d).InternalRationalize();
  }
  T IntegerPart() {
    return n/d;
  }
  BigRational Fraction() {
    return *this-BigRational(IntegerPart(),1);
  }
  T FractionalBits() {
    T zero = 0;
    assert(0);
    return zero;
  }
  BigRational opMulAssign(BigRational b) {
    n=n*b.n;
    d=d*b.d;
    InternalRationalize();
    return *this;
  }
  BigRational opMul(BigRational b) {
    return BigRational(n*b.n,d*b.d).InternalRationalize();
  }
  BigRational opAddAssign(BigRational b) {
    n=n*b.d+b.n*d;
    d=d*b.d;
    return InternalRationalize();
  }
  BigRational opAdd(BigRational b) {
    return BigRational(n*b.d+d*b.n,d*b.d).InternalRationalize();
  }
  BigRational opAdd(long b) {
    return *this+BigRational(b,1);
  }
  BigRational opSubAssign(BigRational b) {
    n=n*b.d-b.n*d;
    d=d*b.d;
    return InternalRationalize();
  }
  BigRational opSub(BigRational b) {
    return BigRational(n*b.d-d*b.n,d*b.d).InternalRationalize();
  }
  BigRational opSub_r(BigRational b) {
    return BigRational(d*b.n-n*b.d,d*b.d).InternalRationalize();
  }
  BigRational opDivAssign(BigRational b) {
    n=n*b.d;
    d=d*b.n;
    InternalRationalize();
    return *this;
  }
  BigRational opDiv(BigRational b) {
    return BigRational(n*b.d,d*b.n).InternalRationalize();
  }
  BigRational opDiv_r(BigRational b) {
    return BigRational(d*b.n,n*b.d).InternalRationalize();
  }
  BigRational opModAssign(BigRational b) {
    n = (n*b.d) % (b.n*d);
    d = b.d*d;
    InternalRationalize();
    return *this;
  }
  BigRational opMod(BigRational b) {
    return BigRational((n*b.d) % (b.n*d),b.d*d).InternalRationalize();
  }
  BigRational opMod_r(BigRational b) {
    return BigRational((b.n*d)%(n*b.d), b.d*d).InternalRationalize();
  }
  int opEqual (BigRational r) {
    return (n*r.d==d*r.n)?1:0;
  }
  int opCmp (BigRational rr) {    
    T thus = n*rr.d;
    T r  = rr.n*d;
    if (thus<r) return -1;
    if (thus>r) return 1;
    return 0;
  }
  BigRational print() {
    //printf ("%d/%d=",cast(int)n,cast(int)d);

    BigRational r=*this;
    r.Rationalize();
    char * num=std.string.toStringz(std.string.toString(r.n));
    char * den=std.string.toStringz(std.string.toString(r.d));
    printf ("%s/%s",num,den);
    //printf ("=%d/%d",cast(int)n,cast(int)d);
    return *this;
  }
}

alias BigRational!(long,0) Rational;