// swift-interface-format-version: 1.0
// swift-compiler-version: Apple Swift version 6.3 effective-5.10 (swiftlang-6.3.0.123.4 clang-2100.0.123.2)
// swift-module-flags: -target arm64e-apple-macos26.4 -target-variant arm64e-apple-ios26.4-macabi -enable-objc-interop -autolink-force-load -enable-library-evolution -module-link-name swiftsimd -swift-version 5 -enforce-exclusivity=checked -O -library-level api -enable-experimental-feature DebugDescriptionMacro -enable-bare-slash-regex -user-module-version 23 -module-name simd
// swift-module-flags-ignorable:  -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3
import Darwin
import Swift
import _Concurrency
import _StringProcessing
import _SwiftConcurrencyShims
@_exported import simd
extension Swift.SIMD {
  @available(swift, deprecated: 5, renamed: "init(repeating:)")
  @_transparent public init(_ scalar: Self.Scalar) { self.init(repeating: scalar) }
}
extension Swift.SIMD2 {
  @inlinable internal var _descriptionAsArray: Swift.String {
    get { return "[\(x), \(y)]" }
  }
}
extension Swift.SIMD3 {
  @inlinable internal var _descriptionAsArray: Swift.String {
    get { return "[\(x), \(y), \(z)]" }
  }
}
extension Swift.SIMD4 {
  @inlinable internal var _descriptionAsArray: Swift.String {
    get { return "[\(x), \(y), \(z), \(w)]" }
  }
}
extension Swift.SIMD where Self.Scalar : Swift.FixedWidthInteger {
  @available(swift, deprecated: 5, message: "use 0 &- rhs")
  @_transparent prefix public static func - (rhs: Self) -> Self { return 0 &- rhs }
}
@available(swift, deprecated: 5.1, message: "Use SIMD2<Float>")
public typealias float2 = Swift.SIMD2<Swift.Float>
@_transparent public func abs(_ x: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_abs(x)
}
@_transparent public func min(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD2<Swift.Float>, _ scalar: Swift.Float) -> Swift.SIMD2<Swift.Float> {
  return min(vector, SIMD2<Float>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD2<Swift.Float>, _ scalar: Swift.Float) -> Swift.SIMD2<Swift.Float> {
  return max(vector, SIMD2<Float>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD2<Swift.Float>, min: Swift.SIMD2<Swift.Float>, max: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD2<Swift.Float>, min: Swift.Float, max: Swift.Float) -> Swift.SIMD2<Swift.Float> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD2<Swift.Float>) -> Swift.Float {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD2<Swift.Float>) -> Swift.Float {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD2<Swift.Float>) -> Swift.Float {
  return simd_reduce_max(x)
}
@_transparent public func sign(_ x: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_sign(x)
}
@_transparent public func mix(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>, t: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return x + t*(y-x)
}
@_transparent public func mix(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>, t: Swift.Float) -> Swift.SIMD2<Swift.Float> {
  return x + t*(y-x)
}
@_transparent public func recip(_ x: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_recip(x)
}
@_transparent public func rsqrt(_ x: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_rsqrt(x)
}
@_transparent public func fmin(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return min(x, y)
}
@_transparent public func fmax(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return max(x, y)
}
@_transparent public func ceil(_ x: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return __tg_ceil(x)
}
@_transparent public func floor(_ x: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return __tg_floor(x)
}
@_transparent public func trunc(_ x: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return __tg_trunc(x)
}
@_transparent public func fract(_ x: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_fract(x)
}
@_transparent public func step(_ x: Swift.SIMD2<Swift.Float>, edge: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_step(edge, x)
}
@_transparent public func smoothstep(_ x: Swift.SIMD2<Swift.Float>, edge0: Swift.SIMD2<Swift.Float>, edge1: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_smoothstep(edge0, edge1, x)
}
@_transparent public func dot(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>) -> Swift.Float {
  return reduce_add(x * y)
}
@_transparent public func project(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_project(x, y)
}
@_transparent public func length_squared(_ x: Swift.SIMD2<Swift.Float>) -> Swift.Float {
  return dot(x, x)
}
@_transparent public func length(_ x: Swift.SIMD2<Swift.Float>) -> Swift.Float {
  return sqrt(length_squared(x))
}
@_transparent public func norm_one(_ x: Swift.SIMD2<Swift.Float>) -> Swift.Float {
  return reduce_add(abs(x))
}
@_transparent public func norm_inf(_ x: Swift.SIMD2<Swift.Float>) -> Swift.Float {
  return reduce_max(abs(x))
}
@_transparent public func distance_squared(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>) -> Swift.Float {
  return length_squared(x - y)
}
@_transparent public func distance(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>) -> Swift.Float {
  return length(x - y)
}
@_transparent public func normalize(_ x: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_normalize(x)
}
@_transparent public func reflect(_ x: Swift.SIMD2<Swift.Float>, n: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
  return simd_reflect(x, n)
}
@_transparent public func refract(_ x: Swift.SIMD2<Swift.Float>, n: Swift.SIMD2<Swift.Float>, eta: Swift.Float) -> Swift.SIMD2<Swift.Float> {
  return simd_refract(x, n, eta)
}
@available(swift, deprecated: 5.1, message: "Use SIMD3<Float>")
public typealias float3 = Swift.SIMD3<Swift.Float>
@_transparent public func abs(_ x: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_abs(x)
}
@_transparent public func min(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD3<Swift.Float>, _ scalar: Swift.Float) -> Swift.SIMD3<Swift.Float> {
  return min(vector, SIMD3<Float>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD3<Swift.Float>, _ scalar: Swift.Float) -> Swift.SIMD3<Swift.Float> {
  return max(vector, SIMD3<Float>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD3<Swift.Float>, min: Swift.SIMD3<Swift.Float>, max: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD3<Swift.Float>, min: Swift.Float, max: Swift.Float) -> Swift.SIMD3<Swift.Float> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD3<Swift.Float>) -> Swift.Float {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD3<Swift.Float>) -> Swift.Float {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD3<Swift.Float>) -> Swift.Float {
  return simd_reduce_max(x)
}
@_transparent public func sign(_ x: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_sign(x)
}
@_transparent public func mix(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>, t: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return x + t*(y-x)
}
@_transparent public func mix(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>, t: Swift.Float) -> Swift.SIMD3<Swift.Float> {
  return x + t*(y-x)
}
@_transparent public func recip(_ x: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_recip(x)
}
@_transparent public func rsqrt(_ x: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_rsqrt(x)
}
@_transparent public func fmin(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return min(x, y)
}
@_transparent public func fmax(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return max(x, y)
}
@_transparent public func ceil(_ x: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return __tg_ceil(x)
}
@_transparent public func floor(_ x: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return __tg_floor(x)
}
@_transparent public func trunc(_ x: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return __tg_trunc(x)
}
@_transparent public func fract(_ x: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_fract(x)
}
@_transparent public func step(_ x: Swift.SIMD3<Swift.Float>, edge: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_step(edge, x)
}
@_transparent public func smoothstep(_ x: Swift.SIMD3<Swift.Float>, edge0: Swift.SIMD3<Swift.Float>, edge1: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_smoothstep(edge0, edge1, x)
}
@_transparent public func dot(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>) -> Swift.Float {
  return reduce_add(x * y)
}
@_transparent public func project(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_project(x, y)
}
@_transparent public func length_squared(_ x: Swift.SIMD3<Swift.Float>) -> Swift.Float {
  return dot(x, x)
}
@_transparent public func length(_ x: Swift.SIMD3<Swift.Float>) -> Swift.Float {
  return sqrt(length_squared(x))
}
@_transparent public func norm_one(_ x: Swift.SIMD3<Swift.Float>) -> Swift.Float {
  return reduce_add(abs(x))
}
@_transparent public func norm_inf(_ x: Swift.SIMD3<Swift.Float>) -> Swift.Float {
  return reduce_max(abs(x))
}
@_transparent public func distance_squared(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>) -> Swift.Float {
  return length_squared(x - y)
}
@_transparent public func distance(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>) -> Swift.Float {
  return length(x - y)
}
@_transparent public func normalize(_ x: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_normalize(x)
}
@_transparent public func reflect(_ x: Swift.SIMD3<Swift.Float>, n: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_reflect(x, n)
}
@_transparent public func refract(_ x: Swift.SIMD3<Swift.Float>, n: Swift.SIMD3<Swift.Float>, eta: Swift.Float) -> Swift.SIMD3<Swift.Float> {
  return simd_refract(x, n, eta)
}
@available(swift, deprecated: 5.1, message: "Use SIMD4<Float>")
public typealias float4 = Swift.SIMD4<Swift.Float>
@_transparent public func abs(_ x: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_abs(x)
}
@_transparent public func min(_ x: Swift.SIMD4<Swift.Float>, _ y: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD4<Swift.Float>, _ y: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD4<Swift.Float>, _ scalar: Swift.Float) -> Swift.SIMD4<Swift.Float> {
  return min(vector, SIMD4<Float>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD4<Swift.Float>, _ scalar: Swift.Float) -> Swift.SIMD4<Swift.Float> {
  return max(vector, SIMD4<Float>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD4<Swift.Float>, min: Swift.SIMD4<Swift.Float>, max: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD4<Swift.Float>, min: Swift.Float, max: Swift.Float) -> Swift.SIMD4<Swift.Float> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD4<Swift.Float>) -> Swift.Float {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD4<Swift.Float>) -> Swift.Float {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD4<Swift.Float>) -> Swift.Float {
  return simd_reduce_max(x)
}
@_transparent public func sign(_ x: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_sign(x)
}
@_transparent public func mix(_ x: Swift.SIMD4<Swift.Float>, _ y: Swift.SIMD4<Swift.Float>, t: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return x + t*(y-x)
}
@_transparent public func mix(_ x: Swift.SIMD4<Swift.Float>, _ y: Swift.SIMD4<Swift.Float>, t: Swift.Float) -> Swift.SIMD4<Swift.Float> {
  return x + t*(y-x)
}
@_transparent public func recip(_ x: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_recip(x)
}
@_transparent public func rsqrt(_ x: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_rsqrt(x)
}
@_transparent public func fmin(_ x: Swift.SIMD4<Swift.Float>, _ y: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return min(x, y)
}
@_transparent public func fmax(_ x: Swift.SIMD4<Swift.Float>, _ y: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return max(x, y)
}
@_transparent public func ceil(_ x: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return __tg_ceil(x)
}
@_transparent public func floor(_ x: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return __tg_floor(x)
}
@_transparent public func trunc(_ x: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return __tg_trunc(x)
}
@_transparent public func fract(_ x: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_fract(x)
}
@_transparent public func step(_ x: Swift.SIMD4<Swift.Float>, edge: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_step(edge, x)
}
@_transparent public func smoothstep(_ x: Swift.SIMD4<Swift.Float>, edge0: Swift.SIMD4<Swift.Float>, edge1: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_smoothstep(edge0, edge1, x)
}
@_transparent public func dot(_ x: Swift.SIMD4<Swift.Float>, _ y: Swift.SIMD4<Swift.Float>) -> Swift.Float {
  return reduce_add(x * y)
}
@_transparent public func project(_ x: Swift.SIMD4<Swift.Float>, _ y: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_project(x, y)
}
@_transparent public func length_squared(_ x: Swift.SIMD4<Swift.Float>) -> Swift.Float {
  return dot(x, x)
}
@_transparent public func length(_ x: Swift.SIMD4<Swift.Float>) -> Swift.Float {
  return sqrt(length_squared(x))
}
@_transparent public func norm_one(_ x: Swift.SIMD4<Swift.Float>) -> Swift.Float {
  return reduce_add(abs(x))
}
@_transparent public func norm_inf(_ x: Swift.SIMD4<Swift.Float>) -> Swift.Float {
  return reduce_max(abs(x))
}
@_transparent public func distance_squared(_ x: Swift.SIMD4<Swift.Float>, _ y: Swift.SIMD4<Swift.Float>) -> Swift.Float {
  return length_squared(x - y)
}
@_transparent public func distance(_ x: Swift.SIMD4<Swift.Float>, _ y: Swift.SIMD4<Swift.Float>) -> Swift.Float {
  return length(x - y)
}
@_transparent public func normalize(_ x: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_normalize(x)
}
@_transparent public func reflect(_ x: Swift.SIMD4<Swift.Float>, n: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
  return simd_reflect(x, n)
}
@_transparent public func refract(_ x: Swift.SIMD4<Swift.Float>, n: Swift.SIMD4<Swift.Float>, eta: Swift.Float) -> Swift.SIMD4<Swift.Float> {
  return simd_refract(x, n, eta)
}
@_transparent public func sign(_ x: Swift.Float) -> Swift.Float {
  return simd_sign(x)
}
@_transparent public func recip(_ x: Swift.Float) -> Swift.Float {
  return simd_recip(x)
}
@_transparent public func rsqrt(_ x: Swift.Float) -> Swift.Float {
  return simd_rsqrt(x)
}
@_transparent public func step(_ x: Swift.Float, edge: Swift.Float) -> Swift.Float {
  return simd_step(edge, x)
}
@_transparent public func cross(_ x: Swift.SIMD2<Swift.Float>, _ y: Swift.SIMD2<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_cross(x,y)
}
@_transparent public func cross(_ x: Swift.SIMD3<Swift.Float>, _ y: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
  return simd_cross(x,y)
}
@available(swift, deprecated: 5.1, message: "Use SIMD2<Double>")
public typealias double2 = Swift.SIMD2<Swift.Double>
@_transparent public func abs(_ x: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_abs(x)
}
@_transparent public func min(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD2<Swift.Double>, _ scalar: Swift.Double) -> Swift.SIMD2<Swift.Double> {
  return min(vector, SIMD2<Double>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD2<Swift.Double>, _ scalar: Swift.Double) -> Swift.SIMD2<Swift.Double> {
  return max(vector, SIMD2<Double>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD2<Swift.Double>, min: Swift.SIMD2<Swift.Double>, max: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD2<Swift.Double>, min: Swift.Double, max: Swift.Double) -> Swift.SIMD2<Swift.Double> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD2<Swift.Double>) -> Swift.Double {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD2<Swift.Double>) -> Swift.Double {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD2<Swift.Double>) -> Swift.Double {
  return simd_reduce_max(x)
}
@_transparent public func sign(_ x: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_sign(x)
}
@_transparent public func mix(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>, t: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return x + t*(y-x)
}
@_transparent public func mix(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>, t: Swift.Double) -> Swift.SIMD2<Swift.Double> {
  return x + t*(y-x)
}
@_transparent public func recip(_ x: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_recip(x)
}
@_transparent public func rsqrt(_ x: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_rsqrt(x)
}
@_transparent public func fmin(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return min(x, y)
}
@_transparent public func fmax(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return max(x, y)
}
@_transparent public func ceil(_ x: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return __tg_ceil(x)
}
@_transparent public func floor(_ x: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return __tg_floor(x)
}
@_transparent public func trunc(_ x: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return __tg_trunc(x)
}
@_transparent public func fract(_ x: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_fract(x)
}
@_transparent public func step(_ x: Swift.SIMD2<Swift.Double>, edge: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_step(edge, x)
}
@_transparent public func smoothstep(_ x: Swift.SIMD2<Swift.Double>, edge0: Swift.SIMD2<Swift.Double>, edge1: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_smoothstep(edge0, edge1, x)
}
@_transparent public func dot(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>) -> Swift.Double {
  return reduce_add(x * y)
}
@_transparent public func project(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_project(x, y)
}
@_transparent public func length_squared(_ x: Swift.SIMD2<Swift.Double>) -> Swift.Double {
  return dot(x, x)
}
@_transparent public func length(_ x: Swift.SIMD2<Swift.Double>) -> Swift.Double {
  return sqrt(length_squared(x))
}
@_transparent public func norm_one(_ x: Swift.SIMD2<Swift.Double>) -> Swift.Double {
  return reduce_add(abs(x))
}
@_transparent public func norm_inf(_ x: Swift.SIMD2<Swift.Double>) -> Swift.Double {
  return reduce_max(abs(x))
}
@_transparent public func distance_squared(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>) -> Swift.Double {
  return length_squared(x - y)
}
@_transparent public func distance(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>) -> Swift.Double {
  return length(x - y)
}
@_transparent public func normalize(_ x: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_normalize(x)
}
@_transparent public func reflect(_ x: Swift.SIMD2<Swift.Double>, n: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
  return simd_reflect(x, n)
}
@_transparent public func refract(_ x: Swift.SIMD2<Swift.Double>, n: Swift.SIMD2<Swift.Double>, eta: Swift.Double) -> Swift.SIMD2<Swift.Double> {
  return simd_refract(x, n, eta)
}
@available(swift, deprecated: 5.1, message: "Use SIMD3<Double>")
public typealias double3 = Swift.SIMD3<Swift.Double>
@_transparent public func abs(_ x: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_abs(x)
}
@_transparent public func min(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD3<Swift.Double>, _ scalar: Swift.Double) -> Swift.SIMD3<Swift.Double> {
  return min(vector, SIMD3<Double>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD3<Swift.Double>, _ scalar: Swift.Double) -> Swift.SIMD3<Swift.Double> {
  return max(vector, SIMD3<Double>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD3<Swift.Double>, min: Swift.SIMD3<Swift.Double>, max: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD3<Swift.Double>, min: Swift.Double, max: Swift.Double) -> Swift.SIMD3<Swift.Double> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD3<Swift.Double>) -> Swift.Double {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD3<Swift.Double>) -> Swift.Double {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD3<Swift.Double>) -> Swift.Double {
  return simd_reduce_max(x)
}
@_transparent public func sign(_ x: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_sign(x)
}
@_transparent public func mix(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>, t: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return x + t*(y-x)
}
@_transparent public func mix(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>, t: Swift.Double) -> Swift.SIMD3<Swift.Double> {
  return x + t*(y-x)
}
@_transparent public func recip(_ x: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_recip(x)
}
@_transparent public func rsqrt(_ x: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_rsqrt(x)
}
@_transparent public func fmin(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return min(x, y)
}
@_transparent public func fmax(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return max(x, y)
}
@_transparent public func ceil(_ x: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return __tg_ceil(x)
}
@_transparent public func floor(_ x: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return __tg_floor(x)
}
@_transparent public func trunc(_ x: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return __tg_trunc(x)
}
@_transparent public func fract(_ x: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_fract(x)
}
@_transparent public func step(_ x: Swift.SIMD3<Swift.Double>, edge: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_step(edge, x)
}
@_transparent public func smoothstep(_ x: Swift.SIMD3<Swift.Double>, edge0: Swift.SIMD3<Swift.Double>, edge1: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_smoothstep(edge0, edge1, x)
}
@_transparent public func dot(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>) -> Swift.Double {
  return reduce_add(x * y)
}
@_transparent public func project(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_project(x, y)
}
@_transparent public func length_squared(_ x: Swift.SIMD3<Swift.Double>) -> Swift.Double {
  return dot(x, x)
}
@_transparent public func length(_ x: Swift.SIMD3<Swift.Double>) -> Swift.Double {
  return sqrt(length_squared(x))
}
@_transparent public func norm_one(_ x: Swift.SIMD3<Swift.Double>) -> Swift.Double {
  return reduce_add(abs(x))
}
@_transparent public func norm_inf(_ x: Swift.SIMD3<Swift.Double>) -> Swift.Double {
  return reduce_max(abs(x))
}
@_transparent public func distance_squared(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>) -> Swift.Double {
  return length_squared(x - y)
}
@_transparent public func distance(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>) -> Swift.Double {
  return length(x - y)
}
@_transparent public func normalize(_ x: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_normalize(x)
}
@_transparent public func reflect(_ x: Swift.SIMD3<Swift.Double>, n: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_reflect(x, n)
}
@_transparent public func refract(_ x: Swift.SIMD3<Swift.Double>, n: Swift.SIMD3<Swift.Double>, eta: Swift.Double) -> Swift.SIMD3<Swift.Double> {
  return simd_refract(x, n, eta)
}
@available(swift, deprecated: 5.1, message: "Use SIMD4<Double>")
public typealias double4 = Swift.SIMD4<Swift.Double>
@_transparent public func abs(_ x: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_abs(x)
}
@_transparent public func min(_ x: Swift.SIMD4<Swift.Double>, _ y: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD4<Swift.Double>, _ y: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD4<Swift.Double>, _ scalar: Swift.Double) -> Swift.SIMD4<Swift.Double> {
  return min(vector, SIMD4<Double>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD4<Swift.Double>, _ scalar: Swift.Double) -> Swift.SIMD4<Swift.Double> {
  return max(vector, SIMD4<Double>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD4<Swift.Double>, min: Swift.SIMD4<Swift.Double>, max: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD4<Swift.Double>, min: Swift.Double, max: Swift.Double) -> Swift.SIMD4<Swift.Double> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD4<Swift.Double>) -> Swift.Double {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD4<Swift.Double>) -> Swift.Double {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD4<Swift.Double>) -> Swift.Double {
  return simd_reduce_max(x)
}
@_transparent public func sign(_ x: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_sign(x)
}
@_transparent public func mix(_ x: Swift.SIMD4<Swift.Double>, _ y: Swift.SIMD4<Swift.Double>, t: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return x + t*(y-x)
}
@_transparent public func mix(_ x: Swift.SIMD4<Swift.Double>, _ y: Swift.SIMD4<Swift.Double>, t: Swift.Double) -> Swift.SIMD4<Swift.Double> {
  return x + t*(y-x)
}
@_transparent public func recip(_ x: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_recip(x)
}
@_transparent public func rsqrt(_ x: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_rsqrt(x)
}
@_transparent public func fmin(_ x: Swift.SIMD4<Swift.Double>, _ y: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return min(x, y)
}
@_transparent public func fmax(_ x: Swift.SIMD4<Swift.Double>, _ y: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return max(x, y)
}
@_transparent public func ceil(_ x: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return __tg_ceil(x)
}
@_transparent public func floor(_ x: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return __tg_floor(x)
}
@_transparent public func trunc(_ x: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return __tg_trunc(x)
}
@_transparent public func fract(_ x: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_fract(x)
}
@_transparent public func step(_ x: Swift.SIMD4<Swift.Double>, edge: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_step(edge, x)
}
@_transparent public func smoothstep(_ x: Swift.SIMD4<Swift.Double>, edge0: Swift.SIMD4<Swift.Double>, edge1: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_smoothstep(edge0, edge1, x)
}
@_transparent public func dot(_ x: Swift.SIMD4<Swift.Double>, _ y: Swift.SIMD4<Swift.Double>) -> Swift.Double {
  return reduce_add(x * y)
}
@_transparent public func project(_ x: Swift.SIMD4<Swift.Double>, _ y: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_project(x, y)
}
@_transparent public func length_squared(_ x: Swift.SIMD4<Swift.Double>) -> Swift.Double {
  return dot(x, x)
}
@_transparent public func length(_ x: Swift.SIMD4<Swift.Double>) -> Swift.Double {
  return sqrt(length_squared(x))
}
@_transparent public func norm_one(_ x: Swift.SIMD4<Swift.Double>) -> Swift.Double {
  return reduce_add(abs(x))
}
@_transparent public func norm_inf(_ x: Swift.SIMD4<Swift.Double>) -> Swift.Double {
  return reduce_max(abs(x))
}
@_transparent public func distance_squared(_ x: Swift.SIMD4<Swift.Double>, _ y: Swift.SIMD4<Swift.Double>) -> Swift.Double {
  return length_squared(x - y)
}
@_transparent public func distance(_ x: Swift.SIMD4<Swift.Double>, _ y: Swift.SIMD4<Swift.Double>) -> Swift.Double {
  return length(x - y)
}
@_transparent public func normalize(_ x: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_normalize(x)
}
@_transparent public func reflect(_ x: Swift.SIMD4<Swift.Double>, n: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
  return simd_reflect(x, n)
}
@_transparent public func refract(_ x: Swift.SIMD4<Swift.Double>, n: Swift.SIMD4<Swift.Double>, eta: Swift.Double) -> Swift.SIMD4<Swift.Double> {
  return simd_refract(x, n, eta)
}
@_transparent public func sign(_ x: Swift.Double) -> Swift.Double {
  return simd_sign(x)
}
@_transparent public func recip(_ x: Swift.Double) -> Swift.Double {
  return simd_recip(x)
}
@_transparent public func rsqrt(_ x: Swift.Double) -> Swift.Double {
  return simd_rsqrt(x)
}
@_transparent public func step(_ x: Swift.Double, edge: Swift.Double) -> Swift.Double {
  return simd_step(edge, x)
}
@_transparent public func cross(_ x: Swift.SIMD2<Swift.Double>, _ y: Swift.SIMD2<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_cross(x,y)
}
@_transparent public func cross(_ x: Swift.SIMD3<Swift.Double>, _ y: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
  return simd_cross(x,y)
}
@available(swift, deprecated: 5.1, message: "Use SIMD2<Int32>")
public typealias int2 = Swift.SIMD2<Swift.Int32>
@_transparent public func abs(_ x: Swift.SIMD2<Swift.Int32>) -> Swift.SIMD2<Swift.Int32> {
  return simd_abs(x)
}
@_transparent public func min(_ x: Swift.SIMD2<Swift.Int32>, _ y: Swift.SIMD2<Swift.Int32>) -> Swift.SIMD2<Swift.Int32> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD2<Swift.Int32>, _ y: Swift.SIMD2<Swift.Int32>) -> Swift.SIMD2<Swift.Int32> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD2<Swift.Int32>, _ scalar: Swift.Int32) -> Swift.SIMD2<Swift.Int32> {
  return min(vector, SIMD2<Int32>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD2<Swift.Int32>, _ scalar: Swift.Int32) -> Swift.SIMD2<Swift.Int32> {
  return max(vector, SIMD2<Int32>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD2<Swift.Int32>, min: Swift.SIMD2<Swift.Int32>, max: Swift.SIMD2<Swift.Int32>) -> Swift.SIMD2<Swift.Int32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD2<Swift.Int32>, min: Swift.Int32, max: Swift.Int32) -> Swift.SIMD2<Swift.Int32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD2<Swift.Int32>) -> Swift.Int32 {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD2<Swift.Int32>) -> Swift.Int32 {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD2<Swift.Int32>) -> Swift.Int32 {
  return simd_reduce_max(x)
}
@available(swift, deprecated: 5.1, message: "Use SIMD3<Int32>")
public typealias int3 = Swift.SIMD3<Swift.Int32>
@_transparent public func abs(_ x: Swift.SIMD3<Swift.Int32>) -> Swift.SIMD3<Swift.Int32> {
  return simd_abs(x)
}
@_transparent public func min(_ x: Swift.SIMD3<Swift.Int32>, _ y: Swift.SIMD3<Swift.Int32>) -> Swift.SIMD3<Swift.Int32> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD3<Swift.Int32>, _ y: Swift.SIMD3<Swift.Int32>) -> Swift.SIMD3<Swift.Int32> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD3<Swift.Int32>, _ scalar: Swift.Int32) -> Swift.SIMD3<Swift.Int32> {
  return min(vector, SIMD3<Int32>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD3<Swift.Int32>, _ scalar: Swift.Int32) -> Swift.SIMD3<Swift.Int32> {
  return max(vector, SIMD3<Int32>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD3<Swift.Int32>, min: Swift.SIMD3<Swift.Int32>, max: Swift.SIMD3<Swift.Int32>) -> Swift.SIMD3<Swift.Int32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD3<Swift.Int32>, min: Swift.Int32, max: Swift.Int32) -> Swift.SIMD3<Swift.Int32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD3<Swift.Int32>) -> Swift.Int32 {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD3<Swift.Int32>) -> Swift.Int32 {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD3<Swift.Int32>) -> Swift.Int32 {
  return simd_reduce_max(x)
}
@available(swift, deprecated: 5.1, message: "Use SIMD4<Int32>")
public typealias int4 = Swift.SIMD4<Swift.Int32>
@_transparent public func abs(_ x: Swift.SIMD4<Swift.Int32>) -> Swift.SIMD4<Swift.Int32> {
  return simd_abs(x)
}
@_transparent public func min(_ x: Swift.SIMD4<Swift.Int32>, _ y: Swift.SIMD4<Swift.Int32>) -> Swift.SIMD4<Swift.Int32> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD4<Swift.Int32>, _ y: Swift.SIMD4<Swift.Int32>) -> Swift.SIMD4<Swift.Int32> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD4<Swift.Int32>, _ scalar: Swift.Int32) -> Swift.SIMD4<Swift.Int32> {
  return min(vector, SIMD4<Int32>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD4<Swift.Int32>, _ scalar: Swift.Int32) -> Swift.SIMD4<Swift.Int32> {
  return max(vector, SIMD4<Int32>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD4<Swift.Int32>, min: Swift.SIMD4<Swift.Int32>, max: Swift.SIMD4<Swift.Int32>) -> Swift.SIMD4<Swift.Int32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD4<Swift.Int32>, min: Swift.Int32, max: Swift.Int32) -> Swift.SIMD4<Swift.Int32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD4<Swift.Int32>) -> Swift.Int32 {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD4<Swift.Int32>) -> Swift.Int32 {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD4<Swift.Int32>) -> Swift.Int32 {
  return simd_reduce_max(x)
}
@available(swift, deprecated: 5.1, message: "Use SIMD2<UInt32>")
public typealias uint2 = Swift.SIMD2<Swift.UInt32>
@_transparent public func min(_ x: Swift.SIMD2<Swift.UInt32>, _ y: Swift.SIMD2<Swift.UInt32>) -> Swift.SIMD2<Swift.UInt32> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD2<Swift.UInt32>, _ y: Swift.SIMD2<Swift.UInt32>) -> Swift.SIMD2<Swift.UInt32> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD2<Swift.UInt32>, _ scalar: Swift.UInt32) -> Swift.SIMD2<Swift.UInt32> {
  return min(vector, SIMD2<UInt32>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD2<Swift.UInt32>, _ scalar: Swift.UInt32) -> Swift.SIMD2<Swift.UInt32> {
  return max(vector, SIMD2<UInt32>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD2<Swift.UInt32>, min: Swift.SIMD2<Swift.UInt32>, max: Swift.SIMD2<Swift.UInt32>) -> Swift.SIMD2<Swift.UInt32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD2<Swift.UInt32>, min: Swift.UInt32, max: Swift.UInt32) -> Swift.SIMD2<Swift.UInt32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD2<Swift.UInt32>) -> Swift.UInt32 {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD2<Swift.UInt32>) -> Swift.UInt32 {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD2<Swift.UInt32>) -> Swift.UInt32 {
  return simd_reduce_max(x)
}
@available(swift, deprecated: 5.1, message: "Use SIMD3<UInt32>")
public typealias uint3 = Swift.SIMD3<Swift.UInt32>
@_transparent public func min(_ x: Swift.SIMD3<Swift.UInt32>, _ y: Swift.SIMD3<Swift.UInt32>) -> Swift.SIMD3<Swift.UInt32> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD3<Swift.UInt32>, _ y: Swift.SIMD3<Swift.UInt32>) -> Swift.SIMD3<Swift.UInt32> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD3<Swift.UInt32>, _ scalar: Swift.UInt32) -> Swift.SIMD3<Swift.UInt32> {
  return min(vector, SIMD3<UInt32>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD3<Swift.UInt32>, _ scalar: Swift.UInt32) -> Swift.SIMD3<Swift.UInt32> {
  return max(vector, SIMD3<UInt32>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD3<Swift.UInt32>, min: Swift.SIMD3<Swift.UInt32>, max: Swift.SIMD3<Swift.UInt32>) -> Swift.SIMD3<Swift.UInt32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD3<Swift.UInt32>, min: Swift.UInt32, max: Swift.UInt32) -> Swift.SIMD3<Swift.UInt32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD3<Swift.UInt32>) -> Swift.UInt32 {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD3<Swift.UInt32>) -> Swift.UInt32 {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD3<Swift.UInt32>) -> Swift.UInt32 {
  return simd_reduce_max(x)
}
@available(swift, deprecated: 5.1, message: "Use SIMD4<UInt32>")
public typealias uint4 = Swift.SIMD4<Swift.UInt32>
@_transparent public func min(_ x: Swift.SIMD4<Swift.UInt32>, _ y: Swift.SIMD4<Swift.UInt32>) -> Swift.SIMD4<Swift.UInt32> {
  return simd_min(x, y)
}
@_transparent public func max(_ x: Swift.SIMD4<Swift.UInt32>, _ y: Swift.SIMD4<Swift.UInt32>) -> Swift.SIMD4<Swift.UInt32> {
  return simd_max(x, y)
}
@_transparent public func min(_ vector: Swift.SIMD4<Swift.UInt32>, _ scalar: Swift.UInt32) -> Swift.SIMD4<Swift.UInt32> {
  return min(vector, SIMD4<UInt32>(repeating: scalar))
}
@_transparent public func max(_ vector: Swift.SIMD4<Swift.UInt32>, _ scalar: Swift.UInt32) -> Swift.SIMD4<Swift.UInt32> {
  return max(vector, SIMD4<UInt32>(repeating: scalar))
}
@_transparent public func clamp(_ x: Swift.SIMD4<Swift.UInt32>, min: Swift.SIMD4<Swift.UInt32>, max: Swift.SIMD4<Swift.UInt32>) -> Swift.SIMD4<Swift.UInt32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func clamp(_ x: Swift.SIMD4<Swift.UInt32>, min: Swift.UInt32, max: Swift.UInt32) -> Swift.SIMD4<Swift.UInt32> {
  return simd.min(simd.max(x, min), max)
}
@_transparent public func reduce_add(_ x: Swift.SIMD4<Swift.UInt32>) -> Swift.UInt32 {
  return simd_reduce_add(x)
}
@_transparent public func reduce_min(_ x: Swift.SIMD4<Swift.UInt32>) -> Swift.UInt32 {
  return simd_reduce_min(x)
}
@_transparent public func reduce_max(_ x: Swift.SIMD4<Swift.UInt32>) -> Swift.UInt32 {
  return simd_reduce_max(x)
}
public typealias float2x2 = simd.simd_float2x2
extension simd.simd_float2x2 {
  @_transparent public init(_ scalar: Swift.Float) {
    self.init(diagonal: SIMD2<Float>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD2<Swift.Float>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
  }
  @_transparent public init(_ columns: [Swift.SIMD2<Swift.Float>]) {
    precondition(columns.count == 2, "Requires array of 2 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
  }
  @_transparent public init(rows: [Swift.SIMD2<Swift.Float>]) {
    precondition(rows.count == 2, "Requires array of 2 vectors")
    self = float2x2(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD2<Swift.Float>, _ col1: Swift.SIMD2<Swift.Float>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_float2x2) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_float2x2 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD2<Swift.Float> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Float {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_float2x2 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_float2x2([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray)])"
  }
  }
}
extension simd.simd_float2x2 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_float2x2, rhs: simd.simd_float2x2) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_float2x2 {
  @_transparent public var transpose: simd.float2x2 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
  @_transparent public var inverse: simd.simd_float2x2 {
    @_transparent get {
    return simd_inverse(self)
  }
  }
  @_transparent public var determinant: Swift.Float {
    @_transparent get {
    return simd_determinant(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_float2x2, rhs: simd.simd_float2x2) -> simd.simd_float2x2 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_float2x2) -> simd.simd_float2x2 {
    return simd_float2x2() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_float2x2, rhs: simd.simd_float2x2) -> simd.simd_float2x2 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_float2x2, rhs: simd.simd_float2x2) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_float2x2, rhs: simd.simd_float2x2) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Float, rhs: simd.simd_float2x2) -> simd.simd_float2x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x2, rhs: Swift.Float) -> simd.simd_float2x2 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_float2x2, rhs: Swift.Float) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_float2x2, rhs: Swift.SIMD2<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD2<Swift.Float>, rhs: simd.simd_float2x2) -> Swift.SIMD2<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x2, rhs: simd.float2x2) -> simd.float2x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x2, rhs: simd.float3x2) -> simd.float3x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x2, rhs: simd.float4x2) -> simd.float4x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_float2x2, rhs: simd.float2x2) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_float2x2(diagonal:)")
