 extension SFloat: CustomStringConvertible {
     
     public var description: String {
-        
-        return Float(self).description
+        #if swift(>=5.3) && !os(macOS) && !(os(iOS) && targetEnvironment(macCatalyst))
+        if #available(iOS 14.0, watchOS 7.0, tvOS 14.0, *) {
+            return Float16(self).description
+        } else {
+            return _description
+        }
+        #else
+        return _description
+        #endif
     }
-}
-
-// MARK: - ExpressibleByIntegerLiteral
-
-extension SFloat: ExpressibleByIntegerLiteral {
     
-    public init(integerLiteral value: Float) {
-        
-        self.init(value)
+    private var _description: String {
+        return toFloat().description
     }
 }
 


import Foundation

/// IEEE-11073 16-bit SFLOAT
public struct SFloat {
    
    internal private(set) var builtin: UInt16
    
    internal init(builtin: UInt16) {
        
        self.builtin = builtin
    }
    
    /// Creates a value initialized to zero.
    public init() {
        
        fatalError()
    }
    
    public init(_ value: Float) {
        
        fatalError()
    }
}

public extension Float {
    
    init(_ value: SFloat) {
        
        fatalError()
    }
}

// MARK: - Equatable

extension SFloat: Equatable {
    
    public static func == (lhs: SFloat, rhs: SFloat) -> Bool {
        
        return lhs.builtin == rhs.builtin
    }
}

// MARK: - Hashable

extension SFloat: Hashable {
    
    public func hash(into hasher: inout Hasher) {
        builtin.hash(into: &hasher)
    }
}


    
    /// A representation of this float with the byte order swapped.
    public var byteSwapped: SFloat {
        return SFloat(bitPattern: bitPattern.byteSwapped)
    }
}
