/* rcalc.cpp - Rational number calculator
Matt Mahoney, mmahoney@cs.fit.edu

This program accepts integer expressions from standard input and
prints the result as a rational number, e.g.

  rcalc                   (run the program)
  9/-6 + 1                (input)
  -1/2                    (output)
  3/(12-4)*4              (input)
  3/2                     (output)
                          (input blank line, program exits)

Expressions consist of integer numbers, parenthesis, and the operators
+ - * / on a single line.  Spaces are discarded.  * and / have higher
precedence than + and - unless overridden with parenthesis.  Unary - has
the highest precedence.  Operators of equal precedence are evaluated
left to right.  Division by 0 or invalid input will result in an error
message and resume input.  Valid input has the grammar:

  Expr ::= Term | Expr + Term | Expr - Term
  Term ::= Factor | Term * Factor | Term / Factor
  Factor ::= Unsigned | - Factor
  Unsigned ::= Number | ( Expr )

A Number is a string of 1 or more digits (0-9).

The output is a rational number of the form either a or a/b where a
and b are integers, b > 1, and gcd(a, b) = 1.
*/

#include <iostream>
#include <cctype>
#include <string>
using namespace std;

// Exceptions
class DivisionByZero {};
class SyntaxError {};

// A Rational number is the quotient of 2 integers
class Rational {
  int n, d;  // n/d such that d > 0 and gcd(n,d) is 1
  static int gcd(int, int);  // Greatest common divisor
public:
  Rational(int a=0, int b=1);    // a/b
  int num() const {return n;}    // numerator, no common factors with denom
  int denom() const {return d;}  // denominator, always > 0
};

// Initialize to a/b removing common factors
Rational::Rational(int a, int b) {
  if (b==0)
    throw DivisionByZero();
  if (b<0) {
    a=-a;
    b=-b;
  }
  int g=gcd(a, b);
  n=a/g;
  d=b/g;
}

// Greatest common divisor
int Rational::gcd(int a, int b) {
  if (b<0)
    return gcd(-a, -b);
  else if (a<0)
    return gcd(-a, b);
  else if (a>b)   // a, b >= 0
    return gcd(b, a);
  else if (a==0)
    return b;
  else
    return gcd(b%a, a); // b >= a > 0
}

// Rational arithmetic
Rational operator+(const Rational& a, const Rational& b) {
  return Rational(a.num()*b.denom()+a.denom()*b.num(), a.denom()*b.denom());
}

Rational operator-(const Rational& a, const Rational& b) {
  return Rational(a.num()*b.denom()-a.denom()*b.num(), a.denom()*b.denom());
}

Rational operator*(const Rational& a, const Rational& b) {
  return Rational(a.num()*b.num(), a.denom()*b.denom());
}

Rational operator/(const Rational& a, const Rational& b) {
  return Rational(a.num()*b.denom(), a.denom()*b.num());
}

Rational operator-(const Rational& a) {  // unary
  return Rational(-a.num(), a.denom());
}

// Rational comparison
bool operator<(const Rational& a, const Rational& b) {return (a-b).num()<0;}
bool operator>(const Rational& a, const Rational& b) {return b<a;}
bool operator<=(const Rational& a, const Rational& b) {return !(a>b);}
bool operator>=(const Rational& a, const Rational& b) {return !(a<b);}
bool operator!=(const Rational& a, const Rational& b) {return a<b || a>b;}
bool operator==(const Rational& a, const Rational& b) {return !(a!=b);}

ostream& operator << (ostream& out, const Rational& a) {
  if (a.denom()==1)
    out << a.num();
  else
    out << a.num() << "/" << a.denom();
  return out;
}

// Remove spaces from s
void trim(string& s) {
  string r;
  for (int i=0; i<int(s.size()); ++i)
    if (!isspace(s[i]))
      r+=s[i];
  s=r;
}

// true if s starts with c
bool peek(const string& s, char c) {
  return !s.empty() && s[0]==c;
}

// The getX functions below implement a recursive descent parser, where
// X is a symbol in the grammar above.

// Read c from s
void get(string& s, char c) {
  if (s=="" || s[0]!=c)
    throw SyntaxError();
  s=s.substr(1);
}

// Read a number from s
Rational getNumber(string& s) {
  if (s=="" || !isdigit(s[0]))
    throw SyntaxError();
  int i; // Find first nondigit
  for (i=1; i<int(s.size()) && isdigit(s[i]); ++i)
    ;
  Rational r=atoi(s.substr(0, i).c_str());
  s=s.substr(i);
  return r;
}

Rational getExpr(string& s);

// Read an unsigened number or parenthesized expression from s
Rational getUnsigned(string& s) {
  Rational r;
  if (s=="")
    throw SyntaxError();
  if (isdigit(s[0]))
    r=getNumber(s);
  else if (s[0]=='(') {
    get(s, '(');
    r=getExpr(s);
    get(s, ')');
  }
  else
    throw SyntaxError();
  return r;
}

// Read a factor, an unsigned with possible leading - such as -3 or -(1+2)
Rational getFactor(string& s) {
  if (peek(s, '-')) {
    get(s, '-');
    return -getFactor(s);
  }
  else
    return getUnsigned(s);
}

// Read a term, a product or quotient of factors such 3*4/5
Rational getTerm(string& s) {
  Rational r=getFactor(s);
  while (true) {
    if (peek(s, '*')) {
      get(s, '*');
      r=r*getFactor(s);
    }
    else if (peek(s, '/')) {
      get(s, '/');
      r=r/getFactor(s);
    }
    else
      break;
  }
  return r;
}

// Read an expression, a sum or difference of terms such as 5+6-7
Rational getExpr(string& s) {
  Rational r=getTerm(s);
  while (true) {
    if (peek(s, '+')) {
      get(s, '+');
      r=r+getTerm(s);
    }
    else if (peek(s, '-')) {
      get(s, '-');
      r=r-getTerm(s);
    }
    else
      break;
  }
  return r;
}

// Read, parse, and evaluate rational expressions
int main() {
  string s;
  while (getline(cin, s)) {
    try {
      trim(s);
      if (s=="")
        return 0;
      cout << getExpr(s) << endl;
      if (s!="")
        throw SyntaxError();
    }
    catch (SyntaxError x) {
      cout << "Syntax error at " << s << endl;
    }
    catch (DivisionByZero x) {
      cout << "Division by 0\n";
    }
  }
  return 0;
}