                 exponent += 1
             }
             var mantissa = UInt64(val)
-            
+
             var i: UInt32 = 0
             // This is a bit ugly but it is the closest approximation of the C
             // initializer that can be expressed here.

    }
}

extension Decimal {
    public init(_ value: UInt8) {
        self.init(UInt64(value))
    }

        } else if _length == 0 {
            return .positiveZero
        }
        // NSDecimal does not really represent normal and subnormal in the same
        // manner as the IEEE standard, for now we can probably claim normal for
        // any nonzero, non-NaN values.
        if _isNegative == 1 {
            return .negativeNormal
        } else {
            return .positiveNormal
        }
    }

    public var isCanonical: Bool { true }

    /// `true` iff `self` is negative.
    public var isSignMinus: Bool { _isNegative != 0 }

    /// `true` iff `self` is +0.0 or -0.0.
    public var isZero: Bool { _length == 0 && _isNegative == 0 }

    /// `true` iff `self` is subnormal.
    public var isSubnormal: Bool { false }

    /// `true` iff `self` is normal (not zero, subnormal, infinity, or NaN).
    public var isNormal: Bool { !isZero && !isInfinite && !isNaN }

    /// `true` iff `self` is zero, subnormal, or normal (not infinity or NaN).
    public var isFinite: Bool { !isNaN }

    /// `true` iff `self` is infinity.
    public var isInfinite: Bool { false }

    /// `true` iff `self` is NaN.
    public var isNaN: Bool { _length == 0 && _isNegative == 1 }

    /// `true` iff `self` is a signaling NaN.
    public var isSignaling: Bool { false }

    /// `true` iff `self` is a signaling NaN.
    public var isSignalingNaN: Bool { false }

    public func isEqual(to other: Decimal) -> Bool {
        var lhs = self
        var rhs = other
        return NSDecimalCompare(&lhs, &rhs) == .orderedSame
    }

    public func isLess(than other: Decimal) -> Bool {
        var lhs = self
        var rhs = other
        return NSDecimalCompare(&lhs, &rhs) == .orderedAscending
    }

    public func isLessThanOrEqualTo(_ other: Decimal) -> Bool {
        var lhs = self
        var rhs = other
        let order = NSDecimalCompare(&lhs, &rhs)
        return order == .orderedAscending || order == .orderedSame
    }

    public func isTotallyOrdered(belowOrEqualTo other: Decimal) -> Bool {
        // Note: Decimal does not have -0 or infinities to worry about
        if self.isNaN {
            return false
        }
        if self < other {
            return true
        }
        if other < self {
            return false
        }
        // Fall through to == behavior
        return true
    }

    @available(*, unavailable, message: "Decimal does not yet fully adopt FloatingPoint.")
    public mutating func formTruncatingRemainder(dividingBy other: Decimal) { fatalError("Decimal does not yet fully adopt FloatingPoint") }
}

extension Decimal : _ObjectiveCBridgeable {