public func matrix_from_diagonal(_ d: Swift.SIMD2<Swift.Float>) -> simd.simd_float2x2
@available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
@available(swift, deprecated: 4, message: "Use the .inverse property instead.")
public func matrix_invert(_ x: simd.simd_float2x2) -> simd.simd_float2x2
@available(swift, deprecated: 4, message: "Use the .determinant property instead.")
public func matrix_determinant(_ x: simd.simd_float2x2) -> Swift.Float
@available(swift, deprecated: 4, renamed: "simd_float2x2")
public func matrix_from_columns(_ col0: Swift.SIMD2<Swift.Float>, _ col1: Swift.SIMD2<Swift.Float>) -> simd.simd_float2x2
public func matrix_from_rows(_ row0: Swift.SIMD2<Swift.Float>, _ row1: Swift.SIMD2<Swift.Float>) -> simd.simd_float2x2
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_float2x2) -> simd.float2x2
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_float2x2, _ rhs: simd.simd_float2x2) -> Swift.Bool
public typealias float3x2 = simd.simd_float3x2
extension simd.simd_float3x2 {
  @_transparent public init(_ scalar: Swift.Float) {
    self.init(diagonal: SIMD2<Float>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD2<Swift.Float>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
  }
  @_transparent public init(_ columns: [Swift.SIMD2<Swift.Float>]) {
    precondition(columns.count == 3, "Requires array of 3 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
  }
  @_transparent public init(rows: [Swift.SIMD3<Swift.Float>]) {
    precondition(rows.count == 2, "Requires array of 2 vectors")
    self = float2x3(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD2<Swift.Float>, _ col1: Swift.SIMD2<Swift.Float>, _ col2: Swift.SIMD2<Swift.Float>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_float3x2) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_float3x2 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD2<Swift.Float> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Float {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_float3x2 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_float3x2([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray)])"
  }
  }
}
extension simd.simd_float3x2 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_float3x2, rhs: simd.simd_float3x2) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_float3x2 {
  @_transparent public var transpose: simd.float2x3 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_float3x2, rhs: simd.simd_float3x2) -> simd.simd_float3x2 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_float3x2) -> simd.simd_float3x2 {
    return simd_float3x2() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_float3x2, rhs: simd.simd_float3x2) -> simd.simd_float3x2 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_float3x2, rhs: simd.simd_float3x2) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_float3x2, rhs: simd.simd_float3x2) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Float, rhs: simd.simd_float3x2) -> simd.simd_float3x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x2, rhs: Swift.Float) -> simd.simd_float3x2 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_float3x2, rhs: Swift.Float) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_float3x2, rhs: Swift.SIMD3<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD2<Swift.Float>, rhs: simd.simd_float3x2) -> Swift.SIMD3<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x2, rhs: simd.float2x3) -> simd.float2x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x2, rhs: simd.float3x3) -> simd.float3x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x2, rhs: simd.float4x3) -> simd.float4x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_float3x2, rhs: simd.float3x3) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_float3x2")
