             }
             var mantissa = UInt64(val)
 
-            var i = Int32(0)
-            // this is a bit ugly but it is the closest approximation of the C initializer that can be expressed here.
+            var i: Int32 = 0
+            // This is a bit ugly but it is the closest approximation of the C
+            // initializer that can be expressed here.
             while mantissa != 0 && i < NSDecimalMaxSize {
                 switch i {
                 case 0:
-                    _mantissa.0 = UInt16(truncatingIfNeeded:mantissa)
+                    _mantissa.0 = UInt16(truncatingIfNeeded: mantissa)
                 case 1:
-                    _mantissa.1 = UInt16(truncatingIfNeeded:mantissa)
+                    _mantissa.1 = UInt16(truncatingIfNeeded: mantissa)
                 case 2:
-                    _mantissa.2 = UInt16(truncatingIfNeeded:mantissa)
+                    _mantissa.2 = UInt16(truncatingIfNeeded: mantissa)
                 case 3:
-                    _mantissa.3 = UInt16(truncatingIfNeeded:mantissa)
+                    _mantissa.3 = UInt16(truncatingIfNeeded: mantissa)
                 case 4:
-                    _mantissa.4 = UInt16(truncatingIfNeeded:mantissa)
+                    _mantissa.4 = UInt16(truncatingIfNeeded: mantissa)
                 case 5:
-                    _mantissa.5 = UInt16(truncatingIfNeeded:mantissa)
+                    _mantissa.5 = UInt16(truncatingIfNeeded: mantissa)
                 case 6:
-                    _mantissa.6 = UInt16(truncatingIfNeeded:mantissa)
+                    _mantissa.6 = UInt16(truncatingIfNeeded: mantissa)
                 case 7:
-                    _mantissa.7 = UInt16(truncatingIfNeeded:mantissa)
+                    _mantissa.7 = UInt16(truncatingIfNeeded: mantissa)
                 default:
                     fatalError("initialization overflow")
                 }

    }

    public static var quietNaN: Decimal {
        var quiet = Decimal()
        quiet._isNegative = 1
        return quiet
    }
    public var floatingPointClass: FloatingPointClassification {
        if _length == 0 && _isNegative == 1 {
            return .quietNaN

    }
}

// The methods in this extension exist to match the protocol requirements of
// FloatingPoint, even if we can't conform directly.
//
// If it becomes clear that conformance is truly impossible, we can deprecate
// some of the methods (e.g. `isEqual(to:)` in favor of operators).
extension Decimal {
    public init(_ value: UInt8) {
        self.init(UInt64(value))
    }

    public init(_ value: Int8) {
        self.init(Int64(value))
    }

    public init(_ value: UInt16) {
        self.init(UInt64(value))
    }

    public init(_ value: Int16) {
        self.init(Int64(value))
    }

    public init(_ value: UInt32) {
        self.init(UInt64(value))
    }

    public init(_ value: Int32) {
        self.init(Int64(value))
    }

    public init(_ value: Double) {
        precondition(!value.isInfinite, "Decimal does not yet fully adopt FloatingPoint")
        if value.isNaN {
