diff --git a/src/__init__.py b/src/__init__.py
index 7b488a05f7fdd02fa851c6e84825963db063179b..6fb21ae69a75fa569a7cae6236bbff85ad3b4ff3 100644
--- a/src/__init__.py
+++ b/src/__init__.py
@@ -22,5 +22,7 @@ if __name__ == "__main__":
     #print evaluate(ex, {"alpha":5, "cos":math.cos, "x":-math.pi, "pi":math.pi})
     #print is_constant(ex)
     #print substitute(ex, {"alpha": ex})
-    print differentiate(ex, "x")
+    ex2 = parse("cos(x**2/x)")
+    print ex2
+    print differentiate(ex2, "x")
 
diff --git a/src/mapper.py b/src/mapper.py
index 004cb6fa3009156d935f452ec912d43de79b46b0..d126fa049e4f79cdec28d8a7000c3458e59057c7 100644
--- a/src/mapper.py
+++ b/src/mapper.py
@@ -28,22 +28,22 @@ class CombineMapper(ByArityMapper):
         return expr.Child.invoke_mapper(self)
 
     def map_binary(self, expr):
-        return self.combine(expr.Child1.invoke_mapper(self),
-                            expr.Child2.invoke_mapper(self))
+        return self.combine((expr.Child1.invoke_mapper(self),
+                             expr.Child2.invoke_mapper(self)))
 
     def map_n_ary(self, expr):
         return self.combine(child.invoke_mapper(self)
                             for child in expr.Children)
 
     def map_polynomial(self, expr):
-        return self.combine([expr.Base.invoke_mapper(self)] 
-                            + [child.invoke_mapper(self)
-                               for child in expr.Children])
+        return self.combine((expr.Base.invoke_mapper(self)) 
+                            + (child.invoke_mapper(self)
+                               for child in expr.Children))
 
     def map_call(self, expr):
-        return self.combine([expr.Function.invoke_mapper(self)] 
-                            + [child.invoke_mapper(self)
-                               for child in expr.Parameters])
+        return self.combine((expr.Function.invoke_mapper(self))
+                            + (child.invoke_mapper(self)
+                               for child in expr.Parameters))
 
 
 
diff --git a/src/parser.py b/src/parser.py
index aa0bb6337be55d6f2aabf13ed059b625e1e8a7a2..60f8dfd189a8f9ce6cbc37311532ec3a033815ab 100644
--- a/src/parser.py
+++ b/src/parser.py
@@ -78,40 +78,47 @@ def parse(expr_str):
 
         left_exp = parse_terminal(pstate)
 
-        if pstate.is_at_end():
-            return left_exp
+        did_something = True
+        while did_something:
+            did_something = False
+            if pstate.is_at_end():
+                return left_exp
+            
+            next_tag = pstate.next_tag()
 
-        next_tag = pstate.next_tag()
-
-        if next_tag is _openpar and _PREC_CALL >= min_precedence:
-            pstate.advance()
-            pstate.expect_not_end()
-            if pstate.next_tag is _closepar:
+            if next_tag is _openpar and _PREC_CALL >= min_precedence:
+                pstate.advance()
+                pstate.expect_not_end()
+                if pstate.next_tag is _closepar:
+                    pstate.advance()
+                    left_exp = primitives.Call(left_exp, ())
+                else:
+                    left_exp = primitives.Call(left_exp, 
+                                             tuple(parse_expr_list(pstate)))
+                    pstate.expect(_closepar)
+                did_something = True
+            elif next_tag is _plus and _PREC_PLUS >= min_precedence:
+                pstate.advance()
+                left_exp = parse_expression(pstate, _PREC_PLUS)
+                did_something = True
+            elif next_tag is _minus and _PREC_PLUS >= min_precedence:
+                pstate.advance()
+                left_exp -= primitives.Negation(parse_expression(pstate, _PREC_PLUS))
+                did_something = True
+            elif next_tag is _times and _PREC_TIMES >= min_precedence:
+                pstate.advance()
+                left_exp *= parse_expression(pstate, _PREC_TIMES)
+                did_something = True
+            elif next_tag is _over and _PREC_TIMES >= min_precedence:
                 pstate.advance()
-                return primitives.Call(left_exp, ())
-            else:
-                result = primitives.Call(left_exp, 
-                                         tuple(parse_expr_list(pstate)))
-                pstate.expect(_closepar)
-                return result
+                left_exp /= parse_expression(pstate, _PREC_TIMES)
+                did_something = True
+            elif next_tag is _power and _PREC_POWER >= min_precedence:
+                pstate.advance()
+                left_exp **= parse_expression(pstate, _PREC_POWER)
+                did_something = True
 
-        if next_tag is _plus and _PREC_PLUS >= min_precedence:
-            pstate.advance()
-            return left_exp+parse_expression(pstate, _PREC_PLUS)
-        elif next_tag is _minus and _PREC_PLUS >= min_precedence:
-            pstate.advance()
-            return left_exp-primitives.Negation(parse_expression(pstate, _PREC_PLUS))
-        elif next_tag is _times and _PREC_TIMES >= min_precedence:
-            pstate.advance()
-            return left_exp*parse_expression(pstate, _PREC_TIMES)
-        elif next_tag is _over and _PREC_TIMES >= min_precedence:
-            pstate.advance()
-            return left_exp/parse_expression(pstate, _PREC_TIMES)
-        elif next_tag is _power and _PREC_POWER >= min_precedence:
-            pstate.advance()
-            return left_exp**parse_expression(pstate, _PREC_TIMES)
-        else:
-            return left_exp
+        return left_exp
 
         
     pstate = lex.LexIterator([(tag, s, idx)