public func matrix_from_columns(_ col0: Swift.SIMD2<Swift.Float>, _ col1: Swift.SIMD2<Swift.Float>, _ col2: Swift.SIMD2<Swift.Float>) -> simd.simd_float3x2
public func matrix_from_rows(_ row0: Swift.SIMD3<Swift.Float>, _ row1: Swift.SIMD3<Swift.Float>) -> simd.simd_float3x2
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_float3x2) -> simd.float2x3
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_float3x2, _ rhs: simd.simd_float3x2) -> Swift.Bool
public typealias float4x2 = simd.simd_float4x2
extension simd.simd_float4x2 {
  @_transparent public init(_ scalar: Swift.Float) {
    self.init(diagonal: SIMD2<Float>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD2<Swift.Float>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
  }
  @_transparent public init(_ columns: [Swift.SIMD2<Swift.Float>]) {
    precondition(columns.count == 4, "Requires array of 4 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
    self.columns.3 = columns[3]
  }
  @_transparent public init(rows: [Swift.SIMD4<Swift.Float>]) {
    precondition(rows.count == 2, "Requires array of 2 vectors")
    self = float2x4(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD2<Swift.Float>, _ col1: Swift.SIMD2<Swift.Float>, _ col2: Swift.SIMD2<Swift.Float>, _ col3: Swift.SIMD2<Swift.Float>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
      self.columns.3 = col3
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_float4x2) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_float4x2 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD2<Swift.Float> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      case 3: return columns.3
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      case 3: columns.3 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Float {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_float4x2 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_float4x2([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray), \(columns.3._descriptionAsArray)])"
  }
  }
}
extension simd.simd_float4x2 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_float4x2, rhs: simd.simd_float4x2) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_float4x2 {
  @_transparent public var transpose: simd.float2x4 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_float4x2, rhs: simd.simd_float4x2) -> simd.simd_float4x2 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_float4x2) -> simd.simd_float4x2 {
    return simd_float4x2() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_float4x2, rhs: simd.simd_float4x2) -> simd.simd_float4x2 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_float4x2, rhs: simd.simd_float4x2) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_float4x2, rhs: simd.simd_float4x2) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Float, rhs: simd.simd_float4x2) -> simd.simd_float4x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x2, rhs: Swift.Float) -> simd.simd_float4x2 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_float4x2, rhs: Swift.Float) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_float4x2, rhs: Swift.SIMD4<Swift.Float>) -> Swift.SIMD2<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD2<Swift.Float>, rhs: simd.simd_float4x2) -> Swift.SIMD4<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x2, rhs: simd.float2x4) -> simd.float2x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x2, rhs: simd.float3x4) -> simd.float3x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x2, rhs: simd.float4x4) -> simd.float4x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_float4x2, rhs: simd.float4x4) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_float4x2")
public func matrix_from_columns(_ col0: Swift.SIMD2<Swift.Float>, _ col1: Swift.SIMD2<Swift.Float>, _ col2: Swift.SIMD2<Swift.Float>, _ col3: Swift.SIMD2<Swift.Float>) -> simd.simd_float4x2
public func matrix_from_rows(_ row0: Swift.SIMD4<Swift.Float>, _ row1: Swift.SIMD4<Swift.Float>) -> simd.simd_float4x2
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_float4x2) -> simd.float2x4
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_float4x2, _ rhs: simd.simd_float4x2) -> Swift.Bool
public typealias float2x3 = simd.simd_float2x3
extension simd.simd_float2x3 {
  @_transparent public init(_ scalar: Swift.Float) {
    self.init(diagonal: SIMD2<Float>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD2<Swift.Float>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
  }
  @_transparent public init(_ columns: [Swift.SIMD3<Swift.Float>]) {
    precondition(columns.count == 2, "Requires array of 2 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
  }
  @_transparent public init(rows: [Swift.SIMD2<Swift.Float>]) {
    precondition(rows.count == 3, "Requires array of 3 vectors")
    self = float3x2(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD3<Swift.Float>, _ col1: Swift.SIMD3<Swift.Float>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_float2x3) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_float2x3 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD3<Swift.Float> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Float {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_float2x3 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_float2x3([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray)])"
  }
  }
}
extension simd.simd_float2x3 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_float2x3, rhs: simd.simd_float2x3) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_float2x3 {
  @_transparent public var transpose: simd.float3x2 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_float2x3, rhs: simd.simd_float2x3) -> simd.simd_float2x3 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_float2x3) -> simd.simd_float2x3 {
    return simd_float2x3() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_float2x3, rhs: simd.simd_float2x3) -> simd.simd_float2x3 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_float2x3, rhs: simd.simd_float2x3) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_float2x3, rhs: simd.simd_float2x3) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Float, rhs: simd.simd_float2x3) -> simd.simd_float2x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x3, rhs: Swift.Float) -> simd.simd_float2x3 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_float2x3, rhs: Swift.Float) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_float2x3, rhs: Swift.SIMD2<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD3<Swift.Float>, rhs: simd.simd_float2x3) -> Swift.SIMD2<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x3, rhs: simd.float2x2) -> simd.float2x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x3, rhs: simd.float3x2) -> simd.float3x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x3, rhs: simd.float4x2) -> simd.float4x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_float2x3, rhs: simd.float2x2) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_float2x3")
public func matrix_from_columns(_ col0: Swift.SIMD3<Swift.Float>, _ col1: Swift.SIMD3<Swift.Float>) -> simd.simd_float2x3
public func matrix_from_rows(_ row0: Swift.SIMD2<Swift.Float>, _ row1: Swift.SIMD2<Swift.Float>, _ row2: Swift.SIMD2<Swift.Float>) -> simd.simd_float2x3
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_float2x3) -> simd.float3x2
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_float2x3, _ rhs: simd.simd_float2x3) -> Swift.Bool
public typealias float3x3 = simd.simd_float3x3
extension simd.simd_float3x3 {
  @_transparent public init(_ scalar: Swift.Float) {
    self.init(diagonal: SIMD3<Float>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD3<Swift.Float>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
    self.columns.2.z = diagonal.z
  }
  @_transparent public init(_ columns: [Swift.SIMD3<Swift.Float>]) {
    precondition(columns.count == 3, "Requires array of 3 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
  }
  @_transparent public init(rows: [Swift.SIMD3<Swift.Float>]) {
    precondition(rows.count == 3, "Requires array of 3 vectors")
    self = float3x3(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD3<Swift.Float>, _ col1: Swift.SIMD3<Swift.Float>, _ col2: Swift.SIMD3<Swift.Float>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_float3x3) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_float3x3 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD3<Swift.Float> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Float {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_float3x3 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_float3x3([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray)])"
  }
  }
}
extension simd.simd_float3x3 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_float3x3, rhs: simd.simd_float3x3) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_float3x3 {
  @_transparent public var transpose: simd.float3x3 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
  @_transparent public var inverse: simd.simd_float3x3 {
    @_transparent get {
    return simd_inverse(self)
  }
  }
  @_transparent public var determinant: Swift.Float {
    @_transparent get {
    return simd_determinant(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_float3x3, rhs: simd.simd_float3x3) -> simd.simd_float3x3 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_float3x3) -> simd.simd_float3x3 {
    return simd_float3x3() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_float3x3, rhs: simd.simd_float3x3) -> simd.simd_float3x3 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_float3x3, rhs: simd.simd_float3x3) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_float3x3, rhs: simd.simd_float3x3) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Float, rhs: simd.simd_float3x3) -> simd.simd_float3x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x3, rhs: Swift.Float) -> simd.simd_float3x3 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_float3x3, rhs: Swift.Float) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_float3x3, rhs: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD3<Swift.Float>, rhs: simd.simd_float3x3) -> Swift.SIMD3<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x3, rhs: simd.float2x3) -> simd.float2x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x3, rhs: simd.float3x3) -> simd.float3x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x3, rhs: simd.float4x3) -> simd.float4x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_float3x3, rhs: simd.float3x3) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_float3x3(diagonal:)")
