 
 
     internal static func +(lhs: Swift.Int, rhs: Swift.Double) -> Swift.Int {
-        return Swift.Int(lhs.doubleValue + rhs)
+        return Swift.Int(Swift.Double(lhs) + rhs)
     }
 
     internal static func -(lhs: Swift.Int, rhs: Swift.Double) -> Swift.Int {
-        return Swift.Int(lhs.doubleValue - rhs)
+        return Swift.Int(Swift.Double(lhs) - rhs)
     }
 
     internal static func *(lhs: Swift.Int, rhs: Swift.Double) -> Swift.Int {
-        return Swift.Int(lhs.doubleValue * rhs)
+        return Swift.Int(Swift.Double(lhs) * rhs)
     }
 
     internal static func /(lhs: Swift.Int, rhs: Swift.Double) -> Swift.Int {
-        return Swift.Int(lhs.doubleValue / rhs)
+        return Swift.Int(Swift.Double(lhs) / rhs)
     }
 
 
     internal static func +(lhs: Swift.Double, rhs: Swift.Int) -> Swift.Int {
-        return Swift.Int(lhs + rhs.doubleValue)
+        return Swift.Int(lhs + Swift.Double(rhs))
     }
 
     internal static func -(lhs: Swift.Double, rhs: Swift.Int) -> Swift.Int {
-        return Swift.Int(lhs - rhs.doubleValue)
+        return Swift.Int(lhs - Swift.Double(rhs))
     }
 
     internal static func *(lhs: Swift.Double, rhs: Swift.Int) -> Swift.Int {
-        return Swift.Int(lhs * rhs.doubleValue)
+        return Swift.Int(lhs * Swift.Double(rhs))
     }
 
     internal static func /(lhs: Swift.Double, rhs: Swift.Int) -> Swift.Int {
-        return Swift.Int(lhs / rhs.doubleValue)
+        return Swift.Int(lhs / Swift.Double(rhs))
     }
 
 }



    internal static func +(lhs: Swift.Float, rhs: Swift.Double) -> Swift.Float {
        return Swift.Float(lhs.doubleValue + rhs)
    }

    internal static func -(lhs: Swift.Float, rhs: Swift.Double) -> Swift.Float {
        return Swift.Float(lhs.doubleValue - rhs)
    }

    internal static func *(lhs: Swift.Float, rhs: Swift.Double) -> Swift.Float {
        return Swift.Float(lhs.doubleValue * rhs)
    }

    internal static func /(lhs: Swift.Float, rhs: Swift.Double) -> Swift.Float {
        return Swift.Float(lhs.doubleValue / rhs)
    }


    internal static func +(lhs: Swift.Double, rhs: Swift.Float) -> Swift.Float {
        return Swift.Float(lhs + rhs.doubleValue)
    }

    internal static func -(lhs: Swift.Double, rhs: Swift.Float) -> Swift.Float {
        return Swift.Float(lhs - rhs.doubleValue)
    }

    internal static func *(lhs: Swift.Double, rhs: Swift.Float) -> Swift.Float {
        return Swift.Float(lhs * rhs.doubleValue)
    }

    internal static func /(lhs: Swift.Double, rhs: Swift.Float) -> Swift.Float {
        return Swift.Float(lhs / rhs.doubleValue)
    }

}



    internal static func +(lhs: Swift.UInt, rhs: Swift.Double) -> Swift.UInt {
        let value = Swift.Double(lhs) + rhs
        return value < 0.0 ? 0 : Swift.UInt(value)
    }

    internal static func -(lhs: Swift.UInt, rhs: Swift.Double) -> Swift.UInt {
        let value = Swift.Double(lhs) - rhs
        return value < 0.0 ? 0 : Swift.UInt(value)
    }

    internal static func *(lhs: Swift.UInt, rhs: Swift.Double) -> Swift.UInt {
        let value = Swift.Double(lhs) * rhs
        return value < 0.0 ? 0 : Swift.UInt(value)
    }

    internal static func /(lhs: Swift.UInt, rhs: Swift.Double) -> Swift.UInt {
        let value = Swift.Double(lhs) / rhs
        return value < 0.0 ? 0 : Swift.UInt(value)
    }


    internal static func +(lhs: Swift.Double, rhs: Swift.UInt) -> Swift.UInt {
        let value = lhs + Swift.Double(rhs)
        return value < 0.0 ? 0 : Swift.UInt(value)
    }

    internal static func -(lhs: Swift.Double, rhs: Swift.UInt) -> Swift.UInt {
        let value = lhs - Swift.Double(rhs)
        return value < 0.0 ? 0 : Swift.UInt(value)
    }

    internal static func *(lhs: Swift.Double, rhs: Swift.UInt) -> Swift.UInt {
        let value = lhs * Swift.Double(rhs)
        return value < 0.0 ? 0 : Swift.UInt(value)
    }

    internal static func /(lhs: Swift.Double, rhs: Swift.UInt) -> Swift.UInt {
        let value = lhs / Swift.Double(rhs)
        return value < 0.0 ? 0 : Swift.UInt(value)
    }

