// swift-interface-format-version: 1.0
// swift-compiler-version: Apple Swift version 5.7.1 (swiftlang-5.7.1.134.4 clang-1400.0.29.51)
// swift-module-flags: -target x86_64-apple-macosx13.1 -enable-objc-interop -autolink-force-load -enable-library-evolution -module-link-name swiftDarwin -swift-version 5 -O -enforce-exclusivity=unchecked -disable-objc-attr-requires-foundation-module -module-name Darwin
// swift-module-flags-ignorable: -enable-lexical-lifetimes=false -target-min-inlining-version min -user-module-version 5.7.1.134.4
@_exported import Darwin
import Swift
import SwiftOverlayShims
import SwiftShims
public var noErr: Darwin.OSStatus {
  get
}
@frozen public struct DarwinBoolean : Swift.ExpressibleByBooleanLiteral {
  @usableFromInline
  internal var _value: Swift.UInt8
  @_transparent public init(_ value: Swift.Bool) {
    self._value = value ? 1 : 0
  }
  @_transparent public var boolValue: Swift.Bool {
    @_transparent get {
    return _value != 0
  }
  }
  @_transparent public init(booleanLiteral value: Swift.Bool) {
    self.init(value)
  }
  public typealias BooleanLiteralType = Swift.Bool
}
extension Darwin.DarwinBoolean : Swift.CustomReflectable {
  public var customMirror: Swift.Mirror {
    get
  }
}
extension Darwin.DarwinBoolean : Swift.CustomStringConvertible {
  public var description: Swift.String {
    get
  }
}
extension Darwin.DarwinBoolean : Swift.Equatable {
  @_transparent public static func == (lhs: Darwin.DarwinBoolean, rhs: Darwin.DarwinBoolean) -> Swift.Bool {
    return lhs.boolValue == rhs.boolValue
  }
}
@_transparent public func _convertBoolToDarwinBoolean(_ x: Swift.Bool) -> Darwin.DarwinBoolean {
  return DarwinBoolean(x)
}
@_transparent public func _convertDarwinBooleanToBool(_ x: Darwin.DarwinBoolean) -> Swift.Bool {
  return x.boolValue
}
public var errno: Swift.Int32 {
  get
  set(val)
}
public var stdin: Swift.UnsafeMutablePointer<Darwin.FILE> {
  get
  set
}
public var stdout: Swift.UnsafeMutablePointer<Darwin.FILE> {
  get
  set
}
public var stderr: Swift.UnsafeMutablePointer<Darwin.FILE> {
  get
  set
}
public func dprintf(_ fd: Swift.Int, _ format: Swift.UnsafePointer<Swift.Int8>, _ args: Swift.CVarArg...) -> Swift.Int32
public func snprintf(ptr: Swift.UnsafeMutablePointer<Swift.Int8>, _ len: Swift.Int, _ format: Swift.UnsafePointer<Swift.Int8>, _ args: Swift.CVarArg...) -> Swift.Int32
public func open(_ path: Swift.UnsafePointer<Swift.CChar>, _ oflag: Swift.Int32) -> Swift.Int32
public func open(_ path: Swift.UnsafePointer<Swift.CChar>, _ oflag: Swift.Int32, _ mode: Darwin.mode_t) -> Swift.Int32
public func openat(_ fd: Swift.Int32, _ path: Swift.UnsafePointer<Swift.CChar>, _ oflag: Swift.Int32) -> Swift.Int32
public func openat(_ fd: Swift.Int32, _ path: Swift.UnsafePointer<Swift.CChar>, _ oflag: Swift.Int32, _ mode: Darwin.mode_t) -> Swift.Int32
public func fcntl(_ fd: Swift.Int32, _ cmd: Swift.Int32) -> Swift.Int32
public func fcntl(_ fd: Swift.Int32, _ cmd: Swift.Int32, _ value: Swift.Int32) -> Swift.Int32
public func fcntl(_ fd: Swift.Int32, _ cmd: Swift.Int32, _ ptr: Swift.UnsafeMutableRawPointer) -> Swift.Int32
public var S_IFMT: Darwin.mode_t {
  get
}
public var S_IFIFO: Darwin.mode_t {
  get
}
public var S_IFCHR: Darwin.mode_t {
  get
}
public var S_IFDIR: Darwin.mode_t {
  get
}
public var S_IFBLK: Darwin.mode_t {
  get
}
public var S_IFREG: Darwin.mode_t {
  get
}
public var S_IFLNK: Darwin.mode_t {
  get
}
public var S_IFSOCK: Darwin.mode_t {
  get
}
public var S_IFWHT: Darwin.mode_t {
  get
}
public var S_IRWXU: Darwin.mode_t {
  get
}
public var S_IRUSR: Darwin.mode_t {
  get
}
public var S_IWUSR: Darwin.mode_t {
  get
}
public var S_IXUSR: Darwin.mode_t {
  get
}
public var S_IRWXG: Darwin.mode_t {
  get
}
public var S_IRGRP: Darwin.mode_t {
  get
}
public var S_IWGRP: Darwin.mode_t {
  get
}
public var S_IXGRP: Darwin.mode_t {
  get
}
public var S_IRWXO: Darwin.mode_t {
  get
}
public var S_IROTH: Darwin.mode_t {
  get
}
public var S_IWOTH: Darwin.mode_t {
  get
}
public var S_IXOTH: Darwin.mode_t {
  get
}
public var S_ISUID: Darwin.mode_t {
  get
}
public var S_ISGID: Darwin.mode_t {
  get
}
public var S_ISVTX: Darwin.mode_t {
  get
}
public var S_ISTXT: Darwin.mode_t {
  get
}
public var S_IREAD: Darwin.mode_t {
  get
}
public var S_IWRITE: Darwin.mode_t {
  get
}
public var S_IEXEC: Darwin.mode_t {
  get
}
public func ioctl(_ fd: Swift.CInt, _ request: Swift.UInt, _ value: Swift.CInt) -> Swift.CInt
public func ioctl(_ fd: Swift.CInt, _ request: Swift.UInt, _ ptr: Swift.UnsafeMutableRawPointer) -> Swift.CInt
public func ioctl(_ fd: Swift.CInt, _ request: Swift.UInt) -> Swift.CInt
@available(*, unavailable, message: "Please use threads or posix_spawn*()")
public func fork() -> Swift.Int32
@available(*, unavailable, message: "Please use threads or posix_spawn*()")
public func vfork() -> Swift.Int32
public var SIG_DFL: Darwin.sig_t? {
  get
}
public var SIG_IGN: Darwin.sig_t {
  get
}
public var SIG_ERR: Darwin.sig_t {
  get
}
public var SIG_HOLD: Darwin.sig_t {
  get
}
public typealias Semaphore = Swift.UnsafeMutablePointer<Darwin.sem_t>
public var SEM_FAILED: Darwin.Semaphore? {
  get
}
public func sem_open(_ name: Swift.UnsafePointer<Swift.CChar>, _ oflag: Swift.Int32) -> Darwin.Semaphore?
public func sem_open(_ name: Swift.UnsafePointer<Swift.CChar>, _ oflag: Swift.Int32, _ mode: Darwin.mode_t, _ value: Swift.CUnsignedInt) -> Darwin.Semaphore?
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
extension Darwin.timespec {
  @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
  public init(_ duration: Swift.Duration)
}
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
extension Swift.Duration {
  @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
  public init(_ ts: Darwin.timespec)
}
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
extension Darwin.timeval {
  @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
  public init(_ duration: Swift.Duration)
}
@available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
extension Swift.Duration {
  @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
  public init(_ tv: Darwin.timeval)
}
public var environ: Swift.UnsafeMutablePointer<Swift.UnsafeMutablePointer<Swift.CChar>?> {
  get
}
public var TIOCEXCL: Swift.UInt {
  get
}
public var TIOCNXCL: Swift.UInt {
  get
}
public var TIOCFLUSH: Swift.UInt {
  get
}
public var TIOCGETD: Swift.UInt {
  get
}
public var TIOCSETD: Swift.UInt {
  get
}
public var TIOCSBRK: Swift.UInt {
  get
}
public var TIOCCBRK: Swift.UInt {
  get
}
public var TIOCSDTR: Swift.UInt {
  get
}
public var TIOCCDTR: Swift.UInt {
  get
}
public var TIOCGPGRP: Swift.UInt {
  get
}
public var TIOCSPGRP: Swift.UInt {
  get
}
public var TIOCOUTQ: Swift.UInt {
  get
}
public var TIOCSTI: Swift.UInt {
  get
}
public var TIOCNOTTY: Swift.UInt {
  get
}
public var TIOCPKT: Swift.UInt {
  get
}
public var TIOCSTOP: Swift.UInt {
  get
}
public var TIOCSTART: Swift.UInt {
  get
}
public var TIOCMSET: Swift.UInt {
  get
}
public var TIOCMBIS: Swift.UInt {
  get
}
public var TIOCMBIC: Swift.UInt {
  get
}
public var TIOCMGET: Swift.UInt {
  get
}
public var TIOCGWINSZ: Swift.UInt {
  get
}
public var TIOCSWINSZ: Swift.UInt {
  get
}
public var TIOCUCNTL: Swift.UInt {
  get
}
public var TIOCSTAT: Swift.UInt {
  get
}
public var TIOCCONS: Swift.UInt {
  get
}
public var TIOCSCTTY: Swift.UInt {
  get
}
public var TIOCEXT: Swift.UInt {
  get
}
public var TIOCDRAIN: Swift.UInt {
  get
}
public var TIOCMSDTRWAIT: Swift.UInt {
  get
}
public var TIOCMGDTRWAIT: Swift.UInt {
  get
}
public var TIOCTIMESTAMP: Swift.UInt {
  get
}
public var TIOCSDRAINWAIT: Swift.UInt {
  get
}
public var TIOCGDRAINWAIT: Swift.UInt {
  get
}
public var TIOCHPCL: Swift.UInt {
  get
}
public var TIOCGETP: Swift.UInt {
  get
}
public var TIOCSETP: Swift.UInt {
  get
}
public var TIOCSETN: Swift.UInt {
  get
}
public var TIOCSETC: Swift.UInt {
  get
}
public var TIOCGETC: Swift.UInt {
  get
}
public var TIOCLBIS: Swift.UInt {
  get
}
public var TIOCLBIC: Swift.UInt {
  get
}
public var TIOCLSET: Swift.UInt {
  get
}
public var TIOCLGET: Swift.UInt {
  get
}
public var TIOCSLTC: Swift.UInt {
  get
}
public var TIOCGLTC: Swift.UInt {
  get
}
public var TIOCGETA: Swift.UInt {
  get
}
public var TIOCSETA: Swift.UInt {
  get
}
public var TIOCSETAW: Swift.UInt {
  get
}
public var TIOCSETAF: Swift.UInt {
  get
}
public var TIOCSIG: Swift.UInt {
  get
}
public var TIOCMODG: Swift.UInt {
  get
}
public var TIOCMODS: Swift.UInt {
  get
}
public var TIOCIXON: Swift.UInt {
  get
}
public var TIOCIXOFF: Swift.UInt {
  get
}
public var TIOCREMOTE: Swift.UInt {
  get
}
public var TIOCSCONS: Swift.UInt {
  get
}
public var TIOCDCDTIMESTAMP: Swift.UInt {
  get
}
public var TIOCDSIMICROCODE: Swift.UInt {
  get
}
public var TIOCPTYGRANT: Swift.UInt {
  get
}
public var TIOCPTYGNAME: Swift.UInt {
  get
}
public var TIOCPTYUNLK: Swift.UInt {
  get
}
@objc public enum POSIXErrorCode : Swift.Int32 {
  case EPERM = 1
  case ENOENT = 2
  case ESRCH = 3
  case EINTR = 4
  case EIO = 5
  case ENXIO = 6
  case E2BIG = 7
  case ENOEXEC = 8
  case EBADF = 9
  case ECHILD = 10
  case EDEADLK = 11
  case ENOMEM = 12
  case EACCES = 13
  case EFAULT = 14
  case ENOTBLK = 15
  case EBUSY = 16
  case EEXIST = 17
  case EXDEV = 18
  case ENODEV = 19
  case ENOTDIR = 20
  case EISDIR = 21
  case EINVAL = 22
  case ENFILE = 23
  case EMFILE = 24
  case ENOTTY = 25
  case ETXTBSY = 26
  case EFBIG = 27
  case ENOSPC = 28
  case ESPIPE = 29
  case EROFS = 30
  case EMLINK = 31
  case EPIPE = 32
  case EDOM = 33
  case ERANGE = 34
  case EAGAIN = 35
  public static var EWOULDBLOCK: Darwin.POSIXErrorCode {
    get
  }
  case EINPROGRESS = 36
  case EALREADY = 37
  case ENOTSOCK = 38
  case EDESTADDRREQ = 39
  case EMSGSIZE = 40
  case EPROTOTYPE = 41
  case ENOPROTOOPT = 42
  case EPROTONOSUPPORT = 43
  case ESOCKTNOSUPPORT = 44
  case ENOTSUP = 45
  case EPFNOSUPPORT = 46
  case EAFNOSUPPORT = 47
  case EADDRINUSE = 48
  case EADDRNOTAVAIL = 49
  case ENETDOWN = 50
  case ENETUNREACH = 51
  case ENETRESET = 52
  case ECONNABORTED = 53
  case ECONNRESET = 54
  case ENOBUFS = 55
  case EISCONN = 56
  case ENOTCONN = 57
  case ESHUTDOWN = 58
  case ETOOMANYREFS = 59
  case ETIMEDOUT = 60
  case ECONNREFUSED = 61
  case ELOOP = 62
  case ENAMETOOLONG = 63
  case EHOSTDOWN = 64
  case EHOSTUNREACH = 65
  case ENOTEMPTY = 66
  case EPROCLIM = 67
  case EUSERS = 68
  case EDQUOT = 69
  case ESTALE = 70
  case EREMOTE = 71
  case EBADRPC = 72
  case ERPCMISMATCH = 73
  case EPROGUNAVAIL = 74
  case EPROGMISMATCH = 75
  case EPROCUNAVAIL = 76
  case ENOLCK = 77
  case ENOSYS = 78
  case EFTYPE = 79
  case EAUTH = 80
  case ENEEDAUTH = 81
  case EPWROFF = 82
  case EDEVERR = 83
  case EOVERFLOW = 84
  case EBADEXEC = 85
  case EBADARCH = 86
  case ESHLIBVERS = 87
  case EBADMACHO = 88
  case ECANCELED = 89
  case EIDRM = 90
  case ENOMSG = 91
  case EILSEQ = 92
  case ENOATTR = 93
  case EBADMSG = 94
  case EMULTIHOP = 95
  case ENODATA = 96
  case ENOLINK = 97
  case ENOSR = 98
  case ENOSTR = 99
  case EPROTO = 100
  case ETIME = 101
  case ENOPOLICY = 103
  case ENOTRECOVERABLE = 104
  case EOWNERDEAD = 105
  case EQFULL = 106
  public static var ELAST: Darwin.POSIXErrorCode {
    get
  }
  public init?(rawValue: Swift.Int32)
  public typealias RawValue = Swift.Int32
  public var rawValue: Swift.Int32 {
    get
  }
}
@objc public enum MachErrorCode : Swift.Int32 {
  case success = 0
  case invalidAddress = 1
  case protectionFailure = 2
  case noSpace = 3
  case invalidArgument = 4
  case failure = 5
  case resourceShortage = 6
  case notReceiver = 7
  case noAccess = 8
  case memoryFailure = 9
  case memoryError = 10
  case alreadyInSet = 11
  case notInSet = 12
  case nameExists = 13
  case aborted = 14
  case invalidName = 15
  case invalidTask = 16
  case invalidRight = 17
  case invalidValue = 18
  case userReferencesOverflow = 19
  case invalidCapability = 20
  case rightExists = 21
  case invalidHost = 22
  case memoryPresent = 23
  case memoryDataMoved = 24
  case memoryRestartCopy = 25
  case invalidProcessorSet = 26
  case policyLimit = 27
  case invalidPolicy = 28
  case invalidObject = 29
  case alreadyWaiting = 30
  case defaultSet = 31
  case exceptionProtected = 32
  case invalidLedger = 33
  case invalidMemoryControl = 34
  case invalidSecurity = 35
  case notDepressed = 36
  case terminated = 37
  case lockSetDestroyed = 38
  case lockUnstable = 39
  case lockOwned = 40
  case lockOwnedSelf = 41
  case semaphoreDestroyed = 42
  case rpcServerTerminated = 43
  case rpcTerminateOrphan = 44
  case rpcContinueOrphan = 45
  case notSupported = 46
  case nodeDown = 47
  case notWaiting = 48
  case operationTimedOut = 49
  case codesignError = 50
  case policyStatic = 51
  public init?(rawValue: Swift.Int32)
  public typealias RawValue = Swift.Int32
  public var rawValue: Swift.Int32 {
    get
  }
}
@available(swift, deprecated: 4.2, renamed: "abs")
@_transparent public func fabs<T>(_ x: T) -> T where T : Swift.FloatingPoint {
  return x.magnitude
}
@_transparent public func sqrt<T>(_ x: T) -> T where T : Swift.FloatingPoint {
  return x.squareRoot()
}
@_transparent public func fma<T>(_ x: T, _ y: T, _ z: T) -> T where T : Swift.FloatingPoint {
  return z.addingProduct(x, y)
}
@_transparent public func remainder<T>(_ x: T, _ y: T) -> T where T : Swift.FloatingPoint {
  return x.remainder(dividingBy: y)
}
@_transparent public func fmod<T>(_ x: T, _ y: T) -> T where T : Swift.FloatingPoint {
  return x.truncatingRemainder(dividingBy: y)
}
@_transparent public func ceil<T>(_ x: T) -> T where T : Swift.FloatingPoint {
  return x.rounded(.up)
}
@_transparent public func floor<T>(_ x: T) -> T where T : Swift.FloatingPoint {
  return x.rounded(.down)
}
@_transparent public func round<T>(_ x: T) -> T where T : Swift.FloatingPoint {
  return x.rounded()
}
@_transparent public func trunc<T>(_ x: T) -> T where T : Swift.FloatingPoint {
  return x.rounded(.towardZero)
}
@_transparent public func scalbn<T>(_ x: T, _ n: Swift.Int) -> T where T : Swift.FloatingPoint {
  return T(sign: .plus, exponent: T.Exponent(n), significand: x)
}
@_transparent public func modf<T>(_ x: T) -> (T, T) where T : Swift.FloatingPoint {
  // inf/NaN: return canonicalized x, fractional part zero.
  guard x.isFinite else { return (x+0, 0) }
  let integral = trunc(x)
  let fractional = x - integral
  return (integral, fractional)
}
@_transparent public func frexp<T>(_ x: T) -> (T, Swift.Int) where T : Swift.BinaryFloatingPoint {
  guard x.isFinite else { return (x+0, 0) }
  guard x != 0 else { return (x, 0) }
  // The C stdlib `frexp` uses a different notion of significand / exponent
  // than IEEE 754, so we need to adjust them by a factor of two.
  return (x.significand / 2, Int(x.exponent + 1))
}
@available(swift, deprecated: 4.2, renamed: "scalbn")
@_transparent public func ldexp(_ x: Swift.Float, _ n: Swift.Int) -> Swift.Float {
  return Float(sign: .plus, exponent: n, significand: x)
}
@available(swift, deprecated: 4.2, renamed: "scalbn")
@_transparent public func ldexp(_ x: Swift.Double, _ n: Swift.Int) -> Swift.Double {
  return Double(sign: .plus, exponent: n, significand: x)
}
@available(*, unavailable, message: "use the floatingPointClass property.")
public func fpclassify<T>(_ value: T) -> Swift.Int where T : Swift.FloatingPoint
@available(*, unavailable, message: "use the isNormal property.")
public func isnormal<T>(_ value: T) -> Swift.Bool where T : Swift.FloatingPoint
@available(*, unavailable, message: "use the isFinite property.")
public func isfinite<T>(_ value: T) -> Swift.Bool where T : Swift.FloatingPoint
@available(*, unavailable, message: "use the isInfinite property.")
public func isinf<T>(_ value: T) -> Swift.Bool where T : Swift.FloatingPoint
@available(*, unavailable, message: "use the isNaN property.")
public func isnan<T>(_ value: T) -> Swift.Bool where T : Swift.FloatingPoint
@available(*, unavailable, message: "use the sign property.")
public func signbit<T>(_ value: T) -> Swift.Int where T : Swift.FloatingPoint
@available(swift, deprecated: 4.2, message: "use the exponent property.")
public func ilogb<T>(_ x: T) -> Swift.Int where T : Swift.BinaryFloatingPoint
@_transparent public func acos(_ x: Swift.Float) -> Swift.Float {
  return Float(acosf(CFloat(x)))
}
@_transparent public func acos(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(acosl(CLongDouble(x)))
}
@_transparent public func asin(_ x: Swift.Float) -> Swift.Float {
  return Float(asinf(CFloat(x)))
}
@_transparent public func asin(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(asinl(CLongDouble(x)))
}
@_transparent public func atan(_ x: Swift.Float) -> Swift.Float {
  return Float(atanf(CFloat(x)))
}
@_transparent public func atan(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(atanl(CLongDouble(x)))
}
@_transparent public func tan(_ x: Swift.Float) -> Swift.Float {
  return Float(tanf(CFloat(x)))
}
@_transparent public func tan(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(tanl(CLongDouble(x)))
}
@_transparent public func acosh(_ x: Swift.Float) -> Swift.Float {
  return Float(acoshf(CFloat(x)))
}
@_transparent public func acosh(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(acoshl(CLongDouble(x)))
}
@_transparent public func asinh(_ x: Swift.Float) -> Swift.Float {
  return Float(asinhf(CFloat(x)))
}
@_transparent public func asinh(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(asinhl(CLongDouble(x)))
}
@_transparent public func atanh(_ x: Swift.Float) -> Swift.Float {
  return Float(atanhf(CFloat(x)))
}
@_transparent public func atanh(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(atanhl(CLongDouble(x)))
}
@_transparent public func cosh(_ x: Swift.Float) -> Swift.Float {
  return Float(coshf(CFloat(x)))
}
@_transparent public func cosh(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(coshl(CLongDouble(x)))
}
@_transparent public func sinh(_ x: Swift.Float) -> Swift.Float {
  return Float(sinhf(CFloat(x)))
}
@_transparent public func sinh(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(sinhl(CLongDouble(x)))
}
@_transparent public func tanh(_ x: Swift.Float) -> Swift.Float {
  return Float(tanhf(CFloat(x)))
}
@_transparent public func tanh(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(tanhl(CLongDouble(x)))
}
@_transparent public func expm1(_ x: Swift.Float) -> Swift.Float {
  return Float(expm1f(CFloat(x)))
}
@_transparent public func expm1(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(expm1l(CLongDouble(x)))
}
@_transparent public func log1p(_ x: Swift.Float) -> Swift.Float {
  return Float(log1pf(CFloat(x)))
}
@_transparent public func log1p(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(log1pl(CLongDouble(x)))
}
@_transparent public func logb(_ x: Swift.Float) -> Swift.Float {
  return Float(logbf(CFloat(x)))
}
@_transparent public func logb(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(logbl(CLongDouble(x)))
}
@_transparent public func cbrt(_ x: Swift.Float) -> Swift.Float {
  return Float(cbrtf(CFloat(x)))
}
@_transparent public func cbrt(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(cbrtl(CLongDouble(x)))
}
@_transparent public func erf(_ x: Swift.Float) -> Swift.Float {
  return Float(erff(CFloat(x)))
}
@_transparent public func erf(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(erfl(CLongDouble(x)))
}
@_transparent public func erfc(_ x: Swift.Float) -> Swift.Float {
  return Float(erfcf(CFloat(x)))
}
@_transparent public func erfc(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(erfcl(CLongDouble(x)))
}
@_transparent public func tgamma(_ x: Swift.Float) -> Swift.Float {
  return Float(tgammaf(CFloat(x)))
}
@_transparent public func tgamma(_ x: Swift.Float80) -> Swift.Float80 {
  return Float80(tgammal(CLongDouble(x)))
}
@_transparent public func cos(_ x: Swift.Float) -> Swift.Float {
  return _cos(x)
}
@_transparent public func cos(_ x: Swift.Double) -> Swift.Double {
  return _cos(x)
}
@_transparent public func cos(_ x: Swift.Float80) -> Swift.Float80 {
  return _cos(x)
}
@_transparent public func sin(_ x: Swift.Float) -> Swift.Float {
  return _sin(x)
}
@_transparent public func sin(_ x: Swift.Double) -> Swift.Double {
  return _sin(x)
}
@_transparent public func sin(_ x: Swift.Float80) -> Swift.Float80 {
  return _sin(x)
}
@_transparent public func exp(_ x: Swift.Float) -> Swift.Float {
  return _exp(x)
}
@_transparent public func exp(_ x: Swift.Double) -> Swift.Double {
  return _exp(x)
}
@_transparent public func exp(_ x: Swift.Float80) -> Swift.Float80 {
  return _exp(x)
}
@_transparent public func exp2(_ x: Swift.Float) -> Swift.Float {
  return _exp2(x)
}
@_transparent public func exp2(_ x: Swift.Double) -> Swift.Double {
  return _exp2(x)
}
@_transparent public func exp2(_ x: Swift.Float80) -> Swift.Float80 {
  return _exp2(x)
}
@_transparent public func log(_ x: Swift.Float) -> Swift.Float {
  return _log(x)
}
@_transparent public func log(_ x: Swift.Double) -> Swift.Double {
  return _log(x)
}
@_transparent public func log(_ x: Swift.Float80) -> Swift.Float80 {
  return _log(x)
}
@_transparent public func log10(_ x: Swift.Float) -> Swift.Float {
  return _log10(x)
}
@_transparent public func log10(_ x: Swift.Double) -> Swift.Double {
  return _log10(x)
}
@_transparent public func log10(_ x: Swift.Float80) -> Swift.Float80 {
  return _log10(x)
}
@_transparent public func log2(_ x: Swift.Float) -> Swift.Float {
  return _log2(x)
}
@_transparent public func log2(_ x: Swift.Double) -> Swift.Double {
  return _log2(x)
}
@_transparent public func log2(_ x: Swift.Float80) -> Swift.Float80 {
  return _log2(x)
}
@_transparent public func nearbyint(_ x: Swift.Float) -> Swift.Float {
  return _nearbyint(x)
}
@_transparent public func nearbyint(_ x: Swift.Double) -> Swift.Double {
  return _nearbyint(x)
}
@_transparent public func nearbyint(_ x: Swift.Float80) -> Swift.Float80 {
  return _nearbyint(x)
}
@_transparent public func rint(_ x: Swift.Float) -> Swift.Float {
  return _rint(x)
}
@_transparent public func rint(_ x: Swift.Double) -> Swift.Double {
  return _rint(x)
}
@_transparent public func rint(_ x: Swift.Float80) -> Swift.Float80 {
  return _rint(x)
}
@_transparent public func atan2(_ lhs: Swift.Float, _ rhs: Swift.Float) -> Swift.Float {
  return Float(atan2f(CFloat(lhs), CFloat(rhs)))
}
@_transparent public func atan2(_ lhs: Swift.Float80, _ rhs: Swift.Float80) -> Swift.Float80 {
  return Float80(atan2l(CLongDouble(lhs), CLongDouble(rhs)))
}
@_transparent public func hypot(_ lhs: Swift.Float, _ rhs: Swift.Float) -> Swift.Float {
  return Float(hypotf(CFloat(lhs), CFloat(rhs)))
}
@_transparent public func hypot(_ lhs: Swift.Float80, _ rhs: Swift.Float80) -> Swift.Float80 {
  return Float80(hypotl(CLongDouble(lhs), CLongDouble(rhs)))
}
@_transparent public func pow(_ lhs: Swift.Float, _ rhs: Swift.Float) -> Swift.Float {
  return Float(powf(CFloat(lhs), CFloat(rhs)))
}
@_transparent public func pow(_ lhs: Swift.Float80, _ rhs: Swift.Float80) -> Swift.Float80 {
  return Float80(powl(CLongDouble(lhs), CLongDouble(rhs)))
}
@_transparent public func copysign(_ lhs: Swift.Float, _ rhs: Swift.Float) -> Swift.Float {
  return Float(copysignf(CFloat(lhs), CFloat(rhs)))
}
@_transparent public func copysign(_ lhs: Swift.Float80, _ rhs: Swift.Float80) -> Swift.Float80 {
  return Float80(copysignl(CLongDouble(lhs), CLongDouble(rhs)))
}
@_transparent public func nextafter(_ lhs: Swift.Float, _ rhs: Swift.Float) -> Swift.Float {
  return Float(nextafterf(CFloat(lhs), CFloat(rhs)))
}
@_transparent public func nextafter(_ lhs: Swift.Float80, _ rhs: Swift.Float80) -> Swift.Float80 {
  return Float80(nextafterl(CLongDouble(lhs), CLongDouble(rhs)))
}
@_transparent public func fdim(_ lhs: Swift.Float, _ rhs: Swift.Float) -> Swift.Float {
  return Float(fdimf(CFloat(lhs), CFloat(rhs)))
}
@_transparent public func fdim(_ lhs: Swift.Float80, _ rhs: Swift.Float80) -> Swift.Float80 {
  return Float80(fdiml(CLongDouble(lhs), CLongDouble(rhs)))
}
@_transparent public func fmax(_ lhs: Swift.Float, _ rhs: Swift.Float) -> Swift.Float {
  return Float(fmaxf(CFloat(lhs), CFloat(rhs)))
}
@_transparent public func fmax(_ lhs: Swift.Float80, _ rhs: Swift.Float80) -> Swift.Float80 {
  return Float80(fmaxl(CLongDouble(lhs), CLongDouble(rhs)))
}
@_transparent public func fmin(_ lhs: Swift.Float, _ rhs: Swift.Float) -> Swift.Float {
  return Float(fminf(CFloat(lhs), CFloat(rhs)))
}
@_transparent public func fmin(_ lhs: Swift.Float80, _ rhs: Swift.Float80) -> Swift.Float80 {
  return Float80(fminl(CLongDouble(lhs), CLongDouble(rhs)))
}
@_transparent public func lgamma(_ x: Swift.Float) -> (Swift.Float, Swift.Int) {
  var sign = Int32(0)
  let value = lgammaf_r(CFloat(x), &sign)
  return (Float(value), Int(sign))
}
@_transparent public func lgamma(_ x: Swift.Double) -> (Swift.Double, Swift.Int) {
  var sign = Int32(0)
  let value = lgamma_r(CDouble(x), &sign)
  return (Double(value), Int(sign))
}
@_transparent public func lgamma(_ x: Swift.Float80) -> (Swift.Float80, Swift.Int) {
  var sign = Int32(0)
  let value = lgammal_r(CLongDouble(x), &sign)
  return (Float80(value), Int(sign))
}
@_transparent public func remquo(_ x: Swift.Float, _ y: Swift.Float) -> (Swift.Float, Swift.Int) {
  var quo = Int32(0)
  let rem = remquof(CFloat(x), CFloat(y), &quo)
  return (Float(rem), Int(quo))
}
@_transparent public func remquo(_ x: Swift.Double, _ y: Swift.Double) -> (Swift.Double, Swift.Int) {
  var quo = Int32(0)
  let rem = remquo(CDouble(x), CDouble(y), &quo)
  return (Double(rem), Int(quo))
}
@_transparent public func remquo(_ x: Swift.Float80, _ y: Swift.Float80) -> (Swift.Float80, Swift.Int) {
  var quo = Int32(0)
  let rem = remquol(CLongDouble(x), CLongDouble(y), &quo)
  return (Float80(rem), Int(quo))
}
@available(swift, deprecated: 4.2, message: "use Float(nan: Float.RawSignificand).")
@_transparent public func nan(_ tag: Swift.String) -> Swift.Float {
  return Float(nanf(tag))
}
@available(swift, deprecated: 4.2, message: "use Float80(nan: Float80.RawSignificand).")
@_transparent public func nan(_ tag: Swift.String) -> Swift.Float80 {
  return Float80(nanl(tag))
}
@_transparent public func jn(_ n: Swift.Int, _ x: Swift.Double) -> Swift.Double {
  return jn(Int32(n), x)
}
@_transparent public func yn(_ n: Swift.Int, _ x: Swift.Double) -> Swift.Double {
  return yn(Int32(n), x)
}
public let MAP_FAILED: Swift.UnsafeMutableRawPointer!
@available(swift, deprecated: 3.0, message: "Please use 'Double.pi' or '.pi' to get the value of correct type and avoid casting.")
public let M_PI: Swift.Double
@available(swift, deprecated: 3.0, message: "Please use 'Double.pi / 2' or '.pi / 2' to get the value of correct type and avoid casting.")
public let M_PI_2: Swift.Double
@available(swift, deprecated: 3.0, message: "Please use 'Double.pi / 4' or '.pi / 4' to get the value of correct type and avoid casting.")
public let M_PI_4: Swift.Double
@available(swift, deprecated: 3.0, message: "Please use '2.squareRoot()'.")
public let M_SQRT2: Swift.Double
@available(swift, deprecated: 3.0, message: "Please use '0.5.squareRoot()'.")
public let M_SQRT1_2: Swift.Double
@available(swift, deprecated: 3.0, message: "Please use 'T.radix' to get the radix of a FloatingPoint type 'T'.")
public let FLT_RADIX: Swift.Int
@available(swift, deprecated: 3.0, message: "Please use 'Float.significandBitCount + 1'.")
public let FLT_MANT_DIG: Swift.Int
@available(swift, deprecated: 3.0, message: "Please use 'Float.greatestFiniteMagnitude.exponent + 1'.")
public let FLT_MAX_EXP: Swift.Int
@available(swift, deprecated: 3.0, message: "Please use 'Float.leastNormalMagnitude.exponent + 1'.")
public let FLT_MIN_EXP: Swift.Int
@available(swift, deprecated: 3.0, message: "Please use 'Float.greatestFiniteMagnitude' or '.greatestFiniteMagnitude'.")
public let FLT_MAX: Swift.Float
@available(swift, deprecated: 3.0, message: "Please use 'Float.ulpOfOne' or '.ulpOfOne'.")
public let FLT_EPSILON: Swift.Float
@available(swift, deprecated: 3.0, message: "Please use 'Float.leastNormalMagnitude' or '.leastNormalMagnitude'.")
public let FLT_MIN: Swift.Float
@available(swift, deprecated: 3.0, message: "Please use 'Float.leastNonzeroMagnitude' or '.leastNonzeroMagnitude'.")
public let FLT_TRUE_MIN: Swift.Float
@available(swift, deprecated: 3.0, message: "Please use 'Double.significandBitCount + 1'.")
public let DBL_MANT_DIG: Swift.Int
@available(swift, deprecated: 3.0, message: "Please use 'Double.greatestFiniteMagnitude.exponent + 1'.")
public let DBL_MAX_EXP: Swift.Int
@available(swift, deprecated: 3.0, message: "Please use 'Double.leastNormalMagnitude.exponent + 1'.")
public let DBL_MIN_EXP: Swift.Int
@available(swift, deprecated: 3.0, message: "Please use 'Double.greatestFiniteMagnitude' or '.greatestFiniteMagnitude'.")
public let DBL_MAX: Swift.Double
@available(swift, deprecated: 3.0, message: "Please use 'Double.ulpOfOne' or '.ulpOfOne'.")
public let DBL_EPSILON: Swift.Double
@available(swift, deprecated: 3.0, message: "Please use 'Double.leastNormalMagnitude' or '.leastNormalMagnitude'.")
public let DBL_MIN: Swift.Double
@available(swift, deprecated: 3.0, message: "Please use 'Double.leastNonzeroMagnitude' or '.leastNonzeroMagnitude'.")
public let DBL_TRUE_MIN: Swift.Double
@available(swift, deprecated: 3.0, message: "Please use 'Float80.significandBitCount + 1'.")
public let LDBL_MANT_DIG: Swift.Int
@available(swift, deprecated: 3.0, message: "Please use 'Float80.greatestFiniteMagnitude.exponent + 1'.")
public let LDBL_MAX_EXP: Swift.Int
@available(swift, deprecated: 3.0, message: "Please use 'Float80.leastNormalMagnitude.exponent + 1'.")
public let LDBL_MIN_EXP: Swift.Int
@available(swift, deprecated: 3.0, message: "Please use 'Float80.greatestFiniteMagnitude' or '.greatestFiniteMagnitude'.")
public let LDBL_MAX: Swift.Float80
@available(swift, deprecated: 3.0, message: "Please use 'Float80.ulpOfOne' or '.ulpOfOne'.")
public let LDBL_EPSILON: Swift.Float80
@available(swift, deprecated: 3.0, message: "Please use 'Float80.leastNormalMagnitude' or '.leastNormalMagnitude'.")
public let LDBL_MIN: Swift.Float80
@available(swift, deprecated: 3.0, message: "Please use 'Float80.leastNonzeroMagnitude' or '.leastNonzeroMagnitude'.")
public let LDBL_TRUE_MIN: Swift.Float80
extension Darwin.extern_proc {
  @_transparent public var p_starttime: Darwin.timeval {
    @_transparent get { return self.p_un.__p_starttime }
    @_transparent set { self.p_un.__p_starttime = newValue }
  }
}
extension Darwin.DarwinBoolean : Swift.Sendable {}
extension Darwin.POSIXErrorCode : Swift.Equatable {}
extension Darwin.POSIXErrorCode : Swift.Hashable {}
extension Darwin.POSIXErrorCode : Swift.RawRepresentable {}
extension Darwin.MachErrorCode : Swift.Equatable {}
extension Darwin.MachErrorCode : Swift.Hashable {}
extension Darwin.MachErrorCode : Swift.RawRepresentable {}