public func matrix_from_diagonal(_ d: Swift.SIMD3<Swift.Float>) -> simd.simd_float3x3
@available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
@available(swift, deprecated: 4, message: "Use the .inverse property instead.")
public func matrix_invert(_ x: simd.simd_float3x3) -> simd.simd_float3x3
@available(swift, deprecated: 4, message: "Use the .determinant property instead.")
public func matrix_determinant(_ x: simd.simd_float3x3) -> Swift.Float
@available(swift, deprecated: 4, renamed: "simd_float3x3")
public func matrix_from_columns(_ col0: Swift.SIMD3<Swift.Float>, _ col1: Swift.SIMD3<Swift.Float>, _ col2: Swift.SIMD3<Swift.Float>) -> simd.simd_float3x3
public func matrix_from_rows(_ row0: Swift.SIMD3<Swift.Float>, _ row1: Swift.SIMD3<Swift.Float>, _ row2: Swift.SIMD3<Swift.Float>) -> simd.simd_float3x3
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_float3x3) -> simd.float3x3
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_float3x3, _ rhs: simd.simd_float3x3) -> Swift.Bool
public typealias float4x3 = simd.simd_float4x3
extension simd.simd_float4x3 {
  @_transparent public init(_ scalar: Swift.Float) {
    self.init(diagonal: SIMD3<Float>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD3<Swift.Float>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
    self.columns.2.z = diagonal.z
  }
  @_transparent public init(_ columns: [Swift.SIMD3<Swift.Float>]) {
    precondition(columns.count == 4, "Requires array of 4 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
    self.columns.3 = columns[3]
  }
  @_transparent public init(rows: [Swift.SIMD4<Swift.Float>]) {
    precondition(rows.count == 3, "Requires array of 3 vectors")
    self = float3x4(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD3<Swift.Float>, _ col1: Swift.SIMD3<Swift.Float>, _ col2: Swift.SIMD3<Swift.Float>, _ col3: Swift.SIMD3<Swift.Float>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
      self.columns.3 = col3
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_float4x3) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_float4x3 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD3<Swift.Float> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      case 3: return columns.3
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      case 3: columns.3 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Float {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_float4x3 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_float4x3([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray), \(columns.3._descriptionAsArray)])"
  }
  }
}
extension simd.simd_float4x3 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_float4x3, rhs: simd.simd_float4x3) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_float4x3 {
  @_transparent public var transpose: simd.float3x4 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_float4x3, rhs: simd.simd_float4x3) -> simd.simd_float4x3 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_float4x3) -> simd.simd_float4x3 {
    return simd_float4x3() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_float4x3, rhs: simd.simd_float4x3) -> simd.simd_float4x3 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_float4x3, rhs: simd.simd_float4x3) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_float4x3, rhs: simd.simd_float4x3) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Float, rhs: simd.simd_float4x3) -> simd.simd_float4x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x3, rhs: Swift.Float) -> simd.simd_float4x3 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_float4x3, rhs: Swift.Float) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_float4x3, rhs: Swift.SIMD4<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD3<Swift.Float>, rhs: simd.simd_float4x3) -> Swift.SIMD4<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x3, rhs: simd.float2x4) -> simd.float2x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x3, rhs: simd.float3x4) -> simd.float3x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x3, rhs: simd.float4x4) -> simd.float4x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_float4x3, rhs: simd.float4x4) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_float4x3")
public func matrix_from_columns(_ col0: Swift.SIMD3<Swift.Float>, _ col1: Swift.SIMD3<Swift.Float>, _ col2: Swift.SIMD3<Swift.Float>, _ col3: Swift.SIMD3<Swift.Float>) -> simd.simd_float4x3
public func matrix_from_rows(_ row0: Swift.SIMD4<Swift.Float>, _ row1: Swift.SIMD4<Swift.Float>, _ row2: Swift.SIMD4<Swift.Float>) -> simd.simd_float4x3
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_float4x3) -> simd.float3x4
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_float4x3, _ rhs: simd.simd_float4x3) -> Swift.Bool
public typealias float2x4 = simd.simd_float2x4
extension simd.simd_float2x4 {
  @_transparent public init(_ scalar: Swift.Float) {
    self.init(diagonal: SIMD2<Float>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD2<Swift.Float>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
  }
  @_transparent public init(_ columns: [Swift.SIMD4<Swift.Float>]) {
    precondition(columns.count == 2, "Requires array of 2 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
  }
  @_transparent public init(rows: [Swift.SIMD2<Swift.Float>]) {
    precondition(rows.count == 4, "Requires array of 4 vectors")
    self = float4x2(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD4<Swift.Float>, _ col1: Swift.SIMD4<Swift.Float>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_float2x4) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_float2x4 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD4<Swift.Float> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Float {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_float2x4 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_float2x4([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray)])"
  }
  }
}
extension simd.simd_float2x4 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_float2x4, rhs: simd.simd_float2x4) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_float2x4 {
  @_transparent public var transpose: simd.float4x2 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_float2x4, rhs: simd.simd_float2x4) -> simd.simd_float2x4 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_float2x4) -> simd.simd_float2x4 {
    return simd_float2x4() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_float2x4, rhs: simd.simd_float2x4) -> simd.simd_float2x4 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_float2x4, rhs: simd.simd_float2x4) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_float2x4, rhs: simd.simd_float2x4) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Float, rhs: simd.simd_float2x4) -> simd.simd_float2x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x4, rhs: Swift.Float) -> simd.simd_float2x4 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_float2x4, rhs: Swift.Float) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_float2x4, rhs: Swift.SIMD2<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD4<Swift.Float>, rhs: simd.simd_float2x4) -> Swift.SIMD2<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x4, rhs: simd.float2x2) -> simd.float2x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x4, rhs: simd.float3x2) -> simd.float3x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float2x4, rhs: simd.float4x2) -> simd.float4x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_float2x4, rhs: simd.float2x2) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_float2x4")
public func matrix_from_columns(_ col0: Swift.SIMD4<Swift.Float>, _ col1: Swift.SIMD4<Swift.Float>) -> simd.simd_float2x4
public func matrix_from_rows(_ row0: Swift.SIMD2<Swift.Float>, _ row1: Swift.SIMD2<Swift.Float>, _ row2: Swift.SIMD2<Swift.Float>, _ row3: Swift.SIMD2<Swift.Float>) -> simd.simd_float2x4
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_float2x4) -> simd.float4x2
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_float2x4, _ rhs: simd.simd_float2x4) -> Swift.Bool
public typealias float3x4 = simd.simd_float3x4
extension simd.simd_float3x4 {
  @_transparent public init(_ scalar: Swift.Float) {
    self.init(diagonal: SIMD3<Float>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD3<Swift.Float>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
    self.columns.2.z = diagonal.z
  }
  @_transparent public init(_ columns: [Swift.SIMD4<Swift.Float>]) {
    precondition(columns.count == 3, "Requires array of 3 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
  }
  @_transparent public init(rows: [Swift.SIMD3<Swift.Float>]) {
    precondition(rows.count == 4, "Requires array of 4 vectors")
    self = float4x3(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD4<Swift.Float>, _ col1: Swift.SIMD4<Swift.Float>, _ col2: Swift.SIMD4<Swift.Float>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_float3x4) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_float3x4 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD4<Swift.Float> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Float {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_float3x4 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_float3x4([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray)])"
  }
  }
}
extension simd.simd_float3x4 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_float3x4, rhs: simd.simd_float3x4) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_float3x4 {
  @_transparent public var transpose: simd.float4x3 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_float3x4, rhs: simd.simd_float3x4) -> simd.simd_float3x4 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_float3x4) -> simd.simd_float3x4 {
    return simd_float3x4() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_float3x4, rhs: simd.simd_float3x4) -> simd.simd_float3x4 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_float3x4, rhs: simd.simd_float3x4) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_float3x4, rhs: simd.simd_float3x4) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Float, rhs: simd.simd_float3x4) -> simd.simd_float3x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x4, rhs: Swift.Float) -> simd.simd_float3x4 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_float3x4, rhs: Swift.Float) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_float3x4, rhs: Swift.SIMD3<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD4<Swift.Float>, rhs: simd.simd_float3x4) -> Swift.SIMD3<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x4, rhs: simd.float2x3) -> simd.float2x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x4, rhs: simd.float3x3) -> simd.float3x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float3x4, rhs: simd.float4x3) -> simd.float4x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_float3x4, rhs: simd.float3x3) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_float3x4")
public func matrix_from_columns(_ col0: Swift.SIMD4<Swift.Float>, _ col1: Swift.SIMD4<Swift.Float>, _ col2: Swift.SIMD4<Swift.Float>) -> simd.simd_float3x4
public func matrix_from_rows(_ row0: Swift.SIMD3<Swift.Float>, _ row1: Swift.SIMD3<Swift.Float>, _ row2: Swift.SIMD3<Swift.Float>, _ row3: Swift.SIMD3<Swift.Float>) -> simd.simd_float3x4
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_float3x4) -> simd.float4x3
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_float3x4, _ rhs: simd.simd_float3x4) -> Swift.Bool
public typealias float4x4 = simd.simd_float4x4
extension simd.simd_float4x4 {
  @_transparent public init(_ scalar: Swift.Float) {
    self.init(diagonal: SIMD4<Float>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD4<Swift.Float>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
    self.columns.2.z = diagonal.z
    self.columns.3.w = diagonal.w
  }
  @_transparent public init(_ columns: [Swift.SIMD4<Swift.Float>]) {
    precondition(columns.count == 4, "Requires array of 4 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
    self.columns.3 = columns[3]
  }
  @_transparent public init(rows: [Swift.SIMD4<Swift.Float>]) {
    precondition(rows.count == 4, "Requires array of 4 vectors")
    self = float4x4(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD4<Swift.Float>, _ col1: Swift.SIMD4<Swift.Float>, _ col2: Swift.SIMD4<Swift.Float>, _ col3: Swift.SIMD4<Swift.Float>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
      self.columns.3 = col3
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_float4x4) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_float4x4 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD4<Swift.Float> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      case 3: return columns.3
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      case 3: columns.3 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Float {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_float4x4 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_float4x4([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray), \(columns.3._descriptionAsArray)])"
  }
  }
}
extension simd.simd_float4x4 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_float4x4, rhs: simd.simd_float4x4) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_float4x4 {
  @_transparent public var transpose: simd.float4x4 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
  @_transparent public var inverse: simd.simd_float4x4 {
    @_transparent get {
    return simd_inverse(self)
  }
  }
  @_transparent public var determinant: Swift.Float {
    @_transparent get {
    return simd_determinant(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_float4x4, rhs: simd.simd_float4x4) -> simd.simd_float4x4 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_float4x4) -> simd.simd_float4x4 {
    return simd_float4x4() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_float4x4, rhs: simd.simd_float4x4) -> simd.simd_float4x4 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_float4x4, rhs: simd.simd_float4x4) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_float4x4, rhs: simd.simd_float4x4) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Float, rhs: simd.simd_float4x4) -> simd.simd_float4x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x4, rhs: Swift.Float) -> simd.simd_float4x4 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_float4x4, rhs: Swift.Float) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_float4x4, rhs: Swift.SIMD4<Swift.Float>) -> Swift.SIMD4<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD4<Swift.Float>, rhs: simd.simd_float4x4) -> Swift.SIMD4<Swift.Float> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x4, rhs: simd.float2x4) -> simd.float2x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x4, rhs: simd.float3x4) -> simd.float3x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_float4x4, rhs: simd.float4x4) -> simd.float4x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_float4x4, rhs: simd.float4x4) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_float4x4(diagonal:)")
public func matrix_from_diagonal(_ d: Swift.SIMD4<Swift.Float>) -> simd.simd_float4x4
@available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
@available(swift, deprecated: 4, message: "Use the .inverse property instead.")
public func matrix_invert(_ x: simd.simd_float4x4) -> simd.simd_float4x4
@available(swift, deprecated: 4, message: "Use the .determinant property instead.")
public func matrix_determinant(_ x: simd.simd_float4x4) -> Swift.Float
@available(swift, deprecated: 4, renamed: "simd_float4x4")
public func matrix_from_columns(_ col0: Swift.SIMD4<Swift.Float>, _ col1: Swift.SIMD4<Swift.Float>, _ col2: Swift.SIMD4<Swift.Float>, _ col3: Swift.SIMD4<Swift.Float>) -> simd.simd_float4x4
public func matrix_from_rows(_ row0: Swift.SIMD4<Swift.Float>, _ row1: Swift.SIMD4<Swift.Float>, _ row2: Swift.SIMD4<Swift.Float>, _ row3: Swift.SIMD4<Swift.Float>) -> simd.simd_float4x4
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_float4x4) -> simd.float4x4
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_float4x4, _ rhs: simd.simd_float4x4) -> Swift.Bool
public typealias double2x2 = simd.simd_double2x2
extension simd.simd_double2x2 {
  @_transparent public init(_ scalar: Swift.Double) {
    self.init(diagonal: SIMD2<Double>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD2<Swift.Double>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
  }
  @_transparent public init(_ columns: [Swift.SIMD2<Swift.Double>]) {
    precondition(columns.count == 2, "Requires array of 2 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
  }
  @_transparent public init(rows: [Swift.SIMD2<Swift.Double>]) {
    precondition(rows.count == 2, "Requires array of 2 vectors")
    self = double2x2(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD2<Swift.Double>, _ col1: Swift.SIMD2<Swift.Double>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_double2x2) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_double2x2 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD2<Swift.Double> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Double {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_double2x2 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_double2x2([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray)])"
  }
  }
}
extension simd.simd_double2x2 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_double2x2, rhs: simd.simd_double2x2) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_double2x2 {
  @_transparent public var transpose: simd.double2x2 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
  @_transparent public var inverse: simd.simd_double2x2 {
    @_transparent get {
    return simd_inverse(self)
  }
  }
  @_transparent public var determinant: Swift.Double {
    @_transparent get {
    return simd_determinant(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_double2x2, rhs: simd.simd_double2x2) -> simd.simd_double2x2 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_double2x2) -> simd.simd_double2x2 {
    return simd_double2x2() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_double2x2, rhs: simd.simd_double2x2) -> simd.simd_double2x2 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_double2x2, rhs: simd.simd_double2x2) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_double2x2, rhs: simd.simd_double2x2) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Double, rhs: simd.simd_double2x2) -> simd.simd_double2x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x2, rhs: Swift.Double) -> simd.simd_double2x2 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_double2x2, rhs: Swift.Double) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_double2x2, rhs: Swift.SIMD2<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD2<Swift.Double>, rhs: simd.simd_double2x2) -> Swift.SIMD2<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x2, rhs: simd.double2x2) -> simd.double2x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x2, rhs: simd.double3x2) -> simd.double3x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x2, rhs: simd.double4x2) -> simd.double4x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_double2x2, rhs: simd.double2x2) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_double2x2(diagonal:)")
public func matrix_from_diagonal(_ d: Swift.SIMD2<Swift.Double>) -> simd.simd_double2x2
@available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
@available(swift, deprecated: 4, message: "Use the .inverse property instead.")
public func matrix_invert(_ x: simd.simd_double2x2) -> simd.simd_double2x2
@available(swift, deprecated: 4, message: "Use the .determinant property instead.")
public func matrix_determinant(_ x: simd.simd_double2x2) -> Swift.Double
@available(swift, deprecated: 4, renamed: "simd_double2x2")
public func matrix_from_columns(_ col0: Swift.SIMD2<Swift.Double>, _ col1: Swift.SIMD2<Swift.Double>) -> simd.simd_double2x2
public func matrix_from_rows(_ row0: Swift.SIMD2<Swift.Double>, _ row1: Swift.SIMD2<Swift.Double>) -> simd.simd_double2x2
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_double2x2) -> simd.double2x2
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_double2x2, _ rhs: simd.simd_double2x2) -> Swift.Bool
public typealias double3x2 = simd.simd_double3x2
extension simd.simd_double3x2 {
  @_transparent public init(_ scalar: Swift.Double) {
    self.init(diagonal: SIMD2<Double>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD2<Swift.Double>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
  }
  @_transparent public init(_ columns: [Swift.SIMD2<Swift.Double>]) {
    precondition(columns.count == 3, "Requires array of 3 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
  }
  @_transparent public init(rows: [Swift.SIMD3<Swift.Double>]) {
    precondition(rows.count == 2, "Requires array of 2 vectors")
    self = double2x3(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD2<Swift.Double>, _ col1: Swift.SIMD2<Swift.Double>, _ col2: Swift.SIMD2<Swift.Double>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_double3x2) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_double3x2 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD2<Swift.Double> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Double {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_double3x2 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_double3x2([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray)])"
  }
  }
}
extension simd.simd_double3x2 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_double3x2, rhs: simd.simd_double3x2) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_double3x2 {
  @_transparent public var transpose: simd.double2x3 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_double3x2, rhs: simd.simd_double3x2) -> simd.simd_double3x2 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_double3x2) -> simd.simd_double3x2 {
    return simd_double3x2() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_double3x2, rhs: simd.simd_double3x2) -> simd.simd_double3x2 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_double3x2, rhs: simd.simd_double3x2) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_double3x2, rhs: simd.simd_double3x2) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Double, rhs: simd.simd_double3x2) -> simd.simd_double3x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x2, rhs: Swift.Double) -> simd.simd_double3x2 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_double3x2, rhs: Swift.Double) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_double3x2, rhs: Swift.SIMD3<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD2<Swift.Double>, rhs: simd.simd_double3x2) -> Swift.SIMD3<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x2, rhs: simd.double2x3) -> simd.double2x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x2, rhs: simd.double3x3) -> simd.double3x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x2, rhs: simd.double4x3) -> simd.double4x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_double3x2, rhs: simd.double3x3) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_double3x2")
