     let (res, overflow3) = Rational.rationalWithOverflow(numer, denom)
     return (res, overflow1 || overflow2 || overflow3)
   }
-  
+
   /// Subtract `rhs` from `lhs` and return a tuple consisting of the result and a boolean which
   /// indicates whether there was an overflow.
   public static func subtractWithOverflow(_ lhs: Rational<T>, _ rhs: Rational<T>)

    let (denom, overflow2) = Rational.lcmWithOverflow(x.denominator, y.denominator)
    return (Rational(numer, denom), overflow1 || overflow2)
  }
  
  /// Returns the least common multiplier for the two given rational numbers and a boolean
  /// which indicates whether there was an overflow.
  public static func lcmWithOverflow(_ x: Rational<T>, _ y: Rational<T>) -> (Rational<T>, Bool) {

  
  /// Raises this rational value to the power of `exp`.
  public func toPower(of exp: T) -> Rational<T> {
    if (exp < 0) {
        return Rational(pow(denominator, -exp), pow(numerator, -exp))
    } else {
        return Rational(pow(numerator, exp), pow(denominator, exp))
    }
  }

  /// Returns the greatest common denominator for the two given rational numbers
  public static func gcd(_ x: Rational<T>, _ y: Rational<T>) -> Rational<T> {
    return Rational(Rational.gcd(x.numerator, y.numerator),
                    Rational.lcm(x.denominator, y.denominator))
  }

  /// Returns the least common multiplier for the two given rational numbers
  public static func lcm(_ x: Rational<T>, _ y: Rational<T>) -> Rational<T> {
    let (xn, yn, denom) = x.commonDenomWith(y)
