         }
         return comparison
     }
-    fileprivate subscript(index:UInt32) -> UInt16 {
-        get {
-            switch index {
-            case 0: return _mantissa.0
-            case 1: return _mantissa.1
-            case 2: return _mantissa.2
-            case 3: return _mantissa.3
-            case 4: return _mantissa.4
-            case 5: return _mantissa.5
-            case 6: return _mantissa.6
-            case 7: return _mantissa.7
-            default: fatalError("Invalid index \(index) for _mantissa")
-            }
-        }
-        set {
-            switch index {
-            case 0: _mantissa.0 = newValue
-            case 1: _mantissa.1 = newValue
-            case 2: _mantissa.2 = newValue
-            case 3: _mantissa.3 = newValue
-            case 4: _mantissa.4 = newValue
-            case 5: _mantissa.5 = newValue
-            case 6: _mantissa.6 = newValue
-            case 7: _mantissa.7 = newValue
-            default: fatalError("Invalid index \(index) for _mantissa")
-            }
-        }
-    }
+
     fileprivate mutating func setNaN() {
         _length = 0
         _isNegative = 1

        return _isNegative != 0 ? -d : d
    }

    // Return the low 64bits of the integer part
    private var _unsignedInt64Value: UInt64 {
        if _exponent < -20 || _exponent > 20 {
            return 0
        }

        if _length == 0 || isZero || magnitude < Decimal(0) {
            return 0
        }


        return uint64
    }

    // A best-effort conversion of the integer value, trying to match Darwin for
    // values outside of UInt64.min...UInt64.max. (Used by NSDecimalNumber.)
    internal var uint64Value: UInt64 {
        let value = _unsignedInt64Value
        if !self.isNegative {
            return value
        }
        if value == Int64.max.magnitude + 1 {
            return UInt64(bitPattern: Int64.min)
        }
        if value <= Int64.max.magnitude {
            var value = Int64(value)
            value.negate()
            return UInt64(bitPattern: value)
        }
        return value
    }

    // A best-effort conversion of the integer value, trying to match Darwin for
    // values outside of Int64.min...Int64.max. (Used by NSDecimalNumber.)
    internal var int64Value: Int64 {
        let uint64Value = _unsignedInt64Value
        if self.isNegative {
            if uint64Value == Int64.max.magnitude + 1 {
                return Int64.min
            }
            if uint64Value <= Int64.max.magnitude {
                var value = Int64(uint64Value)
                value.negate()
                return value