public func matrix_from_columns(_ col0: Swift.SIMD2<Swift.Double>, _ col1: Swift.SIMD2<Swift.Double>, _ col2: Swift.SIMD2<Swift.Double>) -> simd.simd_double3x2
public func matrix_from_rows(_ row0: Swift.SIMD3<Swift.Double>, _ row1: Swift.SIMD3<Swift.Double>) -> simd.simd_double3x2
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_double3x2) -> simd.double2x3
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_double3x2, _ rhs: simd.simd_double3x2) -> Swift.Bool
public typealias double4x2 = simd.simd_double4x2
extension simd.simd_double4x2 {
  @_transparent public init(_ scalar: Swift.Double) {
    self.init(diagonal: SIMD2<Double>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD2<Swift.Double>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
  }
  @_transparent public init(_ columns: [Swift.SIMD2<Swift.Double>]) {
    precondition(columns.count == 4, "Requires array of 4 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
    self.columns.3 = columns[3]
  }
  @_transparent public init(rows: [Swift.SIMD4<Swift.Double>]) {
    precondition(rows.count == 2, "Requires array of 2 vectors")
    self = double2x4(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD2<Swift.Double>, _ col1: Swift.SIMD2<Swift.Double>, _ col2: Swift.SIMD2<Swift.Double>, _ col3: Swift.SIMD2<Swift.Double>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
      self.columns.3 = col3
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_double4x2) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_double4x2 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD2<Swift.Double> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      case 3: return columns.3
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      case 3: columns.3 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Double {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_double4x2 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_double4x2([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray), \(columns.3._descriptionAsArray)])"
  }
  }
}
extension simd.simd_double4x2 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_double4x2, rhs: simd.simd_double4x2) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_double4x2 {
  @_transparent public var transpose: simd.double2x4 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_double4x2, rhs: simd.simd_double4x2) -> simd.simd_double4x2 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_double4x2) -> simd.simd_double4x2 {
    return simd_double4x2() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_double4x2, rhs: simd.simd_double4x2) -> simd.simd_double4x2 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_double4x2, rhs: simd.simd_double4x2) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_double4x2, rhs: simd.simd_double4x2) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Double, rhs: simd.simd_double4x2) -> simd.simd_double4x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x2, rhs: Swift.Double) -> simd.simd_double4x2 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_double4x2, rhs: Swift.Double) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_double4x2, rhs: Swift.SIMD4<Swift.Double>) -> Swift.SIMD2<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD2<Swift.Double>, rhs: simd.simd_double4x2) -> Swift.SIMD4<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x2, rhs: simd.double2x4) -> simd.double2x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x2, rhs: simd.double3x4) -> simd.double3x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x2, rhs: simd.double4x4) -> simd.double4x2 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_double4x2, rhs: simd.double4x4) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_double4x2")
public func matrix_from_columns(_ col0: Swift.SIMD2<Swift.Double>, _ col1: Swift.SIMD2<Swift.Double>, _ col2: Swift.SIMD2<Swift.Double>, _ col3: Swift.SIMD2<Swift.Double>) -> simd.simd_double4x2
public func matrix_from_rows(_ row0: Swift.SIMD4<Swift.Double>, _ row1: Swift.SIMD4<Swift.Double>) -> simd.simd_double4x2
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_double4x2) -> simd.double2x4
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_double4x2, _ rhs: simd.simd_double4x2) -> Swift.Bool
public typealias double2x3 = simd.simd_double2x3
extension simd.simd_double2x3 {
  @_transparent public init(_ scalar: Swift.Double) {
    self.init(diagonal: SIMD2<Double>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD2<Swift.Double>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
  }
  @_transparent public init(_ columns: [Swift.SIMD3<Swift.Double>]) {
    precondition(columns.count == 2, "Requires array of 2 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
  }
  @_transparent public init(rows: [Swift.SIMD2<Swift.Double>]) {
    precondition(rows.count == 3, "Requires array of 3 vectors")
    self = double3x2(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD3<Swift.Double>, _ col1: Swift.SIMD3<Swift.Double>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_double2x3) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_double2x3 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD3<Swift.Double> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Double {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_double2x3 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_double2x3([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray)])"
  }
  }
}
extension simd.simd_double2x3 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_double2x3, rhs: simd.simd_double2x3) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_double2x3 {
  @_transparent public var transpose: simd.double3x2 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_double2x3, rhs: simd.simd_double2x3) -> simd.simd_double2x3 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_double2x3) -> simd.simd_double2x3 {
    return simd_double2x3() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_double2x3, rhs: simd.simd_double2x3) -> simd.simd_double2x3 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_double2x3, rhs: simd.simd_double2x3) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_double2x3, rhs: simd.simd_double2x3) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Double, rhs: simd.simd_double2x3) -> simd.simd_double2x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x3, rhs: Swift.Double) -> simd.simd_double2x3 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_double2x3, rhs: Swift.Double) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_double2x3, rhs: Swift.SIMD2<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD3<Swift.Double>, rhs: simd.simd_double2x3) -> Swift.SIMD2<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x3, rhs: simd.double2x2) -> simd.double2x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x3, rhs: simd.double3x2) -> simd.double3x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x3, rhs: simd.double4x2) -> simd.double4x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_double2x3, rhs: simd.double2x2) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_double2x3")
public func matrix_from_columns(_ col0: Swift.SIMD3<Swift.Double>, _ col1: Swift.SIMD3<Swift.Double>) -> simd.simd_double2x3
public func matrix_from_rows(_ row0: Swift.SIMD2<Swift.Double>, _ row1: Swift.SIMD2<Swift.Double>, _ row2: Swift.SIMD2<Swift.Double>) -> simd.simd_double2x3
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_double2x3) -> simd.double3x2
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_double2x3, _ rhs: simd.simd_double2x3) -> Swift.Bool
public typealias double3x3 = simd.simd_double3x3
extension simd.simd_double3x3 {
  @_transparent public init(_ scalar: Swift.Double) {
    self.init(diagonal: SIMD3<Double>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD3<Swift.Double>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
    self.columns.2.z = diagonal.z
  }
  @_transparent public init(_ columns: [Swift.SIMD3<Swift.Double>]) {
    precondition(columns.count == 3, "Requires array of 3 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
  }
  @_transparent public init(rows: [Swift.SIMD3<Swift.Double>]) {
    precondition(rows.count == 3, "Requires array of 3 vectors")
    self = double3x3(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD3<Swift.Double>, _ col1: Swift.SIMD3<Swift.Double>, _ col2: Swift.SIMD3<Swift.Double>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_double3x3) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_double3x3 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD3<Swift.Double> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Double {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_double3x3 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_double3x3([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray)])"
  }
  }
}
extension simd.simd_double3x3 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_double3x3, rhs: simd.simd_double3x3) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_double3x3 {
  @_transparent public var transpose: simd.double3x3 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
  @_transparent public var inverse: simd.simd_double3x3 {
    @_transparent get {
    return simd_inverse(self)
  }
  }
  @_transparent public var determinant: Swift.Double {
    @_transparent get {
    return simd_determinant(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_double3x3, rhs: simd.simd_double3x3) -> simd.simd_double3x3 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_double3x3) -> simd.simd_double3x3 {
    return simd_double3x3() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_double3x3, rhs: simd.simd_double3x3) -> simd.simd_double3x3 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_double3x3, rhs: simd.simd_double3x3) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_double3x3, rhs: simd.simd_double3x3) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Double, rhs: simd.simd_double3x3) -> simd.simd_double3x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x3, rhs: Swift.Double) -> simd.simd_double3x3 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_double3x3, rhs: Swift.Double) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_double3x3, rhs: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD3<Swift.Double>, rhs: simd.simd_double3x3) -> Swift.SIMD3<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x3, rhs: simd.double2x3) -> simd.double2x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x3, rhs: simd.double3x3) -> simd.double3x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x3, rhs: simd.double4x3) -> simd.double4x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_double3x3, rhs: simd.double3x3) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_double3x3(diagonal:)")
public func matrix_from_diagonal(_ d: Swift.SIMD3<Swift.Double>) -> simd.simd_double3x3
@available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
@available(swift, deprecated: 4, message: "Use the .inverse property instead.")
public func matrix_invert(_ x: simd.simd_double3x3) -> simd.simd_double3x3
@available(swift, deprecated: 4, message: "Use the .determinant property instead.")
public func matrix_determinant(_ x: simd.simd_double3x3) -> Swift.Double
@available(swift, deprecated: 4, renamed: "simd_double3x3")
public func matrix_from_columns(_ col0: Swift.SIMD3<Swift.Double>, _ col1: Swift.SIMD3<Swift.Double>, _ col2: Swift.SIMD3<Swift.Double>) -> simd.simd_double3x3
public func matrix_from_rows(_ row0: Swift.SIMD3<Swift.Double>, _ row1: Swift.SIMD3<Swift.Double>, _ row2: Swift.SIMD3<Swift.Double>) -> simd.simd_double3x3
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_double3x3) -> simd.double3x3
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_double3x3, _ rhs: simd.simd_double3x3) -> Swift.Bool
public typealias double4x3 = simd.simd_double4x3
extension simd.simd_double4x3 {
  @_transparent public init(_ scalar: Swift.Double) {
    self.init(diagonal: SIMD3<Double>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD3<Swift.Double>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
    self.columns.2.z = diagonal.z
  }
  @_transparent public init(_ columns: [Swift.SIMD3<Swift.Double>]) {
    precondition(columns.count == 4, "Requires array of 4 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
    self.columns.3 = columns[3]
  }
  @_transparent public init(rows: [Swift.SIMD4<Swift.Double>]) {
    precondition(rows.count == 3, "Requires array of 3 vectors")
    self = double3x4(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD3<Swift.Double>, _ col1: Swift.SIMD3<Swift.Double>, _ col2: Swift.SIMD3<Swift.Double>, _ col3: Swift.SIMD3<Swift.Double>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
      self.columns.3 = col3
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_double4x3) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_double4x3 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD3<Swift.Double> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      case 3: return columns.3
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      case 3: columns.3 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Double {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_double4x3 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_double4x3([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray), \(columns.3._descriptionAsArray)])"
  }
  }
}
extension simd.simd_double4x3 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_double4x3, rhs: simd.simd_double4x3) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_double4x3 {
  @_transparent public var transpose: simd.double3x4 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_double4x3, rhs: simd.simd_double4x3) -> simd.simd_double4x3 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_double4x3) -> simd.simd_double4x3 {
    return simd_double4x3() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_double4x3, rhs: simd.simd_double4x3) -> simd.simd_double4x3 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_double4x3, rhs: simd.simd_double4x3) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_double4x3, rhs: simd.simd_double4x3) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Double, rhs: simd.simd_double4x3) -> simd.simd_double4x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x3, rhs: Swift.Double) -> simd.simd_double4x3 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_double4x3, rhs: Swift.Double) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_double4x3, rhs: Swift.SIMD4<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD3<Swift.Double>, rhs: simd.simd_double4x3) -> Swift.SIMD4<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x3, rhs: simd.double2x4) -> simd.double2x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x3, rhs: simd.double3x4) -> simd.double3x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x3, rhs: simd.double4x4) -> simd.double4x3 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_double4x3, rhs: simd.double4x4) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_double4x3")
public func matrix_from_columns(_ col0: Swift.SIMD3<Swift.Double>, _ col1: Swift.SIMD3<Swift.Double>, _ col2: Swift.SIMD3<Swift.Double>, _ col3: Swift.SIMD3<Swift.Double>) -> simd.simd_double4x3
public func matrix_from_rows(_ row0: Swift.SIMD4<Swift.Double>, _ row1: Swift.SIMD4<Swift.Double>, _ row2: Swift.SIMD4<Swift.Double>) -> simd.simd_double4x3
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_double4x3) -> simd.double3x4
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_double4x3, _ rhs: simd.simd_double4x3) -> Swift.Bool
public typealias double2x4 = simd.simd_double2x4
extension simd.simd_double2x4 {
  @_transparent public init(_ scalar: Swift.Double) {
    self.init(diagonal: SIMD2<Double>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD2<Swift.Double>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
  }
  @_transparent public init(_ columns: [Swift.SIMD4<Swift.Double>]) {
    precondition(columns.count == 2, "Requires array of 2 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
  }
  @_transparent public init(rows: [Swift.SIMD2<Swift.Double>]) {
    precondition(rows.count == 4, "Requires array of 4 vectors")
    self = double4x2(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD4<Swift.Double>, _ col1: Swift.SIMD4<Swift.Double>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_double2x4) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_double2x4 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD4<Swift.Double> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Double {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_double2x4 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_double2x4([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray)])"
  }
  }
}
extension simd.simd_double2x4 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_double2x4, rhs: simd.simd_double2x4) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_double2x4 {
  @_transparent public var transpose: simd.double4x2 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_double2x4, rhs: simd.simd_double2x4) -> simd.simd_double2x4 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_double2x4) -> simd.simd_double2x4 {
    return simd_double2x4() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_double2x4, rhs: simd.simd_double2x4) -> simd.simd_double2x4 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_double2x4, rhs: simd.simd_double2x4) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_double2x4, rhs: simd.simd_double2x4) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Double, rhs: simd.simd_double2x4) -> simd.simd_double2x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x4, rhs: Swift.Double) -> simd.simd_double2x4 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_double2x4, rhs: Swift.Double) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_double2x4, rhs: Swift.SIMD2<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD4<Swift.Double>, rhs: simd.simd_double2x4) -> Swift.SIMD2<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x4, rhs: simd.double2x2) -> simd.double2x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x4, rhs: simd.double3x2) -> simd.double3x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double2x4, rhs: simd.double4x2) -> simd.double4x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_double2x4, rhs: simd.double2x2) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_double2x4")
public func matrix_from_columns(_ col0: Swift.SIMD4<Swift.Double>, _ col1: Swift.SIMD4<Swift.Double>) -> simd.simd_double2x4
public func matrix_from_rows(_ row0: Swift.SIMD2<Swift.Double>, _ row1: Swift.SIMD2<Swift.Double>, _ row2: Swift.SIMD2<Swift.Double>, _ row3: Swift.SIMD2<Swift.Double>) -> simd.simd_double2x4
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_double2x4) -> simd.double4x2
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_double2x4, _ rhs: simd.simd_double2x4) -> Swift.Bool
public typealias double3x4 = simd.simd_double3x4
extension simd.simd_double3x4 {
  @_transparent public init(_ scalar: Swift.Double) {
    self.init(diagonal: SIMD3<Double>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD3<Swift.Double>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
    self.columns.2.z = diagonal.z
  }
  @_transparent public init(_ columns: [Swift.SIMD4<Swift.Double>]) {
    precondition(columns.count == 3, "Requires array of 3 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
  }
  @_transparent public init(rows: [Swift.SIMD3<Swift.Double>]) {
    precondition(rows.count == 4, "Requires array of 4 vectors")
    self = double4x3(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD4<Swift.Double>, _ col1: Swift.SIMD4<Swift.Double>, _ col2: Swift.SIMD4<Swift.Double>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_double3x4) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_double3x4 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD4<Swift.Double> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Double {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_double3x4 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_double3x4([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray)])"
  }
  }
}
extension simd.simd_double3x4 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_double3x4, rhs: simd.simd_double3x4) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_double3x4 {
  @_transparent public var transpose: simd.double4x3 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_double3x4, rhs: simd.simd_double3x4) -> simd.simd_double3x4 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_double3x4) -> simd.simd_double3x4 {
    return simd_double3x4() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_double3x4, rhs: simd.simd_double3x4) -> simd.simd_double3x4 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_double3x4, rhs: simd.simd_double3x4) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_double3x4, rhs: simd.simd_double3x4) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Double, rhs: simd.simd_double3x4) -> simd.simd_double3x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x4, rhs: Swift.Double) -> simd.simd_double3x4 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_double3x4, rhs: Swift.Double) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_double3x4, rhs: Swift.SIMD3<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD4<Swift.Double>, rhs: simd.simd_double3x4) -> Swift.SIMD3<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x4, rhs: simd.double2x3) -> simd.double2x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x4, rhs: simd.double3x3) -> simd.double3x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double3x4, rhs: simd.double4x3) -> simd.double4x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_double3x4, rhs: simd.double3x3) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_double3x4")
public func matrix_from_columns(_ col0: Swift.SIMD4<Swift.Double>, _ col1: Swift.SIMD4<Swift.Double>, _ col2: Swift.SIMD4<Swift.Double>) -> simd.simd_double3x4
public func matrix_from_rows(_ row0: Swift.SIMD3<Swift.Double>, _ row1: Swift.SIMD3<Swift.Double>, _ row2: Swift.SIMD3<Swift.Double>, _ row3: Swift.SIMD3<Swift.Double>) -> simd.simd_double3x4
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_double3x4) -> simd.double4x3
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_double3x4, _ rhs: simd.simd_double3x4) -> Swift.Bool
public typealias double4x4 = simd.simd_double4x4
extension simd.simd_double4x4 {
  @_transparent public init(_ scalar: Swift.Double) {
    self.init(diagonal: SIMD4<Double>(repeating: scalar))
  }
  @_transparent public init(diagonal: Swift.SIMD4<Swift.Double>) {
    self.init()
    self.columns.0.x = diagonal.x
    self.columns.1.y = diagonal.y
    self.columns.2.z = diagonal.z
    self.columns.3.w = diagonal.w
  }
  @_transparent public init(_ columns: [Swift.SIMD4<Swift.Double>]) {
    precondition(columns.count == 4, "Requires array of 4 vectors")
    self.init()
    self.columns.0 = columns[0]
    self.columns.1 = columns[1]
    self.columns.2 = columns[2]
    self.columns.3 = columns[3]
  }
  @_transparent public init(rows: [Swift.SIMD4<Swift.Double>]) {
    precondition(rows.count == 4, "Requires array of 4 vectors")
    self = double4x4(rows).transpose
  }
  @_transparent public init(_ col0: Swift.SIMD4<Swift.Double>, _ col1: Swift.SIMD4<Swift.Double>, _ col2: Swift.SIMD4<Swift.Double>, _ col3: Swift.SIMD4<Swift.Double>) {
    self.init()
      self.columns.0 = col0
      self.columns.1 = col1
      self.columns.2 = col2
      self.columns.3 = col3
  }
  @available(swift, deprecated: 4, message: "This conversion is no longer necessary; use `cmatrix` directly.")
  @_transparent public init(_ cmatrix: simd.simd_double4x4) {
    self = cmatrix
  }
  @available(swift, deprecated: 4, message: "This property is no longer needed; use the matrix itself.")
  @_transparent public var cmatrix: simd.simd_double4x4 {
    @_transparent get {
    return self
  }
  }
  public subscript(column: Swift.Int) -> Swift.SIMD4<Swift.Double> {
    @_transparent get {
      switch(column) {
      case 0: return columns.0
      case 1: return columns.1
      case 2: return columns.2
      case 3: return columns.3
      default: preconditionFailure("Column index out of range")
      }
    }
    @_transparent set(value) {
      switch(column) {
      case 0: columns.0 = value
      case 1: columns.1 = value
      case 2: columns.2 = value
      case 3: columns.3 = value
      default: preconditionFailure("Column index out of range")
      }
    }
  }
  public subscript(column: Swift.Int, row: Swift.Int) -> Swift.Double {
    @_transparent get { return self[column][row] }
    @_transparent set(value) { self[column][row] = value }
  }
}
extension simd.simd_double4x4 : Swift.CustomDebugStringConvertible {
  @inlinable public var debugDescription: Swift.String {
    get {
    return "simd_double4x4([\(columns.0._descriptionAsArray), \(columns.1._descriptionAsArray), \(columns.2._descriptionAsArray), \(columns.3._descriptionAsArray)])"
  }
  }
}
extension simd.simd_double4x4 : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_double4x4, rhs: simd.simd_double4x4) -> Swift.Bool {
    return simd_equal(lhs, rhs)
  }
}
extension simd.simd_double4x4 {
  @_transparent public var transpose: simd.double4x4 {
    @_transparent get {
    return simd_transpose(self)
  }
  }
  @available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
  @_transparent public var inverse: simd.simd_double4x4 {
    @_transparent get {
    return simd_inverse(self)
  }
  }
  @_transparent public var determinant: Swift.Double {
    @_transparent get {
    return simd_determinant(self)
  }
  }
  @_transparent public static func + (lhs: simd.simd_double4x4, rhs: simd.simd_double4x4) -> simd.simd_double4x4 {
    return simd_add(lhs, rhs)
  }
  @_transparent prefix public static func - (rhs: simd.simd_double4x4) -> simd.simd_double4x4 {
    return simd_double4x4() - rhs
  }
  @_transparent public static func - (lhs: simd.simd_double4x4, rhs: simd.simd_double4x4) -> simd.simd_double4x4 {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_double4x4, rhs: simd.simd_double4x4) {
    lhs = lhs + rhs
  }
  @_transparent public static func -= (lhs: inout simd.simd_double4x4, rhs: simd.simd_double4x4) {
    lhs = lhs - rhs
  }
  @_transparent public static func * (lhs: Swift.Double, rhs: simd.simd_double4x4) -> simd.simd_double4x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x4, rhs: Swift.Double) -> simd.simd_double4x4 {
    return rhs*lhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_double4x4, rhs: Swift.Double) {
    lhs = lhs*rhs
  }
  @_transparent public static func * (lhs: simd.simd_double4x4, rhs: Swift.SIMD4<Swift.Double>) -> Swift.SIMD4<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.SIMD4<Swift.Double>, rhs: simd.simd_double4x4) -> Swift.SIMD4<Swift.Double> {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x4, rhs: simd.double2x4) -> simd.double2x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x4, rhs: simd.double3x4) -> simd.double3x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_double4x4, rhs: simd.double4x4) -> simd.double4x4 {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_double4x4, rhs: simd.double4x4) {
    lhs = lhs*rhs
  }
}
@available(swift, deprecated: 4, renamed: "simd_double4x4(diagonal:)")
public func matrix_from_diagonal(_ d: Swift.SIMD4<Swift.Double>) -> simd.simd_double4x4
@available(macOS 10.10, iOS 8.0, tvOS 10.0, watchOS 3.0, *)
@available(swift, deprecated: 4, message: "Use the .inverse property instead.")
public func matrix_invert(_ x: simd.simd_double4x4) -> simd.simd_double4x4
@available(swift, deprecated: 4, message: "Use the .determinant property instead.")
public func matrix_determinant(_ x: simd.simd_double4x4) -> Swift.Double
@available(swift, deprecated: 4, renamed: "simd_double4x4")
public func matrix_from_columns(_ col0: Swift.SIMD4<Swift.Double>, _ col1: Swift.SIMD4<Swift.Double>, _ col2: Swift.SIMD4<Swift.Double>, _ col3: Swift.SIMD4<Swift.Double>) -> simd.simd_double4x4
public func matrix_from_rows(_ row0: Swift.SIMD4<Swift.Double>, _ row1: Swift.SIMD4<Swift.Double>, _ row2: Swift.SIMD4<Swift.Double>, _ row3: Swift.SIMD4<Swift.Double>) -> simd.simd_double4x4
@available(swift, deprecated: 4, message: "Use the .transpose property instead.")
public func matrix_transpose(_ x: simd.simd_double4x4) -> simd.double4x4
@available(swift, deprecated: 4, renamed: "==")
public func matrix_equal(_ lhs: simd.simd_double4x4, _ rhs: simd.simd_double4x4) -> Swift.Bool
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincos(_ x: simd.simd_double2) -> (sin: simd.simd_double2, cos: simd.simd_double2) {
    
    var sinResult = simd_double2()
    var cosResult = simd_double2()
    
    __tg_sincos(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincospi(_ x: simd.simd_double2) -> (sin: simd.simd_double2, cos: simd.simd_double2) {
    
    var sinResult = simd_double2()
    var cosResult = simd_double2()
    
    __tg_sincospi(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cos(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_cos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cosh(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_cosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cospi(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_cospi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acos(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_acos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acosh(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_acosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sin(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_sin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinh(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_sinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinpi(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_sinpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asin(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_asin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asinh(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_asinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tan(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_tan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanh(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_tanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanpi(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_tanpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_atan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atanh(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_atanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan2(_ x: simd.simd_double2, _ y: simd.simd_double2) -> simd.simd_double2 {
  return __tg_atan2(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_exp(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp2(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_exp2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp10(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_exp10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func expm1(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_expm1(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_log(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log2(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_log2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log10(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_log10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log1p(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_log1p(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func lgamma(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_lgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tgamma(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_tgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erf(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_erf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erfc(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_erfc(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cbrt(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_cbrt(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func pow(_ x: simd.simd_double2, _ y: simd.simd_double2) -> simd.simd_double2 {
  return __tg_pow(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func hypot(_ x: simd.simd_double2, _ y: simd.simd_double2) -> simd.simd_double2 {
  return __tg_hypot(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fma(_ x: simd.simd_double2, _ y: simd.simd_double2, _ z: simd.simd_double2) -> simd.simd_double2 {
  return __tg_fma(x, y, z)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func round(_ x: simd.simd_double2) -> simd.simd_double2 {
  return __tg_round(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fmod(_ x: simd.simd_double2, _ y: simd.simd_double2) -> simd.simd_double2 {
  return __tg_fmod(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func remainder(_ x: simd.simd_double2, _ y: simd.simd_double2) -> simd.simd_double2 {
  return __tg_remainder(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func nextafter(_ x: simd.simd_double2, _ y: simd.simd_double2) -> simd.simd_double2 {
  return __tg_nextafter(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isfinite(_ x: simd.simd_double2) -> simd.simd_long2 {
  return __tg_isfinite(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isinf(_ x: simd.simd_double2) -> simd.simd_long2 {
  return __tg_isinf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnan(_ x: simd.simd_double2) -> simd.simd_long2 {
  return __tg_isnan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnormal(_ x: simd.simd_double2) -> simd.simd_long2 {
  return __tg_isnormal(x)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincos(_ x: simd.simd_double3) -> (sin: simd.simd_double3, cos: simd.simd_double3) {
    
    var sinResult = simd_double3()
    var cosResult = simd_double3()
    
    __tg_sincos(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincospi(_ x: simd.simd_double3) -> (sin: simd.simd_double3, cos: simd.simd_double3) {
    
    var sinResult = simd_double3()
    var cosResult = simd_double3()
    
    __tg_sincospi(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cos(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_cos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cosh(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_cosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cospi(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_cospi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acos(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_acos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acosh(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_acosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sin(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_sin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinh(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_sinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinpi(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_sinpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asin(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_asin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asinh(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_asinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tan(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_tan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanh(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_tanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanpi(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_tanpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_atan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atanh(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_atanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan2(_ x: simd.simd_double3, _ y: simd.simd_double3) -> simd.simd_double3 {
  return __tg_atan2(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_exp(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp2(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_exp2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp10(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_exp10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func expm1(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_expm1(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_log(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log2(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_log2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log10(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_log10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log1p(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_log1p(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func lgamma(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_lgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tgamma(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_tgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erf(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_erf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erfc(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_erfc(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cbrt(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_cbrt(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func pow(_ x: simd.simd_double3, _ y: simd.simd_double3) -> simd.simd_double3 {
  return __tg_pow(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func hypot(_ x: simd.simd_double3, _ y: simd.simd_double3) -> simd.simd_double3 {
  return __tg_hypot(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fma(_ x: simd.simd_double3, _ y: simd.simd_double3, _ z: simd.simd_double3) -> simd.simd_double3 {
  return __tg_fma(x, y, z)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func round(_ x: simd.simd_double3) -> simd.simd_double3 {
  return __tg_round(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fmod(_ x: simd.simd_double3, _ y: simd.simd_double3) -> simd.simd_double3 {
  return __tg_fmod(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func remainder(_ x: simd.simd_double3, _ y: simd.simd_double3) -> simd.simd_double3 {
  return __tg_remainder(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func nextafter(_ x: simd.simd_double3, _ y: simd.simd_double3) -> simd.simd_double3 {
  return __tg_nextafter(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isfinite(_ x: simd.simd_double3) -> simd.simd_long3 {
  return __tg_isfinite(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isinf(_ x: simd.simd_double3) -> simd.simd_long3 {
  return __tg_isinf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnan(_ x: simd.simd_double3) -> simd.simd_long3 {
  return __tg_isnan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnormal(_ x: simd.simd_double3) -> simd.simd_long3 {
  return __tg_isnormal(x)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincos(_ x: simd.simd_double4) -> (sin: simd.simd_double4, cos: simd.simd_double4) {
    
    var sinResult = simd_double4()
    var cosResult = simd_double4()
    
    __tg_sincos(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincospi(_ x: simd.simd_double4) -> (sin: simd.simd_double4, cos: simd.simd_double4) {
    
    var sinResult = simd_double4()
    var cosResult = simd_double4()
    
    __tg_sincospi(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cos(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_cos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cosh(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_cosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cospi(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_cospi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acos(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_acos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acosh(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_acosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sin(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_sin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinh(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_sinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinpi(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_sinpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asin(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_asin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asinh(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_asinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tan(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_tan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanh(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_tanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanpi(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_tanpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_atan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atanh(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_atanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan2(_ x: simd.simd_double4, _ y: simd.simd_double4) -> simd.simd_double4 {
  return __tg_atan2(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_exp(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp2(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_exp2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp10(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_exp10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func expm1(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_expm1(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_log(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log2(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_log2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log10(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_log10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log1p(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_log1p(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func lgamma(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_lgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tgamma(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_tgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erf(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_erf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erfc(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_erfc(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cbrt(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_cbrt(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func pow(_ x: simd.simd_double4, _ y: simd.simd_double4) -> simd.simd_double4 {
  return __tg_pow(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func hypot(_ x: simd.simd_double4, _ y: simd.simd_double4) -> simd.simd_double4 {
  return __tg_hypot(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fma(_ x: simd.simd_double4, _ y: simd.simd_double4, _ z: simd.simd_double4) -> simd.simd_double4 {
  return __tg_fma(x, y, z)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func round(_ x: simd.simd_double4) -> simd.simd_double4 {
  return __tg_round(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fmod(_ x: simd.simd_double4, _ y: simd.simd_double4) -> simd.simd_double4 {
  return __tg_fmod(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func remainder(_ x: simd.simd_double4, _ y: simd.simd_double4) -> simd.simd_double4 {
  return __tg_remainder(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func nextafter(_ x: simd.simd_double4, _ y: simd.simd_double4) -> simd.simd_double4 {
  return __tg_nextafter(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isfinite(_ x: simd.simd_double4) -> simd.simd_long4 {
  return __tg_isfinite(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isinf(_ x: simd.simd_double4) -> simd.simd_long4 {
  return __tg_isinf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnan(_ x: simd.simd_double4) -> simd.simd_long4 {
  return __tg_isnan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnormal(_ x: simd.simd_double4) -> simd.simd_long4 {
  return __tg_isnormal(x)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincos(_ x: simd.simd_double8) -> (sin: simd.simd_double8, cos: simd.simd_double8) {
    
    var sinResult = simd_double8()
    var cosResult = simd_double8()
    
    __tg_sincos(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincospi(_ x: simd.simd_double8) -> (sin: simd.simd_double8, cos: simd.simd_double8) {
    
    var sinResult = simd_double8()
    var cosResult = simd_double8()
    
    __tg_sincospi(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cos(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_cos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cosh(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_cosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cospi(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_cospi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acos(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_acos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acosh(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_acosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sin(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_sin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinh(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_sinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinpi(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_sinpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asin(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_asin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asinh(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_asinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tan(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_tan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanh(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_tanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanpi(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_tanpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_atan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atanh(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_atanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan2(_ x: simd.simd_double8, _ y: simd.simd_double8) -> simd.simd_double8 {
  return __tg_atan2(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_exp(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp2(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_exp2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp10(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_exp10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func expm1(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_expm1(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_log(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log2(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_log2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log10(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_log10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log1p(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_log1p(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func lgamma(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_lgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tgamma(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_tgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erf(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_erf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erfc(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_erfc(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cbrt(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_cbrt(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func pow(_ x: simd.simd_double8, _ y: simd.simd_double8) -> simd.simd_double8 {
  return __tg_pow(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func hypot(_ x: simd.simd_double8, _ y: simd.simd_double8) -> simd.simd_double8 {
  return __tg_hypot(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fma(_ x: simd.simd_double8, _ y: simd.simd_double8, _ z: simd.simd_double8) -> simd.simd_double8 {
  return __tg_fma(x, y, z)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func round(_ x: simd.simd_double8) -> simd.simd_double8 {
  return __tg_round(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fmod(_ x: simd.simd_double8, _ y: simd.simd_double8) -> simd.simd_double8 {
  return __tg_fmod(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func remainder(_ x: simd.simd_double8, _ y: simd.simd_double8) -> simd.simd_double8 {
  return __tg_remainder(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func nextafter(_ x: simd.simd_double8, _ y: simd.simd_double8) -> simd.simd_double8 {
  return __tg_nextafter(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isfinite(_ x: simd.simd_double8) -> simd.simd_long8 {
  return __tg_isfinite(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isinf(_ x: simd.simd_double8) -> simd.simd_long8 {
  return __tg_isinf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnan(_ x: simd.simd_double8) -> simd.simd_long8 {
  return __tg_isnan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnormal(_ x: simd.simd_double8) -> simd.simd_long8 {
  return __tg_isnormal(x)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincos(_ x: simd.simd_float2) -> (sin: simd.simd_float2, cos: simd.simd_float2) {
    
    var sinResult = simd_float2()
    var cosResult = simd_float2()
    
    __tg_sincos(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincospi(_ x: simd.simd_float2) -> (sin: simd.simd_float2, cos: simd.simd_float2) {
    
    var sinResult = simd_float2()
    var cosResult = simd_float2()
    
    __tg_sincospi(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cos(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_cos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cosh(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_cosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cospi(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_cospi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acos(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_acos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acosh(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_acosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sin(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_sin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinh(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_sinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinpi(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_sinpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asin(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_asin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asinh(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_asinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tan(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_tan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanh(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_tanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanpi(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_tanpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_atan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atanh(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_atanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan2(_ x: simd.simd_float2, _ y: simd.simd_float2) -> simd.simd_float2 {
  return __tg_atan2(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_exp(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp2(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_exp2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp10(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_exp10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func expm1(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_expm1(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_log(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log2(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_log2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log10(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_log10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log1p(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_log1p(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func lgamma(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_lgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tgamma(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_tgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erf(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_erf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erfc(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_erfc(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cbrt(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_cbrt(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func pow(_ x: simd.simd_float2, _ y: simd.simd_float2) -> simd.simd_float2 {
  return __tg_pow(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func hypot(_ x: simd.simd_float2, _ y: simd.simd_float2) -> simd.simd_float2 {
  return __tg_hypot(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fma(_ x: simd.simd_float2, _ y: simd.simd_float2, _ z: simd.simd_float2) -> simd.simd_float2 {
  return __tg_fma(x, y, z)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func round(_ x: simd.simd_float2) -> simd.simd_float2 {
  return __tg_round(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fmod(_ x: simd.simd_float2, _ y: simd.simd_float2) -> simd.simd_float2 {
  return __tg_fmod(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func remainder(_ x: simd.simd_float2, _ y: simd.simd_float2) -> simd.simd_float2 {
  return __tg_remainder(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func nextafter(_ x: simd.simd_float2, _ y: simd.simd_float2) -> simd.simd_float2 {
  return __tg_nextafter(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isfinite(_ x: simd.simd_float2) -> simd.simd_int2 {
  return __tg_isfinite(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isinf(_ x: simd.simd_float2) -> simd.simd_int2 {
  return __tg_isinf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnan(_ x: simd.simd_float2) -> simd.simd_int2 {
  return __tg_isnan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnormal(_ x: simd.simd_float2) -> simd.simd_int2 {
  return __tg_isnormal(x)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincos(_ x: simd.simd_float3) -> (sin: simd.simd_float3, cos: simd.simd_float3) {
    
    var sinResult = simd_float3()
    var cosResult = simd_float3()
    
    __tg_sincos(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincospi(_ x: simd.simd_float3) -> (sin: simd.simd_float3, cos: simd.simd_float3) {
    
    var sinResult = simd_float3()
    var cosResult = simd_float3()
    
    __tg_sincospi(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cos(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_cos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cosh(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_cosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cospi(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_cospi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acos(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_acos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acosh(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_acosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sin(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_sin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinh(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_sinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinpi(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_sinpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asin(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_asin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asinh(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_asinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tan(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_tan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanh(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_tanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanpi(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_tanpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_atan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atanh(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_atanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan2(_ x: simd.simd_float3, _ y: simd.simd_float3) -> simd.simd_float3 {
  return __tg_atan2(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_exp(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp2(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_exp2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp10(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_exp10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func expm1(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_expm1(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_log(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log2(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_log2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log10(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_log10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log1p(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_log1p(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func lgamma(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_lgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tgamma(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_tgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erf(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_erf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erfc(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_erfc(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cbrt(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_cbrt(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func pow(_ x: simd.simd_float3, _ y: simd.simd_float3) -> simd.simd_float3 {
  return __tg_pow(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func hypot(_ x: simd.simd_float3, _ y: simd.simd_float3) -> simd.simd_float3 {
  return __tg_hypot(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fma(_ x: simd.simd_float3, _ y: simd.simd_float3, _ z: simd.simd_float3) -> simd.simd_float3 {
  return __tg_fma(x, y, z)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func round(_ x: simd.simd_float3) -> simd.simd_float3 {
  return __tg_round(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fmod(_ x: simd.simd_float3, _ y: simd.simd_float3) -> simd.simd_float3 {
  return __tg_fmod(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func remainder(_ x: simd.simd_float3, _ y: simd.simd_float3) -> simd.simd_float3 {
  return __tg_remainder(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func nextafter(_ x: simd.simd_float3, _ y: simd.simd_float3) -> simd.simd_float3 {
  return __tg_nextafter(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isfinite(_ x: simd.simd_float3) -> simd.simd_int3 {
  return __tg_isfinite(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isinf(_ x: simd.simd_float3) -> simd.simd_int3 {
  return __tg_isinf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnan(_ x: simd.simd_float3) -> simd.simd_int3 {
  return __tg_isnan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnormal(_ x: simd.simd_float3) -> simd.simd_int3 {
  return __tg_isnormal(x)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincos(_ x: simd.simd_float4) -> (sin: simd.simd_float4, cos: simd.simd_float4) {
    
    var sinResult = simd_float4()
    var cosResult = simd_float4()
    
    __tg_sincos(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincospi(_ x: simd.simd_float4) -> (sin: simd.simd_float4, cos: simd.simd_float4) {
    
    var sinResult = simd_float4()
    var cosResult = simd_float4()
    
    __tg_sincospi(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cos(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_cos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cosh(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_cosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cospi(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_cospi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acos(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_acos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acosh(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_acosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sin(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_sin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinh(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_sinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinpi(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_sinpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asin(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_asin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asinh(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_asinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tan(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_tan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanh(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_tanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanpi(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_tanpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_atan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atanh(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_atanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan2(_ x: simd.simd_float4, _ y: simd.simd_float4) -> simd.simd_float4 {
  return __tg_atan2(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_exp(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp2(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_exp2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp10(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_exp10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func expm1(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_expm1(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_log(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log2(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_log2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log10(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_log10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log1p(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_log1p(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func lgamma(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_lgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tgamma(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_tgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erf(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_erf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erfc(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_erfc(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cbrt(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_cbrt(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func pow(_ x: simd.simd_float4, _ y: simd.simd_float4) -> simd.simd_float4 {
  return __tg_pow(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func hypot(_ x: simd.simd_float4, _ y: simd.simd_float4) -> simd.simd_float4 {
  return __tg_hypot(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fma(_ x: simd.simd_float4, _ y: simd.simd_float4, _ z: simd.simd_float4) -> simd.simd_float4 {
  return __tg_fma(x, y, z)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func round(_ x: simd.simd_float4) -> simd.simd_float4 {
  return __tg_round(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fmod(_ x: simd.simd_float4, _ y: simd.simd_float4) -> simd.simd_float4 {
  return __tg_fmod(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func remainder(_ x: simd.simd_float4, _ y: simd.simd_float4) -> simd.simd_float4 {
  return __tg_remainder(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func nextafter(_ x: simd.simd_float4, _ y: simd.simd_float4) -> simd.simd_float4 {
  return __tg_nextafter(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isfinite(_ x: simd.simd_float4) -> simd.simd_int4 {
  return __tg_isfinite(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isinf(_ x: simd.simd_float4) -> simd.simd_int4 {
  return __tg_isinf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnan(_ x: simd.simd_float4) -> simd.simd_int4 {
  return __tg_isnan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnormal(_ x: simd.simd_float4) -> simd.simd_int4 {
  return __tg_isnormal(x)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincos(_ x: simd.simd_float8) -> (sin: simd.simd_float8, cos: simd.simd_float8) {
    
    var sinResult = simd_float8()
    var cosResult = simd_float8()
    
    __tg_sincos(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincospi(_ x: simd.simd_float8) -> (sin: simd.simd_float8, cos: simd.simd_float8) {
    
    var sinResult = simd_float8()
    var cosResult = simd_float8()
    
    __tg_sincospi(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cos(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_cos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cosh(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_cosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cospi(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_cospi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acos(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_acos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acosh(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_acosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sin(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_sin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinh(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_sinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinpi(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_sinpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asin(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_asin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asinh(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_asinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tan(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_tan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanh(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_tanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanpi(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_tanpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_atan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atanh(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_atanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan2(_ x: simd.simd_float8, _ y: simd.simd_float8) -> simd.simd_float8 {
  return __tg_atan2(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_exp(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp2(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_exp2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp10(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_exp10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func expm1(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_expm1(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_log(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log2(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_log2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log10(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_log10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log1p(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_log1p(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func lgamma(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_lgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tgamma(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_tgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erf(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_erf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erfc(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_erfc(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cbrt(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_cbrt(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func pow(_ x: simd.simd_float8, _ y: simd.simd_float8) -> simd.simd_float8 {
  return __tg_pow(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func hypot(_ x: simd.simd_float8, _ y: simd.simd_float8) -> simd.simd_float8 {
  return __tg_hypot(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fma(_ x: simd.simd_float8, _ y: simd.simd_float8, _ z: simd.simd_float8) -> simd.simd_float8 {
  return __tg_fma(x, y, z)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func round(_ x: simd.simd_float8) -> simd.simd_float8 {
  return __tg_round(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fmod(_ x: simd.simd_float8, _ y: simd.simd_float8) -> simd.simd_float8 {
  return __tg_fmod(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func remainder(_ x: simd.simd_float8, _ y: simd.simd_float8) -> simd.simd_float8 {
  return __tg_remainder(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func nextafter(_ x: simd.simd_float8, _ y: simd.simd_float8) -> simd.simd_float8 {
  return __tg_nextafter(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isfinite(_ x: simd.simd_float8) -> simd.simd_int8 {
  return __tg_isfinite(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isinf(_ x: simd.simd_float8) -> simd.simd_int8 {
  return __tg_isinf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnan(_ x: simd.simd_float8) -> simd.simd_int8 {
  return __tg_isnan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnormal(_ x: simd.simd_float8) -> simd.simd_int8 {
  return __tg_isnormal(x)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincos(_ x: simd.simd_float16) -> (sin: simd.simd_float16, cos: simd.simd_float16) {
    
    var sinResult = simd_float16()
    var cosResult = simd_float16()
    
    __tg_sincos(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
@_transparent public func sincospi(_ x: simd.simd_float16) -> (sin: simd.simd_float16, cos: simd.simd_float16) {
    
    var sinResult = simd_float16()
    var cosResult = simd_float16()
    
    __tg_sincospi(x, &sinResult, &cosResult)
    
    return(sinResult, cosResult)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cos(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_cos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cosh(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_cosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cospi(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_cospi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acos(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_acos(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func acosh(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_acosh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sin(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_sin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinh(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_sinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func sinpi(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_sinpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asin(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_asin(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func asinh(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_asinh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tan(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_tan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanh(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_tanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tanpi(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_tanpi(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_atan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atanh(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_atanh(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func atan2(_ x: simd.simd_float16, _ y: simd.simd_float16) -> simd.simd_float16 {
  return __tg_atan2(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_exp(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp2(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_exp2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func exp10(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_exp10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func expm1(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_expm1(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_log(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log2(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_log2(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log10(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_log10(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func log1p(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_log1p(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func lgamma(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_lgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func tgamma(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_tgamma(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erf(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_erf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func erfc(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_erfc(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func cbrt(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_cbrt(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func pow(_ x: simd.simd_float16, _ y: simd.simd_float16) -> simd.simd_float16 {
  return __tg_pow(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func hypot(_ x: simd.simd_float16, _ y: simd.simd_float16) -> simd.simd_float16 {
  return __tg_hypot(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fma(_ x: simd.simd_float16, _ y: simd.simd_float16, _ z: simd.simd_float16) -> simd.simd_float16 {
  return __tg_fma(x, y, z)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func round(_ x: simd.simd_float16) -> simd.simd_float16 {
  return __tg_round(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func fmod(_ x: simd.simd_float16, _ y: simd.simd_float16) -> simd.simd_float16 {
  return __tg_fmod(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func remainder(_ x: simd.simd_float16, _ y: simd.simd_float16) -> simd.simd_float16 {
  return __tg_remainder(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func nextafter(_ x: simd.simd_float16, _ y: simd.simd_float16) -> simd.simd_float16 {
  return __tg_nextafter(x, y)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isfinite(_ x: simd.simd_float16) -> simd.simd_int16 {
  return __tg_isfinite(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isinf(_ x: simd.simd_float16) -> simd.simd_int16 {
  return __tg_isinf(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnan(_ x: simd.simd_float16) -> simd.simd_int16 {
  return __tg_isnan(x)
}
@available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *)
@_transparent public func isnormal(_ x: simd.simd_float16) -> simd.simd_int16 {
  return __tg_isnormal(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func ceil(_ x: simd.simd_half2) -> simd.simd_half2 {
    return __tg_ceil(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func floor(_ x: simd.simd_half2) -> simd.simd_half2 {
    return __tg_floor(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func trunc(_ x: simd.simd_half2) -> simd.simd_half2 {
    return __tg_trunc(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func rint(_ x: simd.simd_half2) -> simd.simd_half2 {
    return __tg_rint(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func sqrt(_ x: simd.simd_half2) -> simd.simd_half2 {
    return __tg_sqrt(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func abs(_ x: simd.simd_half2) -> simd.simd_half2 {
    return __tg_fabs(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ x: simd.simd_half2, _ y: simd.simd_half2) -> simd.simd_half2 {
  return __tg_fmin(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ x: simd.simd_half2, _ y: simd.simd_half2) -> simd.simd_half2 {
  return __tg_fmax(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ vector: simd.simd_half2, _ scalar: Swift.Float16) -> simd.simd_half2 {
  return __tg_fmin(vector, simd_half2(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ vector: simd.simd_half2, _ scalar: Swift.Float16) -> simd.simd_half2 {
  return __tg_fmax(vector, simd_half2(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func ceil(_ x: simd.simd_half3) -> simd.simd_half3 {
    return __tg_ceil(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func floor(_ x: simd.simd_half3) -> simd.simd_half3 {
    return __tg_floor(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func trunc(_ x: simd.simd_half3) -> simd.simd_half3 {
    return __tg_trunc(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func rint(_ x: simd.simd_half3) -> simd.simd_half3 {
    return __tg_rint(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func sqrt(_ x: simd.simd_half3) -> simd.simd_half3 {
    return __tg_sqrt(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func abs(_ x: simd.simd_half3) -> simd.simd_half3 {
    return __tg_fabs(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ x: simd.simd_half3, _ y: simd.simd_half3) -> simd.simd_half3 {
  return __tg_fmin(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ x: simd.simd_half3, _ y: simd.simd_half3) -> simd.simd_half3 {
  return __tg_fmax(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ vector: simd.simd_half3, _ scalar: Swift.Float16) -> simd.simd_half3 {
  return __tg_fmin(vector, simd_half3(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ vector: simd.simd_half3, _ scalar: Swift.Float16) -> simd.simd_half3 {
  return __tg_fmax(vector, simd_half3(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func ceil(_ x: simd.simd_half4) -> simd.simd_half4 {
    return __tg_ceil(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func floor(_ x: simd.simd_half4) -> simd.simd_half4 {
    return __tg_floor(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func trunc(_ x: simd.simd_half4) -> simd.simd_half4 {
    return __tg_trunc(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func rint(_ x: simd.simd_half4) -> simd.simd_half4 {
    return __tg_rint(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func sqrt(_ x: simd.simd_half4) -> simd.simd_half4 {
    return __tg_sqrt(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func abs(_ x: simd.simd_half4) -> simd.simd_half4 {
    return __tg_fabs(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ x: simd.simd_half4, _ y: simd.simd_half4) -> simd.simd_half4 {
  return __tg_fmin(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ x: simd.simd_half4, _ y: simd.simd_half4) -> simd.simd_half4 {
  return __tg_fmax(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ vector: simd.simd_half4, _ scalar: Swift.Float16) -> simd.simd_half4 {
  return __tg_fmin(vector, simd_half4(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ vector: simd.simd_half4, _ scalar: Swift.Float16) -> simd.simd_half4 {
  return __tg_fmax(vector, simd_half4(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func ceil(_ x: simd.simd_half8) -> simd.simd_half8 {
    return __tg_ceil(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func floor(_ x: simd.simd_half8) -> simd.simd_half8 {
    return __tg_floor(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func trunc(_ x: simd.simd_half8) -> simd.simd_half8 {
    return __tg_trunc(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func rint(_ x: simd.simd_half8) -> simd.simd_half8 {
    return __tg_rint(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func sqrt(_ x: simd.simd_half8) -> simd.simd_half8 {
    return __tg_sqrt(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func abs(_ x: simd.simd_half8) -> simd.simd_half8 {
    return __tg_fabs(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ x: simd.simd_half8, _ y: simd.simd_half8) -> simd.simd_half8 {
  return __tg_fmin(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ x: simd.simd_half8, _ y: simd.simd_half8) -> simd.simd_half8 {
  return __tg_fmax(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ vector: simd.simd_half8, _ scalar: Swift.Float16) -> simd.simd_half8 {
  return __tg_fmin(vector, simd_half8(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ vector: simd.simd_half8, _ scalar: Swift.Float16) -> simd.simd_half8 {
  return __tg_fmax(vector, simd_half8(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func ceil(_ x: simd.simd_half16) -> simd.simd_half16 {
    return __tg_ceil(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func floor(_ x: simd.simd_half16) -> simd.simd_half16 {
    return __tg_floor(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func trunc(_ x: simd.simd_half16) -> simd.simd_half16 {
    return __tg_trunc(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func rint(_ x: simd.simd_half16) -> simd.simd_half16 {
    return __tg_rint(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func sqrt(_ x: simd.simd_half16) -> simd.simd_half16 {
    return __tg_sqrt(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func abs(_ x: simd.simd_half16) -> simd.simd_half16 {
    return __tg_fabs(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ x: simd.simd_half16, _ y: simd.simd_half16) -> simd.simd_half16 {
  return __tg_fmin(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ x: simd.simd_half16, _ y: simd.simd_half16) -> simd.simd_half16 {
  return __tg_fmax(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ vector: simd.simd_half16, _ scalar: Swift.Float16) -> simd.simd_half16 {
  return __tg_fmin(vector, simd_half16(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ vector: simd.simd_half16, _ scalar: Swift.Float16) -> simd.simd_half16 {
  return __tg_fmax(vector, simd_half16(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func ceil(_ x: simd.simd_half32) -> simd.simd_half32 {
    return __tg_ceil(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func floor(_ x: simd.simd_half32) -> simd.simd_half32 {
    return __tg_floor(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func trunc(_ x: simd.simd_half32) -> simd.simd_half32 {
    return __tg_trunc(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func rint(_ x: simd.simd_half32) -> simd.simd_half32 {
    return __tg_rint(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func sqrt(_ x: simd.simd_half32) -> simd.simd_half32 {
    return __tg_sqrt(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func abs(_ x: simd.simd_half32) -> simd.simd_half32 {
    return __tg_fabs(x)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ x: simd.simd_half32, _ y: simd.simd_half32) -> simd.simd_half32 {
  return __tg_fmin(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ x: simd.simd_half32, _ y: simd.simd_half32) -> simd.simd_half32 {
  return __tg_fmax(x, y)
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func min(_ vector: simd.simd_half32, _ scalar: Swift.Float16) -> simd.simd_half32 {
  return __tg_fmin(vector, simd_half32(repeating: scalar))
}
@available(macOS 15.0, iOS 18.0, tvOS 18.0, watchOS 11.0, *)
@_transparent public func max(_ vector: simd.simd_half32, _ scalar: Swift.Float16) -> simd.simd_half32 {
  return __tg_fmax(vector, simd_half32(repeating: scalar))
}
extension simd.simd_quatf {
  @_transparent public init(ix: Swift.Float, iy: Swift.Float, iz: Swift.Float, r: Swift.Float) {
    self.init(vector: SIMD4<Float>(ix, iy, iz, r))
  }
  @_transparent public init(real: Swift.Float, imag: Swift.SIMD3<Swift.Float>) {
    self.init(vector: simd_make_float4(imag, real))
  }
  @_transparent public init(angle: Swift.Float, axis: Swift.SIMD3<Swift.Float>) {
    self = simd_quaternion(angle, axis)
  }
  @_transparent public init(from: Swift.SIMD3<Swift.Float>, to: Swift.SIMD3<Swift.Float>) {
    self = simd_quaternion(from, to)
  }
  @_transparent public init(_ rotationMatrix: simd.simd_float3x3) {
    self = simd_quaternion(rotationMatrix)
  }
  @_transparent public init(_ rotationMatrix: simd.simd_float4x4) {
    self = simd_quaternion(rotationMatrix)
  }
  public var real: Swift.Float {
    @_transparent get { return vector.w }
    @_transparent set { vector.w = newValue }
  }
  public var imag: Swift.SIMD3<Swift.Float> {
    @_transparent get { return simd_make_float3(vector) }
    @_transparent set { vector = simd_make_float4(newValue, vector.w) }
  }
  @_transparent public var angle: Swift.Float {
    @_transparent get {
    return simd_angle(self)
  }
  }
  @_transparent public var axis: Swift.SIMD3<Swift.Float> {
    @_transparent get {
    return simd_axis(self)
  }
  }
  @_transparent public var conjugate: simd.simd_quatf {
    @_transparent get {
    return simd_conjugate(self)
  }
  }
  @_transparent public var inverse: simd.simd_quatf {
    @_transparent get {
    return simd_inverse(self)
  }
  }
  @_transparent public var normalized: simd.simd_quatf {
    @_transparent get {
    return simd_normalize(self)
  }
  }
  @_transparent public var length: Swift.Float {
    @_transparent get {
    return simd_length(self)
  }
  }
  @_transparent public func act(_ vector: Swift.SIMD3<Swift.Float>) -> Swift.SIMD3<Swift.Float> {
    return simd_act(self, vector)
  }
}
extension simd.simd_float3x3 {
  public init(_ quaternion: simd.simd_quatf)
}
extension simd.simd_float4x4 {
  public init(_ quaternion: simd.simd_quatf)
}
extension simd.simd_quatf : Swift.CustomDebugStringConvertible {
  public var debugDescription: Swift.String {
    get
  }
}
extension simd.simd_quatf : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_quatf, rhs: simd.simd_quatf) -> Swift.Bool {
    return lhs.vector == rhs.vector
  }
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
extension simd.simd_quatf : Swift.Hashable {
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
extension simd.simd_quatf : @unchecked Swift.Sendable {
}
extension simd.simd_quatf {
  @_transparent public static func + (lhs: simd.simd_quatf, rhs: simd.simd_quatf) -> simd.simd_quatf {
    return simd_add(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_quatf, rhs: simd.simd_quatf) {
    lhs = lhs + rhs
  }
  @_transparent public static func - (lhs: simd.simd_quatf, rhs: simd.simd_quatf) -> simd.simd_quatf {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func -= (lhs: inout simd.simd_quatf, rhs: simd.simd_quatf) {
    lhs = lhs - rhs
  }
  @_transparent prefix public static func - (rhs: simd.simd_quatf) -> simd.simd_quatf {
    return simd_sub(simd_quatf(), rhs)
  }
  @_transparent public static func * (lhs: simd.simd_quatf, rhs: simd.simd_quatf) -> simd.simd_quatf {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.Float, rhs: simd.simd_quatf) -> simd.simd_quatf {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_quatf, rhs: Swift.Float) -> simd.simd_quatf {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_quatf, rhs: simd.simd_quatf) {
    lhs = lhs * rhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_quatf, rhs: Swift.Float) {
    lhs = lhs * rhs
  }
  @_transparent public static func / (lhs: simd.simd_quatf, rhs: simd.simd_quatf) -> simd.simd_quatf {
    return simd_mul(lhs, rhs.inverse)
  }
  @_transparent public static func / (lhs: simd.simd_quatf, rhs: Swift.Float) -> simd.simd_quatf {
    return simd_quatf(vector: lhs.vector/rhs)
  }
  @_transparent public static func /= (lhs: inout simd.simd_quatf, rhs: simd.simd_quatf) {
    lhs = lhs / rhs
  }
  @_transparent public static func /= (lhs: inout simd.simd_quatf, rhs: Swift.Float) {
    lhs = lhs / rhs
  }
}
@_transparent public func dot(_ lhs: simd.simd_quatf, _ rhs: simd.simd_quatf) -> Swift.Float {
  return simd_dot(lhs, rhs)
}
public func log(_ q: simd.simd_quatf) -> simd.simd_quatf
@_transparent public func exp(_ q: simd.simd_quatf) -> simd.simd_quatf {
  return __tg_exp(q)
}
extension simd.simd_quatd {
  @_transparent public init(ix: Swift.Double, iy: Swift.Double, iz: Swift.Double, r: Swift.Double) {
    self.init(vector: SIMD4<Double>(ix, iy, iz, r))
  }
  @_transparent public init(real: Swift.Double, imag: Swift.SIMD3<Swift.Double>) {
    self.init(vector: simd_make_double4(imag, real))
  }
  @_transparent public init(angle: Swift.Double, axis: Swift.SIMD3<Swift.Double>) {
    self = simd_quaternion(angle, axis)
  }
  @_transparent public init(from: Swift.SIMD3<Swift.Double>, to: Swift.SIMD3<Swift.Double>) {
    self = simd_quaternion(from, to)
  }
  @_transparent public init(_ rotationMatrix: simd.simd_double3x3) {
    self = simd_quaternion(rotationMatrix)
  }
  @_transparent public init(_ rotationMatrix: simd.simd_double4x4) {
    self = simd_quaternion(rotationMatrix)
  }
  public var real: Swift.Double {
    @_transparent get { return vector.w }
    @_transparent set { vector.w = newValue }
  }
  public var imag: Swift.SIMD3<Swift.Double> {
    @_transparent get { return simd_make_double3(vector) }
    @_transparent set { vector = simd_make_double4(newValue, vector.w) }
  }
  @_transparent public var angle: Swift.Double {
    @_transparent get {
    return simd_angle(self)
  }
  }
  @_transparent public var axis: Swift.SIMD3<Swift.Double> {
    @_transparent get {
    return simd_axis(self)
  }
  }
  @_transparent public var conjugate: simd.simd_quatd {
    @_transparent get {
    return simd_conjugate(self)
  }
  }
  @_transparent public var inverse: simd.simd_quatd {
    @_transparent get {
    return simd_inverse(self)
  }
  }
  @_transparent public var normalized: simd.simd_quatd {
    @_transparent get {
    return simd_normalize(self)
  }
  }
  @_transparent public var length: Swift.Double {
    @_transparent get {
    return simd_length(self)
  }
  }
  @_transparent public func act(_ vector: Swift.SIMD3<Swift.Double>) -> Swift.SIMD3<Swift.Double> {
    return simd_act(self, vector)
  }
}
extension simd.simd_double3x3 {
  public init(_ quaternion: simd.simd_quatd)
}
extension simd.simd_double4x4 {
  public init(_ quaternion: simd.simd_quatd)
}
extension simd.simd_quatd : Swift.CustomDebugStringConvertible {
  public var debugDescription: Swift.String {
    get
  }
}
extension simd.simd_quatd : Swift.Equatable {
  @_transparent public static func == (lhs: simd.simd_quatd, rhs: simd.simd_quatd) -> Swift.Bool {
    return lhs.vector == rhs.vector
  }
}
@available(macOS 14.0, iOS 17.0, tvOS 17.0, watchOS 10.0, *)
extension simd.simd_quatd : Swift.Hashable {
  public func hash(into hasher: inout Swift.Hasher)
  public var hashValue: Swift.Int {
    get
  }
}
extension simd.simd_quatd : @unchecked Swift.Sendable {
}
extension simd.simd_quatd {
  @_transparent public static func + (lhs: simd.simd_quatd, rhs: simd.simd_quatd) -> simd.simd_quatd {
    return simd_add(lhs, rhs)
  }
  @_transparent public static func += (lhs: inout simd.simd_quatd, rhs: simd.simd_quatd) {
    lhs = lhs + rhs
  }
  @_transparent public static func - (lhs: simd.simd_quatd, rhs: simd.simd_quatd) -> simd.simd_quatd {
    return simd_sub(lhs, rhs)
  }
  @_transparent public static func -= (lhs: inout simd.simd_quatd, rhs: simd.simd_quatd) {
    lhs = lhs - rhs
  }
  @_transparent prefix public static func - (rhs: simd.simd_quatd) -> simd.simd_quatd {
    return simd_sub(simd_quatd(), rhs)
  }
  @_transparent public static func * (lhs: simd.simd_quatd, rhs: simd.simd_quatd) -> simd.simd_quatd {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: Swift.Double, rhs: simd.simd_quatd) -> simd.simd_quatd {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func * (lhs: simd.simd_quatd, rhs: Swift.Double) -> simd.simd_quatd {
    return simd_mul(lhs, rhs)
  }
  @_transparent public static func *= (lhs: inout simd.simd_quatd, rhs: simd.simd_quatd) {
    lhs = lhs * rhs
  }
  @_transparent public static func *= (lhs: inout simd.simd_quatd, rhs: Swift.Double) {
    lhs = lhs * rhs
  }
  @_transparent public static func / (lhs: simd.simd_quatd, rhs: simd.simd_quatd) -> simd.simd_quatd {
    return simd_mul(lhs, rhs.inverse)
  }
  @_transparent public static func / (lhs: simd.simd_quatd, rhs: Swift.Double) -> simd.simd_quatd {
    return simd_quatd(vector: lhs.vector/rhs)
  }
  @_transparent public static func /= (lhs: inout simd.simd_quatd, rhs: simd.simd_quatd) {
    lhs = lhs / rhs
  }
  @_transparent public static func /= (lhs: inout simd.simd_quatd, rhs: Swift.Double) {
    lhs = lhs / rhs
  }
}
@_transparent public func dot(_ lhs: simd.simd_quatd, _ rhs: simd.simd_quatd) -> Swift.Double {
  return simd_dot(lhs, rhs)
}
public func log(_ q: simd.simd_quatd) -> simd.simd_quatd
@_transparent public func exp(_ q: simd.simd_quatd) -> simd.simd_quatd {
  return __tg_exp(q)
}