LLDB Type Lookup Swift

SwiftTypes.swift

import SwiftShims
struct UnsafePointer<Pointee> : Strideable, Hashable, _Pointer {
  typealias Distance = Swift.Int
  let _rawValue: Builtin.RawPointer
  init(_ _rawValue: Builtin.RawPointer)
  init(_ from: Swift.OpaquePointer)
  init?(_ from: Swift.OpaquePointer?)
  init?(bitPattern: Swift.Int)
  init?(bitPattern: Swift.UInt)
  init(_ other: Swift.UnsafePointer<Pointee>)
  init?(_ other: Swift.UnsafePointer<Pointee>?)
  init(_ other: Swift.UnsafeMutablePointer<Pointee>)
  init?(_ other: Swift.UnsafeMutablePointer<Pointee>?)
  let pointee: Pointee
  var pointee: Pointee {
    unsafeAddress {}
  }
  func withMemoryRebound<T, Result>(to: T.Type, capacity count: Swift.Int, _ body: (Swift.UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result
  subscript(i: Swift.Int) -> Pointee {
    unsafeAddress {}
  }
  var hashValue: Swift.Int {
    get {}
  }
  func successor() -> Swift.UnsafePointer<Pointee>
  func predecessor() -> Swift.UnsafePointer<Pointee>
  func distance(to x: Swift.UnsafePointer<Pointee>) -> Swift.Int
  func advanced(by n: Swift.Int) -> Swift.UnsafePointer<Pointee>
  typealias Stride = Swift.Int
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension UnsafePointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension UnsafePointer : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UnsafePointer : CustomPlaygroundQuickLookable {
  var summary: Swift.String {
    get {}
  }
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UnsafePointer {
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init<U>(_ from: Swift.UnsafeMutablePointer<U>)
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init?<U>(_ from: Swift.UnsafeMutablePointer<U>?)
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init<U>(_ from: Swift.UnsafePointer<U>)
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init?<U>(_ from: Swift.UnsafePointer<U>?)
  @available(*, unavailable, renamed: "Pointee") typealias Memory = Pointee
  @available(*, unavailable, message: "use 'nil' literal") init()
  @available(*, unavailable, renamed: "pointee") var memory: Pointee {
    get {}
  }
}
extension UnsafePointer : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
@_versioned final class _CocoaDictionaryIterator : IteratorProtocol {
  typealias Element = (AnyObject, AnyObject)
  final var _fastEnumerationState: SwiftShims._SwiftNSFastEnumerationState
  final var _fastEnumerationStackBuf: Swift._CocoaFastEnumerationStackBuf
  final let cocoaDictionary: _NSDictionary
  final var _fastEnumerationStatePtr: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState> {
    final get {}
  }
  final var _fastEnumerationStackBufPtr: Swift.UnsafeMutablePointer<Swift._CocoaFastEnumerationStackBuf> {
    final get {}
  }
  final var itemIndex: Swift.Int
  final var itemCount: Swift.Int
  @_versioned init(_ cocoaDictionary: _NSDictionary)
  @_versioned final func next() -> Swift._CocoaDictionaryIterator.Element?
  @objc deinit
}
func _rawPointerToString(_ value: Builtin.RawPointer) -> Swift.String
protocol BidirectionalCollection : BidirectionalIndexable, Collection {
  func index(before i: Self.Index) -> Self.Index
  func formIndex(before i: inout Self.Index)
  associatedtype SubSequence : BidirectionalIndexable, Collection = Swift.BidirectionalSlice<Self>
  associatedtype Indices : BidirectionalIndexable, Collection = Swift.DefaultBidirectionalIndices<Self>
  var last: Self.Iterator.Element? { get }
}
extension BidirectionalCollection {
  var last: Self.Iterator.Element? {
    get {}
  }
}
extension BidirectionalCollection where Indices == DefaultBidirectionalIndices<Self> {
  var indices: Swift.DefaultBidirectionalIndices<Self> {
    get {}
  }
}
extension BidirectionalCollection where SubSequence == BidirectionalSlice<Self> {
  subscript(bounds: Swift.Range<Self.Index>) -> Swift.BidirectionalSlice<Self> {
    get {}
  }
}
extension BidirectionalCollection where SubSequence == Self {
  mutating func popLast() -> Self.Iterator.Element?
  @discardableResult mutating func removeLast() -> Self.Iterator.Element
  mutating func removeLast(_ n: Swift.Int)
}
extension BidirectionalCollection {
  func dropLast(_ n: Swift.Int) -> Self.SubSequence
  func suffix(_ maxLength: Swift.Int) -> Self.SubSequence
}
extension BidirectionalCollection where Iterator.Element : BidirectionalCollection {
  func joined() -> Swift.FlattenBidirectionalCollection<Self>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.FlattenBidirectionalCollection<Self>
}
extension BidirectionalCollection {
  var lazy: Swift.LazyBidirectionalCollection<Self> {
    get {}
  }
}
extension BidirectionalCollection where Self : LazyCollectionProtocol {
  var lazy: Self {
    get {}
  }
}
extension BidirectionalCollection {
  func reversed() -> Swift.ReversedCollection<Self>
}
extension BidirectionalCollection {
  @available(*, unavailable, renamed: "reversed()") func reverse() -> Swift.ReversedCollection<Self>
}
@_silgen_name("swift_float32ToString") func _float32ToStringImpl(_ buffer: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>, _ bufferLength: Swift.UInt, _ value: Swift.Float32, _ debug: Swift.Bool) -> Swift.UInt
protocol UnicodeCodec {
  associatedtype CodeUnit
  init()
  mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> Swift.UnicodeDecodingResult
  static func encode(_ input: Swift.UnicodeScalar, into processCodeUnit: (Self.CodeUnit) -> Swift.Void)
  static func _nullCodeUnitOffset(in input: Swift.UnsafePointer<Self.CodeUnit>) -> Swift.Int
}
extension UnicodeCodec where CodeUnit : UnsignedInteger {
  static func _nullCodeUnitOffset(in input: Swift.UnsafePointer<Self.CodeUnit>) -> Swift.Int
}
extension UnicodeCodec {
  static func _nullCodeUnitOffset(in input: Swift.UnsafePointer<Self.CodeUnit>) -> Swift.Int
}
extension UnicodeCodec {
  @available(*, unavailable, renamed: "encode(_:into:)") static func encode(_ input: Swift.UnicodeScalar, output put: (Self.CodeUnit) -> Swift.Void)
}
protocol _AnyIndexBox : class {
  var _typeID: Swift.ObjectIdentifier { get }
  func _unbox<T : Comparable>() -> T?
  func _isEqual(to rhs: _AnyIndexBox) -> Swift.Bool
  func _isLess(than rhs: _AnyIndexBox) -> Swift.Bool
}
var _hashContainerDefaultMaxLoadFactorInverse: Swift.Double {
  get {}
}
protocol Error {
  var _domain: Swift.String { get }
  var _code: Swift.Int { get }
  var _userInfo: Any? { get }
  func _getEmbeddedNSError() -> AnyObject?
}
extension Error {
  var _domain: Swift.String {
    get {}
  }
  var _userInfo: Any? {
    get {}
  }
}
extension Error {
  func _getEmbeddedNSError() -> AnyObject?
}
extension Error where Self : CustomNSError {
  var _domain: Swift.String {
    get {}
  }
  var _code: Swift.Int {
    get {}
  }
}
extension Error {
  var localizedDescription: Swift.String {
    get {}
  }
}
func _getClassPlaygroundQuickLook(_ object: AnyObject) -> Swift.PlaygroundQuickLook?
protocol _Integer : _ExpressibleByBuiltinIntegerLiteral, ExpressibleByIntegerLiteral, CustomStringConvertible, Hashable, IntegerArithmetic, BitwiseOperations, _Incrementable {
}
@_silgen_name("_forceBridgeFromObjectiveC_bridgeable") func _forceBridgeFromObjectiveC_bridgeable<T : _ObjectiveCBridgeable>(_ x: T._ObjectiveCType, _: T.Type) -> T
@inline(__always) func _class_getInstancePositiveExtentSize(_ theClass: Swift.AnyClass) -> Swift.Int
func _convertMutableArrayToPointerArgument<FromElement, ToPointer : _Pointer>(_ a: inout [FromElement]) -> (AnyObject?, ToPointer)
func _writeBackMutableSlice<C, Slice_ where C : MutableCollection, Slice_ : Collection, C._Element == Slice_.Iterator.Element, C.Index == Slice_.Index>(_ self_: inout C, bounds: Swift.Range<C.Index>, slice: Slice_)
struct Dictionary<Key : Hashable, Value> : Collection, ExpressibleByDictionaryLiteral {
  typealias _Self = [Key : Value]
  typealias _VariantStorage = Swift._VariantDictionaryStorage<Key, Value>
  typealias _NativeStorage = Swift._NativeDictionaryStorage<Key, Value>
  typealias Element = (key: Key, value: Value)
  typealias Index = Swift.DictionaryIndex<Key, Value>
  var _variantStorage: Swift._VariantDictionaryStorage<Key, Value>
  init()
  init(minimumCapacity: Swift.Int)
  init(_nativeStorage: Swift._NativeDictionaryStorage<Key, Value>)
  init(_nativeStorageOwner: Swift._NativeDictionaryStorageOwner<Key, Value>)
  init(_immutableCocoaDictionary: _NSDictionary)
  var startIndex: Swift.DictionaryIndex<Key, Value> {
    get {}
  }
  var endIndex: Swift.DictionaryIndex<Key, Value> {
    get {}
  }
  func index(after i: Swift.DictionaryIndex<Key, Value>) -> Swift.DictionaryIndex<Key, Value>
  @inline(__always) func index(forKey key: Key) -> Swift.DictionaryIndex<Key, Value>?
  subscript(position: Swift.DictionaryIndex<Key, Value>) -> (key: Key, value: Value) {
    get {}
  }
  subscript(key: Key) -> Value? {
    @inline(__always) get {}
    set(newValue) {}
  }
  @discardableResult mutating func updateValue(_ value: Value, forKey key: Key) -> Value?
  @discardableResult mutating func remove(at index: Swift.DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
  @discardableResult mutating func removeValue(forKey key: Key) -> Value?
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
  var count: Swift.Int {
    get {}
  }
  @inline(__always) func makeIterator() -> Swift.DictionaryIterator<Key, Value>
  init(dictionaryLiteral elements: (Key, Value)...)
  var keys: Swift.LazyMapCollection<[Key : Value], Key> {
    get {}
  }
  var values: Swift.LazyMapCollection<[Key : Value], Value> {
    get {}
  }
  var isEmpty: Swift.Bool {
    get {}
  }
  typealias _Element = (key: Key, value: Value)
  typealias SubSequence = Swift.Slice<[Key : Value]>
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.DictionaryIterator<Key, Value>
  typealias Indices = Swift.DefaultIndices<[Key : Value]>
  typealias Key = Key
  typealias Value = Value
}
extension Dictionary where Key : Equatable, Value : Equatable {
  static func ==(lhs: [Key : Value], rhs: [Key : Value]) -> Swift.Bool
  static func !=(lhs: [Key : Value], rhs: [Key : Value]) -> Swift.Bool
}
extension Dictionary : CustomStringConvertible, CustomDebugStringConvertible {
  func _makeDescription() -> Swift.String
  var description: Swift.String {
    get {}
  }
  var debugDescription: Swift.String {
    get {}
  }
}
extension Dictionary : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Dictionary {
  mutating func popFirst() -> (key: Key, value: Value)?
}
extension Dictionary {
  func _bridgeToObjectiveCImpl() -> _NSDictionaryCore
  static func _bridgeFromObjectiveCAdoptingNativeStorageOf(_ s: AnyObject) -> [Key : Value]?
}
extension Dictionary {
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ index: Swift.DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
  @available(*, unavailable, renamed: "index(forKey:)") func indexForKey(_ key: Key) -> Swift.DictionaryIndex<Key, Value>?
  @available(*, unavailable, renamed: "removeValue(forKey:)") mutating func removeValueForKey(_ key: Key) -> Value?
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.DictionaryIterator<Key, Value>
}
extension Dictionary {
  subscript(_concreteKey key: Key) -> Value? {
    @inline(__always) get {}
    @inline(__always) set(newValue) {}
  }
  @inline(__always) mutating func _concreteKey_updateValue(_ value: Value, forKey key: Key) -> Value?
  @inline(__always) mutating func _concreteKey_removeValue(forKey key: Key) -> Value?
}
extension Dictionary where Key : _AnyHashableProtocol {
  subscript(key: _Hashable) -> Value? {
    get {}
    set(newValue) {}
  }
  @discardableResult mutating func updateValue<ConcreteKey : Hashable>(_ value: Value, forKey key: ConcreteKey) -> Value?
  @discardableResult mutating func removeValue<ConcreteKey : Hashable>(forKey key: ConcreteKey) -> Value?
}
extension Dictionary {
  init(_cocoaDictionary: _NSDictionary)
}
extension Dictionary : _ObjectiveCBridgeable {
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSDictionary
  static func _forceBridgeFromObjectiveC(_ d: Foundation.NSDictionary, result: inout [Key : Value]?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSDictionary, result: inout [Key : Value]?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ d: Foundation.NSDictionary?) -> [Key : Value]
  typealias _ObjectiveCType = Foundation.NSDictionary
}
extension Dictionary : CVarArg {
}
struct FlattenCollection<Base where Base : Collection, Base.Iterator.Element : Collection> : Collection {
  typealias Index = Swift.FlattenCollectionIndex<Base>
  typealias IndexDistance = Base.IndexDistance
  init(_ base: Base)
  func makeIterator() -> Swift.FlattenIterator<Base.Iterator>
  var startIndex: Swift.FlattenCollectionIndex<Base> {
    get {}
  }
  var endIndex: Swift.FlattenCollectionIndex<Base> {
    get {}
  }
  func index(after i: Swift.FlattenCollectionIndex<Base>) -> Swift.FlattenCollectionIndex<Base>
  subscript(position: Swift.FlattenCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.FlattenCollectionIndex<Base>>) -> Swift.Slice<Swift.FlattenCollection<Base>> {
    get {}
  }
  var underestimatedCount: Swift.Int {
    get {}
  }
  func _copyToContiguousArray() -> Swift.ContiguousArray<Base.Iterator.Element.Iterator.Element>
  func forEach(_ body: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows
  var _base: Base
  typealias _Element = Base.Iterator.Element.Iterator.Element
  typealias SubSequence = Swift.Slice<Swift.FlattenCollection<Base>>
  typealias Iterator = Swift.FlattenIterator<Base.Iterator>
  typealias Indices = Swift.DefaultIndices<Swift.FlattenCollection<Base>>
}
extension FlattenCollection {
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
}
func ==<Element : Equatable>(lhs: Swift.ContiguousArray<Element>, rhs: Swift.ContiguousArray<Element>) -> Swift.Bool
func ==<Element : Equatable>(lhs: Swift.ArraySlice<Element>, rhs: Swift.ArraySlice<Element>) -> Swift.Bool
func ==<Element : Equatable>(lhs: [Element], rhs: [Element]) -> Swift.Bool
func ==<Pointee>(lhs: Swift.AutoreleasingUnsafeMutablePointer<Pointee>, rhs: Swift.AutoreleasingUnsafeMutablePointer<Pointee>) -> Swift.Bool
func ==(lhs: Builtin.NativeObject, rhs: Builtin.NativeObject) -> Swift.Bool
func ==(lhs: Builtin.RawPointer, rhs: Builtin.RawPointer) -> Swift.Bool
func ==(t0: Any.Type?, t1: Any.Type?) -> Swift.Bool
func ==<T : RawRepresentable where T.RawValue : Equatable>(lhs: T, rhs: T) -> Swift.Bool
func ==(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.Bool
func ==(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Bool
func ==(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.Bool
func ==(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Bool
func ==(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.Bool
func ==(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Bool
func ==(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.Bool
func ==(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Bool
func ==(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.Bool
func ==(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Bool
func ==<T : FloatingPoint>(lhs: T, rhs: T) -> Swift.Bool
func ==<Value, Element>(lhs: Swift._HeapBuffer<Value, Element>, rhs: Swift._HeapBuffer<Value, Element>) -> Swift.Bool
func ==<Header, Element>(lhs: Swift.ManagedBufferPointer<Header, Element>, rhs: Swift.ManagedBufferPointer<Header, Element>) -> Swift.Bool
func ==<T : Equatable>(lhs: T?, rhs: T?) -> Swift.Bool
func ==<T>(lhs: T?, rhs: Swift._OptionalNilComparisonType) -> Swift.Bool
func ==<T>(lhs: Swift._OptionalNilComparisonType, rhs: T?) -> Swift.Bool
func ==<T : Strideable>(x: T, y: T) -> Swift.Bool
func ==<Pointee>(lhs: Swift.UnsafeMutablePointer<Pointee>, rhs: Swift.UnsafeMutablePointer<Pointee>) -> Swift.Bool
func ==<Pointee>(lhs: Swift.UnsafePointer<Pointee>, rhs: Swift.UnsafePointer<Pointee>) -> Swift.Bool
func ==(lhs: Swift.UnsafeMutableRawPointer, rhs: Swift.UnsafeMutableRawPointer) -> Swift.Bool
func ==(lhs: Swift.UnsafeRawPointer, rhs: Swift.UnsafeRawPointer) -> Swift.Bool
func ==<A : Equatable, B : Equatable>(lhs: (A, B), rhs: (A, B)) -> Swift.Bool
func ==<A : Equatable, B : Equatable, C : Equatable>(lhs: (A, B, C), rhs: (A, B, C)) -> Swift.Bool
func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Swift.Bool
func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Swift.Bool
func ==<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Swift.Bool
protocol SetAlgebra : Equatable, ExpressibleByArrayLiteral {
  associatedtype Element
  init()
  func contains(_ member: Self.Element) -> Swift.Bool
  func union(_ other: Self) -> Self
  func intersection(_ other: Self) -> Self
  func symmetricDifference(_ other: Self) -> Self
  @discardableResult mutating func insert(_ newMember: Self.Element) -> (inserted: Swift.Bool, memberAfterInsert: Self.Element)
  @discardableResult mutating func remove(_ member: Self.Element) -> Self.Element?
  @discardableResult mutating func update(with newMember: Self.Element) -> Self.Element?
  mutating func formUnion(_ other: Self)
  mutating func formIntersection(_ other: Self)
  mutating func formSymmetricDifference(_ other: Self)
  func subtracting(_ other: Self) -> Self
  func isSubset(of other: Self) -> Swift.Bool
  func isDisjoint(with other: Self) -> Swift.Bool
  func isSuperset(of other: Self) -> Swift.Bool
  var isEmpty: Swift.Bool { get }
  init<S : Sequence where S.Iterator.Element == Element>(_ sequence: S)
  mutating func subtract(_ other: Self)
}
extension SetAlgebra {
  convenience init<S : Sequence where S.Iterator.Element == Element>(_ sequence: S)
  convenience init(arrayLiteral: Self.Element...)
  mutating func subtract(_ other: Self)
  func isSubset(of other: Self) -> Swift.Bool
  func isSuperset(of other: Self) -> Swift.Bool
  func isDisjoint(with other: Self) -> Swift.Bool
  func subtracting(_ other: Self) -> Self
  var isEmpty: Swift.Bool {
    get {}
  }
  func isStrictSuperset(of other: Self) -> Swift.Bool
  func isStrictSubset(of other: Self) -> Swift.Bool
}
extension SetAlgebra {
  @available(*, unavailable, renamed: "intersection(_:)") func intersect(_ other: Self) -> Self
  @available(*, unavailable, renamed: "symmetricDifference(_:)") func exclusiveOr(_ other: Self) -> Self
  @available(*, unavailable, renamed: "formUnion(_:)") mutating func unionInPlace(_ other: Self)
  @available(*, unavailable, renamed: "formIntersection(_:)") mutating func intersectInPlace(_ other: Self)
  @available(*, unavailable, renamed: "formSymmetricDifference(_:)") mutating func exclusiveOrInPlace(_ other: Self)
  @available(*, unavailable, renamed: "isSubset(of:)") func isSubsetOf(_ other: Self) -> Swift.Bool
  @available(*, unavailable, renamed: "isDisjoint(with:)") func isDisjointWith(_ other: Self) -> Swift.Bool
  @available(*, unavailable, renamed: "isSuperset(of:)") func isSupersetOf(_ other: Self) -> Swift.Bool
  @available(*, unavailable, renamed: "subtract(_:)") mutating func subtractInPlace(_ other: Self)
  @available(*, unavailable, renamed: "isStrictSuperset(of:)") func isStrictSupersetOf(_ other: Self) -> Swift.Bool
  @available(*, unavailable, renamed: "isStrictSubset(of:)") func isStrictSubsetOf(_ other: Self) -> Swift.Bool
}
func _swift_stdlib_atomicFetchAndInt64(object target: Swift.UnsafeMutablePointer<Swift.Int64>, operand: Swift.Int64) -> Swift.Int64
struct _TupleMirror : _Mirror {
  let data: Swift._MagicMirrorData
  var value: Any {
    get {}
  }
  var valueType: Any.Type {
    get {}
  }
  var objectIdentifier: Swift.ObjectIdentifier? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  subscript(i: Swift.Int) -> (Swift.String, _Mirror) {
    get {}
  }
  var summary: Swift.String {
    get {}
  }
  var quickLookObject: Swift.PlaygroundQuickLook? {
    get {}
  }
  var disposition: Swift._MirrorDisposition {
    get {}
  }
  init(data: Swift._MagicMirrorData)
}
func _unsafePlus(_ lhs: Swift.Int, _ rhs: Swift.Int) -> Swift.Int
struct UInt32 : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int32
  init()
  init(_ _v: Builtin.Int32)
  init(_bits: Builtin.Int32)
  init(bigEndian value: Swift.UInt32)
  init(littleEndian value: Swift.UInt32)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt32)
  var bigEndian: Swift.UInt32 {
    get {}
  }
  var littleEndian: Swift.UInt32 {
    get {}
  }
  var byteSwapped: Swift.UInt32 {
    get {}
  }
  static var max: Swift.UInt32 {
    get {}
  }
  static var min: Swift.UInt32 {
    get {}
  }
  static var _sizeInBits: Swift.UInt32 {
    get {}
  }
  static var _sizeInBytes: Swift.UInt32 {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt32
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt32 : BitwiseOperations {
  static var allZeros: Swift.UInt32 {
    get {}
  }
}
extension UInt32 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt32 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt32 {
  static func addWithOverflow(_ lhs: Swift.UInt32, _ rhs: Swift.UInt32) -> (Swift.UInt32, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt32, _ rhs: Swift.UInt32) -> (Swift.UInt32, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt32, _ rhs: Swift.UInt32) -> (Swift.UInt32, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt32, _ rhs: Swift.UInt32) -> (Swift.UInt32, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt32, _ rhs: Swift.UInt32) -> (Swift.UInt32, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt32 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt32 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt32 {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt32 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to UInt32 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension UInt32 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
}
extension UInt32 {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to UInt32 will always succeed.") init?(exactly value: Swift.UInt32)
}
extension UInt32 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
}
extension UInt32 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension UInt32 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension UInt32 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension UInt32 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension UInt32 {
  init(bitPattern: Swift.Int32)
}
extension UInt32 {
  typealias _DisabledRangeIndex = Swift.UInt32
}
extension UInt32 {
  var signBitIndex: Swift.Int {
    get {}
  }
  var countTrailingZeros: Swift.Int {
    get {}
  }
}
extension UInt32 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt32 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt32 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt32 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UInt32 {
  init(_ v: Swift.UnicodeScalar)
}
extension UInt32 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension UInt32 {
  init(_ value: CoreGraphics.CGFloat)
}
func %(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.UInt8
func %(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Int8
func %(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.UInt16
func %(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Int16
func %(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.UInt32
func %(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Int32
func %(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.UInt64
func %(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Int64
func %(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.UInt
func %(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Int
@available(*, unavailable, message: "Use truncatingRemainder instead") func %(lhs: Swift.Float, rhs: Swift.Float) -> Swift.Float
@available(*, unavailable, message: "Use truncatingRemainder instead") func %(lhs: Swift.Double, rhs: Swift.Double) -> Swift.Double
@available(*, unavailable, message: "Use truncatingRemainder instead") func %(lhs: Swift.Float80, rhs: Swift.Float80) -> Swift.Float80
func %<T : _IntegerArithmetic>(lhs: T, rhs: T) -> T
func &(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.UInt8
func &(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Int8
func &(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.UInt16
func &(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Int16
func &(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.UInt32
func &(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Int32
func &(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.UInt64
func &(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Int64
func &(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.UInt
func &(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Int
class _AnySequenceBox<Element> {
  func _makeIterator() -> Swift.AnyIterator<Element>
  var _underestimatedCount: Swift.Int {
    get {}
  }
  func _map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
  func _filter(_ isIncluded: (Element) throws -> Swift.Bool) rethrows -> [Element]
  func _forEach(_ body: (Element) throws -> Swift.Void) rethrows
  func __customContainsEquatableElement(_ element: Element) -> Swift.Bool?
  func __preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func __copyToContiguousArray() -> Swift.ContiguousArray<Element>
  func __copyContents(initializing ptr: Swift.UnsafeMutablePointer<Element>) -> Swift.UnsafeMutablePointer<Element>
  func _dropFirst(_ n: Swift.Int) -> Swift._AnySequenceBox<Element>
  func _dropLast(_ n: Swift.Int) -> Swift._AnySequenceBox<Element>
  func _prefix(_ maxLength: Swift.Int) -> Swift._AnySequenceBox<Element>
  func _suffix(_ maxLength: Swift.Int) -> Swift._AnySequenceBox<Element>
  func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (Element) throws -> Swift.Bool) rethrows -> [Swift.AnySequence<Element>]
  init()
  @objc deinit
}
func *(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.UInt8
func *(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Int8
func *(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.UInt16
func *(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Int16
func *(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.UInt32
func *(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Int32
func *(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.UInt64
func *(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Int64
func *(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.UInt
func *(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Int
func *<T : FloatingPoint>(lhs: T, rhs: T) -> T
func *(lhs: Swift.Float, rhs: Swift.Float) -> Swift.Float
func *(lhs: Swift.Double, rhs: Swift.Double) -> Swift.Double
func *(lhs: Swift.Float80, rhs: Swift.Float80) -> Swift.Float80
func *<T : _IntegerArithmetic>(lhs: T, rhs: T) -> T
func +(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.UInt8
func +(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Int8
func +(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.UInt16
func +(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Int16
func +(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.UInt32
func +(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Int32
func +(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.UInt64
func +(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Int64
func +(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.UInt
func +(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Int
prefix func +<T : FloatingPoint>(x: T) -> T
func +<T : FloatingPoint>(lhs: T, rhs: T) -> T
prefix func +(x: Swift.Float) -> Swift.Float
func +(lhs: Swift.Float, rhs: Swift.Float) -> Swift.Float
prefix func +(x: Swift.Double) -> Swift.Double
func +(lhs: Swift.Double, rhs: Swift.Double) -> Swift.Double
prefix func +(x: Swift.Float80) -> Swift.Float80
func +(lhs: Swift.Float80, rhs: Swift.Float80) -> Swift.Float80
func +<T : _IntegerArithmetic>(lhs: T, rhs: T) -> T
prefix func +<T : SignedNumber>(x: T) -> T
func +<C : RangeReplaceableCollection, S : Sequence where S.Iterator.Element == C.Iterator.Element>(lhs: C, rhs: S) -> C
func +<C : RangeReplaceableCollection, S : Sequence where S.Iterator.Element == C.Iterator.Element>(lhs: S, rhs: C) -> C
func +<RRC1 : RangeReplaceableCollection, RRC2 : RangeReplaceableCollection where RRC1.Iterator.Element == RRC2.Iterator.Element>(lhs: RRC1, rhs: RRC2) -> RRC1
func +<T : Strideable>(lhs: T, rhs: T.Stride) -> T
func +<T : Strideable>(lhs: T.Stride, rhs: T) -> T
func +<T : UnsignedInteger>(lhs: T, rhs: T._DisallowMixedSignArithmetic) -> T
func +<T : UnsignedInteger>(lhs: T._DisallowMixedSignArithmetic, rhs: T) -> T
func +<Pointee>(lhs: Swift.UnsafeMutablePointer<Pointee>, rhs: Swift.Int) -> Swift.UnsafeMutablePointer<Pointee>
func +<Pointee>(lhs: Swift.Int, rhs: Swift.UnsafeMutablePointer<Pointee>) -> Swift.UnsafeMutablePointer<Pointee>
func +<Pointee>(lhs: Swift.UnsafePointer<Pointee>, rhs: Swift.Int) -> Swift.UnsafePointer<Pointee>
func +<Pointee>(lhs: Swift.Int, rhs: Swift.UnsafePointer<Pointee>) -> Swift.UnsafePointer<Pointee>
@_silgen_name("swift_stdlib_getErrorUserInfoNSDictionary") func _stdlib_getErrorUserInfoNSDictionary<T : Error>(_ x: Swift.UnsafePointer<T>) -> AnyObject?
func _swift_stdlib_atomicFetchAddInt32(object target: Swift.UnsafeMutablePointer<Swift.Int32>, operand: Swift.Int32) -> Swift.Int32
func -(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.UInt8
func -(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Int8
func -(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.UInt16
func -(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Int16
func -(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.UInt32
func -(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Int32
func -(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.UInt64
func -(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Int64
func -(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.UInt
func -(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Int
prefix func -<T : FloatingPoint>(x: T) -> T
func -<T : FloatingPoint>(lhs: T, rhs: T) -> T
prefix func -(x: Swift.Float) -> Swift.Float
func -(lhs: Swift.Float, rhs: Swift.Float) -> Swift.Float
prefix func -(x: Swift.Double) -> Swift.Double
func -(lhs: Swift.Double, rhs: Swift.Double) -> Swift.Double
prefix func -(x: Swift.Float80) -> Swift.Float80
func -(lhs: Swift.Float80, rhs: Swift.Float80) -> Swift.Float80
func -<T : _IntegerArithmetic>(lhs: T, rhs: T) -> T
prefix func -<T : SignedNumber>(x: T) -> T
func -<T : Strideable>(lhs: T, rhs: T.Stride) -> T
func -<T : Strideable>(lhs: T, rhs: T) -> T.Stride
func -<T : _DisallowMixedSignArithmetic>(lhs: T, rhs: T._DisallowMixedSignArithmetic) -> T
func -<T : _DisallowMixedSignArithmetic>(lhs: T, rhs: T) -> T._DisallowMixedSignArithmetic
func -<Pointee>(lhs: Swift.UnsafeMutablePointer<Pointee>, rhs: Swift.Int) -> Swift.UnsafeMutablePointer<Pointee>
func -<Pointee>(lhs: Swift.UnsafeMutablePointer<Pointee>, rhs: Swift.UnsafeMutablePointer<Pointee>) -> Swift.Int
func -<Pointee>(lhs: Swift.UnsafePointer<Pointee>, rhs: Swift.Int) -> Swift.UnsafePointer<Pointee>
func -<Pointee>(lhs: Swift.UnsafePointer<Pointee>, rhs: Swift.UnsafePointer<Pointee>) -> Swift.Int
func /(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.UInt8
func /(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Int8
func /(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.UInt16
func /(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Int16
func /(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.UInt32
func /(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Int32
func /(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.UInt64
func /(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Int64
func /(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.UInt
func /(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Int
func /<T : FloatingPoint>(lhs: T, rhs: T) -> T
func /(lhs: Swift.Float, rhs: Swift.Float) -> Swift.Float
func /(lhs: Swift.Double, rhs: Swift.Double) -> Swift.Double
func /(lhs: Swift.Float80, rhs: Swift.Float80) -> Swift.Float80
func /<T : _IntegerArithmetic>(lhs: T, rhs: T) -> T
struct _CocoaDictionaryStorage : _HashStorage {
  var cocoaDictionary: _NSDictionary
  typealias Index = Swift._CocoaDictionaryIndex
  typealias SequenceElement = (AnyObject, AnyObject)
  typealias SequenceElementWithoutLabels = (AnyObject, AnyObject)
  typealias Key = AnyObject
  typealias Value = AnyObject
  var startIndex: Swift._CocoaDictionaryStorage.Index {
    get {}
  }
  var endIndex: Swift._CocoaDictionaryStorage.Index {
    get {}
  }
  @_versioned func index(after i: Swift._CocoaDictionaryStorage.Index) -> Swift._CocoaDictionaryStorage.Index
  func formIndex(after i: inout Swift._CocoaDictionaryStorage.Index)
  @_versioned func index(forKey key: Swift._CocoaDictionaryStorage.Key) -> Swift._CocoaDictionaryStorage.Index?
  func assertingGet(_ i: Swift._CocoaDictionaryStorage.Index) -> Swift._CocoaDictionaryStorage.SequenceElement
  func assertingGet(_ key: Swift._CocoaDictionaryStorage.Key) -> Swift._CocoaDictionaryStorage.Value
  @inline(__always) func maybeGet(_ key: Swift._CocoaDictionaryStorage.Key) -> Swift._CocoaDictionaryStorage.Value?
  @discardableResult mutating func updateValue(_ value: Swift._CocoaDictionaryStorage.Value, forKey key: Swift._CocoaDictionaryStorage.Key) -> Swift._CocoaDictionaryStorage.Value?
  @discardableResult mutating func insert(_ value: Swift._CocoaDictionaryStorage.Value, forKey key: Swift._CocoaDictionaryStorage.Key) -> (inserted: Swift.Bool, memberAfterInsert: Swift._CocoaDictionaryStorage.Value)
  @discardableResult mutating func remove(at index: Swift._CocoaDictionaryStorage.Index) -> Swift._CocoaDictionaryStorage.SequenceElement
  @discardableResult mutating func removeValue(forKey key: Swift._CocoaDictionaryStorage.Key) -> Swift._CocoaDictionaryStorage.Value?
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool)
  var count: Swift.Int {
    get {}
  }
  static func fromArray(_ elements: [Swift._CocoaDictionaryStorage.SequenceElementWithoutLabels]) -> Swift._CocoaDictionaryStorage
  init(cocoaDictionary: _NSDictionary)
}
protocol Equatable {
  static func ==(lhs: Self, rhs: Self) -> Swift.Bool
}
@_versioned @_silgen_name("_swift_stdlib_reportUnimplementedInitializer") func _reportUnimplementedInitializer(_ className: Swift.UnsafePointer<Swift.UInt8>, _ classNameLength: Swift.UInt, _ initName: Swift.UnsafePointer<Swift.UInt8>, _ initNameLength: Swift.UInt, flags: Swift.UInt32)
func |=(lhs: inout Swift.UInt8, rhs: Swift.UInt8)
func |=(lhs: inout Swift.Int8, rhs: Swift.Int8)
func |=(lhs: inout Swift.UInt16, rhs: Swift.UInt16)
func |=(lhs: inout Swift.Int16, rhs: Swift.Int16)
func |=(lhs: inout Swift.UInt32, rhs: Swift.UInt32)
func |=(lhs: inout Swift.Int32, rhs: Swift.Int32)
func |=(lhs: inout Swift.UInt64, rhs: Swift.UInt64)
func |=(lhs: inout Swift.Int64, rhs: Swift.Int64)
func |=(lhs: inout Swift.UInt, rhs: Swift.UInt)
func |=(lhs: inout Swift.Int, rhs: Swift.Int)
func |=<T : BitwiseOperations>(lhs: inout T, rhs: T)
func >=<T : Comparable>(lhs: T, rhs: T) -> Swift.Bool
func >=(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.Bool
func >=(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Bool
func >=(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.Bool
func >=(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Bool
func >=(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.Bool
func >=(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Bool
func >=(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.Bool
func >=(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Bool
func >=(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.Bool
func >=(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Bool
func >=<T : FloatingPoint>(lhs: T, rhs: T) -> Swift.Bool
func >=<T : _SwiftNewtypeWrapper where T.RawValue : Comparable>(lhs: T, rhs: T) -> Swift.Bool
func >=<A : Comparable, B : Comparable>(lhs: (A, B), rhs: (A, B)) -> Swift.Bool
func >=<A : Comparable, B : Comparable, C : Comparable>(lhs: (A, B, C), rhs: (A, B, C)) -> Swift.Bool
func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Swift.Bool
func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Swift.Bool
func >=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Swift.Bool
func >>(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.UInt8
func >>(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Int8
func >>(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.UInt16
func >>(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Int16
func >>(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.UInt32
func >>(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Int32
func >>(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.UInt64
func >>(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Int64
func >>(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.UInt
func >>(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Int
func <(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.Bool
func <(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Bool
func <(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.Bool
func <(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Bool
func <(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.Bool
func <(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Bool
func <(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.Bool
func <(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Bool
func <(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.Bool
func <(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Bool
func <<T : FloatingPoint>(lhs: T, rhs: T) -> Swift.Bool
func <<T : _SwiftNewtypeWrapper where T.RawValue : Comparable>(lhs: T, rhs: T) -> Swift.Bool
func <<T : Strideable>(x: T, y: T) -> Swift.Bool
func <<Pointee>(lhs: Swift.UnsafeMutablePointer<Pointee>, rhs: Swift.UnsafeMutablePointer<Pointee>) -> Swift.Bool
func <<Pointee>(lhs: Swift.UnsafePointer<Pointee>, rhs: Swift.UnsafePointer<Pointee>) -> Swift.Bool
func <(lhs: Swift.UnsafeMutableRawPointer, rhs: Swift.UnsafeMutableRawPointer) -> Swift.Bool
func <(lhs: Swift.UnsafeRawPointer, rhs: Swift.UnsafeRawPointer) -> Swift.Bool
func <<A : Comparable, B : Comparable>(lhs: (A, B), rhs: (A, B)) -> Swift.Bool
func <<A : Comparable, B : Comparable, C : Comparable>(lhs: (A, B, C), rhs: (A, B, C)) -> Swift.Bool
func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Swift.Bool
func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Swift.Bool
func <<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Swift.Bool
protocol _ObjectiveCBridgeable {
  associatedtype _ObjectiveCType : AnyObject
  func _bridgeToObjectiveC() -> Self._ObjectiveCType
  static func _forceBridgeFromObjectiveC(_ source: Self._ObjectiveCType, result: inout Self?)
  @discardableResult static func _conditionallyBridgeFromObjectiveC(_ source: Self._ObjectiveCType, result: inout Self?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Self._ObjectiveCType?) -> Self
}
func ><T : Comparable>(lhs: T, rhs: T) -> Swift.Bool
func >(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.Bool
func >(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Bool
func >(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.Bool
func >(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Bool
func >(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.Bool
func >(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Bool
func >(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.Bool
func >(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Bool
func >(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.Bool
func >(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Bool
func ><T : FloatingPoint>(lhs: T, rhs: T) -> Swift.Bool
func ><T : _SwiftNewtypeWrapper where T.RawValue : Comparable>(lhs: T, rhs: T) -> Swift.Bool
func ><A : Comparable, B : Comparable>(lhs: (A, B), rhs: (A, B)) -> Swift.Bool
func ><A : Comparable, B : Comparable, C : Comparable>(lhs: (A, B, C), rhs: (A, B, C)) -> Swift.Bool
func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Swift.Bool
func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Swift.Bool
func ><A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Swift.Bool
@available(*, unavailable, renamed: "ClosedRange") struct ClosedInterval<Bound> {
  init()
}
struct RangeReplaceableRandomAccessSlice<Base : RandomAccessIndexable & RangeReplaceableIndexable> : RandomAccessCollection, RangeReplaceableCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
  }
  typealias SubSequence = Swift.RangeReplaceableRandomAccessSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.RangeReplaceableRandomAccessSlice<Base> {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(before i: Base.Index) -> Base.Index
  func formIndex(before i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init()
  init(repeating repeatedValue: Base._Element, count: Swift.Int)
  init<S where S : Sequence, S.Iterator.Element == Base._Element>(_ elements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_ subRange: Swift.Range<Base.Index>, with newElements: C)
  mutating func insert(_ newElement: Base._Element, at i: Base.Index)
  mutating func insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf newElements: S, at i: Base.Index)
  mutating func remove(at i: Base.Index) -> Base._Element
  mutating func removeSubrange(_ bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  var _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.RangeReplaceableRandomAccessSlice<Base>>
  typealias Indices = Swift.DefaultRandomAccessIndices<Swift.RangeReplaceableRandomAccessSlice<Base>>
}
func _unsafeMultiply(_ lhs: Swift.Int, _ rhs: Swift.Int) -> Swift.Int
func _makeSwiftNSFastEnumerationState() -> SwiftShims._SwiftNSFastEnumerationState
@available(*, unavailable, renamed: "UnsafeBufferPointerIterator") struct UnsafeBufferPointerGenerator<Element> {
  init()
}
protocol RangeReplaceableCollection : RangeReplaceableIndexable, Collection {
  init()
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_ subrange: Swift.Range<Self.Index>, with newElements: C)
  mutating func reserveCapacity(_ n: Self.IndexDistance)
  init(repeating repeatedValue: Self.Iterator.Element, count: Swift.Int)
  init<S : Sequence where S.Iterator.Element == Iterator.Element>(_ elements: S)
  mutating func append(_ newElement: Self.Iterator.Element)
  mutating func append<S : Sequence where S.Iterator.Element == Iterator.Element>(contentsOf newElements: S)
  mutating func insert(_ newElement: Self.Iterator.Element, at i: Self.Index)
  mutating func insert<S : Collection where S.Iterator.Element == Iterator.Element>(contentsOf newElements: S, at i: Self.Index)
  @discardableResult mutating func remove(at i: Self.Index) -> Self.Iterator.Element
  mutating func _customRemoveLast() -> Self.Iterator.Element?
  mutating func _customRemoveLast(_ n: Swift.Int) -> Swift.Bool
  @discardableResult mutating func removeFirst() -> Self.Iterator.Element
  mutating func removeFirst(_ n: Swift.Int)
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool)
}
extension RangeReplaceableCollection {
  convenience init(repeating repeatedValue: Self.Iterator.Element, count: Swift.Int)
  convenience init<S : Sequence where S.Iterator.Element == Iterator.Element>(_ elements: S)
  mutating func append(_ newElement: Self.Iterator.Element)
  mutating func append<S : Sequence where S.Iterator.Element == Iterator.Element>(contentsOf newElements: S)
  mutating func insert(_ newElement: Self.Iterator.Element, at i: Self.Index)
  mutating func insert<C : Collection where C.Iterator.Element == Iterator.Element>(contentsOf newElements: C, at i: Self.Index)
  @discardableResult mutating func remove(at position: Self.Index) -> Self.Iterator.Element
  mutating func removeSubrange(_ bounds: Swift.Range<Self.Index>)
  mutating func removeFirst(_ n: Swift.Int)
  @discardableResult mutating func removeFirst() -> Self.Iterator.Element
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
  mutating func reserveCapacity(_ n: Self.IndexDistance)
}
extension RangeReplaceableCollection where SubSequence == Self {
  @discardableResult mutating func removeFirst() -> Self.Iterator.Element
  mutating func removeFirst(_ n: Swift.Int)
}
extension RangeReplaceableCollection where Index : Strideable, Index.Stride : SignedInteger {
  func _makeHalfOpen(_ r: Swift.CountableRange<Self.Index>) -> Swift.Range<Self.Index>
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_ subrange: Swift.CountableRange<Self.Index>, with newElements: C)
  mutating func removeSubrange(_ bounds: Swift.CountableRange<Self.Index>)
}
extension RangeReplaceableCollection {
  func _makeHalfOpen(_ r: Swift.ClosedRange<Self.Index>) -> Swift.Range<Self.Index>
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_ subrange: Swift.ClosedRange<Self.Index>, with newElements: C)
  mutating func removeSubrange(_ bounds: Swift.ClosedRange<Self.Index>)
}
extension RangeReplaceableCollection where Index : Strideable, Index.Stride : SignedInteger {
  func _makeHalfOpen(_ r: Swift.CountableClosedRange<Self.Index>) -> Swift.Range<Self.Index>
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_ subrange: Swift.CountableClosedRange<Self.Index>, with newElements: C)
  mutating func removeSubrange(_ bounds: Swift.CountableClosedRange<Self.Index>)
}
extension RangeReplaceableCollection {
  mutating func _customRemoveLast() -> Self.Iterator.Element?
  mutating func _customRemoveLast(_ n: Swift.Int) -> Swift.Bool
}
extension RangeReplaceableCollection where Self : BidirectionalCollection, SubSequence == Self {
  mutating func _customRemoveLast() -> Self.Iterator.Element?
  mutating func _customRemoveLast(_ n: Swift.Int) -> Swift.Bool
}
extension RangeReplaceableCollection where Self : BidirectionalCollection {
  @discardableResult mutating func removeLast() -> Self.Iterator.Element
  mutating func removeLast(_ n: Swift.Int)
}
extension RangeReplaceableCollection where Self : BidirectionalCollection, SubSequence == Self {
  @discardableResult mutating func removeLast() -> Self.Iterator.Element
  mutating func removeLast(_ n: Swift.Int)
}
extension RangeReplaceableCollection {
  @available(*, unavailable, renamed: "replaceSubrange(_:with:)") mutating func replaceRange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_ subrange: Swift.Range<Self.Index>, with newElements: C)
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ i: Self.Index) -> Self.Iterator.Element
  @available(*, unavailable, renamed: "removeSubrange") mutating func removeRange(_ subrange: Swift.Range<Self.Index>)
  @available(*, unavailable, renamed: "append(contentsOf:)") mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Iterator.Element>(_ newElements: S)
  @available(*, unavailable, renamed: "insert(contentsOf:at:)") mutating func insertContentsOf<C : Collection where C.Iterator.Element == Iterator.Element>(_ newElements: C, at i: Self.Index)
}
protocol _ExpressibleByColorLiteral {
  init(colorLiteralRed red: Swift.Float, green: Swift.Float, blue: Swift.Float, alpha: Swift.Float)
}
()
func _setBridgeToObjectiveC<SwiftValue, ObjCValue>(_ source: Swift.Set<SwiftValue>) -> Swift.Set<ObjCValue>
func _parseUnsignedAsciiAsUIntMax(_ u16: Swift.String.UTF16View, _ radix: Swift.Int, _ maximum: Swift.UIntMax) -> Swift.UIntMax?
protocol Sequence {
  associatedtype Iterator : IteratorProtocol
  associatedtype SubSequence
  func makeIterator() -> Self.Iterator
  var underestimatedCount: Swift.Int { get }
  func map<T>(_ transform: (Self.Iterator.Element) throws -> T) rethrows -> [T]
  func filter(_ isIncluded: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.Iterator.Element]
  func forEach(_ body: (Self.Iterator.Element) throws -> Swift.Void) rethrows
  func dropFirst(_ n: Swift.Int) -> Self.SubSequence
  func dropLast(_ n: Swift.Int) -> Self.SubSequence
  func prefix(_ maxLength: Swift.Int) -> Self.SubSequence
  func suffix(_ maxLength: Swift.Int) -> Self.SubSequence
  func split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.SubSequence]
  func first(where predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
  func _customContainsEquatableElement(_ element: Self.Iterator.Element) -> Swift.Bool?
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Iterator.Element>
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Self.Iterator.Element>) -> Swift.UnsafeMutablePointer<Self.Iterator.Element>
}
extension Sequence {
  func map<T>(_ transform: (Self.Iterator.Element) throws -> T) rethrows -> [T]
  func filter(_ isIncluded: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.Iterator.Element]
  func suffix(_ maxLength: Swift.Int) -> Swift.AnySequence<Self.Iterator.Element>
  func split(maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default, whereSeparator isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnySequence<Self.Iterator.Element>]
  var underestimatedCount: Swift.Int {
    get {}
  }
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func _customContainsEquatableElement(_ element: Self.Iterator.Element) -> Swift.Bool?
  func forEach(_ body: (Self.Iterator.Element) throws -> Swift.Void) rethrows
}
extension Sequence {
  func first(where predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
}
extension Sequence {
  func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Iterator.Element>
}
extension Sequence {
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Self.Iterator.Element>) -> Swift.UnsafeMutablePointer<Self.Iterator.Element>
}
extension Sequence where Self : _ArrayProtocol, Self.Element == Self.Iterator.Element {
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Self.Element>) -> Swift.UnsafeMutablePointer<Self.Element>
}
extension Sequence where Self.Iterator.Element : Comparable {
  func sorted() -> [Self.Iterator.Element]
}
extension Sequence {
  func sorted(by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool) -> [Self.Iterator.Element]
}
extension Sequence {
  @available(*, unavailable, renamed: "sorted(by:)") func sort(_ isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool) -> [Self.Iterator.Element]
}
extension Sequence where Iterator.Element : Comparable {
  @available(*, unavailable, renamed: "sorted()") func sort() -> [Self.Iterator.Element]
}
extension Sequence where Iterator.Element : Sequence {
  func joined() -> Swift.FlattenSequence<Self>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.FlattenSequence<Self>
}
extension Sequence where Iterator.Element : Sequence {
  func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> Swift.JoinedSequence<Self>
}
extension Sequence where Iterator.Element : Sequence {
  @available(*, unavailable, renamed: "joined(separator:)") func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> Swift.JoinedSequence<Self>
}
extension Sequence {
  var lazy: Swift.LazySequence<Self> {
    get {}
  }
}
extension Sequence where Self.Iterator == Self, Self : IteratorProtocol {
  func makeIterator() -> Self
}
extension Sequence where Iterator.Element : Equatable {
  func split(separator: Self.Iterator.Element, maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default) -> [Swift.AnySequence<Self.Iterator.Element>]
}
extension Sequence where SubSequence : Sequence, SubSequence.Iterator.Element == Iterator.Element, SubSequence.SubSequence == SubSequence {
  func dropFirst(_ n: Swift.Int) -> Swift.AnySequence<Self.Iterator.Element>
  func dropLast(_ n: Swift.Int) -> Swift.AnySequence<Self.Iterator.Element>
  func prefix(_ maxLength: Swift.Int) -> Swift.AnySequence<Self.Iterator.Element>
}
extension Sequence {
  func dropFirst() -> Self.SubSequence
  func dropLast() -> Self.SubSequence
}
extension Sequence {
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Self.Iterator
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
  @available(*, unavailable, message: "call 'split(maxSplits:omittingEmptySubsequences:whereSeparator:)' and invert the 'allowEmptySlices' argument") func split(_ maxSplit: Swift.Int, allowEmptySlices: Swift.Bool, isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.SubSequence]
}
extension Sequence where Iterator.Element : Equatable {
  @available(*, unavailable, message: "call 'split(separator:maxSplits:omittingEmptySubsequences:)' and invert the 'allowEmptySlices' argument") func split(_ separator: Self.Iterator.Element, maxSplit: Swift.Int = default, allowEmptySlices: Swift.Bool = default) -> [Swift.AnySequence<Self.Iterator.Element>]
}
extension Sequence {
  func enumerated() -> Swift.EnumeratedSequence<Self>
}
extension Sequence {
  @warn_unqualified_access func min(by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
  @warn_unqualified_access func max(by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
}
extension Sequence where Iterator.Element : Comparable {
  @warn_unqualified_access func min() -> Self.Iterator.Element?
  @warn_unqualified_access func max() -> Self.Iterator.Element?
}
extension Sequence {
  func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Sequence where Iterator.Element : Equatable {
  func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Swift.Bool
}
extension Sequence {
  func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Sequence where Iterator.Element : Equatable {
  func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence) -> Swift.Bool
}
extension Sequence {
  func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Sequence where Iterator.Element : Comparable {
  func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence) -> Swift.Bool
}
extension Sequence where Iterator.Element : Equatable {
  func contains(_ element: Self.Iterator.Element) -> Swift.Bool
}
extension Sequence {
  func contains(where predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Sequence {
  func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Self.Iterator.Element) throws -> Result) rethrows -> Result
}
extension Sequence {
  func reversed() -> [Self.Iterator.Element]
}
extension Sequence {
  func flatMap<SegmentOfResult : Sequence>(_ transform: (Self.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
}
extension Sequence {
  func flatMap<ElementOfResult>(_ transform: (Self.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
}
extension Sequence {
  @available(*, unavailable, renamed: "enumerated()") func enumerate() -> Swift.EnumeratedSequence<Self>
  @available(*, unavailable, renamed: "min(by:)") func minElement(_ isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
  @available(*, unavailable, renamed: "max(by:)") func maxElement(_ isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
  @available(*, unavailable, renamed: "reversed()") func reverse() -> [Self.Iterator.Element]
  @available(*, unavailable, renamed: "starts(with:by:)") func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
  @available(*, unavailable, renamed: "elementsEqual(_:by:)") func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence, isEquivalent: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
  @available(*, unavailable, renamed: "lexicographicallyPrecedes(_:by:)") func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence, isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
  @available(*, unavailable, renamed: "contains(where:)") func contains(_ predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
  @available(*, unavailable, renamed: "reduce(_:_:)") func reduce<Result>(_ initial: Result, combine: (Result, Self.Iterator.Element) throws -> Result) rethrows -> Result
}
extension Sequence where Iterator.Element : Comparable {
  @available(*, unavailable, renamed: "min()") func minElement() -> Self.Iterator.Element?
  @available(*, unavailable, renamed: "max()") func maxElement() -> Self.Iterator.Element?
  @available(*, unavailable, renamed: "starts(with:)") func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Swift.Bool
  @available(*, unavailable, renamed: "lexicographicallyPrecedes") func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence) -> Swift.Bool
}
extension Sequence where Self : _SequenceWrapper, Self.Iterator == Self.Base.Iterator {
  func makeIterator() -> Self.Iterator
  func map<T>(_ transform: (Self.Iterator.Element) throws -> T) rethrows -> [T]
  func filter(_ isIncluded: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.Iterator.Element]
  func _customContainsEquatableElement(_ element: Self.Iterator.Element) -> Swift.Bool?
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Iterator.Element>
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Self.Iterator.Element>) -> Swift.UnsafeMutablePointer<Self.Iterator.Element>
}
extension Sequence where Iterator.Element == String {
  func joined(separator: Swift.String = default) -> Swift.String
}
extension Sequence where Iterator.Element == String {
  @available(*, unavailable, renamed: "joined(separator:)") func joinWithSeparator(_ separator: Swift.String) -> Swift.String
}
func _rint(_ x: Swift.Float) -> Swift.Float
func _rint(_ x: Swift.Double) -> Swift.Double
func ^(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.UInt8
func ^(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Int8
func ^(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.UInt16
func ^(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Int16
func ^(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.UInt32
func ^(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Int32
func ^(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.UInt64
func ^(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Int64
func ^(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.UInt
func ^(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Int
func ??<T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T
func ??<T>(optional: T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T?
func _swift_stdlib_atomicLoadInt64(object target: Swift.UnsafeMutablePointer<Swift.Int64>) -> Swift.Int64
var _nilNativeObject: AnyObject? {
  get {}
}
protocol _ExpressibleByBuiltinBooleanLiteral {
  init(_builtinBooleanLiteral value: Builtin.Int1)
}
struct LazyMapBidirectionalCollection<Base : BidirectionalCollection, Element> : LazyCollectionProtocol, BidirectionalCollection {
  typealias Index = Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(before i: Base.Index) -> Base.Index
  func formIndex(before i: inout Base.Index)
  subscript(position: Base.Index) -> Element {
    get {}
  }
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.BidirectionalSlice<Swift.LazyMapBidirectionalCollection<Base, Element>> {
    get {}
  }
  typealias IndexDistance = Base.IndexDistance
  typealias Indices = Base.Indices
  var indices: Base.Indices {
    get {}
  }
  var isEmpty: Swift.Bool {
    get {}
  }
  var count: Base.IndexDistance {
    get {}
  }
  var first: Element? {
    get {}
  }
  var last: Element? {
    get {}
  }
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func makeIterator() -> Swift.LazyMapIterator<Base.Iterator, Element>
  var underestimatedCount: Swift.Int {
    get {}
  }
  init(_base: Base, transform: @escaping (Base.Iterator.Element) -> Element)
  var _base: Base
  let _transform: (Base.Iterator.Element) -> Element
  typealias _Element = Element
  typealias SubSequence = Swift.BidirectionalSlice<Swift.LazyMapBidirectionalCollection<Base, Element>>
  typealias Elements = Swift.LazyMapBidirectionalCollection<Base, Element>
  typealias Iterator = Swift.LazyMapIterator<Base.Iterator, Element>
}
struct DefaultIndices<Elements : Indexable> : Collection {
  typealias Index = Elements.Index
  init(_elements: Elements, startIndex: Elements.Index, endIndex: Elements.Index)
  var startIndex: Elements.Index {
    get {}
  }
  var endIndex: Elements.Index {
    get {}
  }
  subscript(i: Elements.Index) -> Elements.Index {
    get {}
  }
  typealias SubSequence = Swift.DefaultIndices<Elements>
  subscript(bounds: Swift.Range<Elements.Index>) -> Swift.DefaultIndices<Elements> {
    get {}
  }
  func index(after i: Elements.Index) -> Elements.Index
  func formIndex(after i: inout Elements.Index)
  typealias Indices = Swift.DefaultIndices<Elements>
  var indices: Swift.DefaultIndices<Elements> {
    get {}
  }
  var _elements: Elements
  var _startIndex: Elements.Index
  var _endIndex: Elements.Index
  typealias _Element = Elements.Index
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift.DefaultIndices<Elements>>
}
let _x86_64CountGPRegisters: Swift.Int
func _swift_stdlib_atomicLoadPtrImpl(object target: Swift.UnsafeMutablePointer<Swift.OpaquePointer>) -> Swift.OpaquePointer?
enum _GraphemeClusterBreakPropertyValue : Swift.Int {
  case Other
  case CR
  case LF
  case Control
  case Extend
  case Regional_Indicator
  case Prepend
  case SpacingMark
  case L
  case V
  case T
  case LV
  case LVT
  typealias RawValue = Swift.Int
  var hashValue: Swift.Int {
    get {}
  }
  init?(rawValue: Swift.Int)
  var rawValue: Swift.Int {
    get {}
  }
}
protocol _Hashable {
  func _toAnyHashable() -> Swift.AnyHashable
}
struct ReversedIndex<Base : Collection> : Comparable {
  init(_ base: Base.Index)
  let base: Base.Index
  static func ==(lhs: Swift.ReversedIndex<Base>, rhs: Swift.ReversedIndex<Base>) -> Swift.Bool
  static func <(lhs: Swift.ReversedIndex<Base>, rhs: Swift.ReversedIndex<Base>) -> Swift.Bool
}
func ~=<T>(lhs: Swift._OptionalNilComparisonType, rhs: T?) -> Swift.Bool
func ~=<T : Equatable>(a: T, b: T) -> Swift.Bool
func |(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.UInt8
func |(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Int8
func |(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.UInt16
func |(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Int16
func |(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.UInt32
func |(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Int32
func |(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.UInt64
func |(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Int64
func |(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.UInt
func |(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Int
enum ImplicitlyUnwrappedOptional<Wrapped> : ExpressibleByNilLiteral {
  case none
  case some(Wrapped)
  init(_ some: Wrapped)
  init(nilLiteral: ())
}
extension ImplicitlyUnwrappedOptional : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension ImplicitlyUnwrappedOptional : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension ImplicitlyUnwrappedOptional : _ObjectiveCBridgeable {
  func _bridgeToObjectiveC() -> AnyObject
  static func _forceBridgeFromObjectiveC(_ x: AnyObject, result: inout Wrapped!?)
  static func _conditionallyBridgeFromObjectiveC(_ x: AnyObject, result: inout Wrapped!?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: AnyObject?) -> Wrapped!
  typealias _ObjectiveCType = AnyObject
}
extension ImplicitlyUnwrappedOptional {
  @available(*, unavailable, message: "Please use nil literal instead.") init()
  @available(*, unavailable, message: "Has been removed in Swift 3.") func map<U>(_ f: (Wrapped) throws -> U) rethrows -> U!
  @available(*, unavailable, message: "Has been removed in Swift 3.") func flatMap<U>(_ f: (Wrapped) throws -> U!) rethrows -> U!
}
func ~><T : SignedNumber>(x: T, _: (Swift._Abs, ())) -> T
func ~><T : AbsoluteValuable>(x: T, _: (Swift._Abs, ())) -> T
prefix func ~(rhs: Swift.UInt8) -> Swift.UInt8
prefix func ~(rhs: Swift.Int8) -> Swift.Int8
prefix func ~(rhs: Swift.UInt16) -> Swift.UInt16
prefix func ~(rhs: Swift.Int16) -> Swift.Int16
prefix func ~(rhs: Swift.UInt32) -> Swift.UInt32
prefix func ~(rhs: Swift.Int32) -> Swift.Int32
prefix func ~(rhs: Swift.UInt64) -> Swift.UInt64
prefix func ~(rhs: Swift.Int64) -> Swift.Int64
prefix func ~(rhs: Swift.UInt) -> Swift.UInt
prefix func ~(rhs: Swift.Int) -> Swift.Int
struct _BridgeStorage<NativeClass : AnyObject, ObjCClass : AnyObject> {
  typealias Native = NativeClass
  typealias ObjC = ObjCClass
  @inline(__always) init(native: NativeClass, bits: Swift.Int)
  @inline(__always) init(objC: ObjCClass)
  @inline(__always) init(native: NativeClass)
  var spareBits: Swift.Int {
    @inline(__always) get {}
  }
  @inline(__always) mutating func isUniquelyReferencedNative() -> Swift.Bool
  @inline(__always) mutating func isUniquelyReferencedOrPinnedNative() -> Swift.Bool
  var isNative: Swift.Bool {
    @inline(__always) get {}
  }
  @inline(__always) func isNativeWithClearedSpareBits(_ bits: Swift.Int) -> Swift.Bool
  var isObjC: Swift.Bool {
    @inline(__always) get {}
  }
  var nativeInstance: NativeClass {
    @inline(__always) get {}
  }
  var nativeInstance_noSpareBits: NativeClass {
    @inline(__always) get {}
  }
  @inline(__always) mutating func isUniquelyReferenced_native_noSpareBits() -> Swift.Bool
  @inline(__always) mutating func isUniquelyReferencedOrPinned_native_noSpareBits() -> Swift.Bool
  var objCInstance: ObjCClass {
    @inline(__always) get {}
  }
  var _isTagged: Swift.Bool {
    @inline(__always) get {}
  }
  var rawValue: Builtin.BridgeObject
}
@_silgen_name("_swift_convertToAnyHashable") func _convertToAnyHashable<H : Hashable>(_ value: H) -> Swift.AnyHashable
struct _ContiguousArrayBuffer<Element> : _ArrayBufferProtocol {
  init(uninitializedCount: Swift.Int, minimumCapacity: Swift.Int)
  init(count: Swift.Int, storage: Swift._ContiguousArrayStorage<Element>)
  init(_ storage: Swift._ContiguousArrayStorageBase)
  func _initStorageHeader(count: Swift.Int, capacity: Swift.Int)
  var arrayPropertyIsNativeTypeChecked: Swift.Bool {
    get {}
  }
  var firstElementAddress: Swift.UnsafeMutablePointer<Element> {
    get {}
  }
  var firstElementAddressIfContiguous: Swift.UnsafeMutablePointer<Element>? {
    get {}
  }
  func withUnsafeBufferPointer<R>(_ body: (Swift.UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
  mutating func withUnsafeMutableBufferPointer<R>(_ body: (Swift.UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
  init()
  init(_ buffer: Swift._ContiguousArrayBuffer<Element>, shiftedToStartIndex: Swift.Int)
  mutating func requestUniqueMutableBackingBuffer(minimumCapacity: Swift.Int) -> Swift._ContiguousArrayBuffer<Element>?
  mutating func isMutableAndUniquelyReferenced() -> Swift.Bool
  mutating func isMutableAndUniquelyReferencedOrPinned() -> Swift.Bool
  func requestNativeBuffer() -> Swift._ContiguousArrayBuffer<Element>?
  @_versioned func getElement(_ i: Swift.Int) -> Element
  subscript(i: Swift.Int) -> Element {
    get {}
    set(newValue) {}
  }
  var count: Swift.Int {
    get {}
    set(newValue) {}
  }
  @inline(__always) func _checkValidSubscript(_ index: Swift.Int)
  var capacity: Swift.Int {
    get {}
  }
  @discardableResult func _copyContents(subRange bounds: Swift.Range<Swift.Int>, initializing target: Swift.UnsafeMutablePointer<Element>) -> Swift.UnsafeMutablePointer<Element>
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift._SliceBuffer<Element> {
    get {}
    set(newValue) {}
  }
  mutating func isUniquelyReferenced() -> Swift.Bool
  mutating func isUniquelyReferencedOrPinned() -> Swift.Bool
  func _asCocoaArray() -> _NSArrayCore
  var owner: AnyObject {
    get {}
  }
  var nativeOwner: AnyObject {
    get {}
  }
  var identity: Swift.UnsafeRawPointer {
    get {}
  }
  func canStoreElements(ofDynamicType proposedElementType: Any.Type) -> Swift.Bool
  func storesOnlyElementsOfType<U>(_: U.Type) -> Swift.Bool
  var _storage: Swift._ContiguousArrayStorageBase {
    get {}
  }
  var __bufferPointer: Swift.ManagedBufferPointer<Swift._ArrayBody, Element>
  typealias Index = Swift.Int
  typealias _Element = Element
  typealias SubSequence = Swift._SliceBuffer<Element>
  typealias Element = Element
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift._ContiguousArrayBuffer<Element>>
}
extension _ContiguousArrayBuffer : RandomAccessCollection {
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  typealias Indices = Swift.CountableRange<Swift.Int>
}
extension _ContiguousArrayBuffer {
  func _copyToContiguousArray() -> Swift.ContiguousArray<Element>
}
func _convertPointerToPointerArgument<FromPointer : _Pointer, ToPointer : _Pointer>(_ from: FromPointer) -> ToPointer
@unsafe_no_objc_tagged_pointer @objc protocol _NSArrayCore : _NSCopying, _NSFastEnumeration {
  @objc(objectAtIndex:) func objectAt(_ index: Swift.Int) -> AnyObject
  @objc func getObjects(_: Swift.UnsafeMutablePointer<AnyObject>, range: SwiftShims._SwiftNSRange)
  @objc(countByEnumeratingWithState:objects:count:) func countByEnumerating(with state: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState>, objects: Swift.UnsafeMutablePointer<AnyObject>?, count: Swift.Int) -> Swift.Int
  @objc var count: Swift.Int { get }
}
protocol _HasCustomAnyHashableRepresentation {
  func _toCustomAnyHashable() -> Swift.AnyHashable?
}
struct UInt64 : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(bigEndian value: Swift.UInt64)
  init(littleEndian value: Swift.UInt64)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt64)
  var bigEndian: Swift.UInt64 {
    get {}
  }
  var littleEndian: Swift.UInt64 {
    get {}
  }
  var byteSwapped: Swift.UInt64 {
    get {}
  }
  static var max: Swift.UInt64 {
    get {}
  }
  static var min: Swift.UInt64 {
    get {}
  }
  static var _sizeInBits: Swift.UInt64 {
    get {}
  }
  static var _sizeInBytes: Swift.UInt64 {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt64
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt64 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt64 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt64 {
  static func addWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt64 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt64 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt64 {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt64 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to UInt64 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension UInt64 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
}
extension UInt64 {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to UInt64 will always succeed.") init?(exactly value: Swift.UInt32)
}
extension UInt64 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
}
extension UInt64 {
  init(_ value: Swift.UInt64)
  @available(*, message: "Converting UInt64 to UInt64 will always succeed.") init?(exactly value: Swift.UInt64)
}
extension UInt64 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
}
extension UInt64 {
  init(_ value: Swift.UInt)
  @available(*, message: "Converting UInt to UInt64 will always succeed.") init?(exactly value: Swift.UInt)
}
extension UInt64 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
}
extension UInt64 {
  init(bitPattern: Swift.Int64)
}
extension UInt64 : BitwiseOperations {
  static var allZeros: Swift.UInt64 {
    get {}
  }
}
extension UInt64 {
  typealias _DisabledRangeIndex = Swift.UInt64
}
extension UInt64 {
  var signBitIndex: Swift.Int {
    get {}
  }
  var countTrailingZeros: Swift.Int {
    get {}
  }
}
extension UInt64 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt64 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt64 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt64 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UInt64 {
  init(_ v: Swift.UnicodeScalar)
}
extension UInt64 : CVarArg, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension UInt64 {
  init(_ value: CoreGraphics.CGFloat)
}
struct UnsafeMutablePointer<Pointee> : Strideable, Hashable, _Pointer {
  typealias Distance = Swift.Int
  let _rawValue: Builtin.RawPointer
  init(_ _rawValue: Builtin.RawPointer)
  init(_ from: Swift.OpaquePointer)
  init?(_ from: Swift.OpaquePointer?)
  init?(bitPattern: Swift.Int)
  init?(bitPattern: Swift.UInt)
  init(_ other: Swift.UnsafeMutablePointer<Pointee>)
  init?(_ other: Swift.UnsafeMutablePointer<Pointee>?)
  init(mutating other: Swift.UnsafePointer<Pointee>)
  init?(mutating other: Swift.UnsafePointer<Pointee>?)
  static func allocate(capacity count: Swift.Int) -> Swift.UnsafeMutablePointer<Pointee>
  func deallocate(capacity: Swift.Int)
  var pointee: Pointee
  var pointee: Pointee {
    unsafeAddress {}
    unsafeMutableAddress {}
  }
  func initialize(to newValue: Pointee, count: Swift.Int = default)
  func move() -> Pointee
  func assign(from source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  func moveInitialize(from source: Swift.UnsafeMutablePointer<Pointee>, count: Swift.Int)
  func initialize(from source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  func initialize<C : Collection where C.Iterator.Element == Pointee>(from source: C)
  func moveAssign(from source: Swift.UnsafeMutablePointer<Pointee>, count: Swift.Int)
  @discardableResult func deinitialize(count: Swift.Int = default) -> Swift.UnsafeMutableRawPointer
  func withMemoryRebound<T, Result>(to: T.Type, capacity count: Swift.Int, _ body: (Swift.UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result
  subscript(i: Swift.Int) -> Pointee {
    unsafeAddress {}
    unsafeMutableAddress {}
  }
  var hashValue: Swift.Int {
    get {}
  }
  func successor() -> Swift.UnsafeMutablePointer<Pointee>
  func predecessor() -> Swift.UnsafeMutablePointer<Pointee>
  func distance(to x: Swift.UnsafeMutablePointer<Pointee>) -> Swift.Int
  func advanced(by n: Swift.Int) -> Swift.UnsafeMutablePointer<Pointee>
  typealias Stride = Swift.Int
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension UnsafeMutablePointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension UnsafeMutablePointer : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UnsafeMutablePointer : CustomPlaygroundQuickLookable {
  var summary: Swift.String {
    get {}
  }
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UnsafeMutablePointer {
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init<U>(_ from: Swift.UnsafeMutablePointer<U>)
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init?<U>(_ from: Swift.UnsafeMutablePointer<U>?)
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init<U>(_ from: Swift.UnsafePointer<U>)
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init?<U>(_ from: Swift.UnsafePointer<U>?)
  @available(*, unavailable, renamed: "init(mutating:)") init(_ from: Swift.UnsafePointer<Pointee>)
  @available(*, unavailable, renamed: "init(mutating:)") init?(_ from: Swift.UnsafePointer<Pointee>?)
  @available(*, unavailable, renamed: "Pointee") typealias Memory = Pointee
  @available(*, unavailable, message: "use 'nil' literal") init()
  @available(*, unavailable, renamed: "allocate(capacity:)") static func alloc(_ num: Swift.Int) -> Swift.UnsafeMutablePointer<Pointee>
  @available(*, unavailable, message: "use 'UnsafeMutablePointer.allocate(capacity:)'") init(allocatingCapacity: Swift.Int)
  @available(*, unavailable, renamed: "deallocate(capacity:)") func dealloc(_ num: Swift.Int)
  @available(*, unavailable, renamed: "deallocate(capacity:)") func deallocateCapacity(_ num: Swift.Int)
  @available(*, unavailable, renamed: "pointee") var memory: Pointee {
    get {}
    set(newValue) {}
  }
  @available(*, unavailable, renamed: "initialize(to:)") func initialize(_ newvalue: Pointee)
  @available(*, unavailable, renamed: "initialize(to:count:)") func initialize(with newvalue: Pointee, count: Swift.Int = default)
  @available(*, unavailable, renamed: "deinitialize(count:)") func destroy()
  @available(*, unavailable, renamed: "deinitialize(count:)") func destroy(_ count: Swift.Int)
  @available(*, unavailable, renamed: "initialize(from:)") func initializeFrom<C : Collection>(_ source: C)
  @available(*, unavailable, renamed: "initialize(from:count:)") func initializeFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  @available(*, unavailable, renamed: "assign(from:count:)") func assignFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  @available(*, unavailable, renamed: "assign(from:count:)") func assignBackwardFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  @available(*, unavailable, renamed: "moveInitialize(from:count:)") func moveInitializeFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  @available(*, unavailable, renamed: "moveInitialize(from:count:)") func moveInitializeBackwardFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  @available(*, unavailable, renamed: "moveAssign(from:count:)") func moveAssignFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
}
extension UnsafeMutablePointer : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
protocol Integer : _Integer, Strideable {
}
@_silgen_name("swift_EnumCaseName") func _getEnumCaseName<T>(_ value: T) -> Swift.UnsafePointer<Swift.CChar>?
func _swift_stdlib_atomicFetchAddInt64(object target: Swift.UnsafeMutablePointer<Swift.Int64>, operand: Swift.Int64) -> Swift.Int64
struct StrideThroughIterator<Element : Strideable> : IteratorProtocol {
  let _start: Element
  let _end: Element
  let _stride: Element.Stride
  var _current: (index: Swift.Int?, value: Element)
  var _didReturnEnd: Swift.Bool
  init(_start: Element, end: Element, stride: Element.Stride)
  mutating func next() -> Element?
  typealias Element = Element
}
@objc protocol _ShadowProtocol {
}
func _swift_stdlib_atomicStoreUInt32(object target: Swift.UnsafeMutablePointer<Swift.UInt32>, desired: Swift.UInt32)
@_versioned var _objectPointerLowSpareBitShift: Swift.UInt {
  @inline(__always) get {}
}
struct _BridgedNativeDictionaryStorage {
  typealias StorageImpl = Swift._NativeDictionaryStorageImpl<AnyObject, AnyObject>
  typealias SequenceElement = (AnyObject, AnyObject)
  let buffer: Swift._BridgedNativeDictionaryStorage.StorageImpl
  let initializedEntries: Swift._UnsafeBitMap
  let keys: Swift.UnsafeMutablePointer<AnyObject>
  let values: Swift.UnsafeMutablePointer<AnyObject>
  init(buffer: Swift._BridgedNativeDictionaryStorage.StorageImpl)
  var capacity: Swift.Int {
    get {}
  }
  @_versioned func isInitializedEntry(at i: Swift.Int) -> Swift.Bool
  func key(at i: Swift.Int) -> AnyObject
  func setKey(_ key: AnyObject, at i: Swift.Int)
  func initializeKey(_ k: AnyObject, value v: AnyObject, at i: Swift.Int)
  func value(at i: Swift.Int) -> AnyObject
  func assertingGet(_ i: Swift.Int) -> Swift._BridgedNativeDictionaryStorage.SequenceElement
}
protocol SignedNumber : Comparable, ExpressibleByIntegerLiteral {
  prefix static func -(x: Self) -> Self
  static func -(lhs: Self, rhs: Self) -> Self
  static func ~>(_: Self, _: (Swift._Abs, ())) -> Self
}
protocol CVarArg {
  var _cVarArgEncoding: [Swift.Int] { get }
}
extension CVarArg where Self : _ObjectiveCBridgeable {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
func _dump_unlocked<TargetStream : TextOutputStream>(_ value: Any, to target: inout TargetStream, name: Swift.String?, indent: Swift.Int, maxDepth: Swift.Int, maxItemCounter: inout Swift.Int, visitedItems: inout [Swift.ObjectIdentifier : Swift.Int])
let _x86_64SSERegisterWords: Swift.Int
struct RangeReplaceableSlice<Base : RangeReplaceableIndexable> : Collection, RangeReplaceableCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
  }
  typealias SubSequence = Swift.RangeReplaceableSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.RangeReplaceableSlice<Base> {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init()
  init(repeating repeatedValue: Base._Element, count: Swift.Int)
  init<S where S : Sequence, S.Iterator.Element == Base._Element>(_ elements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_ subRange: Swift.Range<Base.Index>, with newElements: C)
  mutating func insert(_ newElement: Base._Element, at i: Base.Index)
  mutating func insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf newElements: S, at i: Base.Index)
  mutating func remove(at i: Base.Index) -> Base._Element
  mutating func removeSubrange(_ bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  var _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.RangeReplaceableSlice<Base>>
  typealias Indices = Swift.DefaultIndices<Swift.RangeReplaceableSlice<Base>>
}
func _setDownCast<BaseValue, DerivedValue>(_ source: Swift.Set<BaseValue>) -> Swift.Set<DerivedValue>
func _arrayAppendSequence<Buffer, S where Buffer : _ArrayBufferProtocol, S : Sequence, S.Iterator.Element == Buffer.Element, Buffer.Index == Int>(_ buffer: inout Buffer, _ newItems: S)
protocol _AnyHashableProtocol {
  var base: Any { get }
}
func _swift_stdlib_atomicFetchAndInt(object target: Swift.UnsafeMutablePointer<Swift.Int>, operand: Swift.Int) -> Swift.Int
@_silgen_name("_swift_arrayDownCastIndirect") func _arrayDownCastIndirect<SourceValue, TargetValue>(_ source: Swift.UnsafePointer<[SourceValue]>, _ target: Swift.UnsafeMutablePointer<[TargetValue]>)
struct AnyIndex {
  init<BaseIndex : Comparable>(_ base: BaseIndex)
  init(_box: _AnyIndexBox)
  var _typeID: Swift.ObjectIdentifier {
    get {}
  }
  var _box: _AnyIndexBox
}
extension AnyIndex : Comparable {
  static func ==(lhs: Swift.AnyIndex, rhs: Swift.AnyIndex) -> Swift.Bool
  static func <(lhs: Swift.AnyIndex, rhs: Swift.AnyIndex) -> Swift.Bool
}
protocol _SwiftNewtypeWrapper : RawRepresentable {
}
extension _SwiftNewtypeWrapper where Self.RawValue : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension _SwiftNewtypeWrapper where Self.RawValue : _ObjectiveCBridgeable {
  func _bridgeToObjectiveC() -> Self.RawValue._ObjectiveCType
  static func _forceBridgeFromObjectiveC(_ source: Self.RawValue._ObjectiveCType, result: inout Self?)
  static func _conditionallyBridgeFromObjectiveC(_ source: Self.RawValue._ObjectiveCType, result: inout Self?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Self.RawValue._ObjectiveCType?) -> Self
}
func _unimplementedInitializer(className: Swift.StaticString, initName: Swift.StaticString = #function, file: Swift.StaticString = #file, line: Swift.UInt = #line, column: Swift.UInt = #column) -> Swift.Never
class _AnyCollectionBox<Element> : Swift._AnySequenceBox<Element> {
  override func _dropFirst(_ n: Swift.Int) -> Swift._AnyCollectionBox<Element>
  override func _dropLast(_ n: Swift.Int) -> Swift._AnyCollectionBox<Element>
  override func _prefix(_ maxLength: Swift.Int) -> Swift._AnyCollectionBox<Element>
  override func _suffix(_ maxLength: Swift.Int) -> Swift._AnyCollectionBox<Element>
  func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (Element) throws -> Swift.Bool) rethrows -> [Swift.AnyCollection<Element>]
  subscript(i: _AnyIndexBox) -> Element {
    get {}
  }
  func _index(after i: _AnyIndexBox) -> _AnyIndexBox
  func _formIndex(after i: _AnyIndexBox)
  func _index(_ i: _AnyIndexBox, offsetBy n: Swift.IntMax) -> _AnyIndexBox
  func _index(_ i: _AnyIndexBox, offsetBy n: Swift.IntMax, limitedBy limit: _AnyIndexBox) -> _AnyIndexBox?
  func _formIndex(_ i: inout _AnyIndexBox, offsetBy n: Swift.IntMax)
  func _formIndex(_ i: inout _AnyIndexBox, offsetBy n: Swift.IntMax, limitedBy limit: _AnyIndexBox) -> Swift.Bool
  func _distance(from start: _AnyIndexBox, to end: _AnyIndexBox) -> Swift.IntMax
  var _count: Swift.IntMax {
    get {}
  }
  var _first: Element? {
    get {}
  }
  init(_startIndex: _AnyIndexBox, endIndex: _AnyIndexBox)
  final let _startIndex: _AnyIndexBox
  final let _endIndex: _AnyIndexBox
  subscript(start start: _AnyIndexBox, end end: _AnyIndexBox) -> Swift._AnyCollectionBox<Element> {
    get {}
  }
  init()
  @objc deinit
}
protocol _ExpressibleByBuiltinUnicodeScalarLiteral {
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
}
@_silgen_name("swift_unexpectedError") func _unexpectedError(_ error: Error)
struct Double {
  var _value: Builtin.FPIEEE64
  init()
  init(_bits v: Builtin.FPIEEE64)
}
extension Double : LosslessStringConvertible {
  init?(_ text: Swift.String)
}
extension Double : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Double : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Double : BinaryFloatingPoint {
  typealias Exponent = Swift.Int
  typealias RawSignificand = Swift.UInt64
  static var exponentBitCount: Swift.Int {
    get {}
  }
  static var significandBitCount: Swift.Int {
    get {}
  }
  @_versioned static var _infinityExponent: Swift.UInt {
    @inline(__always) get {}
  }
  static var _exponentBias: Swift.UInt {
    @inline(__always) get {}
  }
  static var _significandMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  @_versioned static var _quietNaNMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  var bitPattern: Swift.UInt64 {
    get {}
  }
  init(bitPattern: Swift.UInt64)
  var sign: Swift.FloatingPointSign {
    get {}
  }
  @available(*, unavailable, renamed: "sign") var isSignMinus: Swift.Bool {
    get {}
  }
  var exponentBitPattern: Swift.UInt {
    get {}
  }
  var significandBitPattern: Swift.UInt64 {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponentBitPattern: Swift.UInt, significandBitPattern: Swift.UInt64)
  var isCanonical: Swift.Bool {
    get {}
  }
  static var infinity: Swift.Double {
    get {}
  }
  static var nan: Swift.Double {
    get {}
  }
  static var signalingNaN: Swift.Double {
    get {}
  }
  @available(*, unavailable, renamed: "nan") static var quietNaN: Swift.Double {
    get {}
  }
  static var greatestFiniteMagnitude: Swift.Double {
    get {}
  }
  static var pi: Swift.Double {
    get {}
  }
  var ulp: Swift.Double {
    get {}
  }
  static var leastNormalMagnitude: Swift.Double {
    get {}
  }
  static var leastNonzeroMagnitude: Swift.Double {
    get {}
  }
  var exponent: Swift.Int {
    get {}
  }
  var significand: Swift.Double {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponent: Swift.Int, significand: Swift.Double)
  init(nan payload: Swift.Double.RawSignificand, signaling: Swift.Bool)
  var nextUp: Swift.Double {
    get {}
  }
  mutating func round(_ rule: Swift.FloatingPointRoundingRule)
  mutating func negate()
  mutating func add(_ other: Swift.Double)
  mutating func subtract(_ other: Swift.Double)
  mutating func multiply(by other: Swift.Double)
  mutating func divide(by other: Swift.Double)
  mutating func formRemainder(dividingBy other: Swift.Double)
  mutating func formTruncatingRemainder(dividingBy other: Swift.Double)
  mutating func formSquareRoot()
  mutating func addProduct(_ lhs: Swift.Double, _ rhs: Swift.Double)
  func isEqual(to other: Swift.Double) -> Swift.Bool
  func isLess(than other: Swift.Double) -> Swift.Bool
  func isLessThanOrEqualTo(_ other: Swift.Double) -> Swift.Bool
  var isNormal: Swift.Bool {
    get {}
  }
  var isFinite: Swift.Bool {
    get {}
  }
  var isZero: Swift.Bool {
    get {}
  }
  var isSubnormal: Swift.Bool {
    get {}
  }
  var isInfinite: Swift.Bool {
    get {}
  }
  var isNaN: Swift.Bool {
    get {}
  }
  var isSignalingNaN: Swift.Bool {
    get {}
  }
  var binade: Swift.Double {
    get {}
  }
  var significandWidth: Swift.Int {
    get {}
  }
  init(floatLiteral value: Swift.Double)
  typealias FloatLiteralType = Swift.Double
  typealias RawExponent = Swift.UInt
}
extension Double : _ExpressibleByBuiltinIntegerLiteral, ExpressibleByIntegerLiteral {
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  typealias IntegerLiteralType = Swift.Int64
}
extension Double : _ExpressibleByBuiltinFloatLiteral {
  init(_builtinFloatLiteral value: Builtin.FPIEEE80)
}
extension Double : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension Double : AbsoluteValuable {
  static func abs(_ x: Swift.Double) -> Swift.Double
}
extension Double {
  init(_ v: Swift.UInt8)
  init(_ v: Swift.Int8)
  init(_ v: Swift.UInt16)
  init(_ v: Swift.Int16)
  init(_ v: Swift.UInt32)
  init(_ v: Swift.Int32)
  init(_ v: Swift.UInt64)
  init(_ v: Swift.Int64)
  init(_ v: Swift.UInt)
  init(_ v: Swift.Int)
}
extension Double {
  init(_ other: Swift.Float)
  @inline(__always) init?(exactly other: Swift.Float)
  init(_ other: Swift.Double)
  @inline(__always) init?(exactly other: Swift.Double)
  init(_ other: Swift.Float80)
  @inline(__always) init?(exactly other: Swift.Float80)
}
extension Double : Strideable {
  func distance(to other: Swift.Double) -> Swift.Double
  func advanced(by amount: Swift.Double) -> Swift.Double
  typealias Stride = Swift.Double
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension Double : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Double : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Double : _CVarArgPassedAsDouble, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension Double {
  init(_ value: CoreGraphics.CGFloat)
}
extension Double : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Double?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Double?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Double
  typealias _ObjectiveCType = Foundation.NSNumber
}
@_silgen_name("swift_int64ToString") func _int64ToStringImpl(_ buffer: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>, _ bufferLength: Swift.UInt, _ value: Swift.Int64, _ radix: Swift.Int64, _ uppercase: Swift.Bool) -> Swift.UInt
var _emptyStringBase: Swift.UnsafeMutableRawPointer {
  get {}
}
func _isValidArrayIndex(_ index: Swift.Int, count: Swift.Int) -> Swift.Bool
@_versioned final class _ContiguousArrayStorage<Element> : Swift._ContiguousArrayStorage1 {
  @objc deinit
  override final func _withVerbatimBridgedUnsafeBufferImpl(_ body: (Swift.UnsafeBufferPointer<AnyObject>) throws -> Swift.Void) rethrows
  override final func _getNonVerbatimBridgedCount(_ dummy: Swift.Void) -> Swift.Int
  override final func _getNonVerbatimBridgedHeapBuffer(_ dummy: Swift.Void) -> Swift._HeapBuffer<Swift.Int, AnyObject>
  override final func canStoreElements(ofDynamicType proposedElementType: Any.Type) -> Swift.Bool
  override final var staticElementType: Any.Type {
    override final get {}
  }
  typealias Manager = Swift.ManagedBufferPointer<Swift._ArrayBody, Element>
  final var __manager: Swift.ManagedBufferPointer<Swift._ArrayBody, Element> {
    final get {}
  }
  @objc init()
}
struct _MetatypeMirror : _Mirror {
  let data: Swift._MagicMirrorData
  var value: Any {
    get {}
  }
  var valueType: Any.Type {
    get {}
  }
  var objectIdentifier: Swift.ObjectIdentifier? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  subscript(i: Swift.Int) -> (Swift.String, _Mirror) {
    get {}
  }
  var summary: Swift.String {
    get {}
  }
  var quickLookObject: Swift.PlaygroundQuickLook? {
    get {}
  }
  var disposition: Swift._MirrorDisposition {
    get {}
  }
  init(data: Swift._MagicMirrorData)
}
@_silgen_name("swift_ClassMirror_quickLookObject") func _swift_ClassMirror_quickLookObject(_: Swift._MagicMirrorData) -> AnyObject
@available(*, unavailable, renamed: "LazyMapIterator") struct LazyMapGenerator<Base : IteratorProtocol, Element> {
  init()
}
struct IteratorOverOne<Element> : IteratorProtocol, Sequence {
  init(_elements: Element?)
  mutating func next() -> Element?
  var _elements: Element?
  typealias Element = Element
  typealias Iterator = Swift.IteratorOverOne<Element>
  typealias SubSequence = Swift.AnySequence<Element>
}
extension IteratorOverOne {
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.IteratorOverOne<Element>
}
protocol SignedInteger : _SignedInteger, Integer {
  func toIntMax() -> Swift.IntMax
  init(_: Swift.IntMax)
}
extension SignedInteger {
  func distance(to other: Self) -> Swift.Int
  func advanced(by n: Swift.Int) -> Self
}
@available(*, unavailable, renamed: "MemoryLayout.size(ofValue:)") func sizeofValue<T>(_: T) -> Swift.Int
struct Character : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral, ExpressibleByExtendedGraphemeClusterLiteral, Hashable {
  @_versioned enum Representation {
    case large(Swift._StringBuffer._Storage)
    case small(Builtin.Int63)
  }
  init(_ scalar: Swift.UnicodeScalar)
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
  init(unicodeScalarLiteral value: Swift.Character)
  init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
  init(extendedGraphemeClusterLiteral value: Swift.Character)
  init(_ s: Swift.String)
  static func _smallSize(_ value: Swift.UInt64) -> Swift.Int
  static func _smallValue(_ value: Builtin.Int63) -> Swift.UInt64
  struct _SmallUTF8 : RandomAccessCollection {
    typealias Indices = Swift.CountableRange<Swift.Int>
    var indices: Swift.CountableRange<Swift.Int> {
      get {}
    }
    init(_ u8: Swift.UInt64)
    var startIndex: Swift.Int {
      get {}
    }
    var endIndex: Swift.Int {
      get {}
    }
    subscript(position: Swift.Int) -> Swift.UTF8.CodeUnit {
      get {}
    }
    struct Iterator : IteratorProtocol {
      init(_ data: Swift.UInt64)
      mutating func next() -> Swift.UInt8?
      var _data: Swift.UInt64
      typealias Element = Swift.UInt8
    }
    func makeIterator() -> Swift.Character._SmallUTF8.Iterator
    var count: Swift.UInt16
    var data: Swift.UInt64
    typealias Index = Swift.Int
    typealias _Element = Swift.UTF8.CodeUnit
    typealias SubSequence = Swift.RandomAccessSlice<Swift.Character._SmallUTF8>
    typealias IndexDistance = Swift.Int
  }
  struct _SmallUTF16 : RandomAccessCollection {
    typealias Indices = Swift.CountableRange<Swift.Int>
    init(_ u8: Swift.UInt64)
    var startIndex: Swift.Int {
      get {}
    }
    var endIndex: Swift.Int {
      get {}
    }
    subscript(position: Swift.Int) -> Swift.UTF16.CodeUnit {
      get {}
    }
    var count: Swift.UInt16
    var data: Swift.UInt64
    typealias Index = Swift.Int
    typealias _Element = Swift.UTF16.CodeUnit
    typealias SubSequence = Swift.RandomAccessSlice<Swift.Character._SmallUTF16>
    typealias IndexDistance = Swift.Int
    typealias Iterator = Swift.IndexingIterator<Swift.Character._SmallUTF16>
  }
  var hashValue: Swift.Int {
    get {}
  }
  typealias UTF16View = Swift.String.UTF16View
  var utf16: Swift.Character.UTF16View {
    get {}
  }
  @_versioned var _representation: Swift.Character.Representation
  typealias ExtendedGraphemeClusterLiteralType = Swift.Character
  typealias UnicodeScalarLiteralType = Swift.Character
}
extension Character : Equatable {
  static func ==(lhs: Swift.Character, rhs: Swift.Character) -> Swift.Bool
}
extension Character : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Character : LosslessStringConvertible {
}
extension Character : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Character : Comparable {
  static func <(lhs: Swift.Character, rhs: Swift.Character) -> Swift.Bool
}
extension Character : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Character : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Character : TextOutputStreamable {
  func write<Target : TextOutputStream>(to target: inout Target)
}
struct _NativeDictionaryStorage<Key : Hashable, Value> : _HashStorage, CustomStringConvertible {
  typealias Owner = Swift._NativeDictionaryStorageOwner<Key, Value>
  typealias StorageImpl = Swift._NativeDictionaryStorageImpl<Key, Value>
  typealias SequenceElement = (key: Key, value: Value)
  typealias SequenceElementWithoutLabels = (Key, Value)
  typealias Storage = Swift._NativeDictionaryStorage<Key, Value>
  let buffer: Swift._NativeDictionaryStorageImpl<Key, Value>
  let initializedEntries: Swift._UnsafeBitMap
  let keys: Swift.UnsafeMutablePointer<Key>
  let values: Swift.UnsafeMutablePointer<Value>
  init(capacity: Swift.Int)
  init(minimumCapacity: Swift.Int = default)
  var capacity: Swift.Int {
    get {}
  }
  @_versioned var count: Swift.Int {
    get {}
    set(newValue) {}
  }
  var maxLoadFactorInverse: Swift.Double {
    get {}
  }
  @_versioned @inline(__always) func key(at i: Swift.Int) -> Key
  @_versioned func isInitializedEntry(at i: Swift.Int) -> Swift.Bool
  func destroyEntry(at i: Swift.Int)
  func initializeKey(_ k: Key, value v: Value, at i: Swift.Int)
  func moveInitializeEntry(from: Swift._NativeDictionaryStorage<Key, Value>, at: Swift.Int, toEntryAt: Swift.Int)
  @_versioned func value(at i: Swift.Int) -> Value
  func setKey(_ key: Key, value: Value, at i: Swift.Int)
  var _bucketMask: Swift.Int {
    get {}
  }
  @_versioned func _bucket(_ k: Key) -> Swift.Int
  @_versioned func _index(after bucket: Swift.Int) -> Swift.Int
  func _prev(_ bucket: Swift.Int) -> Swift.Int
  @_versioned @inline(__always) func _find(_ key: Key, startBucket: Swift.Int) -> (pos: Swift._NativeDictionaryIndex<Key, Value>, found: Swift.Bool)
  static func minimumCapacity(minimumCount: Swift.Int, maxLoadFactorInverse: Swift.Double) -> Swift.Int
  mutating func unsafeAddNew(key newKey: Key, value: Value)
  var description: Swift.String {
    get {}
  }
  typealias Index = Swift._NativeDictionaryIndex<Key, Value>
  @_versioned var startIndex: Swift._NativeDictionaryIndex<Key, Value> {
    get {}
  }
  @_versioned var endIndex: Swift._NativeDictionaryIndex<Key, Value> {
    get {}
  }
  @_versioned func index(after i: Swift._NativeDictionaryIndex<Key, Value>) -> Swift._NativeDictionaryIndex<Key, Value>
  func formIndex(after i: inout Swift._NativeDictionaryIndex<Key, Value>)
  @_versioned @inline(__always) func index(forKey key: Key) -> Swift._NativeDictionaryIndex<Key, Value>?
  func assertingGet(_ i: Swift._NativeDictionaryIndex<Key, Value>) -> (key: Key, value: Value)
  func assertingGet(_ key: Key) -> Value
  @_versioned @inline(__always) func maybeGet(_ key: Key) -> Value?
  @discardableResult mutating func updateValue(_ value: Value, forKey key: Key) -> Value?
  @discardableResult mutating func insert(_ value: Value, forKey key: Key) -> (inserted: Swift.Bool, memberAfterInsert: Value)
  @discardableResult mutating func remove(at index: Swift._NativeDictionaryIndex<Key, Value>) -> (key: Key, value: Value)
  @discardableResult mutating func removeValue(forKey key: Key) -> Value?
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool)
  static func fromArray(_ elements: [(Key, Value)]) -> Swift._NativeDictionaryStorage<Key, Value>
  typealias Key = Key
  typealias Value = Value
}
protocol _ExpressibleByBuiltinIntegerLiteral {
  init(_builtinIntegerLiteral value: Swift._MaxBuiltinIntegerType)
}
enum _VariantSetStorage<Element : Hashable> : _HashStorage {
  typealias NativeStorage = Swift._NativeSetStorage<Element>
  typealias NativeStorageOwner = Swift._NativeSetStorageOwner<Element>
  typealias NativeIndex = Swift._NativeSetIndex<Element>
  typealias CocoaStorage = Swift._CocoaSetStorage
  typealias SequenceElement = Element
  typealias SequenceElementWithoutLabels = Element
  typealias SelfType = Swift._VariantSetStorage<Element>
  typealias Key = Element
  typealias Value = Element
  case native(Swift._NativeSetStorageOwner<Element>)
  case cocoa(Swift._VariantSetStorage.CocoaStorage)
  @_versioned var guaranteedNative: Swift.Bool {
    get {}
  }
  mutating func isUniquelyReferenced() -> Swift.Bool
  @_versioned var asNative: Swift._NativeSetStorage<Element> {
    get {}
  }
  var asCocoa: Swift._VariantSetStorage.CocoaStorage {
    get {}
  }
  mutating func ensureUniqueNativeStorage(_ minimumCapacity: Swift.Int) -> (reallocated: Swift.Bool, capacityChanged: Swift.Bool)
  @inline(never) mutating func migrateDataToNativeStorage(_ cocoaStorage: Swift._CocoaSetStorage)
  typealias Index = Swift.SetIndex<Element>
  var startIndex: Swift.SetIndex<Element> {
    get {}
  }
  var endIndex: Swift.SetIndex<Element> {
    get {}
  }
  @_versioned func index(after i: Swift.SetIndex<Element>) -> Swift.SetIndex<Element>
  func formIndex(after i: inout Swift.SetIndex<Element>)
  @_versioned @inline(__always) func index(forKey key: Element) -> Swift.SetIndex<Element>?
  func assertingGet(_ i: Swift.SetIndex<Element>) -> Element
  func assertingGet(_ key: Element) -> Element
  @_versioned @inline(never) static func maybeGetFromCocoaStorage(_ cocoaStorage: Swift._VariantSetStorage.CocoaStorage, forKey key: Element) -> Element?
  @_versioned @inline(__always) func maybeGet(_ key: Element) -> Element?
  mutating func nativeUpdateValue(_ value: Element, forKey key: Element) -> Element?
  @discardableResult mutating func updateValue(_ value: Element, forKey key: Element) -> Element?
  mutating func nativeInsert(_ value: Element, forKey key: Element) -> (inserted: Swift.Bool, memberAfterInsert: Element)
  @discardableResult mutating func insert(_ value: Element, forKey key: Element) -> (inserted: Swift.Bool, memberAfterInsert: Element)
  mutating func nativeDeleteImpl(_ nativeStorage: Swift._NativeSetStorage<Element>, idealBucket: Swift.Int, offset: Swift.Int)
  mutating func nativeRemoveObject(forKey key: Element) -> Element?
  mutating func nativeRemove(at nativeIndex: Swift._NativeSetIndex<Element>) -> Element
  @discardableResult mutating func remove(at index: Swift.SetIndex<Element>) -> Element
  @discardableResult mutating func removeValue(forKey key: Element) -> Element?
  mutating func nativeRemoveAll()
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool)
  var count: Swift.Int {
    get {}
  }
  @_versioned @inline(__always) func makeIterator() -> Swift.SetIterator<Element>
  static func fromArray(_ elements: [Element]) -> Swift._VariantSetStorage<Element>
}
@_silgen_name("_swift_getBridgedNonVerbatimObjectiveCType") func _getBridgedNonVerbatimObjectiveCType<T>(_: T.Type) -> Any.Type?
func _unreachable(_ condition: Swift.Bool = default)
@_silgen_name("swift_ClassMirror_subscript") func _getClassChild<T>(_: Swift.Int, _: Swift._MagicMirrorData) -> (T, _Mirror)
struct EmptyCollection<Element> : RandomAccessCollection, MutableCollection {
  typealias Index = Swift.Int
  typealias IndexDistance = Swift.Int
  typealias SubSequence = Swift.EmptyCollection<Element>
  init()
  var startIndex: Swift.EmptyCollection.Index {
    get {}
  }
  var endIndex: Swift.EmptyCollection.Index {
    get {}
  }
  func index(after i: Swift.EmptyCollection.Index) -> Swift.EmptyCollection.Index
  func index(before i: Swift.EmptyCollection.Index) -> Swift.EmptyCollection.Index
  func makeIterator() -> Swift.EmptyIterator<Element>
  subscript(position: Swift.EmptyCollection.Index) -> Element {
    get {}
    set(newValue) {}
  }
  subscript(bounds: Swift.Range<Swift.EmptyCollection.Index>) -> Swift.EmptyCollection<Element> {
    get {}
    set(newValue) {}
  }
  var count: Swift.Int {
    get {}
  }
  func index(_ i: Swift.EmptyCollection.Index, offsetBy n: Swift.EmptyCollection.IndexDistance) -> Swift.EmptyCollection.Index
  func index(_ i: Swift.EmptyCollection.Index, offsetBy n: Swift.EmptyCollection.IndexDistance, limitedBy limit: Swift.EmptyCollection.Index) -> Swift.EmptyCollection.Index?
  func distance(from start: Swift.EmptyCollection.Index, to end: Swift.EmptyCollection.Index) -> Swift.EmptyCollection.IndexDistance
  func _failEarlyRangeCheck(_ index: Swift.EmptyCollection.Index, bounds: Swift.Range<Swift.EmptyCollection.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Swift.EmptyCollection.Index>, bounds: Swift.Range<Swift.EmptyCollection.Index>)
  typealias Indices = Swift.CountableRange<Swift.Int>
  typealias _Element = Element
  typealias Iterator = Swift.EmptyIterator<Element>
}
extension EmptyCollection : Equatable {
  static func ==(lhs: Swift.EmptyCollection<Element>, rhs: Swift.EmptyCollection<Element>) -> Swift.Bool
}
@_versioned @inline(__always) func _roundUpImpl(_ offset: Swift.UInt, toAlignment alignment: Swift.Int) -> Swift.UInt
@inline(__always) func assertionFailure(_ message: @autoclosure () -> Swift.String = default, file: Swift.StaticString = #file, line: Swift.UInt = #line)
@_silgen_name("swift_stdlib_compareNSStringDeterministicUnicodeCollationPtr") func _stdlib_compareNSStringDeterministicUnicodeCollationPointer(_ lhs: Swift.OpaquePointer, _ rhs: Swift.OpaquePointer) -> Swift.Int32
struct _BridgeStorage<NativeClass : AnyObject, ObjCClass : AnyObject> {
  typealias Native = NativeClass
  typealias ObjC = ObjCClass
  @inline(__always) init(native: NativeClass, bits: Swift.Int)
  @inline(__always) init(objC: ObjCClass)
  @inline(__always) init(native: NativeClass)
  var spareBits: Swift.Int {
    @inline(__always) get {}
  }
  @inline(__always) mutating func isUniquelyReferencedNative() -> Swift.Bool
  @inline(__always) mutating func isUniquelyReferencedOrPinnedNative() -> Swift.Bool
  var isNative: Swift.Bool {
    @inline(__always) get {}
  }
  @inline(__always) func isNativeWithClearedSpareBits(_ bits: Swift.Int) -> Swift.Bool
  var isObjC: Swift.Bool {
    @inline(__always) get {}
  }
  var nativeInstance: NativeClass {
    @inline(__always) get {}
  }
  var nativeInstance_noSpareBits: NativeClass {
    @inline(__always) get {}
  }
  @inline(__always) mutating func isUniquelyReferenced_native_noSpareBits() -> Swift.Bool
  @inline(__always) mutating func isUniquelyReferencedOrPinned_native_noSpareBits() -> Swift.Bool
  var objCInstance: ObjCClass {
    @inline(__always) get {}
  }
  var _isTagged: Swift.Bool {
    @inline(__always) get {}
  }
  var rawValue: Builtin.BridgeObject
}
struct FlattenSequence<Base : Sequence where Base.Iterator.Element : Sequence> : Sequence {
  init(_base: Base)
  func makeIterator() -> Swift.FlattenIterator<Base.Iterator>
  var _base: Base
  typealias Iterator = Swift.FlattenIterator<Base.Iterator>
  typealias SubSequence = Swift.AnySequence<Base.Iterator.Element.Iterator.Element>
}
extension FlattenSequence {
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.FlattenIterator<Base.Iterator>
}
struct _TeeStream<L : TextOutputStream, R : TextOutputStream> : TextOutputStream {
  var left: L
  var right: R
  mutating func write(_ string: Swift.String)
  mutating func _lock()
  mutating func _unlock()
  init(left: L, right: R)
}
func repeatElement<T>(_ element: T, count n: Swift.Int) -> Swift.Repeated<T>
@inline(never) @_semantics("stdlib_binary_only") func print(_ items: Any..., separator: Swift.String = default, terminator: Swift.String = default)
@inline(__always) func print<Target : TextOutputStream>(_ items: Any..., separator: Swift.String = default, terminator: Swift.String = default, to output: inout Target)
@available(*, unavailable, renamed: "print(_:separator:terminator:to:)") func print<Target : TextOutputStream>(_ items: Any..., separator: Swift.String = default, terminator: Swift.String = default, toStream output: inout Target)
@available(*, unavailable, message: "Please use 'terminator: \"\"' instead of 'appendNewline: false': 'print((...), terminator: \"\")'") func print<T>(_: T, appendNewline: Swift.Bool = default)
@available(*, unavailable, message: "Please use the 'to' label for the target stream: 'print((...), to: &...)'") func print<T>(_: T, _: inout TextOutputStream)
@available(*, unavailable, message: "Please use 'terminator: \"\"' instead of 'appendNewline: false' and use the 'to' label for the target stream: 'print((...), terminator: \"\", to: &...)'") func print<T>(_: T, _: inout TextOutputStream, appendNewline: Swift.Bool = default)
func _withVaList<R>(_ builder: Swift._VaListBuilder, _ body: (Swift.CVaListPointer) -> R) -> R
protocol Integer : _Integer, Strideable {
}
@available(*, unavailable, message: "use nested withUnsafePointer(to:_:) instead") func withUnsafePointers<A0, A1, Result>(_ arg0: inout A0, _ arg1: inout A1, _ body: (Swift.UnsafePointer<A0>, Swift.UnsafePointer<A1>) throws -> Result) rethrows -> Result
@available(*, unavailable, message: "use nested withUnsafePointer(to:_:) instead") func withUnsafePointers<A0, A1, A2, Result>(_ arg0: inout A0, _ arg1: inout A1, _ arg2: inout A2, _ body: (Swift.UnsafePointer<A0>, Swift.UnsafePointer<A1>, Swift.UnsafePointer<A2>) throws -> Result) rethrows -> Result
protocol CustomReflectable {
  var customMirror: Swift.Mirror { get }
}
final class _CollectionBox<S : Collection where S.SubSequence : Collection, S.SubSequence.Iterator.Element == S.Iterator.Element, S.SubSequence.SubSequence == S.SubSequence, S.SubSequence.Index == S.Index, S.SubSequence.Indices : Collection, S.SubSequence.Indices.Iterator.Element == S.Index, S.SubSequence.Indices.Index == S.Index, S.SubSequence.Indices.SubSequence == S.SubSequence.Indices, S.Indices : Collection, S.Indices.Iterator.Element == S.Index, S.Indices.Index == S.Index, S.Indices.SubSequence == S.Indices> : Swift._AnyCollectionBox<S.Iterator.Element> {
  typealias Element = S.Iterator.Element
  override final func _makeIterator() -> Swift.AnyIterator<S.Iterator.Element>
  override final var _underestimatedCount: Swift.Int {
    override final get {}
  }
  override final func _map<T>(_ transform: (S.Iterator.Element) throws -> T) rethrows -> [T]
  override final func _filter(_ isIncluded: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [S.Iterator.Element]
  override final func _forEach(_ body: (S.Iterator.Element) throws -> Swift.Void) rethrows
  override final func __customContainsEquatableElement(_ element: S.Iterator.Element) -> Swift.Bool?
  override final func __preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  override final func __copyToContiguousArray() -> Swift.ContiguousArray<S.Iterator.Element>
  override final func __copyContents(initializing ptr: Swift.UnsafeMutablePointer<S.Iterator.Element>) -> Swift.UnsafeMutablePointer<S.Iterator.Element>
  override final func _dropFirst(_ n: Swift.Int) -> Swift._AnyCollectionBox<S.Iterator.Element>
  override final func _dropLast(_ n: Swift.Int) -> Swift._AnyCollectionBox<S.Iterator.Element>
  override final func _prefix(_ maxLength: Swift.Int) -> Swift._AnyCollectionBox<S.Iterator.Element>
  override final func _suffix(_ maxLength: Swift.Int) -> Swift._AnyCollectionBox<S.Iterator.Element>
  override final func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnySequence<S.Iterator.Element>]
  override final func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnyCollection<S.Iterator.Element>]
  init(_base: S)
  final func _unbox(_ position: _AnyIndexBox, file: Swift.StaticString = #file, line: Swift.UInt = #line) -> S.Index
  override final subscript(position: _AnyIndexBox) -> S.Iterator.Element {
    override final get {}
  }
  override final subscript(start start: _AnyIndexBox, end end: _AnyIndexBox) -> Swift._AnyCollectionBox<S.Iterator.Element> {
    override final get {}
  }
  override final func _index(after position: _AnyIndexBox) -> _AnyIndexBox
  override final func _formIndex(after position: _AnyIndexBox)
  override final func _index(_ i: _AnyIndexBox, offsetBy n: Swift.IntMax) -> _AnyIndexBox
  override final func _index(_ i: _AnyIndexBox, offsetBy n: Swift.IntMax, limitedBy limit: _AnyIndexBox) -> _AnyIndexBox?
  override final func _formIndex(_ i: inout _AnyIndexBox, offsetBy n: Swift.IntMax)
  override final func _formIndex(_ i: inout _AnyIndexBox, offsetBy n: Swift.IntMax, limitedBy limit: _AnyIndexBox) -> Swift.Bool
  override final func _distance(from start: _AnyIndexBox, to end: _AnyIndexBox) -> Swift.IntMax
  override final var _count: Swift.IntMax {
    override final get {}
  }
  override final var _first: S.Iterator.Element? {
    override final get {}
  }
  final var _base: S
  @objc deinit
  init(_startIndex: _AnyIndexBox, endIndex: _AnyIndexBox)
}
enum MemoryLayout<T> {
  static var size: Swift.Int {
    get {}
  }
  static var stride: Swift.Int {
    get {}
  }
  static var alignment: Swift.Int {
    get {}
  }
}
extension MemoryLayout {
  static func size(ofValue _: T) -> Swift.Int
  static func stride(ofValue _: T) -> Swift.Int
  static func alignment(ofValue _: T) -> Swift.Int
}
protocol IntegerArithmetic : _IntegerArithmetic, Comparable {
  static func +(lhs: Self, rhs: Self) -> Self
  static func -(lhs: Self, rhs: Self) -> Self
  static func *(lhs: Self, rhs: Self) -> Self
  static func /(lhs: Self, rhs: Self) -> Self
  static func %(lhs: Self, rhs: Self) -> Self
  func toIntMax() -> Swift.IntMax
}
func _swift_stdlib_atomicStoreUInt64(object target: Swift.UnsafeMutablePointer<Swift.UInt64>, desired: Swift.UInt64)
class _PrefixSequence<Base : IteratorProtocol> : Sequence, IteratorProtocol {
  final let _maxLength: Swift.Int
  var _iterator: Base
  var _taken: Swift.Int
  init(_iterator: Base, maxLength: Swift.Int, taken: Swift.Int = default)
  func makeIterator() -> Swift._PrefixSequence<Base>
  func next() -> Base.Element?
  func prefix(_ maxLength: Swift.Int) -> Swift.AnySequence<Base.Element>
  @objc deinit
  typealias Iterator = Swift._PrefixSequence<Base>
  typealias SubSequence = Swift.AnySequence<Base.Element>
  typealias Element = Base.Element
}
protocol _ArrayBufferProtocol : MutableCollection, RandomAccessCollection {
  associatedtype Indices : RandomAccessCollection = Swift.CountableRange<Swift.Int>
  associatedtype Element
  init()
  init(_ buffer: Swift._ContiguousArrayBuffer<Self.Element>, shiftedToStartIndex: Swift.Int)
  @discardableResult func _copyContents(subRange bounds: Swift.Range<Swift.Int>, initializing target: Swift.UnsafeMutablePointer<Self.Element>) -> Swift.UnsafeMutablePointer<Self.Element>
  subscript(index: Swift.Int) -> Self.Element { get nonmutating set }
  mutating func requestUniqueMutableBackingBuffer(minimumCapacity: Swift.Int) -> Swift._ContiguousArrayBuffer<Self.Element>?
  mutating func isMutableAndUniquelyReferenced() -> Swift.Bool
  func requestNativeBuffer() -> Swift._ContiguousArrayBuffer<Self.Element>?
  mutating func replace<C where C : Collection, C.Iterator.Element == Element>(subRange: Swift.Range<Swift.Int>, with newCount: Swift.Int, elementsOf newValues: C)
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift._SliceBuffer<Self.Element> { get }
  func withUnsafeBufferPointer<R>(_ body: (Swift.UnsafeBufferPointer<Self.Element>) throws -> R) rethrows -> R
  mutating func withUnsafeMutableBufferPointer<R>(_ body: (Swift.UnsafeMutableBufferPointer<Self.Element>) throws -> R) rethrows -> R
  var count: Swift.Int { get set }
  var capacity: Swift.Int { get }
  var owner: AnyObject { get }
  var firstElementAddress: Swift.UnsafeMutablePointer<Self.Element> { get }
  var firstElementAddressIfContiguous: Swift.UnsafeMutablePointer<Self.Element>? { get }
  var subscriptBaseAddress: Swift.UnsafeMutablePointer<Self.Element> { get }
  var identity: Swift.UnsafeRawPointer { get }
  var startIndex: Swift.Int { get }
}
extension _ArrayBufferProtocol where Index == Int {
  var subscriptBaseAddress: Swift.UnsafeMutablePointer<Self.Element> {
    get {}
  }
  mutating func replace<C where C : Collection, C.Iterator.Element == Element>(subRange: Swift.Range<Swift.Int>, with newCount: Swift.Int, elementsOf newValues: C)
}
@inline(never) @_semantics("stdlib_binary_only") func _cocoaStringSlice(_ target: Swift._StringCore, _ bounds: Swift.Range<Swift.Int>) -> Swift._StringCore
protocol LosslessStringConvertible : CustomStringConvertible {
  init?(_ description: Swift.String)
}
func _unsafeMinus(_ lhs: Swift.Int, _ rhs: Swift.Int) -> Swift.Int
protocol ExpressibleByNilLiteral {
  init(nilLiteral: ())
}
@available(*, unavailable, renamed: "FlattenIterator") struct FlattenGenerator<Base : IteratorProtocol where Base.Element : Sequence> {
  init()
}
protocol Hashable : _Hashable, Equatable {
  var hashValue: Swift.Int { get }
}
extension Hashable {
  func _toAnyHashable() -> Swift.AnyHashable
}
protocol MutableCollection : MutableIndexable, Collection {
  associatedtype SubSequence : Collection = Swift.MutableSlice<Self>
  subscript(position: Self.Index) -> Self.Iterator.Element { get set }
  subscript(bounds: Swift.Range<Self.Index>) -> Self.SubSequence { get set }
  mutating func partition(by belongsInSecondPartition: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index
  mutating func _withUnsafeMutableBufferPointerIfSupported<R>(_ body: (Swift.UnsafeMutablePointer<Self.Iterator.Element>, Swift.Int) throws -> R) rethrows -> R?
}
extension MutableCollection {
  mutating func partition(by belongsInSecondPartition: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index
}
extension MutableCollection where Self : BidirectionalCollection {
  mutating func partition(by belongsInSecondPartition: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index
}
extension MutableCollection where Self.Iterator.Element : Comparable {
  func sorted() -> [Self.Iterator.Element]
}
extension MutableCollection {
  func sorted(by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool) -> [Self.Iterator.Element]
}
extension MutableCollection where Self : RandomAccessCollection, Self.Iterator.Element : Comparable {
  mutating func sort()
}
extension MutableCollection where Self : RandomAccessCollection {
  mutating func sort(by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool)
}
extension MutableCollection where Self : RandomAccessCollection {
  @available(*, unavailable, message: "call partition(by:)") mutating func partition(isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool) -> Self.Index
  @available(*, unavailable, message: "slice the collection using the range, and call partition(by:)") mutating func partition(_ range: Swift.Range<Self.Index>, isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool) -> Self.Index
}
extension MutableCollection where Self : RandomAccessCollection, Iterator.Element : Comparable {
  @available(*, unavailable, message: "call partition(by:)") mutating func partition() -> Self.Index
  @available(*, unavailable, message: "slice the collection using the range, and call partition(by:)") mutating func partition(_ range: Swift.Range<Self.Index>) -> Self.Index
}
extension MutableCollection where Self : RandomAccessCollection, Self.Iterator.Element : Comparable {
  @available(*, unavailable, renamed: "sort()") mutating func sortInPlace()
}
extension MutableCollection where Self : RandomAccessCollection {
  @available(*, unavailable, renamed: "sort(by:)") mutating func sortInPlace(_ isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool)
}
extension MutableCollection {
  mutating func _withUnsafeMutableBufferPointerIfSupported<R>(_ body: (Swift.UnsafeMutablePointer<Self.Iterator.Element>, Swift.Int) throws -> R) rethrows -> R?
  subscript(bounds: Swift.Range<Self.Index>) -> Swift.MutableSlice<Self> {
    get {}
    set(newValue) {}
  }
}
extension MutableCollection where Self : BidirectionalCollection {
  mutating func reverse()
}
var _fastEnumerationStorageMutationsPtr: Swift.UnsafeMutablePointer<Swift.CUnsignedLong> {
  get {}
}
@_silgen_name("_swift_stdlib_makeAnyHashableUpcastingToHashableBaseType") func _stdlib_makeAnyHashableUpcastingToHashableBaseType<H : Hashable>(_ value: H, storingResultInto result: Swift.UnsafeMutablePointer<Swift.AnyHashable>)
func _stdlib_atomicCompareExchangeStrongUInt32(object target: Swift.UnsafeMutablePointer<Swift.UInt32>, expected: Swift.UnsafeMutablePointer<Swift.UInt32>, desired: Swift.UInt32) -> Swift.Bool
struct _NativeSetIndex<Element : Hashable> : Comparable {
  typealias NativeStorage = Swift._NativeSetStorage<Element>
  typealias NativeIndex = Swift._NativeSetIndex<Element>
  @_versioned var nativeStorage: Swift._NativeSetStorage<Element>
  var offset: Swift.Int
  @_versioned init(nativeStorage: Swift._NativeSetStorage<Element>, offset: Swift.Int)
  func successor() -> Swift._NativeSetIndex<Element>
}
extension _NativeSetIndex {
  static func ==(lhs: Swift._NativeSetIndex<Element>, rhs: Swift._NativeSetIndex<Element>) -> Swift.Bool
  static func <(lhs: Swift._NativeSetIndex<Element>, rhs: Swift._NativeSetIndex<Element>) -> Swift.Bool
}
protocol _ExpressibleByImageLiteral {
  init(imageLiteralResourceName path: Swift.String)
}
protocol ExpressibleByBooleanLiteral {
  associatedtype BooleanLiteralType : _ExpressibleByBuiltinBooleanLiteral
  init(booleanLiteral value: Self.BooleanLiteralType)
}
@available(*, unavailable, renamed: "AnyIterator.init(_:)") func anyGenerator<G : IteratorProtocol>(_ base: G) -> Swift.AnyIterator<G.Element>
@available(*, unavailable, renamed: "AnyIterator.init(_:)") func anyGenerator<Element>(_ body: () -> Element?) -> Swift.AnyIterator<Element>
func _stdlib_atomicLoadARCRef(object target: Swift.UnsafeMutablePointer<AnyObject?>) -> AnyObject?
func _memmove(dest destination: Swift.UnsafeMutableRawPointer, src: Swift.UnsafeRawPointer, size: Swift.UInt)
func _overflowChecked<T>(_ args: (T, Swift.Bool), file: Swift.StaticString = #file, line: Swift.UInt = #line) -> T
@available(*, unavailable, renamed: "IndexingIterator") struct IndexingGenerator<Elements : IndexableBase> {
  init()
}
func _typeByName(_ name: Swift.String) -> Any.Type?
@available(*, unavailable, renamed: "EnumeratedSequence") struct EnumerateSequence<Base : Sequence> {
  init()
}
func _reinterpretCastToAnyObject<T>(_ x: T) -> AnyObject
protocol ExpressibleByStringLiteral : ExpressibleByExtendedGraphemeClusterLiteral {
  associatedtype StringLiteralType : _ExpressibleByBuiltinStringLiteral
  init(stringLiteral value: Self.StringLiteralType)
}
struct _NativeSetStorage<Element : Hashable> : _HashStorage, CustomStringConvertible {
  typealias Owner = Swift._NativeSetStorageOwner<Element>
  typealias StorageImpl = Swift._NativeSetStorageImpl<Element>
  typealias SequenceElement = Element
  typealias SequenceElementWithoutLabels = Element
  typealias Storage = Swift._NativeSetStorage<Element>
  typealias Key = Element
  typealias Value = Element
  let buffer: Swift._NativeSetStorageImpl<Element>
  let initializedEntries: Swift._UnsafeBitMap
  let keys: Swift.UnsafeMutablePointer<Element>
  init(capacity: Swift.Int)
  init(minimumCapacity: Swift.Int = default)
  var capacity: Swift.Int {
    get {}
  }
  @_versioned var count: Swift.Int {
    get {}
    set(newValue) {}
  }
  var maxLoadFactorInverse: Swift.Double {
    get {}
  }
  @_versioned @inline(__always) func key(at i: Swift.Int) -> Element
  @_versioned func isInitializedEntry(at i: Swift.Int) -> Swift.Bool
  func destroyEntry(at i: Swift.Int)
  func initializeKey(_ k: Element, at i: Swift.Int)
  func moveInitializeEntry(from: Swift._NativeSetStorage<Element>, at: Swift.Int, toEntryAt: Swift.Int)
  func setKey(_ key: Element, at i: Swift.Int)
  var _bucketMask: Swift.Int {
    get {}
  }
  @_versioned func _bucket(_ k: Element) -> Swift.Int
  @_versioned func _index(after bucket: Swift.Int) -> Swift.Int
  func _prev(_ bucket: Swift.Int) -> Swift.Int
  @_versioned @inline(__always) func _find(_ key: Element, startBucket: Swift.Int) -> (pos: Swift._NativeSetIndex<Element>, found: Swift.Bool)
  static func minimumCapacity(minimumCount: Swift.Int, maxLoadFactorInverse: Swift.Double) -> Swift.Int
  mutating func unsafeAddNew(key newKey: Element)
  var description: Swift.String {
    get {}
  }
  typealias Index = Swift._NativeSetIndex<Element>
  @_versioned var startIndex: Swift._NativeSetIndex<Element> {
    get {}
  }
  @_versioned var endIndex: Swift._NativeSetIndex<Element> {
    get {}
  }
  @_versioned func index(after i: Swift._NativeSetIndex<Element>) -> Swift._NativeSetIndex<Element>
  func formIndex(after i: inout Swift._NativeSetIndex<Element>)
  @_versioned @inline(__always) func index(forKey key: Element) -> Swift._NativeSetIndex<Element>?
  func assertingGet(_ i: Swift._NativeSetIndex<Element>) -> Element
  func assertingGet(_ key: Element) -> Element
  @_versioned @inline(__always) func maybeGet(_ key: Element) -> Element?
  @discardableResult mutating func updateValue(_ value: Element, forKey key: Element) -> Element?
  @discardableResult mutating func insert(_ value: Element, forKey key: Element) -> (inserted: Swift.Bool, memberAfterInsert: Element)
  @discardableResult mutating func remove(at index: Swift._NativeSetIndex<Element>) -> Element
  @discardableResult mutating func removeValue(forKey key: Element) -> Element?
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool)
  static func fromArray(_ elements: [Element]) -> Swift._NativeSetStorage<Element>
}
struct UInt16 : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int16
  init()
  init(_ _v: Builtin.Int16)
  init(_bits: Builtin.Int16)
  init(bigEndian value: Swift.UInt16)
  init(littleEndian value: Swift.UInt16)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt16)
  var bigEndian: Swift.UInt16 {
    get {}
  }
  var littleEndian: Swift.UInt16 {
    get {}
  }
  var byteSwapped: Swift.UInt16 {
    get {}
  }
  static var max: Swift.UInt16 {
    get {}
  }
  static var min: Swift.UInt16 {
    get {}
  }
  static var _sizeInBits: Swift.UInt16 {
    get {}
  }
  static var _sizeInBytes: Swift.UInt16 {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt16
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt16 : BitwiseOperations {
  static var allZeros: Swift.UInt16 {
    get {}
  }
}
extension UInt16 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt16 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt16 {
  static func addWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt16 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt16 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt16 {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt16 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to UInt16 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension UInt16 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
}
extension UInt16 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
  init(truncatingBitPattern: Swift.UInt32)
}
extension UInt16 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
  init(truncatingBitPattern: Swift.Int32)
}
extension UInt16 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension UInt16 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension UInt16 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension UInt16 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension UInt16 {
  init(bitPattern: Swift.Int16)
}
extension UInt16 {
  typealias _DisabledRangeIndex = Swift.UInt16
}
extension UInt16 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt16 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt16 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt16 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Swift.UTF16.CodeUnit : _StringElement {
  static func _toUTF16CodeUnit(_ x: Swift.UTF16.CodeUnit) -> Swift.UTF16.CodeUnit
  static func _fromUTF16CodeUnit(_ utf16: Swift.UTF16.CodeUnit) -> Swift.UTF16.CodeUnit
}
extension UInt16 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension UInt16 {
  init(_ value: CoreGraphics.CGFloat)
}
@objc @_swift_native_objc_runtime_base(_SwiftNativeNSStringBase) class _SwiftNativeNSString {
  @objc init()
  @objc deinit
}
@available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'Collection' instead") protocol Indexable : IndexableBase {
  associatedtype IndexDistance : SignedInteger = Swift.Int
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance) -> Self.Index
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Self.Index?
  func formIndex(_ i: inout Self.Index, offsetBy n: Self.IndexDistance)
  func formIndex(_ i: inout Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Swift.Bool
  func distance(from start: Self.Index, to end: Self.Index) -> Self.IndexDistance
}
extension Indexable {
  @inline(__always) func formIndex(after i: inout Self.Index)
  func _failEarlyRangeCheck(_ index: Self.Index, bounds: Swift.Range<Self.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Self.Index>, bounds: Swift.Range<Self.Index>)
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance) -> Self.Index
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Self.Index?
  func formIndex(_ i: inout Self.Index, offsetBy n: Self.IndexDistance)
  func formIndex(_ i: inout Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Swift.Bool
  func distance(from start: Self.Index, to end: Self.Index) -> Self.IndexDistance
  @inline(__always) func _advanceForward(_ i: Self.Index, by n: Self.IndexDistance) -> Self.Index
  @inline(__always) func _advanceForward(_ i: Self.Index, by n: Self.IndexDistance, limitedBy limit: Self.Index) -> Self.Index?
}
extension Indexable {
  subscript(bounds: Swift.ClosedRange<Self.Index>) -> Self.SubSequence {
    get {}
  }
}
extension Indexable where Index : Strideable, Index.Stride : SignedInteger {
  subscript(bounds: Swift.CountableRange<Self.Index>) -> Self.SubSequence {
    get {}
  }
  subscript(bounds: Swift.CountableClosedRange<Self.Index>) -> Self.SubSequence {
    get {}
  }
}
@objc class _ContiguousArrayStorage1 : Swift._ContiguousArrayStorageBase {
  override final func _withVerbatimBridgedUnsafeBuffer<R>(_ body: (Swift.UnsafeBufferPointer<AnyObject>) throws -> R) rethrows -> R?
  func _withVerbatimBridgedUnsafeBufferImpl(_ body: (Swift.UnsafeBufferPointer<AnyObject>) throws -> Swift.Void) rethrows
  @objc init()
  @objc deinit
}
struct Float {
  var _value: Builtin.FPIEEE32
  init()
  init(_bits v: Builtin.FPIEEE32)
}
extension Float : LosslessStringConvertible {
  init?(_ text: Swift.String)
}
extension Float : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Float : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Float : BinaryFloatingPoint {
  typealias Exponent = Swift.Int
  typealias RawSignificand = Swift.UInt32
  static var exponentBitCount: Swift.Int {
    get {}
  }
  static var significandBitCount: Swift.Int {
    get {}
  }
  @_versioned static var _infinityExponent: Swift.UInt {
    @inline(__always) get {}
  }
  static var _exponentBias: Swift.UInt {
    @inline(__always) get {}
  }
  static var _significandMask: Swift.UInt32 {
    @inline(__always) get {}
  }
  @_versioned static var _quietNaNMask: Swift.UInt32 {
    @inline(__always) get {}
  }
  var bitPattern: Swift.UInt32 {
    get {}
  }
  init(bitPattern: Swift.UInt32)
  var sign: Swift.FloatingPointSign {
    get {}
  }
  @available(*, unavailable, renamed: "sign") var isSignMinus: Swift.Bool {
    get {}
  }
  var exponentBitPattern: Swift.UInt {
    get {}
  }
  var significandBitPattern: Swift.UInt32 {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponentBitPattern: Swift.UInt, significandBitPattern: Swift.UInt32)
  var isCanonical: Swift.Bool {
    get {}
  }
  static var infinity: Swift.Float {
    get {}
  }
  static var nan: Swift.Float {
    get {}
  }
  static var signalingNaN: Swift.Float {
    get {}
  }
  @available(*, unavailable, renamed: "nan") static var quietNaN: Swift.Float {
    get {}
  }
  static var greatestFiniteMagnitude: Swift.Float {
    get {}
  }
  static var pi: Swift.Float {
    get {}
  }
  var ulp: Swift.Float {
    get {}
  }
  static var leastNormalMagnitude: Swift.Float {
    get {}
  }
  static var leastNonzeroMagnitude: Swift.Float {
    get {}
  }
  var exponent: Swift.Int {
    get {}
  }
  var significand: Swift.Float {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponent: Swift.Int, significand: Swift.Float)
  init(nan payload: Swift.Float.RawSignificand, signaling: Swift.Bool)
  var nextUp: Swift.Float {
    get {}
  }
  mutating func round(_ rule: Swift.FloatingPointRoundingRule)
  mutating func negate()
  mutating func add(_ other: Swift.Float)
  mutating func subtract(_ other: Swift.Float)
  mutating func multiply(by other: Swift.Float)
  mutating func divide(by other: Swift.Float)
  mutating func formRemainder(dividingBy other: Swift.Float)
  mutating func formTruncatingRemainder(dividingBy other: Swift.Float)
  mutating func formSquareRoot()
  mutating func addProduct(_ lhs: Swift.Float, _ rhs: Swift.Float)
  func isEqual(to other: Swift.Float) -> Swift.Bool
  func isLess(than other: Swift.Float) -> Swift.Bool
  func isLessThanOrEqualTo(_ other: Swift.Float) -> Swift.Bool
  var isNormal: Swift.Bool {
    get {}
  }
  var isFinite: Swift.Bool {
    get {}
  }
  var isZero: Swift.Bool {
    get {}
  }
  var isSubnormal: Swift.Bool {
    get {}
  }
  var isInfinite: Swift.Bool {
    get {}
  }
  var isNaN: Swift.Bool {
    get {}
  }
  var isSignalingNaN: Swift.Bool {
    get {}
  }
  var binade: Swift.Float {
    get {}
  }
  var significandWidth: Swift.Int {
    get {}
  }
  init(floatLiteral value: Swift.Float)
  typealias FloatLiteralType = Swift.Float
  typealias RawExponent = Swift.UInt
}
extension Float : _ExpressibleByBuiltinIntegerLiteral, ExpressibleByIntegerLiteral {
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  typealias IntegerLiteralType = Swift.Int64
}
extension Float : _ExpressibleByBuiltinFloatLiteral {
  init(_builtinFloatLiteral value: Builtin.FPIEEE80)
}
extension Float : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension Float : AbsoluteValuable {
  static func abs(_ x: Swift.Float) -> Swift.Float
}
extension Float {
  init(_ v: Swift.UInt8)
  init(_ v: Swift.Int8)
  init(_ v: Swift.UInt16)
  init(_ v: Swift.Int16)
  init(_ v: Swift.UInt32)
  init(_ v: Swift.Int32)
  init(_ v: Swift.UInt64)
  init(_ v: Swift.Int64)
  init(_ v: Swift.UInt)
  init(_ v: Swift.Int)
}
extension Float {
  init(_ other: Swift.Float)
  @inline(__always) init?(exactly other: Swift.Float)
  init(_ other: Swift.Double)
  @inline(__always) init?(exactly other: Swift.Double)
  init(_ other: Swift.Float80)
  @inline(__always) init?(exactly other: Swift.Float80)
}
extension Float : Strideable {
  func distance(to other: Swift.Float) -> Swift.Float
  func advanced(by amount: Swift.Float) -> Swift.Float
  typealias Stride = Swift.Float
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension Float : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Float : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Float : _CVarArgPassedAsDouble, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension Float {
  init(_ value: CoreGraphics.CGFloat)
}
extension Float : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Float?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Float?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Float
  typealias _ObjectiveCType = Foundation.NSNumber
}
@_silgen_name("_conditionallyBridgeFromObjectiveC_bridgeable") func _conditionallyBridgeFromObjectiveC_bridgeable<T : _ObjectiveCBridgeable>(_ x: T._ObjectiveCType, _: T.Type) -> T?
protocol _SequenceWrapper {
  associatedtype Base : Sequence
  associatedtype Iterator : IteratorProtocol = Self.Base.Iterator
  var _base: Self.Base { get }
}
extension _SequenceWrapper where Self : Sequence, Self.Iterator == Self.Base.Iterator {
  var underestimatedCount: Swift.Int {
    get {}
  }
}
@inline(__always) func _makeObjCBridgeObject(_ objCObject: AnyObject) -> Builtin.BridgeObject
struct UInt : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(_ _v: Builtin.Word)
  var _builtinWordValue: Builtin.Word {
    get {}
  }
  init(bigEndian value: Swift.UInt)
  init(littleEndian value: Swift.UInt)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt)
  var bigEndian: Swift.UInt {
    get {}
  }
  var littleEndian: Swift.UInt {
    get {}
  }
  var byteSwapped: Swift.UInt {
    get {}
  }
  static var max: Swift.UInt {
    get {}
  }
  static var min: Swift.UInt {
    get {}
  }
  static var _sizeInBits: Swift.UInt {
    get {}
  }
  static var _sizeInBytes: Swift.UInt {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt : BitwiseOperations {
  static var allZeros: Swift.UInt {
    get {}
  }
}
extension UInt : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt {
  init(bitPattern pointer: Swift.OpaquePointer?)
}
extension UInt {
  static func addWithOverflow(_ lhs: Swift.UInt, _ rhs: Swift.UInt) -> (Swift.UInt, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt, _ rhs: Swift.UInt) -> (Swift.UInt, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt, _ rhs: Swift.UInt) -> (Swift.UInt, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt, _ rhs: Swift.UInt) -> (Swift.UInt, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt, _ rhs: Swift.UInt) -> (Swift.UInt, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to UInt will always succeed.") init?(exactly value: Swift.UInt16)
}
extension UInt {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
}
extension UInt {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to UInt will always succeed.") init?(exactly value: Swift.UInt32)
}
extension UInt {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
}
extension UInt {
  init(_ value: Swift.UInt64)
  @available(*, message: "Converting UInt64 to UInt will always succeed.") init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension UInt {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension UInt {
  init(_ value: Swift.UInt)
  @available(*, message: "Converting UInt to UInt will always succeed.") init?(exactly value: Swift.UInt)
}
extension UInt {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
}
extension UInt {
  init(bitPattern: Swift.Int)
}
extension UInt {
  typealias _DisabledRangeIndex = Swift.UInt
}
extension UInt {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UInt {
  init(bitPattern objectID: Swift.ObjectIdentifier)
}
extension UInt {
  @available(*, unavailable, renamed: "init(bitPattern:)") init(_ objectID: Swift.ObjectIdentifier)
}
extension UInt {
  init<U>(bitPattern: Swift.UnsafeMutablePointer<U>?)
}
extension UInt {
  init<U>(bitPattern: Swift.UnsafePointer<U>?)
}
extension UInt {
  init(bitPattern: Swift.UnsafeMutableRawPointer?)
}
extension UInt {
  init(bitPattern: Swift.UnsafeRawPointer?)
}
extension UInt : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension UInt {
  init(_ value: CoreGraphics.CGFloat)
}
extension UInt : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.UInt?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.UInt?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.UInt
  typealias _ObjectiveCType = Foundation.NSNumber
}
func _swift_stdlib_atomicStoreInt(object target: Swift.UnsafeMutablePointer<Swift.Int>, desired: Swift.Int)
@_silgen_name("_swift_stdlib_reportFatalErrorInFile") func _reportFatalErrorInFile(_ prefix: Swift.UnsafePointer<Swift.UInt8>, _ prefixLength: Swift.UInt, _ message: Swift.UnsafePointer<Swift.UInt8>, _ messageLength: Swift.UInt, _ file: Swift.UnsafePointer<Swift.UInt8>, _ fileLength: Swift.UInt, _ line: Swift.UInt, flags: Swift.UInt32)
@_silgen_name("swift_errorInMain") func _errorInMain(_ error: Error)
struct Double {
  var _value: Builtin.FPIEEE64
  init()
  init(_bits v: Builtin.FPIEEE64)
}
extension Double : LosslessStringConvertible {
  init?(_ text: Swift.String)
}
extension Double : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Double : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Double : BinaryFloatingPoint {
  typealias Exponent = Swift.Int
  typealias RawSignificand = Swift.UInt64
  static var exponentBitCount: Swift.Int {
    get {}
  }
  static var significandBitCount: Swift.Int {
    get {}
  }
  @_versioned static var _infinityExponent: Swift.UInt {
    @inline(__always) get {}
  }
  static var _exponentBias: Swift.UInt {
    @inline(__always) get {}
  }
  static var _significandMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  @_versioned static var _quietNaNMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  var bitPattern: Swift.UInt64 {
    get {}
  }
  init(bitPattern: Swift.UInt64)
  var sign: Swift.FloatingPointSign {
    get {}
  }
  @available(*, unavailable, renamed: "sign") var isSignMinus: Swift.Bool {
    get {}
  }
  var exponentBitPattern: Swift.UInt {
    get {}
  }
  var significandBitPattern: Swift.UInt64 {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponentBitPattern: Swift.UInt, significandBitPattern: Swift.UInt64)
  var isCanonical: Swift.Bool {
    get {}
  }
  static var infinity: Swift.Double {
    get {}
  }
  static var nan: Swift.Double {
    get {}
  }
  static var signalingNaN: Swift.Double {
    get {}
  }
  @available(*, unavailable, renamed: "nan") static var quietNaN: Swift.Double {
    get {}
  }
  static var greatestFiniteMagnitude: Swift.Double {
    get {}
  }
  static var pi: Swift.Double {
    get {}
  }
  var ulp: Swift.Double {
    get {}
  }
  static var leastNormalMagnitude: Swift.Double {
    get {}
  }
  static var leastNonzeroMagnitude: Swift.Double {
    get {}
  }
  var exponent: Swift.Int {
    get {}
  }
  var significand: Swift.Double {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponent: Swift.Int, significand: Swift.Double)
  init(nan payload: Swift.Double.RawSignificand, signaling: Swift.Bool)
  var nextUp: Swift.Double {
    get {}
  }
  mutating func round(_ rule: Swift.FloatingPointRoundingRule)
  mutating func negate()
  mutating func add(_ other: Swift.Double)
  mutating func subtract(_ other: Swift.Double)
  mutating func multiply(by other: Swift.Double)
  mutating func divide(by other: Swift.Double)
  mutating func formRemainder(dividingBy other: Swift.Double)
  mutating func formTruncatingRemainder(dividingBy other: Swift.Double)
  mutating func formSquareRoot()
  mutating func addProduct(_ lhs: Swift.Double, _ rhs: Swift.Double)
  func isEqual(to other: Swift.Double) -> Swift.Bool
  func isLess(than other: Swift.Double) -> Swift.Bool
  func isLessThanOrEqualTo(_ other: Swift.Double) -> Swift.Bool
  var isNormal: Swift.Bool {
    get {}
  }
  var isFinite: Swift.Bool {
    get {}
  }
  var isZero: Swift.Bool {
    get {}
  }
  var isSubnormal: Swift.Bool {
    get {}
  }
  var isInfinite: Swift.Bool {
    get {}
  }
  var isNaN: Swift.Bool {
    get {}
  }
  var isSignalingNaN: Swift.Bool {
    get {}
  }
  var binade: Swift.Double {
    get {}
  }
  var significandWidth: Swift.Int {
    get {}
  }
  init(floatLiteral value: Swift.Double)
  typealias FloatLiteralType = Swift.Double
  typealias RawExponent = Swift.UInt
}
extension Double : _ExpressibleByBuiltinIntegerLiteral, ExpressibleByIntegerLiteral {
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  typealias IntegerLiteralType = Swift.Int64
}
extension Double : _ExpressibleByBuiltinFloatLiteral {
  init(_builtinFloatLiteral value: Builtin.FPIEEE80)
}
extension Double : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension Double : AbsoluteValuable {
  static func abs(_ x: Swift.Double) -> Swift.Double
}
extension Double {
  init(_ v: Swift.UInt8)
  init(_ v: Swift.Int8)
  init(_ v: Swift.UInt16)
  init(_ v: Swift.Int16)
  init(_ v: Swift.UInt32)
  init(_ v: Swift.Int32)
  init(_ v: Swift.UInt64)
  init(_ v: Swift.Int64)
  init(_ v: Swift.UInt)
  init(_ v: Swift.Int)
}
extension Double {
  init(_ other: Swift.Float)
  @inline(__always) init?(exactly other: Swift.Float)
  init(_ other: Swift.Double)
  @inline(__always) init?(exactly other: Swift.Double)
  init(_ other: Swift.Float80)
  @inline(__always) init?(exactly other: Swift.Float80)
}
extension Double : Strideable {
  func distance(to other: Swift.Double) -> Swift.Double
  func advanced(by amount: Swift.Double) -> Swift.Double
  typealias Stride = Swift.Double
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension Double : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Double : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Double : _CVarArgPassedAsDouble, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension Double {
  init(_ value: CoreGraphics.CGFloat)
}
extension Double : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Double?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Double?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Double
  typealias _ObjectiveCType = Foundation.NSNumber
}
protocol MirrorPath {
}
@objc @_swift_native_objc_runtime_base(_SwiftNativeNSCharacterSetBase) class _SwiftNativeNSCharacterSet {
  @objc init()
  @objc deinit
}
@available(*, unavailable, renamed: "OpaquePointer") struct COpaquePointer {
  init()
}
func _isPowerOf2(_ x: Swift.UInt) -> Swift.Bool
func _isPowerOf2(_ x: Swift.Int) -> Swift.Bool
protocol _ExpressibleByBuiltinUTF16StringLiteral : _ExpressibleByBuiltinStringLiteral {
  init(_builtinUTF16StringLiteral start: Builtin.RawPointer, utf16CodeUnitCount: Builtin.Word)
}
protocol _ExpressibleByBuiltinStringLiteral : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral {
  init(_builtinStringLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
@_silgen_name("swift_stdlib_NSStringHashValuePointer") func _stdlib_NSStringHashValuePointer(_ str: Swift.OpaquePointer, _ isASCII: Swift.Bool) -> Swift.Int
@objc protocol AnyObject {
}
@_versioned @inline(never) @_semantics("stdlib_binary_only") func _assertionFailed(_ prefix: Swift.StaticString, _ message: Swift.StaticString, _ file: Swift.StaticString, _ line: Swift.UInt, flags: Swift.UInt32) -> Swift.Never
@_versioned @inline(never) @_semantics("stdlib_binary_only") func _assertionFailed(_ prefix: Swift.StaticString, _ message: Swift.String, _ file: Swift.StaticString, _ line: Swift.UInt, flags: Swift.UInt32) -> Swift.Never
@_versioned func _fatalErrorFlags() -> Swift.UInt32
struct AnyIndex {
  init<BaseIndex : Comparable>(_ base: BaseIndex)
  init(_box: _AnyIndexBox)
  var _typeID: Swift.ObjectIdentifier {
    get {}
  }
  var _box: _AnyIndexBox
}
extension AnyIndex : Comparable {
  static func ==(lhs: Swift.AnyIndex, rhs: Swift.AnyIndex) -> Swift.Bool
  static func <(lhs: Swift.AnyIndex, rhs: Swift.AnyIndex) -> Swift.Bool
}
struct UnicodeScalar : _ExpressibleByBuiltinUnicodeScalarLiteral, ExpressibleByUnicodeScalarLiteral {
  var _value: Swift.UInt32
  var value: Swift.UInt32 {
    get {}
  }
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
  init(unicodeScalarLiteral value: Swift.UnicodeScalar)
  init?(_ v: Swift.UInt32)
  init?(_ v: Swift.UInt16)
  init(_ v: Swift.UInt8)
  init(_ v: Swift.UnicodeScalar)
  func escaped(asASCII forceASCII: Swift.Bool) -> Swift.String
  var isASCII: Swift.Bool {
    get {}
  }
  var _isASCIIDigit: Swift.Bool {
    get {}
  }
  var _isPrintableASCII: Swift.Bool {
    get {}
  }
  typealias UnicodeScalarLiteralType = Swift.UnicodeScalar
}
extension UnicodeScalar : Equatable {
  static func ==(lhs: Swift.UnicodeScalar, rhs: Swift.UnicodeScalar) -> Swift.Bool
}
extension UnicodeScalar : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UnicodeScalar : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UnicodeScalar : TextOutputStreamable {
  func write<Target : TextOutputStream>(to target: inout Target)
}
extension UnicodeScalar {
  init(_unchecked value: Swift.UInt32)
}
extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible {
  var description: Swift.String {
    get {}
  }
  var debugDescription: Swift.String {
    get {}
  }
}
extension UnicodeScalar : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension UnicodeScalar : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension UnicodeScalar {
  init?(_ v: Swift.Int)
}
extension UnicodeScalar : Comparable {
  static func <(lhs: Swift.UnicodeScalar, rhs: Swift.UnicodeScalar) -> Swift.Bool
}
extension UnicodeScalar {
  struct UTF16View {
    var value: Swift.UnicodeScalar
    init(value: Swift.UnicodeScalar)
  }
  var utf16: Swift.UnicodeScalar.UTF16View {
    get {}
  }
}
extension UnicodeScalar {
  @available(*, unavailable, message: "use 'UnicodeScalar(0)'") init()
  @available(*, unavailable, renamed: "escaped(asASCII:)") func escape(asASCII forceASCII: Swift.Bool) -> Swift.String
}
enum FloatingPointClassification {
  case signalingNaN
  case quietNaN
  case negativeInfinity
  case negativeNormal
  case negativeSubnormal
  case negativeZero
  case positiveZero
  case positiveSubnormal
  case positiveNormal
  case positiveInfinity
  infix static func ==(a: Swift.FloatingPointClassification, b: Swift.FloatingPointClassification) -> Swift.Bool
  var hashValue: Swift.Int {
    get {}
  }
}
func _stdlib_atomicCompareExchangeStrongUInt64(object target: Swift.UnsafeMutablePointer<Swift.UInt64>, expected: Swift.UnsafeMutablePointer<Swift.UInt64>, desired: Swift.UInt64) -> Swift.Bool
struct AnyIndex {
  init<BaseIndex : Comparable>(_ base: BaseIndex)
  init(_box: _AnyIndexBox)
  var _typeID: Swift.ObjectIdentifier {
    get {}
  }
  var _box: _AnyIndexBox
}
extension AnyIndex : Comparable {
  static func ==(lhs: Swift.AnyIndex, rhs: Swift.AnyIndex) -> Swift.Bool
  static func <(lhs: Swift.AnyIndex, rhs: Swift.AnyIndex) -> Swift.Bool
}
@objc @_swift_native_objc_runtime_base(_SwiftNativeNSArrayBase) class _SwiftNativeNSArray {
  @objc init()
  @objc deinit
}
struct _Abs {
  init()
}
func _isStdlibInternalChecksEnabled() -> Swift.Bool
enum SetIndexRepresentation<Element : Hashable> {
  typealias _Index = Swift.SetIndex<Element>
  typealias _NativeIndex = Swift._NativeSetIndex<Element>
  typealias _CocoaIndex = Swift.SetIndex._CocoaIndex
  case _native(Swift._NativeSetIndex<Element>)
  case _cocoa(Swift.SetIndexRepresentation._CocoaIndex)
}
func withExtendedLifetime<T, Result>(_ x: T, _ body: () throws -> Result) rethrows -> Result
func withExtendedLifetime<T, Result>(_ x: T, _ body: (T) throws -> Result) rethrows -> Result
final class _NativeDictionaryStorageKeyNSEnumerator<Key : Hashable, Value> : Swift._SwiftNativeNSEnumerator, _NSEnumerator {
  typealias NativeStorageOwner = Swift._NativeDictionaryStorageOwner<Key, Value>
  typealias Index = Swift._NativeDictionaryIndex<Key, Value>
  @objc required init()
  init(_ nativeStorageOwner: Swift._NativeDictionaryStorageOwner<Key, Value>)
  final var nativeStorageOwner: Swift._NativeDictionaryStorageOwner<Key, Value>
  final var nextIndex: Swift._NativeDictionaryIndex<Key, Value>
  final var endIndex: Swift._NativeDictionaryIndex<Key, Value>
  @objc final func nextObject() -> AnyObject?
  @objc(countByEnumeratingWithState:objects:count:) final func countByEnumerating(with state: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState>, objects: Swift.UnsafeMutablePointer<AnyObject>, count: Swift.Int) -> Swift.Int
  @objc deinit
}
protocol TextOutputStream {
  mutating func _lock()
  mutating func _unlock()
  mutating func write(_ string: Swift.String)
}
extension TextOutputStream {
  mutating func _lock()
  mutating func _unlock()
}
func _swift_stdlib_atomicFetchOrInt32(object target: Swift.UnsafeMutablePointer<Swift.Int32>, operand: Swift.Int32) -> Swift.Int32
@_semantics("array.dealloc_uninitialized") func _deallocateUninitializedArray<Element>(_ array: [Element])
struct LazyMapIterator<Base : IteratorProtocol, Element> : IteratorProtocol, Sequence {
  mutating func next() -> Element?
  var base: Base {
    get {}
  }
  var _base: Base
  let _transform: (Base.Element) -> Element
  typealias Element = Element
  init(_base: Base, _transform: @escaping (Base.Element) -> Element)
  typealias Iterator = Swift.LazyMapIterator<Base, Element>
  typealias SubSequence = Swift.AnySequence<Element>
}
protocol Error {
  var _domain: Swift.String { get }
  var _code: Swift.Int { get }
  var _userInfo: Any? { get }
  func _getEmbeddedNSError() -> AnyObject?
}
extension Error {
  var _domain: Swift.String {
    get {}
  }
  var _userInfo: Any? {
    get {}
  }
}
extension Error {
  func _getEmbeddedNSError() -> AnyObject?
}
extension Error where Self : CustomNSError {
  var _domain: Swift.String {
    get {}
  }
  var _code: Swift.Int {
    get {}
  }
}
extension Error {
  var localizedDescription: Swift.String {
    get {}
  }
}
struct Bool {
  var _value: Builtin.Int1
  init()
  @_versioned init(_ v: Builtin.Int1)
  init(_ value: Swift.Bool)
}
extension Bool : Equatable, Hashable {
  var hashValue: Swift.Int {
    get {}
  }
  static func ==(lhs: Swift.Bool, rhs: Swift.Bool) -> Swift.Bool
}
extension Bool : _ExpressibleByBuiltinBooleanLiteral, ExpressibleByBooleanLiteral {
  init(_builtinBooleanLiteral value: Builtin.Int1)
  init(booleanLiteral value: Swift.Bool)
  typealias BooleanLiteralType = Swift.Bool
}
extension Bool {
  func _getBuiltinLogicValue() -> Builtin.Int1
}
extension Bool : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Bool : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension Bool {
  prefix static func !(a: Swift.Bool) -> Swift.Bool
}
extension Bool {
  @inline(__always) static func &&(lhs: Swift.Bool, rhs: @autoclosure () throws -> Swift.Bool) rethrows -> Swift.Bool
  @inline(__always) static func ||(lhs: Swift.Bool, rhs: @autoclosure () throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Bool : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Bool : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Bool : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Bool?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Bool?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Bool
  typealias _ObjectiveCType = Foundation.NSNumber
}
struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
  var result: Swift._ContiguousArrayBuffer<Element>
  var p: Swift.UnsafeMutablePointer<Element>
  var remainingCapacity: Swift.Int
  @inline(__always) init(initialCapacity: Swift.Int)
  @inline(__always) mutating func add(_ element: Element)
  @inline(__always) mutating func addWithExistingCapacity(_ element: Element)
  @inline(__always) mutating func finish() -> Swift.ContiguousArray<Element>
  @inline(__always) mutating func finishWithOriginalCount() -> Swift.ContiguousArray<Element>
}
@_silgen_name("_swift_isBridgedNonVerbatimToObjectiveC") func _isBridgedNonVerbatimToObjectiveC<T>(_: T.Type) -> Swift.Bool
@_versioned func _abs<Args>(_ args: Args) -> (Swift._Abs, Args)
@_silgen_name("swift_uint64ToString") func _uint64ToStringImpl(_ buffer: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>, _ bufferLength: Swift.UInt, _ value: Swift.UInt64, _ radix: Swift.Int64, _ uppercase: Swift.Bool) -> Swift.UInt
protocol Comparable : Equatable {
  static func <(lhs: Self, rhs: Self) -> Swift.Bool
  static func <=(lhs: Self, rhs: Self) -> Swift.Bool
  static func >=(lhs: Self, rhs: Self) -> Swift.Bool
  static func >(lhs: Self, rhs: Self) -> Swift.Bool
}
func abs<T : SignedNumber>(_ x: T) -> T
func isKnownUniquelyReferenced<T : AnyObject>(_ object: inout T) -> Swift.Bool
func isKnownUniquelyReferenced<T : AnyObject>(_ object: inout T?) -> Swift.Bool
@_silgen_name("swift_stdlib_getErrorDefaultUserInfo") func _stdlib_getErrorDefaultUserInfo(_ error: Error) -> AnyObject?
func _sanityCheckFailure(_ message: Swift.StaticString = default, file: Swift.StaticString = #file, line: Swift.UInt = #line) -> Swift.Never
@_silgen_name("swift_stdlib_NSStringHasSuffixNFD") func _stdlib_NSStringHasSuffixNFD(_ theString: AnyObject, _ suffix: AnyObject) -> Swift.Bool
@discardableResult func _stdlib_atomicInitializeARCRef(object target: Swift.UnsafeMutablePointer<AnyObject?>, desired: AnyObject) -> Swift.Bool
@objc protocol _NSEnumerator : _ShadowProtocol {
  @objc init()
  @objc func nextObject() -> AnyObject?
}
@inline(never) func _debugPrint_unlocked<T, TargetStream : TextOutputStream>(_ value: T, _ target: inout TargetStream)
enum SetIteratorRepresentation<Element : Hashable> {
  typealias _Iterator = Swift.SetIterator<Element>
  typealias _NativeStorageOwner = Swift._NativeSetStorageOwner<Element>
  typealias _NativeIndex = Swift._NativeSetIndex<Element>
  case _native(start: Swift._NativeSetIndex<Element>, end: Swift._NativeSetIndex<Element>, owner: Swift._NativeSetStorageOwner<Element>)
  case _cocoa(Swift._CocoaSetIterator)
}
protocol IteratorProtocol {
  associatedtype Element
  mutating func next() -> Self.Element?
}
func ...<Bound : Comparable>(minimum: Bound, maximum: Bound) -> Swift.ClosedRange<Bound>
func ...<Bound where Bound : _Strideable & Comparable, Bound.Stride : SignedInteger>(minimum: Bound, maximum: Bound) -> Swift.CountableClosedRange<Bound>
func _copyCollectionToContiguousArray<C : Collection>(_ source: C) -> Swift.ContiguousArray<C.Iterator.Element>
func ..<<Bound : Comparable>(minimum: Bound, maximum: Bound) -> Swift.Range<Bound>
func ..<<Bound where Bound : _Strideable & Comparable, Bound.Stride : Integer>(minimum: Bound, maximum: Bound) -> Swift.CountableRange<Bound>
struct UInt64 : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(bigEndian value: Swift.UInt64)
  init(littleEndian value: Swift.UInt64)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt64)
  var bigEndian: Swift.UInt64 {
    get {}
  }
  var littleEndian: Swift.UInt64 {
    get {}
  }
  var byteSwapped: Swift.UInt64 {
    get {}
  }
  static var max: Swift.UInt64 {
    get {}
  }
  static var min: Swift.UInt64 {
    get {}
  }
  static var _sizeInBits: Swift.UInt64 {
    get {}
  }
  static var _sizeInBytes: Swift.UInt64 {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt64
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt64 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt64 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt64 {
  static func addWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt64 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt64 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt64 {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt64 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to UInt64 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension UInt64 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
}
extension UInt64 {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to UInt64 will always succeed.") init?(exactly value: Swift.UInt32)
}
extension UInt64 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
}
extension UInt64 {
  init(_ value: Swift.UInt64)
  @available(*, message: "Converting UInt64 to UInt64 will always succeed.") init?(exactly value: Swift.UInt64)
}
extension UInt64 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
}
extension UInt64 {
  init(_ value: Swift.UInt)
  @available(*, message: "Converting UInt to UInt64 will always succeed.") init?(exactly value: Swift.UInt)
}
extension UInt64 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
}
extension UInt64 {
  init(bitPattern: Swift.Int64)
}
extension UInt64 : BitwiseOperations {
  static var allZeros: Swift.UInt64 {
    get {}
  }
}
extension UInt64 {
  typealias _DisabledRangeIndex = Swift.UInt64
}
extension UInt64 {
  var signBitIndex: Swift.Int {
    get {}
  }
  var countTrailingZeros: Swift.Int {
    get {}
  }
}
extension UInt64 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt64 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt64 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt64 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UInt64 {
  init(_ v: Swift.UnicodeScalar)
}
extension UInt64 : CVarArg, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension UInt64 {
  init(_ value: CoreGraphics.CGFloat)
}
@available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'RandomAccessCollection' instead") protocol RangeReplaceableIndexable : Indexable {
  init()
  init(repeating repeatedValue: Self._Element, count: Swift.Int)
  init<S : Sequence where S.Iterator.Element == _Element>(_ elements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == _Element>(_ subrange: Swift.Range<Self.Index>, with newElements: C)
  mutating func insert(_ newElement: Self._Element, at i: Self.Index)
  mutating func insert<S : Collection where S.Iterator.Element == _Element>(contentsOf newElements: S, at i: Self.Index)
  @discardableResult mutating func remove(at i: Self.Index) -> Self._Element
  mutating func removeSubrange(_ bounds: Swift.Range<Self.Index>)
}
struct FlattenBidirectionalCollectionIndex<BaseElements where BaseElements : BidirectionalCollection, BaseElements.Iterator.Element : BidirectionalCollection> {
  init(_ _outer: BaseElements.Index, _ inner: BaseElements.Iterator.Element.Index?)
  let _outer: BaseElements.Index
  let _inner: BaseElements.Iterator.Element.Index?
}
extension FlattenBidirectionalCollectionIndex : Comparable {
  static func ==(lhs: Swift.FlattenBidirectionalCollectionIndex<BaseElements>, rhs: Swift.FlattenBidirectionalCollectionIndex<BaseElements>) -> Swift.Bool
  static func <(lhs: Swift.FlattenBidirectionalCollectionIndex<BaseElements>, rhs: Swift.FlattenBidirectionalCollectionIndex<BaseElements>) -> Swift.Bool
}
func stride<T : Strideable>(from start: T, to end: T, by stride: T.Stride) -> Swift.StrideTo<T>
func stride<T : Strideable>(from start: T, through end: T, by stride: T.Stride) -> Swift.StrideThrough<T>
struct MutableRandomAccessSlice<Base : MutableIndexable & RandomAccessIndexable> : RandomAccessCollection, MutableCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
    set(newValue) {}
  }
  typealias SubSequence = Swift.MutableRandomAccessSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.MutableRandomAccessSlice<Base> {
    get {}
    set(newValue) {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(before i: Base.Index) -> Base.Index
  func formIndex(before i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  var _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.MutableRandomAccessSlice<Base>>
  typealias Indices = Swift.DefaultRandomAccessIndices<Swift.MutableRandomAccessSlice<Base>>
}
@available(*, unavailable, renamed: "isKnownUniquelyReferenced") func isUniquelyReferencedNonObjC<T : AnyObject>(_ object: inout T) -> Swift.Bool
@available(*, unavailable, renamed: "isKnownUniquelyReferenced") func isUniquelyReferencedNonObjC<T : AnyObject>(_ object: inout T?) -> Swift.Bool
func _floorLog2(_ x: Swift.Int64) -> Swift.Int
struct _HeapBuffer<Value, Element> : Equatable {
  typealias Storage = Swift._HeapBufferStorage<Value, Element>
  var _storage: Builtin.NativeObject?
  var storage: AnyObject? {
    get {}
  }
  static func _valueOffset() -> Swift.Int
  static func _elementOffset() -> Swift.Int
  static func _requiredAlignMask() -> Swift.Int
  var _address: Swift.UnsafeMutableRawPointer {
    get {}
  }
  var _value: Swift.UnsafeMutablePointer<Value> {
    get {}
  }
  var baseAddress: Swift.UnsafeMutablePointer<Element> {
    get {}
  }
  func _allocatedSize() -> Swift.Int
  func _allocatedAlignMask() -> Swift.Int
  func _allocatedSizeAndAlignMask() -> (Swift.Int, Swift.Int)
  func _capacity() -> Swift.Int
  init()
  init(_ storage: Swift._HeapBufferStorage<Value, Element>)
  init(_ storage: AnyObject)
  init<T : AnyObject>(_ storage: T?)
  init(nativeStorage: Builtin.NativeObject?)
  init(_ storageClass: Swift.AnyClass, _ initializer: Value, _ capacity: Swift.Int)
  var value: Value
  var value: Value {
    unsafeAddress {}
    unsafeMutableAddress {}
  }
  var hasStorage: Swift.Bool {
    get {}
  }
  subscript(i: Swift.Int) -> Element {
    unsafeAddress {}
    unsafeMutableAddress {}
  }
  var _nativeObject: Builtin.NativeObject {
    get {}
  }
  static func fromNativeObject(_ x: Builtin.NativeObject) -> Swift._HeapBuffer<Value, Element>
  mutating func isUniquelyReferenced() -> Swift.Bool
  mutating func isUniquelyReferencedOrPinned() -> Swift.Bool
}
protocol _Incrementable : Equatable {
}
protocol LazySequenceProtocol : Sequence {
  associatedtype Elements : Sequence = Self
  var elements: Self.Elements { get }
}
extension LazySequenceProtocol {
  func filter(_ isIncluded: @escaping (Self.Elements.Iterator.Element) -> Swift.Bool) -> Swift.LazyFilterSequence<Self.Elements>
}
extension LazySequenceProtocol {
  func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Self.Elements.Iterator.Element) -> SegmentOfResult) -> Swift.LazySequence<Swift.FlattenSequence<Swift.LazyMapSequence<Self.Elements, SegmentOfResult>>>
  func flatMap<ElementOfResult>(_ transform: @escaping (Self.Elements.Iterator.Element) -> ElementOfResult?) -> Swift.LazyMapSequence<Swift.LazyFilterSequence<Swift.LazyMapSequence<Self.Elements, ElementOfResult?>>, ElementOfResult>
}
extension LazySequenceProtocol where Elements.Iterator.Element == Iterator.Element, Iterator.Element : Sequence {
  func joined() -> Swift.LazySequence<Swift.FlattenSequence<Self.Elements>>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.LazySequence<Swift.FlattenSequence<Self.Elements>>
}
extension LazySequenceProtocol where Elements == Self {
  var elements: Self {
    get {}
  }
}
extension LazySequenceProtocol {
  var lazy: Self {
    get {}
  }
}
extension LazySequenceProtocol {
  @available(*, unavailable, message: "Please use Array initializer instead.") var array: [Self.Iterator.Element] {
    get {}
  }
}
extension LazySequenceProtocol {
  func map<U>(_ transform: @escaping (Self.Elements.Iterator.Element) -> U) -> Swift.LazyMapSequence<Self.Elements, U>
}
enum FloatingPointRoundingRule {
  case toNearestOrAwayFromZero
  case toNearestOrEven
  case up
  case down
  case towardZero
  case awayFromZero
  infix static func ==(a: Swift.FloatingPointRoundingRule, b: Swift.FloatingPointRoundingRule) -> Swift.Bool
  var hashValue: Swift.Int {
    get {}
  }
}
protocol IteratorProtocol {
  associatedtype Element
  mutating func next() -> Self.Element?
}
func _squeezeHashValue(_ hashValue: Swift.Int, _ resultRange: Swift.Range<Swift.Int>) -> Swift.Int
func _squeezeHashValue(_ hashValue: Swift.Int, _ resultRange: Swift.Range<Swift.UInt>) -> Swift.UInt
func _uint64ToString(_ value: Swift.UInt64, radix: Swift.Int64 = default, uppercase: Swift.Bool = default) -> Swift.String
func _swift_stdlib_atomicFetchOrInt64(object target: Swift.UnsafeMutablePointer<Swift.Int64>, operand: Swift.Int64) -> Swift.Int64
struct UInt : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(_ _v: Builtin.Word)
  var _builtinWordValue: Builtin.Word {
    get {}
  }
  init(bigEndian value: Swift.UInt)
  init(littleEndian value: Swift.UInt)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt)
  var bigEndian: Swift.UInt {
    get {}
  }
  var littleEndian: Swift.UInt {
    get {}
  }
  var byteSwapped: Swift.UInt {
    get {}
  }
  static var max: Swift.UInt {
    get {}
  }
  static var min: Swift.UInt {
    get {}
  }
  static var _sizeInBits: Swift.UInt {
    get {}
  }
  static var _sizeInBytes: Swift.UInt {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt : BitwiseOperations {
  static var allZeros: Swift.UInt {
    get {}
  }
}
extension UInt : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt {
  init(bitPattern pointer: Swift.OpaquePointer?)
}
extension UInt {
  static func addWithOverflow(_ lhs: Swift.UInt, _ rhs: Swift.UInt) -> (Swift.UInt, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt, _ rhs: Swift.UInt) -> (Swift.UInt, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt, _ rhs: Swift.UInt) -> (Swift.UInt, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt, _ rhs: Swift.UInt) -> (Swift.UInt, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt, _ rhs: Swift.UInt) -> (Swift.UInt, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to UInt will always succeed.") init?(exactly value: Swift.UInt16)
}
extension UInt {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
}
extension UInt {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to UInt will always succeed.") init?(exactly value: Swift.UInt32)
}
extension UInt {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
}
extension UInt {
  init(_ value: Swift.UInt64)
  @available(*, message: "Converting UInt64 to UInt will always succeed.") init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension UInt {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension UInt {
  init(_ value: Swift.UInt)
  @available(*, message: "Converting UInt to UInt will always succeed.") init?(exactly value: Swift.UInt)
}
extension UInt {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
}
extension UInt {
  init(bitPattern: Swift.Int)
}
extension UInt {
  typealias _DisabledRangeIndex = Swift.UInt
}
extension UInt {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UInt {
  init(bitPattern objectID: Swift.ObjectIdentifier)
}
extension UInt {
  @available(*, unavailable, renamed: "init(bitPattern:)") init(_ objectID: Swift.ObjectIdentifier)
}
extension UInt {
  init<U>(bitPattern: Swift.UnsafeMutablePointer<U>?)
}
extension UInt {
  init<U>(bitPattern: Swift.UnsafePointer<U>?)
}
extension UInt {
  init(bitPattern: Swift.UnsafeMutableRawPointer?)
}
extension UInt {
  init(bitPattern: Swift.UnsafeRawPointer?)
}
extension UInt : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension UInt {
  init(_ value: CoreGraphics.CGFloat)
}
extension UInt : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.UInt?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.UInt?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.UInt
  typealias _ObjectiveCType = Foundation.NSNumber
}
func _debugPrecondition(_ condition: @autoclosure () -> Swift.Bool, _ message: Swift.StaticString = default, file: Swift.StaticString = #file, line: Swift.UInt = #line)
@_silgen_name("swift_stdlib_NSStringLowercaseString") func _stdlib_NSStringLowercaseString(_ str: AnyObject) -> Swift._CocoaString
@objc class _SwiftNativeNSArrayWithContiguousStorage : Swift._SwiftNativeNSArray {
  func withUnsafeBufferOfObjects<R>(_ body: (Swift.UnsafeBufferPointer<AnyObject>) throws -> R) rethrows -> R
  @objc init()
  @objc deinit
}
extension _SwiftNativeNSArrayWithContiguousStorage : _NSArrayCore {
  @objc dynamic var count: Swift.Int {
    @objc dynamic get {}
  }
  @objc(objectAtIndex:) dynamic func objectAt(_ index: Swift.Int) -> AnyObject
  @objc dynamic func getObjects(_ aBuffer: Swift.UnsafeMutablePointer<AnyObject>, range: SwiftShims._SwiftNSRange)
  @objc(countByEnumeratingWithState:objects:count:) dynamic func countByEnumerating(with state: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState>, objects: Swift.UnsafeMutablePointer<AnyObject>?, count: Swift.Int) -> Swift.Int
  @objc(copyWithZone:) dynamic func copy(with _: Swift._SwiftNSZone?) -> AnyObject
}
func _partition<C where C : MutableCollection & RandomAccessCollection>(_ elements: inout C, subRange range: Swift.Range<C.Index>, by areInIncreasingOrder: inout @escaping (C.Iterator.Element, C.Iterator.Element) -> Swift.Bool) -> C.Index
func _partition<C where C : MutableCollection & RandomAccessCollection, C.Iterator.Element : Comparable>(_ elements: inout C, subRange range: Swift.Range<C.Index>) -> C.Index
func _setUpCast<DerivedValue, BaseValue>(_ source: Swift.Set<DerivedValue>) -> Swift.Set<BaseValue>
func _is(_ object: AnyObject, kindOf class: Swift.String) -> Swift.Bool
protocol Error {
  var _domain: Swift.String { get }
  var _code: Swift.Int { get }
  var _userInfo: Any? { get }
  func _getEmbeddedNSError() -> AnyObject?
}
extension Error {
  var _domain: Swift.String {
    get {}
  }
  var _userInfo: Any? {
    get {}
  }
}
extension Error {
  func _getEmbeddedNSError() -> AnyObject?
}
extension Error where Self : CustomNSError {
  var _domain: Swift.String {
    get {}
  }
  var _code: Swift.Int {
    get {}
  }
}
extension Error {
  var localizedDescription: Swift.String {
    get {}
  }
}
func _log(_ x: Swift.Float) -> Swift.Float
func _log(_ x: Swift.Double) -> Swift.Double
func _insertionSort<C where C : MutableCollection & BidirectionalCollection>(_ elements: inout C, subRange range: Swift.Range<C.Index>, by areInIncreasingOrder: inout @escaping (C.Iterator.Element, C.Iterator.Element) -> Swift.Bool)
func _insertionSort<C where C : MutableCollection & BidirectionalCollection, C.Iterator.Element : Comparable>(_ elements: inout C, subRange range: Swift.Range<C.Index>)
@objc class _stdlib_ReturnAutoreleasedDummy {
  @objc dynamic func returnsAutoreleased(_ x: AnyObject) -> AnyObject
  @objc dynamic func initializeReturnAutoreleased()
  @objc deinit
  @objc init()
}
struct _UnwrappingFailed : Error {
  init()
  var _code: Swift.Int {
    get {}
  }
}
protocol _ExpressibleByImageLiteral {
  init(imageLiteralResourceName path: Swift.String)
}
@inline(never) @_semantics("stdlib_binary_only") func debugPrint(_ items: Any..., separator: Swift.String = default, terminator: Swift.String = default)
@inline(__always) func debugPrint<Target : TextOutputStream>(_ items: Any..., separator: Swift.String = default, terminator: Swift.String = default, to output: inout Target)
@available(*, unavailable, renamed: "debugPrint(_:separator:terminator:to:)") func debugPrint<Target : TextOutputStream>(_ items: Any..., separator: Swift.String = default, terminator: Swift.String = default, toStream output: inout Target)
@available(*, unavailable, message: "Please use 'terminator: \"\"' instead of 'appendNewline: false': 'debugPrint((...), terminator: \"\")'") func debugPrint<T>(_: T, appendNewline: Swift.Bool = default)
@available(*, unavailable, message: "Please use the 'to' label for the target stream: 'debugPrint((...), to: &...))'") func debugPrint<T>(_: T, _: inout TextOutputStream)
@available(*, unavailable, message: "Please use 'terminator: \"\"' instead of 'appendNewline: false' and use the 'to' label for the target stream: 'debugPrint((...), terminator: \"\", to: &...)'") func debugPrint<T>(_: T, _: inout TextOutputStream, appendNewline: Swift.Bool = default)
struct _BridgedNativeSetStorage {
  typealias StorageImpl = Swift._NativeSetStorageImpl<AnyObject>
  typealias SequenceElement = AnyObject
  let buffer: Swift._BridgedNativeSetStorage.StorageImpl
  let initializedEntries: Swift._UnsafeBitMap
  let keys: Swift.UnsafeMutablePointer<AnyObject>
  init(buffer: Swift._BridgedNativeSetStorage.StorageImpl)
  var capacity: Swift.Int {
    get {}
  }
  @_versioned func isInitializedEntry(at i: Swift.Int) -> Swift.Bool
  func key(at i: Swift.Int) -> AnyObject
  func setKey(_ key: AnyObject, at i: Swift.Int)
  func initializeKey(_ k: AnyObject, at i: Swift.Int)
  func assertingGet(_ i: Swift.Int) -> Swift._BridgedNativeSetStorage.SequenceElement
}
struct Double {
  var _value: Builtin.FPIEEE64
  init()
  init(_bits v: Builtin.FPIEEE64)
}
extension Double : LosslessStringConvertible {
  init?(_ text: Swift.String)
}
extension Double : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Double : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Double : BinaryFloatingPoint {
  typealias Exponent = Swift.Int
  typealias RawSignificand = Swift.UInt64
  static var exponentBitCount: Swift.Int {
    get {}
  }
  static var significandBitCount: Swift.Int {
    get {}
  }
  @_versioned static var _infinityExponent: Swift.UInt {
    @inline(__always) get {}
  }
  static var _exponentBias: Swift.UInt {
    @inline(__always) get {}
  }
  static var _significandMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  @_versioned static var _quietNaNMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  var bitPattern: Swift.UInt64 {
    get {}
  }
  init(bitPattern: Swift.UInt64)
  var sign: Swift.FloatingPointSign {
    get {}
  }
  @available(*, unavailable, renamed: "sign") var isSignMinus: Swift.Bool {
    get {}
  }
  var exponentBitPattern: Swift.UInt {
    get {}
  }
  var significandBitPattern: Swift.UInt64 {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponentBitPattern: Swift.UInt, significandBitPattern: Swift.UInt64)
  var isCanonical: Swift.Bool {
    get {}
  }
  static var infinity: Swift.Double {
    get {}
  }
  static var nan: Swift.Double {
    get {}
  }
  static var signalingNaN: Swift.Double {
    get {}
  }
  @available(*, unavailable, renamed: "nan") static var quietNaN: Swift.Double {
    get {}
  }
  static var greatestFiniteMagnitude: Swift.Double {
    get {}
  }
  static var pi: Swift.Double {
    get {}
  }
  var ulp: Swift.Double {
    get {}
  }
  static var leastNormalMagnitude: Swift.Double {
    get {}
  }
  static var leastNonzeroMagnitude: Swift.Double {
    get {}
  }
  var exponent: Swift.Int {
    get {}
  }
  var significand: Swift.Double {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponent: Swift.Int, significand: Swift.Double)
  init(nan payload: Swift.Double.RawSignificand, signaling: Swift.Bool)
  var nextUp: Swift.Double {
    get {}
  }
  mutating func round(_ rule: Swift.FloatingPointRoundingRule)
  mutating func negate()
  mutating func add(_ other: Swift.Double)
  mutating func subtract(_ other: Swift.Double)
  mutating func multiply(by other: Swift.Double)
  mutating func divide(by other: Swift.Double)
  mutating func formRemainder(dividingBy other: Swift.Double)
  mutating func formTruncatingRemainder(dividingBy other: Swift.Double)
  mutating func formSquareRoot()
  mutating func addProduct(_ lhs: Swift.Double, _ rhs: Swift.Double)
  func isEqual(to other: Swift.Double) -> Swift.Bool
  func isLess(than other: Swift.Double) -> Swift.Bool
  func isLessThanOrEqualTo(_ other: Swift.Double) -> Swift.Bool
  var isNormal: Swift.Bool {
    get {}
  }
  var isFinite: Swift.Bool {
    get {}
  }
  var isZero: Swift.Bool {
    get {}
  }
  var isSubnormal: Swift.Bool {
    get {}
  }
  var isInfinite: Swift.Bool {
    get {}
  }
  var isNaN: Swift.Bool {
    get {}
  }
  var isSignalingNaN: Swift.Bool {
    get {}
  }
  var binade: Swift.Double {
    get {}
  }
  var significandWidth: Swift.Int {
    get {}
  }
  init(floatLiteral value: Swift.Double)
  typealias FloatLiteralType = Swift.Double
  typealias RawExponent = Swift.UInt
}
extension Double : _ExpressibleByBuiltinIntegerLiteral, ExpressibleByIntegerLiteral {
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  typealias IntegerLiteralType = Swift.Int64
}
extension Double : _ExpressibleByBuiltinFloatLiteral {
  init(_builtinFloatLiteral value: Builtin.FPIEEE80)
}
extension Double : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension Double : AbsoluteValuable {
  static func abs(_ x: Swift.Double) -> Swift.Double
}
extension Double {
  init(_ v: Swift.UInt8)
  init(_ v: Swift.Int8)
  init(_ v: Swift.UInt16)
  init(_ v: Swift.Int16)
  init(_ v: Swift.UInt32)
  init(_ v: Swift.Int32)
  init(_ v: Swift.UInt64)
  init(_ v: Swift.Int64)
  init(_ v: Swift.UInt)
  init(_ v: Swift.Int)
}
extension Double {
  init(_ other: Swift.Float)
  @inline(__always) init?(exactly other: Swift.Float)
  init(_ other: Swift.Double)
  @inline(__always) init?(exactly other: Swift.Double)
  init(_ other: Swift.Float80)
  @inline(__always) init?(exactly other: Swift.Float80)
}
extension Double : Strideable {
  func distance(to other: Swift.Double) -> Swift.Double
  func advanced(by amount: Swift.Double) -> Swift.Double
  typealias Stride = Swift.Double
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension Double : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Double : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Double : _CVarArgPassedAsDouble, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension Double {
  init(_ value: CoreGraphics.CGFloat)
}
extension Double : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Double?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Double?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Double
  typealias _ObjectiveCType = Foundation.NSNumber
}
protocol LazyCollectionProtocol : Collection, LazySequenceProtocol {
  associatedtype Elements : Collection = Self
}
extension LazyCollectionProtocol where Self : Collection, Elements : Collection {
  func filter(_ isIncluded: @escaping (Self.Elements.Iterator.Element) -> Swift.Bool) -> Swift.LazyFilterCollection<Self.Elements>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection {
  func filter(_ isIncluded: @escaping (Self.Elements.Iterator.Element) -> Swift.Bool) -> Swift.LazyFilterBidirectionalCollection<Self.Elements>
}
extension LazyCollectionProtocol {
  func flatMap<SegmentOfResult : Collection>(_ transform: @escaping (Self.Elements.Iterator.Element) -> SegmentOfResult) -> Swift.LazyCollection<Swift.FlattenCollection<Swift.LazyMapCollection<Self.Elements, SegmentOfResult>>>
  func flatMap<ElementOfResult>(_ transform: @escaping (Self.Elements.Iterator.Element) -> ElementOfResult?) -> Swift.LazyMapCollection<Swift.LazyFilterCollection<Swift.LazyMapCollection<Self.Elements, ElementOfResult?>>, ElementOfResult>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection {
  func flatMap<SegmentOfResult : Collection where SegmentOfResult : BidirectionalCollection>(_ transform: @escaping (Self.Elements.Iterator.Element) -> SegmentOfResult) -> Swift.LazyCollection<Swift.FlattenBidirectionalCollection<Swift.LazyMapBidirectionalCollection<Self.Elements, SegmentOfResult>>>
  func flatMap<ElementOfResult>(_ transform: @escaping (Self.Elements.Iterator.Element) -> ElementOfResult?) -> Swift.LazyMapBidirectionalCollection<Swift.LazyFilterBidirectionalCollection<Swift.LazyMapBidirectionalCollection<Self.Elements, ElementOfResult?>>, ElementOfResult>
}
extension LazyCollectionProtocol where Self : Collection, Elements : Collection, Iterator.Element : Collection, Elements.Iterator.Element : Collection, Iterator.Element == Elements.Iterator.Element {
  func joined() -> Swift.LazyCollection<Swift.FlattenCollection<Self.Elements>>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.LazyCollection<Swift.FlattenCollection<Self.Elements>>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection, Iterator.Element : BidirectionalCollection, Elements.Iterator.Element : BidirectionalCollection, Iterator.Element == Elements.Iterator.Element {
  func joined() -> Swift.LazyCollection<Swift.FlattenBidirectionalCollection<Self.Elements>>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.LazyCollection<Swift.FlattenBidirectionalCollection<Self.Elements>>
}
extension LazyCollectionProtocol where Elements == Self {
  var elements: Self {
    get {}
  }
}
extension LazyCollectionProtocol where Self : Collection, Elements : Collection {
  func map<U>(_ transform: @escaping (Self.Elements.Iterator.Element) -> U) -> Swift.LazyMapCollection<Self.Elements, U>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection {
  func map<U>(_ transform: @escaping (Self.Elements.Iterator.Element) -> U) -> Swift.LazyMapBidirectionalCollection<Self.Elements, U>
}
extension LazyCollectionProtocol where Self : RandomAccessCollection, Elements : RandomAccessCollection {
  func map<U>(_ transform: @escaping (Self.Elements.Iterator.Element) -> U) -> Swift.LazyMapRandomAccessCollection<Self.Elements, U>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection {
  func reversed() -> Swift.LazyBidirectionalCollection<Swift.ReversedCollection<Self.Elements>>
}
extension LazyCollectionProtocol where Self : RandomAccessCollection, Elements : RandomAccessCollection {
  func reversed() -> Swift.LazyRandomAccessCollection<Swift.ReversedRandomAccessCollection<Self.Elements>>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection {
  @available(*, unavailable, renamed: "reversed()") func reverse() -> Swift.LazyCollection<Swift.ReversedCollection<Self.Elements>>
}
extension LazyCollectionProtocol where Self : RandomAccessCollection, Elements : RandomAccessCollection {
  @available(*, unavailable, renamed: "reversed()") func reverse() -> Swift.LazyCollection<Swift.ReversedRandomAccessCollection<Self.Elements>>
}
@_silgen_name("swift_stdlib_NSStringHasSuffixNFDPointer") func _stdlib_NSStringHasSuffixNFDPointer(_ theString: Swift.OpaquePointer, _ suffix: Swift.OpaquePointer) -> Swift.Bool
func _dictionaryUpCast<DerivedKey, DerivedValue, BaseKey, BaseValue>(_ source: [DerivedKey : DerivedValue]) -> [BaseKey : BaseValue]
@_silgen_name("swift_objc_class_unknownGetInstanceExtents") func swift_objc_class_unknownGetInstanceExtents(_ theClass: Swift.AnyClass) -> (negative: Swift.UInt, positive: Swift.UInt)
class _AnyRandomAccessCollectionBox<Element> : Swift._AnyBidirectionalCollectionBox<Element> {
  override func _dropFirst(_ n: Swift.Int) -> Swift._AnyRandomAccessCollectionBox<Element>
  override func _dropLast(_ n: Swift.Int) -> Swift._AnyRandomAccessCollectionBox<Element>
  override func _prefix(_ maxLength: Swift.Int) -> Swift._AnyRandomAccessCollectionBox<Element>
  override func _suffix(_ maxLength: Swift.Int) -> Swift._AnyRandomAccessCollectionBox<Element>
  func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (Element) throws -> Swift.Bool) rethrows -> [Swift.AnyRandomAccessCollection<Element>]
  override subscript(start start: _AnyIndexBox, end end: _AnyIndexBox) -> Swift._AnyRandomAccessCollectionBox<Element> {
    override get {}
  }
  init(_startIndex: _AnyIndexBox, endIndex: _AnyIndexBox)
  @objc deinit
}
struct _ClassMirror : _Mirror {
  let data: Swift._MagicMirrorData
  var value: Any {
    get {}
  }
  var valueType: Any.Type {
    get {}
  }
  var objectIdentifier: Swift.ObjectIdentifier? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  subscript(i: Swift.Int) -> (Swift.String, _Mirror) {
    get {}
  }
  var summary: Swift.String {
    get {}
  }
  var quickLookObject: Swift.PlaygroundQuickLook? {
    get {}
  }
  var disposition: Swift._MirrorDisposition {
    get {}
  }
  init(data: Swift._MagicMirrorData)
}
@inline(never) func _abstract(file: Swift.StaticString = #file, line: Swift.UInt = #line) -> Swift.Never
@inline(never) func _arrayOutOfPlaceUpdate<_Buffer, Initializer where _Buffer : _ArrayBufferProtocol, Initializer : _PointerFunction, Initializer.Element == _Buffer.Element, _Buffer.Index == Int>(_ source: inout _Buffer, _ dest: inout Swift._ContiguousArrayBuffer<_Buffer.Element>, _ headCount: Swift.Int, _ newCount: Swift.Int, _ initializeNewElements: Initializer)
struct _HashingDetail {
  static var fixedSeedOverride: Swift.UInt64 {
    get {}
    set(newValue) {}
  }
  @_versioned static func getExecutionSeed() -> Swift.UInt64
  @_versioned static func hash16Bytes(_ low: Swift.UInt64, _ high: Swift.UInt64) -> Swift.UInt64
  init()
}
protocol CustomDebugStringConvertible {
  var debugDescription: Swift.String { get }
}
@objc protocol _NSCopying : _ShadowProtocol {
  @objc(copyWithZone:) func copy(with zone: Swift._SwiftNSZone?) -> AnyObject
}
@available(*, unavailable) final class VaListBuilder {
  @objc deinit
  init()
}
@available(*, unavailable, renamed: "MemoryLayout.stride(ofValue:)") func strideofValue<T>(_: T) -> Swift.Int
@available(*, unavailable, renamed: "IteratorOverOne") struct GeneratorOfOne<Element> {
  init()
}
struct _StringCore {
  var _baseAddress: Swift.UnsafeMutableRawPointer?
  var _countAndFlags: Swift.UInt
  var _owner: AnyObject?
  init(baseAddress: Swift.UnsafeMutableRawPointer?, _countAndFlags: Swift.UInt, owner: AnyObject?)
  func _invariantCheck()
  var _countMask: Swift.UInt {
    get {}
  }
  var _flagMask: Swift.UInt {
    get {}
  }
  var _highByteMultiplier: Swift.UTF16.CodeUnit {
    get {}
  }
  func _pointer(toElementAt n: Swift.Int) -> Swift.UnsafeMutableRawPointer
  static func _copyElements(_ srcStart: Swift.UnsafeMutableRawPointer, srcElementWidth: Swift.Int, dstStart: Swift.UnsafeMutableRawPointer, dstElementWidth: Swift.Int, count: Swift.Int)
  init(baseAddress: Swift.UnsafeMutableRawPointer?, count: Swift.Int, elementShift: Swift.Int, hasCocoaBuffer: Swift.Bool, owner: AnyObject?)
  init(_ buffer: Swift._StringBuffer)
  init()
  var count: Swift.Int {
    get {}
    set(newValue) {}
  }
  var elementShift: Swift.Int {
    get {}
  }
  var elementWidth: Swift.Int {
    get {}
  }
  var hasContiguousStorage: Swift.Bool {
    get {}
  }
  var hasCocoaBuffer: Swift.Bool {
    get {}
  }
  var startASCII: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit> {
    get {}
  }
  var isASCII: Swift.Bool {
    get {}
  }
  var startUTF16: Swift.UnsafeMutablePointer<Swift.UTF16.CodeUnit> {
    get {}
  }
  var nativeBuffer: Swift._StringBuffer? {
    get {}
  }
  var cocoaBuffer: Swift._CocoaString? {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift._StringCore {
    get {}
  }
  @_versioned func _nthContiguous(_ position: Swift.Int) -> Swift.UTF16.CodeUnit
  subscript(position: Swift.Int) -> Swift.UTF16.CodeUnit {
    @inline(__always) get {}
  }
  func encode<Encoding : UnicodeCodec>(_ encoding: Encoding.Type, into processCodeUnit: (Encoding.CodeUnit) -> Swift.Void)
  mutating func _claimCapacity(_ newSize: Swift.Int, minElementWidth: Swift.Int) -> (Swift.Int, Swift.UnsafeMutableRawPointer?)
  mutating func _growBuffer(_ newSize: Swift.Int, minElementWidth: Swift.Int) -> Swift.UnsafeMutableRawPointer
  mutating func _copyInPlace(newSize: Swift.Int, newCapacity: Swift.Int, minElementWidth: Swift.Int)
  mutating func append(_ c: Swift.UnicodeScalar)
  mutating func append(_ u: Swift.UTF16.CodeUnit)
  mutating func append(_ u0: Swift.UTF16.CodeUnit, _ u1: Swift.UTF16.CodeUnit?)
  @inline(never) mutating func append(_ rhs: Swift._StringCore)
  func isRepresentableAsASCII() -> Swift.Bool
}
extension _StringCore {
  typealias _UTF8Chunk = Swift.UInt64
  func _encodeSomeUTF8(from i: Swift.Int) -> (Swift.Int, Swift._StringCore._UTF8Chunk)
  func _encodeSomeContiguousUTF16AsUTF8(from i: Swift.Int) -> (Swift.Int, Swift._StringCore._UTF8Chunk)
  func _encodeSomeNonContiguousUTF16AsUTF8(from i: Swift.Int) -> (Swift.Int, Swift._StringCore._UTF8Chunk)
}
extension _StringCore : RandomAccessCollection {
  typealias Indices = Swift.CountableRange<Swift.Int>
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  typealias Index = Swift.Int
  typealias _Element = Swift.UTF16.CodeUnit
  typealias SubSequence = Swift._StringCore
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift._StringCore>
}
extension _StringCore : RangeReplaceableCollection {
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == UTF16.CodeUnit>(_ bounds: Swift.Range<Swift.Int>, with newElements: C)
  mutating func reserveCapacity(_ n: Swift.Int)
  mutating func append<S : Sequence where S.Iterator.Element == UTF16.CodeUnit>(contentsOf s: S)
}
protocol TextOutputStreamable {
  func write<Target : TextOutputStream>(to target: inout Target)
}
extension TextOutputStreamable {
  @available(*, unavailable, renamed: "write(to:)") func writeTo<Target : TextOutputStream>(_ target: inout Target)
}
protocol _StringElement {
  static func _toUTF16CodeUnit(_: Self) -> Swift.UTF16.CodeUnit
  static func _fromUTF16CodeUnit(_ utf16: Swift.UTF16.CodeUnit) -> Self
}
final class _SequenceBox<S : Sequence where S.SubSequence : Sequence, S.SubSequence.Iterator.Element == S.Iterator.Element, S.SubSequence.SubSequence == S.SubSequence> : Swift._AnySequenceBox<S.Iterator.Element> {
  typealias Element = S.Iterator.Element
  override final func _makeIterator() -> Swift.AnyIterator<S.Iterator.Element>
  override final var _underestimatedCount: Swift.Int {
    override final get {}
  }
  override final func _map<T>(_ transform: (S.Iterator.Element) throws -> T) rethrows -> [T]
  override final func _filter(_ isIncluded: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [S.Iterator.Element]
  override final func _forEach(_ body: (S.Iterator.Element) throws -> Swift.Void) rethrows
  override final func __customContainsEquatableElement(_ element: S.Iterator.Element) -> Swift.Bool?
  override final func __preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  override final func __copyToContiguousArray() -> Swift.ContiguousArray<S.Iterator.Element>
  override final func __copyContents(initializing ptr: Swift.UnsafeMutablePointer<S.Iterator.Element>) -> Swift.UnsafeMutablePointer<S.Iterator.Element>
  override final func _dropFirst(_ n: Swift.Int) -> Swift._AnySequenceBox<S.Iterator.Element>
  override final func _dropLast(_ n: Swift.Int) -> Swift._AnySequenceBox<S.Iterator.Element>
  override final func _prefix(_ maxLength: Swift.Int) -> Swift._AnySequenceBox<S.Iterator.Element>
  override final func _suffix(_ maxLength: Swift.Int) -> Swift._AnySequenceBox<S.Iterator.Element>
  override final func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnySequence<S.Iterator.Element>]
  init(_base: S)
  final var _base: S
  @objc deinit
  init()
}
struct Int64 : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(bigEndian value: Swift.Int64)
  init(littleEndian value: Swift.Int64)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  var bigEndian: Swift.Int64 {
    get {}
  }
  var littleEndian: Swift.Int64 {
    get {}
  }
  var byteSwapped: Swift.Int64 {
    get {}
  }
  static var max: Swift.Int64 {
    get {}
  }
  static var min: Swift.Int64 {
    get {}
  }
  static var _sizeInBits: Swift.Int64 {
    get {}
  }
  static var _sizeInBytes: Swift.Int64 {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int64
  typealias Stride = Swift.Int
}
extension Int64 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int64 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int64 {
  static func addWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int64 : SignedNumber {
}
extension Int64 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to Int64 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension Int64 {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int64 will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int64 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to Int64 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension Int64 {
  init(_ value: Swift.Int16)
  @available(*, message: "Converting Int16 to Int64 will always succeed.") init?(exactly value: Swift.Int16)
}
extension Int64 {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to Int64 will always succeed.") init?(exactly value: Swift.UInt32)
}
extension Int64 {
  init(_ value: Swift.Int32)
  @available(*, message: "Converting Int32 to Int64 will always succeed.") init?(exactly value: Swift.Int32)
}
extension Int64 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
}
extension Int64 {
  init(_ value: Swift.Int64)
  @available(*, message: "Converting Int64 to Int64 will always succeed.") init?(exactly value: Swift.Int64)
}
extension Int64 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
}
extension Int64 {
  init(_ value: Swift.Int)
  @available(*, message: "Converting Int to Int64 will always succeed.") init?(exactly value: Swift.Int)
}
extension Int64 {
  init(bitPattern: Swift.UInt64)
}
extension Int64 : BitwiseOperations {
  static var allZeros: Swift.Int64 {
    get {}
  }
}
extension Int64 {
  typealias _DisabledRangeIndex = Swift.Int64
}
extension Int64 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int64 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int64 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int64 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Swift.IntMax : MirrorPath {
}
extension Int64 : CVarArg, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension Int64 {
  init(_ value: CoreGraphics.CGFloat)
}
struct _OpaqueMirror : _Mirror {
  let data: Swift._MagicMirrorData
  var value: Any {
    get {}
  }
  var valueType: Any.Type {
    get {}
  }
  var objectIdentifier: Swift.ObjectIdentifier? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  subscript(i: Swift.Int) -> (Swift.String, _Mirror) {
    get {}
  }
  var summary: Swift.String {
    get {}
  }
  var quickLookObject: Swift.PlaygroundQuickLook? {
    get {}
  }
  var disposition: Swift._MirrorDisposition {
    get {}
  }
  init(data: Swift._MagicMirrorData)
}
protocol RangeReplaceableCollection : RangeReplaceableIndexable, Collection {
  init()
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_ subrange: Swift.Range<Self.Index>, with newElements: C)
  mutating func reserveCapacity(_ n: Self.IndexDistance)
  init(repeating repeatedValue: Self.Iterator.Element, count: Swift.Int)
  init<S : Sequence where S.Iterator.Element == Iterator.Element>(_ elements: S)
  mutating func append(_ newElement: Self.Iterator.Element)
  mutating func append<S : Sequence where S.Iterator.Element == Iterator.Element>(contentsOf newElements: S)
  mutating func insert(_ newElement: Self.Iterator.Element, at i: Self.Index)
  mutating func insert<S : Collection where S.Iterator.Element == Iterator.Element>(contentsOf newElements: S, at i: Self.Index)
  @discardableResult mutating func remove(at i: Self.Index) -> Self.Iterator.Element
  mutating func _customRemoveLast() -> Self.Iterator.Element?
  mutating func _customRemoveLast(_ n: Swift.Int) -> Swift.Bool
  @discardableResult mutating func removeFirst() -> Self.Iterator.Element
  mutating func removeFirst(_ n: Swift.Int)
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool)
}
extension RangeReplaceableCollection {
  convenience init(repeating repeatedValue: Self.Iterator.Element, count: Swift.Int)
  convenience init<S : Sequence where S.Iterator.Element == Iterator.Element>(_ elements: S)
  mutating func append(_ newElement: Self.Iterator.Element)
  mutating func append<S : Sequence where S.Iterator.Element == Iterator.Element>(contentsOf newElements: S)
  mutating func insert(_ newElement: Self.Iterator.Element, at i: Self.Index)
  mutating func insert<C : Collection where C.Iterator.Element == Iterator.Element>(contentsOf newElements: C, at i: Self.Index)
  @discardableResult mutating func remove(at position: Self.Index) -> Self.Iterator.Element
  mutating func removeSubrange(_ bounds: Swift.Range<Self.Index>)
  mutating func removeFirst(_ n: Swift.Int)
  @discardableResult mutating func removeFirst() -> Self.Iterator.Element
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
  mutating func reserveCapacity(_ n: Self.IndexDistance)
}
extension RangeReplaceableCollection where SubSequence == Self {
  @discardableResult mutating func removeFirst() -> Self.Iterator.Element
  mutating func removeFirst(_ n: Swift.Int)
}
extension RangeReplaceableCollection where Index : Strideable, Index.Stride : SignedInteger {
  func _makeHalfOpen(_ r: Swift.CountableRange<Self.Index>) -> Swift.Range<Self.Index>
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_ subrange: Swift.CountableRange<Self.Index>, with newElements: C)
  mutating func removeSubrange(_ bounds: Swift.CountableRange<Self.Index>)
}
extension RangeReplaceableCollection {
  func _makeHalfOpen(_ r: Swift.ClosedRange<Self.Index>) -> Swift.Range<Self.Index>
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_ subrange: Swift.ClosedRange<Self.Index>, with newElements: C)
  mutating func removeSubrange(_ bounds: Swift.ClosedRange<Self.Index>)
}
extension RangeReplaceableCollection where Index : Strideable, Index.Stride : SignedInteger {
  func _makeHalfOpen(_ r: Swift.CountableClosedRange<Self.Index>) -> Swift.Range<Self.Index>
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_ subrange: Swift.CountableClosedRange<Self.Index>, with newElements: C)
  mutating func removeSubrange(_ bounds: Swift.CountableClosedRange<Self.Index>)
}
extension RangeReplaceableCollection {
  mutating func _customRemoveLast() -> Self.Iterator.Element?
  mutating func _customRemoveLast(_ n: Swift.Int) -> Swift.Bool
}
extension RangeReplaceableCollection where Self : BidirectionalCollection, SubSequence == Self {
  mutating func _customRemoveLast() -> Self.Iterator.Element?
  mutating func _customRemoveLast(_ n: Swift.Int) -> Swift.Bool
}
extension RangeReplaceableCollection where Self : BidirectionalCollection {
  @discardableResult mutating func removeLast() -> Self.Iterator.Element
  mutating func removeLast(_ n: Swift.Int)
}
extension RangeReplaceableCollection where Self : BidirectionalCollection, SubSequence == Self {
  @discardableResult mutating func removeLast() -> Self.Iterator.Element
  mutating func removeLast(_ n: Swift.Int)
}
extension RangeReplaceableCollection {
  @available(*, unavailable, renamed: "replaceSubrange(_:with:)") mutating func replaceRange<C where C : Collection, C.Iterator.Element == Iterator.Element>(_ subrange: Swift.Range<Self.Index>, with newElements: C)
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ i: Self.Index) -> Self.Iterator.Element
  @available(*, unavailable, renamed: "removeSubrange") mutating func removeRange(_ subrange: Swift.Range<Self.Index>)
  @available(*, unavailable, renamed: "append(contentsOf:)") mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Iterator.Element>(_ newElements: S)
  @available(*, unavailable, renamed: "insert(contentsOf:at:)") mutating func insertContentsOf<C : Collection where C.Iterator.Element == Iterator.Element>(_ newElements: C, at i: Self.Index)
}
struct CountableRange<Bound where Bound : _Strideable & Comparable, Bound.Stride : SignedInteger> : RandomAccessCollection {
  let lowerBound: Bound
  let upperBound: Bound
  typealias Element = Bound
  typealias Index = Bound
  typealias IndexDistance = Bound.Stride
  var startIndex: Bound {
    get {}
  }
  var endIndex: Bound {
    get {}
  }
  func index(after i: Bound) -> Bound
  func index(before i: Bound) -> Bound
  func index(_ i: Bound, offsetBy n: Bound.Stride) -> Bound
  func distance(from start: Bound, to end: Bound) -> Bound.Stride
  typealias SubSequence = Swift.CountableRange<Bound>
  subscript(bounds: Swift.Range<Bound>) -> Swift.CountableRange<Bound> {
    get {}
  }
  subscript(bounds: Swift.CountableRange<Bound>) -> Swift.CountableRange<Bound> {
    get {}
  }
  typealias Indices = Swift.CountableRange<Bound>
  var indices: Swift.CountableRange<Bound> {
    get {}
  }
  init(uncheckedBounds bounds: (lower: Bound, upper: Bound))
  func _customContainsEquatableElement(_ element: Bound) -> Swift.Bool?
  var isEmpty: Swift.Bool {
    get {}
  }
  typealias _Element = Bound
  typealias Iterator = Swift.IndexingIterator<Swift.CountableRange<Bound>>
}
extension CountableRange : Equatable {
  static func ==(lhs: Swift.CountableRange<Bound>, rhs: Swift.CountableRange<Bound>) -> Swift.Bool
  static func ~=(pattern: Swift.CountableRange<Bound>, value: Bound) -> Swift.Bool
}
extension CountableRange {
  subscript(position: Bound) -> Bound {
    get {}
  }
  subscript(_position: Bound._DisabledRangeIndex) -> Bound {
    get {}
  }
}
extension CountableRange where Bound._DisabledRangeIndex : Strideable, Bound._DisabledRangeIndex.Stride : SignedInteger {
  subscript(_bounds: Swift.Range<Bound._DisabledRangeIndex>) -> Swift.CountableRange<Bound> {
    get {}
  }
  subscript(_bounds: Swift.CountableRange<Bound._DisabledRangeIndex>) -> Swift.CountableRange<Bound> {
    get {}
  }
  subscript(_bounds: Swift.ClosedRange<Bound._DisabledRangeIndex>) -> Swift.CountableRange<Bound> {
    get {}
  }
  subscript(_bounds: Swift.CountableClosedRange<Bound._DisabledRangeIndex>) -> Swift.CountableRange<Bound> {
    get {}
  }
  subscript(bounds: Swift.ClosedRange<Bound>) -> Swift.CountableRange<Bound> {
    get {}
  }
  subscript(bounds: Swift.CountableClosedRange<Bound>) -> Swift.CountableRange<Bound> {
    get {}
  }
}
extension CountableRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.Range<Bound>)
}
extension CountableRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.Range<Bound>) -> Swift.Bool
}
extension CountableRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.CountableRange<Bound>)
}
extension CountableRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.CountableRange<Bound>) -> Swift.Bool
}
extension CountableRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.ClosedRange<Bound>)
}
extension CountableRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.ClosedRange<Bound>) -> Swift.Bool
}
extension CountableRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.CountableClosedRange<Bound>)
}
extension CountableRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.CountableClosedRange<Bound>) -> Swift.Bool
}
extension CountableRange {
  @inline(__always) func clamped(to limits: Swift.CountableRange<Bound>) -> Swift.CountableRange<Bound>
}
extension CountableRange : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension CountableRange : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension CountableRange : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
struct Int16 : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int16
  init()
  init(_ _v: Builtin.Int16)
  init(_bits: Builtin.Int16)
  init(bigEndian value: Swift.Int16)
  init(littleEndian value: Swift.Int16)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int16)
  var bigEndian: Swift.Int16 {
    get {}
  }
  var littleEndian: Swift.Int16 {
    get {}
  }
  var byteSwapped: Swift.Int16 {
    get {}
  }
  static var max: Swift.Int16 {
    get {}
  }
  static var min: Swift.Int16 {
    get {}
  }
  static var _sizeInBits: Swift.Int16 {
    get {}
  }
  static var _sizeInBytes: Swift.Int16 {
    get {}
  }
  typealias Stride = Swift.Int
  typealias IntegerLiteralType = Swift.Int16
}
extension Int16 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int16 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int16 {
  static func addWithOverflow(_ lhs: Swift.Int16, _ rhs: Swift.Int16) -> (Swift.Int16, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int16, _ rhs: Swift.Int16) -> (Swift.Int16, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int16, _ rhs: Swift.Int16) -> (Swift.Int16, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int16, _ rhs: Swift.Int16) -> (Swift.Int16, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int16, _ rhs: Swift.Int16) -> (Swift.Int16, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int16 : SignedNumber {
}
extension Int16 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to Int16 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension Int16 {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int16 will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int16 {
  init(_ value: Swift.UInt16)
  init?(exactly value: Swift.UInt16)
}
extension Int16 {
  init(_ value: Swift.Int16)
  @available(*, message: "Converting Int16 to Int16 will always succeed.") init?(exactly value: Swift.Int16)
}
extension Int16 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
  init(truncatingBitPattern: Swift.UInt32)
}
extension Int16 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
  init(truncatingBitPattern: Swift.Int32)
}
extension Int16 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension Int16 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension Int16 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension Int16 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension Int16 {
  init(bitPattern: Swift.UInt16)
}
extension Int16 : BitwiseOperations {
  static var allZeros: Swift.Int16 {
    get {}
  }
}
extension Int16 {
  typealias _DisabledRangeIndex = Swift.Int16
}
extension Int16 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int16 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int16 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int16 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Int16 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension Int16 {
  init(_ value: CoreGraphics.CGFloat)
}
struct AnyIndex {
  init<BaseIndex : Comparable>(_ base: BaseIndex)
  init(_box: _AnyIndexBox)
  var _typeID: Swift.ObjectIdentifier {
    get {}
  }
  var _box: _AnyIndexBox
}
extension AnyIndex : Comparable {
  static func ==(lhs: Swift.AnyIndex, rhs: Swift.AnyIndex) -> Swift.Bool
  static func <(lhs: Swift.AnyIndex, rhs: Swift.AnyIndex) -> Swift.Bool
}
protocol Sequence {
  associatedtype Iterator : IteratorProtocol
  associatedtype SubSequence
  func makeIterator() -> Self.Iterator
  var underestimatedCount: Swift.Int { get }
  func map<T>(_ transform: (Self.Iterator.Element) throws -> T) rethrows -> [T]
  func filter(_ isIncluded: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.Iterator.Element]
  func forEach(_ body: (Self.Iterator.Element) throws -> Swift.Void) rethrows
  func dropFirst(_ n: Swift.Int) -> Self.SubSequence
  func dropLast(_ n: Swift.Int) -> Self.SubSequence
  func prefix(_ maxLength: Swift.Int) -> Self.SubSequence
  func suffix(_ maxLength: Swift.Int) -> Self.SubSequence
  func split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.SubSequence]
  func first(where predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
  func _customContainsEquatableElement(_ element: Self.Iterator.Element) -> Swift.Bool?
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Iterator.Element>
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Self.Iterator.Element>) -> Swift.UnsafeMutablePointer<Self.Iterator.Element>
}
extension Sequence {
  func map<T>(_ transform: (Self.Iterator.Element) throws -> T) rethrows -> [T]
  func filter(_ isIncluded: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.Iterator.Element]
  func suffix(_ maxLength: Swift.Int) -> Swift.AnySequence<Self.Iterator.Element>
  func split(maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default, whereSeparator isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnySequence<Self.Iterator.Element>]
  var underestimatedCount: Swift.Int {
    get {}
  }
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func _customContainsEquatableElement(_ element: Self.Iterator.Element) -> Swift.Bool?
  func forEach(_ body: (Self.Iterator.Element) throws -> Swift.Void) rethrows
}
extension Sequence {
  func first(where predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
}
extension Sequence {
  func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Iterator.Element>
}
extension Sequence {
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Self.Iterator.Element>) -> Swift.UnsafeMutablePointer<Self.Iterator.Element>
}
extension Sequence where Self : _ArrayProtocol, Self.Element == Self.Iterator.Element {
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Self.Element>) -> Swift.UnsafeMutablePointer<Self.Element>
}
extension Sequence where Self.Iterator.Element : Comparable {
  func sorted() -> [Self.Iterator.Element]
}
extension Sequence {
  func sorted(by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool) -> [Self.Iterator.Element]
}
extension Sequence {
  @available(*, unavailable, renamed: "sorted(by:)") func sort(_ isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool) -> [Self.Iterator.Element]
}
extension Sequence where Iterator.Element : Comparable {
  @available(*, unavailable, renamed: "sorted()") func sort() -> [Self.Iterator.Element]
}
extension Sequence where Iterator.Element : Sequence {
  func joined() -> Swift.FlattenSequence<Self>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.FlattenSequence<Self>
}
extension Sequence where Iterator.Element : Sequence {
  func joined<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(separator: Separator) -> Swift.JoinedSequence<Self>
}
extension Sequence where Iterator.Element : Sequence {
  @available(*, unavailable, renamed: "joined(separator:)") func joinWithSeparator<Separator : Sequence where Separator.Iterator.Element == Iterator.Element.Iterator.Element>(_ separator: Separator) -> Swift.JoinedSequence<Self>
}
extension Sequence {
  var lazy: Swift.LazySequence<Self> {
    get {}
  }
}
extension Sequence where Self.Iterator == Self, Self : IteratorProtocol {
  func makeIterator() -> Self
}
extension Sequence where Iterator.Element : Equatable {
  func split(separator: Self.Iterator.Element, maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default) -> [Swift.AnySequence<Self.Iterator.Element>]
}
extension Sequence where SubSequence : Sequence, SubSequence.Iterator.Element == Iterator.Element, SubSequence.SubSequence == SubSequence {
  func dropFirst(_ n: Swift.Int) -> Swift.AnySequence<Self.Iterator.Element>
  func dropLast(_ n: Swift.Int) -> Swift.AnySequence<Self.Iterator.Element>
  func prefix(_ maxLength: Swift.Int) -> Swift.AnySequence<Self.Iterator.Element>
}
extension Sequence {
  func dropFirst() -> Self.SubSequence
  func dropLast() -> Self.SubSequence
}
extension Sequence {
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Self.Iterator
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
  @available(*, unavailable, message: "call 'split(maxSplits:omittingEmptySubsequences:whereSeparator:)' and invert the 'allowEmptySlices' argument") func split(_ maxSplit: Swift.Int, allowEmptySlices: Swift.Bool, isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.SubSequence]
}
extension Sequence where Iterator.Element : Equatable {
  @available(*, unavailable, message: "call 'split(separator:maxSplits:omittingEmptySubsequences:)' and invert the 'allowEmptySlices' argument") func split(_ separator: Self.Iterator.Element, maxSplit: Swift.Int = default, allowEmptySlices: Swift.Bool = default) -> [Swift.AnySequence<Self.Iterator.Element>]
}
extension Sequence {
  func enumerated() -> Swift.EnumeratedSequence<Self>
}
extension Sequence {
  @warn_unqualified_access func min(by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
  @warn_unqualified_access func max(by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
}
extension Sequence where Iterator.Element : Comparable {
  @warn_unqualified_access func min() -> Self.Iterator.Element?
  @warn_unqualified_access func max() -> Self.Iterator.Element?
}
extension Sequence {
  func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(with possiblePrefix: PossiblePrefix, by areEquivalent: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Sequence where Iterator.Element : Equatable {
  func starts<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(with possiblePrefix: PossiblePrefix) -> Swift.Bool
}
extension Sequence {
  func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence, by areEquivalent: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Sequence where Iterator.Element : Equatable {
  func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence) -> Swift.Bool
}
extension Sequence {
  func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence, by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Sequence where Iterator.Element : Comparable {
  func lexicographicallyPrecedes<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence) -> Swift.Bool
}
extension Sequence where Iterator.Element : Equatable {
  func contains(_ element: Self.Iterator.Element) -> Swift.Bool
}
extension Sequence {
  func contains(where predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Sequence {
  func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Self.Iterator.Element) throws -> Result) rethrows -> Result
}
extension Sequence {
  func reversed() -> [Self.Iterator.Element]
}
extension Sequence {
  func flatMap<SegmentOfResult : Sequence>(_ transform: (Self.Iterator.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Iterator.Element]
}
extension Sequence {
  func flatMap<ElementOfResult>(_ transform: (Self.Iterator.Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult]
}
extension Sequence {
  @available(*, unavailable, renamed: "enumerated()") func enumerate() -> Swift.EnumeratedSequence<Self>
  @available(*, unavailable, renamed: "min(by:)") func minElement(_ isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
  @available(*, unavailable, renamed: "max(by:)") func maxElement(_ isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Iterator.Element?
  @available(*, unavailable, renamed: "reversed()") func reverse() -> [Self.Iterator.Element]
  @available(*, unavailable, renamed: "starts(with:by:)") func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(_ possiblePrefix: PossiblePrefix, isEquivalent: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
  @available(*, unavailable, renamed: "elementsEqual(_:by:)") func elementsEqual<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence, isEquivalent: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
  @available(*, unavailable, renamed: "lexicographicallyPrecedes(_:by:)") func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence, isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
  @available(*, unavailable, renamed: "contains(where:)") func contains(_ predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Swift.Bool
  @available(*, unavailable, renamed: "reduce(_:_:)") func reduce<Result>(_ initial: Result, combine: (Result, Self.Iterator.Element) throws -> Result) rethrows -> Result
}
extension Sequence where Iterator.Element : Comparable {
  @available(*, unavailable, renamed: "min()") func minElement() -> Self.Iterator.Element?
  @available(*, unavailable, renamed: "max()") func maxElement() -> Self.Iterator.Element?
  @available(*, unavailable, renamed: "starts(with:)") func startsWith<PossiblePrefix where PossiblePrefix : Sequence, PossiblePrefix.Iterator.Element == Iterator.Element>(_ possiblePrefix: PossiblePrefix) -> Swift.Bool
  @available(*, unavailable, renamed: "lexicographicallyPrecedes") func lexicographicalCompare<OtherSequence where OtherSequence : Sequence, OtherSequence.Iterator.Element == Iterator.Element>(_ other: OtherSequence) -> Swift.Bool
}
extension Sequence where Self : _SequenceWrapper, Self.Iterator == Self.Base.Iterator {
  func makeIterator() -> Self.Iterator
  func map<T>(_ transform: (Self.Iterator.Element) throws -> T) rethrows -> [T]
  func filter(_ isIncluded: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.Iterator.Element]
  func _customContainsEquatableElement(_ element: Self.Iterator.Element) -> Swift.Bool?
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Iterator.Element>
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Self.Iterator.Element>) -> Swift.UnsafeMutablePointer<Self.Iterator.Element>
}
extension Sequence where Iterator.Element == String {
  func joined(separator: Swift.String = default) -> Swift.String
}
extension Sequence where Iterator.Element == String {
  @available(*, unavailable, renamed: "joined(separator:)") func joinWithSeparator(_ separator: Swift.String) -> Swift.String
}
enum UnicodeDecodingResult : Equatable {
  case scalarValue(Swift.UnicodeScalar)
  case emptyInput
  case error
  static func ==(lhs: Swift.UnicodeDecodingResult, rhs: Swift.UnicodeDecodingResult) -> Swift.Bool
}
@inline(__always) func _getSuperclass(_ t: Swift.AnyClass) -> Swift.AnyClass?
@inline(__always) func _getSuperclass(_ t: Any.Type) -> Swift.AnyClass?
protocol CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook { get }
}
func _setBridgeFromObjectiveC<ObjCValue, SwiftValue>(_ source: Swift.Set<ObjCValue>) -> Swift.Set<SwiftValue>
@_silgen_name("swift_stdlib_NSObject_isEqual") func _stdlib_NSObject_isEqual(_ lhs: AnyObject, _ rhs: AnyObject) -> Swift.Bool
struct Int32 : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int32
  init()
  init(_ _v: Builtin.Int32)
  init(_bits: Builtin.Int32)
  init(bigEndian value: Swift.Int32)
  init(littleEndian value: Swift.Int32)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int32)
  var bigEndian: Swift.Int32 {
    get {}
  }
  var littleEndian: Swift.Int32 {
    get {}
  }
  var byteSwapped: Swift.Int32 {
    get {}
  }
  static var max: Swift.Int32 {
    get {}
  }
  static var min: Swift.Int32 {
    get {}
  }
  static var _sizeInBits: Swift.Int32 {
    get {}
  }
  static var _sizeInBytes: Swift.Int32 {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int32
  typealias Stride = Swift.Int
}
extension Int32 : SignedNumber {
}
extension Int32 : BitwiseOperations {
  static var allZeros: Swift.Int32 {
    get {}
  }
}
extension Int32 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int32 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int32 {
  static func addWithOverflow(_ lhs: Swift.Int32, _ rhs: Swift.Int32) -> (Swift.Int32, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int32, _ rhs: Swift.Int32) -> (Swift.Int32, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int32, _ rhs: Swift.Int32) -> (Swift.Int32, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int32, _ rhs: Swift.Int32) -> (Swift.Int32, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int32, _ rhs: Swift.Int32) -> (Swift.Int32, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int32 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to Int32 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension Int32 {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int32 will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int32 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to Int32 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension Int32 {
  init(_ value: Swift.Int16)
  @available(*, message: "Converting Int16 to Int32 will always succeed.") init?(exactly value: Swift.Int16)
}
extension Int32 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
}
extension Int32 {
  init(_ value: Swift.Int32)
  @available(*, message: "Converting Int32 to Int32 will always succeed.") init?(exactly value: Swift.Int32)
}
extension Int32 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension Int32 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension Int32 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension Int32 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension Int32 {
  init(bitPattern: Swift.UInt32)
}
extension Int32 {
  typealias _DisabledRangeIndex = Swift.Int32
}
extension Int32 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int32 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int32 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int32 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Int32 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension Int32 {
  init(_ value: CoreGraphics.CGFloat)
}
struct MutableRangeReplaceableBidirectionalSlice<Base : BidirectionalIndexable & MutableIndexable & RangeReplaceableIndexable> : BidirectionalCollection, MutableCollection, RangeReplaceableCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
    set(newValue) {}
  }
  typealias SubSequence = Swift.MutableRangeReplaceableBidirectionalSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.MutableRangeReplaceableBidirectionalSlice<Base> {
    get {}
    set(newValue) {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(before i: Base.Index) -> Base.Index
  func formIndex(before i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init()
  init(repeating repeatedValue: Base._Element, count: Swift.Int)
  init<S where S : Sequence, S.Iterator.Element == Base._Element>(_ elements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_ subRange: Swift.Range<Base.Index>, with newElements: C)
  mutating func insert(_ newElement: Base._Element, at i: Base.Index)
  mutating func insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf newElements: S, at i: Base.Index)
  mutating func remove(at i: Base.Index) -> Base._Element
  mutating func removeSubrange(_ bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  var _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.MutableRangeReplaceableBidirectionalSlice<Base>>
  typealias Indices = Swift.DefaultBidirectionalIndices<Swift.MutableRangeReplaceableBidirectionalSlice<Base>>
}
struct LazyMapSequence<Base : Sequence, Element> : LazySequenceProtocol {
  typealias Elements = Swift.LazyMapSequence<Base, Element>
  func makeIterator() -> Swift.LazyMapIterator<Base.Iterator, Element>
  var underestimatedCount: Swift.Int {
    get {}
  }
  init(_base: Base, transform: @escaping (Base.Iterator.Element) -> Element)
  var _base: Base
  let _transform: (Base.Iterator.Element) -> Element
  typealias Iterator = Swift.LazyMapIterator<Base.Iterator, Element>
  typealias SubSequence = Swift.AnySequence<Element>
}
extension LazyMapSequence {
  @available(*, unavailable, message: "use '.lazy.map' on the sequence") init(_ base: Base, transform: (Base.Iterator.Element) -> Element)
}
struct _ArrayBuffer<Element> : _ArrayBufferProtocol {
  init()
  init(nsArray: _NSArrayCore)
  func cast<U>(toBufferOf _: U.Type) -> Swift._ArrayBuffer<U>
  var deferredTypeCheckMask: Swift.Int {
    get {}
  }
  func downcast<U>(toBufferWithDeferredTypeCheckOf _: U.Type) -> Swift._ArrayBuffer<U>
  var needsElementTypeCheck: Swift.Bool {
    get {}
  }
  init(storage: Swift._ArrayBridgeStorage)
  var _storage: Swift._ArrayBridgeStorage
  typealias Index = Swift.Int
  typealias _Element = Element
  typealias SubSequence = Swift._SliceBuffer<Element>
  typealias Element = Element
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift._ArrayBuffer<Element>>
}
extension _ArrayBuffer {
  init(_ source: Swift._ContiguousArrayBuffer<Element>, shiftedToStartIndex: Swift.Int)
  var arrayPropertyIsNativeTypeChecked: Swift.Bool {
    get {}
  }
  mutating func isUniquelyReferenced() -> Swift.Bool
  mutating func isUniquelyReferencedOrPinned() -> Swift.Bool
  func _asCocoaArray() -> _NSArrayCore
  mutating func requestUniqueMutableBackingBuffer(minimumCapacity: Swift.Int) -> Swift._ContiguousArrayBuffer<Element>?
  mutating func isMutableAndUniquelyReferenced() -> Swift.Bool
  mutating func isMutableAndUniquelyReferencedOrPinned() -> Swift.Bool
  func requestNativeBuffer() -> Swift._ContiguousArrayBuffer<Element>?
  @inline(never) func _typeCheckSlowPath(_ index: Swift.Int)
  func _typeCheck(_ subRange: Swift.Range<Swift.Int>)
  @discardableResult func _copyContents(subRange bounds: Swift.Range<Swift.Int>, initializing target: Swift.UnsafeMutablePointer<Element>) -> Swift.UnsafeMutablePointer<Element>
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift._SliceBuffer<Element> {
    get {}
    set(newValue) {}
  }
  var firstElementAddress: Swift.UnsafeMutablePointer<Element> {
    get {}
  }
  var firstElementAddressIfContiguous: Swift.UnsafeMutablePointer<Element>? {
    get {}
  }
  var count: Swift.Int {
    @inline(__always) get {}
    set(newValue) {}
  }
  func _checkInoutAndNativeBounds(_ index: Swift.Int, wasNative: Swift.Bool)
  func _checkInoutAndNativeTypeCheckedBounds(_ index: Swift.Int, wasNativeTypeChecked: Swift.Bool)
  var capacity: Swift.Int {
    get {}
  }
  @_versioned @inline(__always) func getElement(_ i: Swift.Int, wasNativeTypeChecked: Swift.Bool) -> Element
  @_versioned @inline(never) func _getElementSlowPath(_ i: Swift.Int) -> AnyObject
  subscript(i: Swift.Int) -> Element {
    get {}
    set(newValue) {}
  }
  func withUnsafeBufferPointer<R>(_ body: (Swift.UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
  mutating func withUnsafeMutableBufferPointer<R>(_ body: (Swift.UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
  var owner: AnyObject {
    get {}
  }
  var nativeOwner: AnyObject {
    get {}
  }
  var identity: Swift.UnsafeRawPointer {
    get {}
  }
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  typealias Indices = Swift.CountableRange<Swift.Int>
  typealias Storage = Swift._ContiguousArrayStorage<Element>
  typealias NativeBuffer = Swift._ContiguousArrayBuffer<Element>
  @_versioned var _isNative: Swift.Bool {
    get {}
  }
  var _isNativeTypeChecked: Swift.Bool {
    get {}
  }
  @_versioned var _native: Swift._ContiguousArrayBuffer<Element> {
    get {}
  }
  @_versioned var _nativeTypeChecked: Swift._ContiguousArrayBuffer<Element> {
    get {}
  }
  @_versioned var _nonNative: _NSArrayCore {
    @inline(__always) get {}
  }
}
@_versioned @inline(__always) func _isClassOrObjCExistential<T>(_ x: T.Type) -> Swift.Bool
struct _CollectionOf<IndexType : Strideable, Element> : Collection {
  init(_startIndex: IndexType, endIndex: IndexType, _ subscriptImpl: @escaping (IndexType) -> Element)
  func makeIterator() -> Swift.AnyIterator<Element>
  let startIndex: IndexType
  let endIndex: IndexType
  func index(after i: IndexType) -> IndexType
  subscript(i: IndexType) -> Element {
    get {}
  }
  let _subscriptImpl: (IndexType) -> Element
  typealias Index = IndexType
  typealias _Element = Element
  typealias SubSequence = Swift.Slice<Swift._CollectionOf<IndexType, Element>>
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.AnyIterator<Element>
  typealias Indices = Swift.DefaultIndices<Swift._CollectionOf<IndexType, Element>>
}
@objc_non_lazy_realization @objc final class _EmptyArrayStorage : Swift._ContiguousArrayStorageBase {
  @objc init(_doNotCallMe: ())
  final var countAndCapacity: Swift._ArrayBody
  override final func _withVerbatimBridgedUnsafeBuffer<R>(_ body: (Swift.UnsafeBufferPointer<AnyObject>) throws -> R) rethrows -> R?
  override final func _getNonVerbatimBridgedCount(_ dummy: Swift.Void) -> Swift.Int
  override final func _getNonVerbatimBridgedHeapBuffer(_ dummy: Swift.Void) -> Swift._HeapBuffer<Swift.Int, AnyObject>
  override final func canStoreElements(ofDynamicType _: Any.Type) -> Swift.Bool
  override final var staticElementType: Any.Type {
    override final get {}
  }
  @objc init()
  @objc deinit
}
struct RandomAccessSlice<Base : RandomAccessIndexable> : RandomAccessCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
  }
  typealias SubSequence = Swift.RandomAccessSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.RandomAccessSlice<Base> {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(before i: Base.Index) -> Base.Index
  func formIndex(before i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  let _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.RandomAccessSlice<Base>>
  typealias Indices = Swift.DefaultRandomAccessIndices<Swift.RandomAccessSlice<Base>>
}
enum Optional<Wrapped> : ExpressibleByNilLiteral {
  case none
  case some(Wrapped)
  init(_ some: Wrapped)
  func map<U>(_ transform: (Wrapped) throws -> U) rethrows -> U?
  func flatMap<U>(_ transform: (Wrapped) throws -> U?) rethrows -> U?
  init(nilLiteral: ())
  var unsafelyUnwrapped: Wrapped {
    @inline(__always) get {}
  }
  var _unsafelyUnwrappedUnchecked: Wrapped {
    @inline(__always) get {}
  }
}
extension Optional {
  func unwrappedOrError() throws -> Wrapped
}
extension Optional : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Optional : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Optional {
  @available(*, unavailable, renamed: "none") static var None: Wrapped? {
    get {}
  }
  @available(*, unavailable, renamed: "some") static func Some(_ x: Wrapped) -> Wrapped?
}
extension Optional {
  func _withNilOrAddress<NSType : AnyObject, ResultType>(of object: inout NSType?, _ body: (Swift.AutoreleasingUnsafeMutablePointer<NSType?>?) -> ResultType) -> ResultType
}
@_silgen_name("_swift_anyHashableDownCastConditionalIndirect") func _anyHashableDownCastConditionalIndirect<T>(_ value: Swift.UnsafePointer<Swift.AnyHashable>, _ target: Swift.UnsafeMutablePointer<T>) -> Swift.Bool
func _forceBridgeFromObjectiveC<T>(_ x: AnyObject, _: T.Type) -> T
struct Int32 : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int32
  init()
  init(_ _v: Builtin.Int32)
  init(_bits: Builtin.Int32)
  init(bigEndian value: Swift.Int32)
  init(littleEndian value: Swift.Int32)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int32)
  var bigEndian: Swift.Int32 {
    get {}
  }
  var littleEndian: Swift.Int32 {
    get {}
  }
  var byteSwapped: Swift.Int32 {
    get {}
  }
  static var max: Swift.Int32 {
    get {}
  }
  static var min: Swift.Int32 {
    get {}
  }
  static var _sizeInBits: Swift.Int32 {
    get {}
  }
  static var _sizeInBytes: Swift.Int32 {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int32
  typealias Stride = Swift.Int
}
extension Int32 : SignedNumber {
}
extension Int32 : BitwiseOperations {
  static var allZeros: Swift.Int32 {
    get {}
  }
}
extension Int32 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int32 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int32 {
  static func addWithOverflow(_ lhs: Swift.Int32, _ rhs: Swift.Int32) -> (Swift.Int32, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int32, _ rhs: Swift.Int32) -> (Swift.Int32, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int32, _ rhs: Swift.Int32) -> (Swift.Int32, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int32, _ rhs: Swift.Int32) -> (Swift.Int32, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int32, _ rhs: Swift.Int32) -> (Swift.Int32, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int32 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to Int32 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension Int32 {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int32 will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int32 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to Int32 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension Int32 {
  init(_ value: Swift.Int16)
  @available(*, message: "Converting Int16 to Int32 will always succeed.") init?(exactly value: Swift.Int16)
}
extension Int32 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
}
extension Int32 {
  init(_ value: Swift.Int32)
  @available(*, message: "Converting Int32 to Int32 will always succeed.") init?(exactly value: Swift.Int32)
}
extension Int32 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension Int32 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension Int32 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension Int32 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension Int32 {
  init(bitPattern: Swift.UInt32)
}
extension Int32 {
  typealias _DisabledRangeIndex = Swift.Int32
}
extension Int32 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int32 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int32 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int32 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Int32 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension Int32 {
  init(_ value: CoreGraphics.CGFloat)
}
struct Int16 : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int16
  init()
  init(_ _v: Builtin.Int16)
  init(_bits: Builtin.Int16)
  init(bigEndian value: Swift.Int16)
  init(littleEndian value: Swift.Int16)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int16)
  var bigEndian: Swift.Int16 {
    get {}
  }
  var littleEndian: Swift.Int16 {
    get {}
  }
  var byteSwapped: Swift.Int16 {
    get {}
  }
  static var max: Swift.Int16 {
    get {}
  }
  static var min: Swift.Int16 {
    get {}
  }
  static var _sizeInBits: Swift.Int16 {
    get {}
  }
  static var _sizeInBytes: Swift.Int16 {
    get {}
  }
  typealias Stride = Swift.Int
  typealias IntegerLiteralType = Swift.Int16
}
extension Int16 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int16 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int16 {
  static func addWithOverflow(_ lhs: Swift.Int16, _ rhs: Swift.Int16) -> (Swift.Int16, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int16, _ rhs: Swift.Int16) -> (Swift.Int16, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int16, _ rhs: Swift.Int16) -> (Swift.Int16, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int16, _ rhs: Swift.Int16) -> (Swift.Int16, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int16, _ rhs: Swift.Int16) -> (Swift.Int16, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int16 : SignedNumber {
}
extension Int16 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to Int16 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension Int16 {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int16 will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int16 {
  init(_ value: Swift.UInt16)
  init?(exactly value: Swift.UInt16)
}
extension Int16 {
  init(_ value: Swift.Int16)
  @available(*, message: "Converting Int16 to Int16 will always succeed.") init?(exactly value: Swift.Int16)
}
extension Int16 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
  init(truncatingBitPattern: Swift.UInt32)
}
extension Int16 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
  init(truncatingBitPattern: Swift.Int32)
}
extension Int16 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension Int16 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension Int16 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension Int16 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension Int16 {
  init(bitPattern: Swift.UInt16)
}
extension Int16 : BitwiseOperations {
  static var allZeros: Swift.Int16 {
    get {}
  }
}
extension Int16 {
  typealias _DisabledRangeIndex = Swift.Int16
}
extension Int16 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int16 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int16 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int16 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Int16 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension Int16 {
  init(_ value: CoreGraphics.CGFloat)
}
builtin floating-point type of width 80 bits
protocol _ExpressibleByBuiltinFloatLiteral {
  init(_builtinFloatLiteral value: Swift._MaxBuiltinFloatType)
}
struct LazyMapRandomAccessCollection<Base : RandomAccessCollection, Element> : LazyCollectionProtocol, RandomAccessCollection {
  typealias Index = Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(before i: Base.Index) -> Base.Index
  func formIndex(before i: inout Base.Index)
  subscript(position: Base.Index) -> Element {
    get {}
  }
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.RandomAccessSlice<Swift.LazyMapRandomAccessCollection<Base, Element>> {
    get {}
  }
  typealias IndexDistance = Base.IndexDistance
  typealias Indices = Base.Indices
  var indices: Base.Indices {
    get {}
  }
  var isEmpty: Swift.Bool {
    get {}
  }
  var count: Base.IndexDistance {
    get {}
  }
  var first: Element? {
    get {}
  }
  var last: Element? {
    get {}
  }
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func makeIterator() -> Swift.LazyMapIterator<Base.Iterator, Element>
  var underestimatedCount: Swift.Int {
    get {}
  }
  init(_base: Base, transform: @escaping (Base.Iterator.Element) -> Element)
  var _base: Base
  let _transform: (Base.Iterator.Element) -> Element
  typealias _Element = Element
  typealias SubSequence = Swift.RandomAccessSlice<Swift.LazyMapRandomAccessCollection<Base, Element>>
  typealias Elements = Swift.LazyMapRandomAccessCollection<Base, Element>
  typealias Iterator = Swift.LazyMapIterator<Base.Iterator, Element>
}
struct _ClassSuperMirror : _Mirror {
  let data: Swift._MagicMirrorData
  var value: Any {
    get {}
  }
  var valueType: Any.Type {
    get {}
  }
  var objectIdentifier: Swift.ObjectIdentifier? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  subscript(i: Swift.Int) -> (Swift.String, _Mirror) {
    get {}
  }
  var summary: Swift.String {
    get {}
  }
  var quickLookObject: Swift.PlaygroundQuickLook? {
    get {}
  }
  var disposition: Swift._MirrorDisposition {
    get {}
  }
  init(data: Swift._MagicMirrorData)
}
var _emptyArrayStorage: Swift._EmptyArrayStorage {
  get {}
}
struct Int8 : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int8
  init()
  init(_ _v: Builtin.Int8)
  init(_bits: Builtin.Int8)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int8)
  static var max: Swift.Int8 {
    get {}
  }
  static var min: Swift.Int8 {
    get {}
  }
  static var _sizeInBits: Swift.Int8 {
    get {}
  }
  static var _sizeInBytes: Swift.Int8 {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int8
  typealias Stride = Swift.Int
}
extension Int8 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int8 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int8 {
  static func addWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int8 : SignedNumber {
}
extension Int8 {
  init(_ value: Swift.UInt8)
  init?(exactly value: Swift.UInt8)
}
extension Int8 {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int8 will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int8 {
  init(_ value: Swift.UInt16)
  init?(exactly value: Swift.UInt16)
  init(truncatingBitPattern: Swift.UInt16)
}
extension Int8 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
  init(truncatingBitPattern: Swift.Int16)
}
extension Int8 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
  init(truncatingBitPattern: Swift.UInt32)
}
extension Int8 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
  init(truncatingBitPattern: Swift.Int32)
}
extension Int8 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension Int8 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension Int8 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension Int8 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension Int8 {
  init(bitPattern: Swift.UInt8)
}
extension Int8 : BitwiseOperations {
  static var allZeros: Swift.Int8 {
    get {}
  }
}
extension Int8 {
  typealias _DisabledRangeIndex = Swift.Int8
}
extension Int8 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int8 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int8 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int8 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Int8 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension Int8 {
  init(_ value: CoreGraphics.CGFloat)
}
@objc final class _NSContiguousString : Swift._SwiftNativeNSString {
  init(_ _core: Swift._StringCore)
  @objc init(coder aDecoder: AnyObject)
  @objc final func length() -> Swift.Int
  @objc final func characterAtIndex(_ index: Swift.Int) -> Swift.UInt16
  @inline(__always) @objc final func getCharacters(_ buffer: Swift.UnsafeMutablePointer<Swift.UInt16>, range aRange: SwiftShims._SwiftNSRange)
  @objc final func _fastCharacterContents() -> Swift.UnsafeMutablePointer<Swift.UInt16>?
  @objc final func substringFromIndex(_ start: Swift.Int) -> Swift._NSContiguousString
  @objc final func substringToIndex(_ end: Swift.Int) -> Swift._NSContiguousString
  @objc final func substringWithRange(_ aRange: SwiftShims._SwiftNSRange) -> Swift._NSContiguousString
  @objc final func copy() -> AnyObject
  @_semantics("self_no_escaping_closure") final func _unsafeWithNotEscapedSelfPointer<Result>(_ body: (Swift.OpaquePointer) throws -> Result) rethrows -> Result
  @_semantics("pair_no_escaping_closure") final func _unsafeWithNotEscapedSelfPointerPair<Result>(_ rhs: Swift._NSContiguousString, _ body: (Swift.OpaquePointer, Swift.OpaquePointer) throws -> Result) rethrows -> Result
  final let _core: Swift._StringCore
  @objc init()
  @objc deinit
}
struct UTF8 : UnicodeCodec {
  typealias CodeUnit = Swift.UInt8
  init()
  var _decodeBuffer: Swift.UInt32
  var _bitsInBuffer: Swift.UInt8
  mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> Swift.UnicodeDecodingResult
  static func _decodeOne(_ buffer: Swift.UInt32) -> (result: Swift.UInt32?, length: Swift.UInt8)
  static func encode(_ input: Swift.UnicodeScalar, into processCodeUnit: (Swift.UTF8.CodeUnit) -> Swift.Void)
  static func isContinuation(_ byte: Swift.UTF8.CodeUnit) -> Swift.Bool
  static func _nullCodeUnitOffset(in input: Swift.UnsafePointer<Swift.UTF8.CodeUnit>) -> Swift.Int
  static func _nullCodeUnitOffset(in input: Swift.UnsafePointer<Swift.CChar>) -> Swift.Int
}
func _isUnique_native<T>(_ object: inout T) -> Swift.Bool
@_silgen_name("swift_ClassMirror_count") func _getClassCount(_: Swift._MagicMirrorData) -> Swift.Int
struct ClosedRangeIndex<Bound where Bound : _Strideable & Comparable, Bound.Stride : SignedInteger> {
  init()
  init(_ x: Bound)
  var _value: Swift._ClosedRangeIndexRepresentation<Bound>
  var _dereferenced: Bound {
    get {}
  }
}
extension ClosedRangeIndex : Comparable {
  static func ==(lhs: Swift.ClosedRangeIndex<Bound>, rhs: Swift.ClosedRangeIndex<Bound>) -> Swift.Bool
  static func <(lhs: Swift.ClosedRangeIndex<Bound>, rhs: Swift.ClosedRangeIndex<Bound>) -> Swift.Bool
}
enum DictionaryIndexRepresentation<Key : Hashable, Value> {
  typealias _Index = Swift.DictionaryIndex<Key, Value>
  typealias _NativeIndex = Swift._NativeDictionaryIndex<Key, Value>
  typealias _CocoaIndex = Swift.DictionaryIndex._CocoaIndex
  case _native(Swift._NativeDictionaryIndex<Key, Value>)
  case _cocoa(Swift.DictionaryIndexRepresentation._CocoaIndex)
}
@available(*, unavailable, message: "Removed in Swift 3. Use Unmanaged.passUnretained(x).toOpaque() instead.") func unsafeAddress(of object: AnyObject) -> Swift.UnsafePointer<Swift.Void>
struct _UnmanagedAnyObjectArray {
  var value: Swift.UnsafeMutableRawPointer
  init(_ up: Swift.UnsafeMutablePointer<AnyObject>)
  init?(_ up: Swift.UnsafeMutablePointer<AnyObject>?)
  subscript(i: Swift.Int) -> AnyObject {
    get {}
    set(newValue) {}
  }
}
@objc @_swift_native_objc_runtime_base(_SwiftNativeNSDataBase) class _SwiftNativeNSData {
  @objc init()
  @objc deinit
}
struct UTF16 : UnicodeCodec {
  typealias CodeUnit = Swift.UInt16
  init()
  var _decodeLookahead: Swift.UInt16?
  mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> Swift.UnicodeDecodingResult
  @_versioned mutating func _decodeOne<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> (Swift.UnicodeDecodingResult, Swift.Int)
  static func encode(_ input: Swift.UnicodeScalar, into processCodeUnit: (Swift.UTF16.CodeUnit) -> Swift.Void)
}
extension UTF16 {
  static func width(_ x: Swift.UnicodeScalar) -> Swift.Int
  static func leadSurrogate(_ x: Swift.UnicodeScalar) -> Swift.UTF16.CodeUnit
  static func trailSurrogate(_ x: Swift.UnicodeScalar) -> Swift.UTF16.CodeUnit
  static func isLeadSurrogate(_ x: Swift.UTF16.CodeUnit) -> Swift.Bool
  static func isTrailSurrogate(_ x: Swift.UTF16.CodeUnit) -> Swift.Bool
  static func _copy<T : _StringElement, U : _StringElement>(source: Swift.UnsafeMutablePointer<T>, destination: Swift.UnsafeMutablePointer<U>, count: Swift.Int)
  static func transcodedLength<Input, Encoding where Input : IteratorProtocol, Encoding : UnicodeCodec, Encoding.CodeUnit == Input.Element>(of input: Input, decodedAs sourceEncoding: Encoding.Type, repairingIllFormedSequences: Swift.Bool) -> (count: Swift.Int, isASCII: Swift.Bool)?
}
extension UTF16 {
  @available(*, unavailable, message: "use 'transcodedLength(of:decodedAs:repairingIllFormedSequences:)'") static func measure<Encoding, Input where Encoding : UnicodeCodec, Input : IteratorProtocol, Encoding.CodeUnit == Input.Element>(_: Encoding.Type, input: Input, repairIllFormedSequences: Swift.Bool) -> (Swift.Int, Swift.Bool)?
}
final class _NativeSetStorageImpl<Element> : Swift.ManagedBuffer<Swift._HashedContainerStorageHeader, Swift.UInt8> {
  typealias BufferPointer = Swift.ManagedBufferPointer<Swift._HashedContainerStorageHeader, Swift.UInt8>
  typealias StorageImpl = Swift._NativeSetStorageImpl<Element>
  typealias Key = Element
  static func bytesForBitMap(capacity: Swift.Int) -> Swift.Int
  static func bytesForKeys(capacity: Swift.Int) -> Swift.Int
  final var buffer: Swift._NativeSetStorageImpl.BufferPointer {
    final get {}
  }
  final var _body: Swift._HashedContainerStorageHeader
  final var _body: Swift._HashedContainerStorageHeader {
    unsafeAddress {}
    unsafeMutableAddress {}
  }
  @_versioned final var _capacity: Swift.Int {
    final get {}
  }
  @_versioned final var _count: Swift.Int {
    final get {}
    final set(newValue) {}
  }
  final var _maxLoadFactorInverse: Swift.Double {
    final get {}
  }
  final var _initializedHashtableEntriesBitMapStorage: Swift.UnsafeMutablePointer<Swift.UInt> {
    final get {}
  }
  final var _keys: Swift.UnsafeMutablePointer<Element> {
    final get {}
  }
  final class func create(capacity: Swift.Int) -> Swift._NativeSetStorageImpl<Element>
  @objc deinit
  init(_doNotCallMe: ())
}
@_versioned @inline(never) @_semantics("stdlib_binary_only") func _cocoaStringSubscript(_ target: Swift._StringCore, _ position: Swift.Int) -> Swift.UTF16.CodeUnit
protocol ExpressibleByIntegerLiteral {
  associatedtype IntegerLiteralType : _ExpressibleByBuiltinIntegerLiteral
  init(integerLiteral value: Self.IntegerLiteralType)
}
func _getBool(_ v: Builtin.Int1) -> Swift.Bool
struct StrideThrough<Element : Strideable> : Sequence, CustomReflectable {
  func makeIterator() -> Swift.StrideThroughIterator<Element>
  init(_start: Element, end: Element, stride: Element.Stride)
  let _start: Element
  let _end: Element
  let _stride: Element.Stride
  var customMirror: Swift.Mirror {
    get {}
  }
  typealias Iterator = Swift.StrideThroughIterator<Element>
  typealias SubSequence = Swift.AnySequence<Element>
}
struct Int64 : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(bigEndian value: Swift.Int64)
  init(littleEndian value: Swift.Int64)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  var bigEndian: Swift.Int64 {
    get {}
  }
  var littleEndian: Swift.Int64 {
    get {}
  }
  var byteSwapped: Swift.Int64 {
    get {}
  }
  static var max: Swift.Int64 {
    get {}
  }
  static var min: Swift.Int64 {
    get {}
  }
  static var _sizeInBits: Swift.Int64 {
    get {}
  }
  static var _sizeInBytes: Swift.Int64 {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int64
  typealias Stride = Swift.Int
}
extension Int64 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int64 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int64 {
  static func addWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int64 : SignedNumber {
}
extension Int64 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to Int64 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension Int64 {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int64 will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int64 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to Int64 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension Int64 {
  init(_ value: Swift.Int16)
  @available(*, message: "Converting Int16 to Int64 will always succeed.") init?(exactly value: Swift.Int16)
}
extension Int64 {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to Int64 will always succeed.") init?(exactly value: Swift.UInt32)
}
extension Int64 {
  init(_ value: Swift.Int32)
  @available(*, message: "Converting Int32 to Int64 will always succeed.") init?(exactly value: Swift.Int32)
}
extension Int64 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
}
extension Int64 {
  init(_ value: Swift.Int64)
  @available(*, message: "Converting Int64 to Int64 will always succeed.") init?(exactly value: Swift.Int64)
}
extension Int64 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
}
extension Int64 {
  init(_ value: Swift.Int)
  @available(*, message: "Converting Int to Int64 will always succeed.") init?(exactly value: Swift.Int)
}
extension Int64 {
  init(bitPattern: Swift.UInt64)
}
extension Int64 : BitwiseOperations {
  static var allZeros: Swift.Int64 {
    get {}
  }
}
extension Int64 {
  typealias _DisabledRangeIndex = Swift.Int64
}
extension Int64 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int64 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int64 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int64 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Swift.IntMax : MirrorPath {
}
extension Int64 : CVarArg, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension Int64 {
  init(_ value: CoreGraphics.CGFloat)
}
func _preconditionFailure(_ message: Swift.StaticString = default, file: Swift.StaticString = #file, line: Swift.UInt = #line) -> Swift.Never
struct CVaListPointer {
  var value: Swift.UnsafeMutableRawPointer
  init(_fromUnsafeMutablePointer from: Swift.UnsafeMutableRawPointer)
}
extension CVaListPointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
struct IndexingIterator<Elements : IndexableBase> : IteratorProtocol, Sequence {
  init(_elements: Elements)
  mutating func next() -> Elements._Element?
  let _elements: Elements
  var _position: Elements.Index
  typealias Element = Elements._Element
  typealias Iterator = Swift.IndexingIterator<Elements>
  typealias SubSequence = Swift.AnySequence<Elements._Element>
}
protocol _Pointer {
  var _rawValue: Builtin.RawPointer { get }
  init(_ _rawValue: Builtin.RawPointer)
}
func _heapSort<C where C : MutableCollection & RandomAccessCollection>(_ elements: inout C, subRange range: Swift.Range<C.Index>, by areInIncreasingOrder: inout @escaping (C.Iterator.Element, C.Iterator.Element) -> Swift.Bool)
func _heapSort<C where C : MutableCollection & RandomAccessCollection, C.Iterator.Element : Comparable>(_ elements: inout C, subRange range: Swift.Range<C.Index>)
func _isBridgedToObjectiveC<T>(_: T.Type) -> Swift.Bool
struct DictionaryIndex<Key : Hashable, Value> : Comparable {
  typealias _NativeIndex = Swift._NativeDictionaryIndex<Key, Value>
  typealias _CocoaIndex = Swift._CocoaDictionaryIndex
  var _value: Swift.DictionaryIndexRepresentation<Key, Value>
  @_versioned static func _native(_ index: Swift._NativeDictionaryIndex<Key, Value>) -> Swift.DictionaryIndex<Key, Value>
  @_versioned static func _cocoa(_ index: Swift.DictionaryIndex._CocoaIndex) -> Swift.DictionaryIndex<Key, Value>
  @_versioned var _guaranteedNative: Swift.Bool {
    get {}
  }
  var _nativeIndex: Swift._NativeDictionaryIndex<Key, Value> {
    get {}
  }
  var _cocoaIndex: Swift.DictionaryIndex._CocoaIndex {
    get {}
  }
  func successor() -> Swift.DictionaryIndex<Key, Value>
  init(_value: Swift.DictionaryIndexRepresentation<Key, Value>)
}
extension DictionaryIndex {
  static func ==(lhs: Swift.DictionaryIndex<Key, Value>, rhs: Swift.DictionaryIndex<Key, Value>) -> Swift.Bool
  static func <(lhs: Swift.DictionaryIndex<Key, Value>, rhs: Swift.DictionaryIndex<Key, Value>) -> Swift.Bool
}
()
@_versioned func _isUnique<T>(_ object: inout T) -> Swift.Bool
func _stdlib_binary_CFStringCreateCopy(_ source: Swift._CocoaString) -> Swift._CocoaString
@available(*, unavailable, renamed: "IndexingIterator") struct RangeGenerator<Bound> {
  init()
}
func _stdlib_atomicCompareExchangeStrongInt32(object target: Swift.UnsafeMutablePointer<Swift.Int32>, expected: Swift.UnsafeMutablePointer<Swift.Int32>, desired: Swift.Int32) -> Swift.Bool
struct UTF32 : UnicodeCodec {
  typealias CodeUnit = Swift.UInt32
  init()
  mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> Swift.UnicodeDecodingResult
  static func _decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> Swift.UnicodeDecodingResult
  static func encode(_ input: Swift.UnicodeScalar, into processCodeUnit: (Swift.UTF32.CodeUnit) -> Swift.Void)
}
@_semantics("fastpath") func _fastPath(_ x: Swift.Bool) -> Swift.Bool
func _stdlib_atomicCompareExchangeStrongPtr(object target: Swift._PointerToPointer, expected: Swift._PointerToPointer, desired: Swift.UnsafeRawPointer?) -> Swift.Bool
func _stdlib_atomicCompareExchangeStrongPtr<T>(object target: Swift.UnsafeMutablePointer<Swift.UnsafeMutablePointer<T>>, expected: Swift.UnsafeMutablePointer<Swift.UnsafeMutablePointer<T>>, desired: Swift.UnsafeMutablePointer<T>) -> Swift.Bool
func _stdlib_atomicCompareExchangeStrongPtr<T>(object target: Swift.UnsafeMutablePointer<Swift.UnsafeMutablePointer<T>?>, expected: Swift.UnsafeMutablePointer<Swift.UnsafeMutablePointer<T>?>, desired: Swift.UnsafeMutablePointer<T>?) -> Swift.Bool
@available(*, unavailable, message: "use nested withUnsafeMutablePointer(to:_:) instead") func withUnsafeMutablePointers<A0, A1, Result>(_ arg0: inout A0, _ arg1: inout A1, _ body: (Swift.UnsafeMutablePointer<A0>, Swift.UnsafeMutablePointer<A1>) throws -> Result) rethrows -> Result
@available(*, unavailable, message: "use nested withUnsafeMutablePointer(to:_:) instead") func withUnsafeMutablePointers<A0, A1, A2, Result>(_ arg0: inout A0, _ arg1: inout A1, _ arg2: inout A2, _ body: (Swift.UnsafeMutablePointer<A0>, Swift.UnsafeMutablePointer<A1>, Swift.UnsafeMutablePointer<A2>) throws -> Result) rethrows -> Result
protocol BitwiseOperations {
  static func &(lhs: Self, rhs: Self) -> Self
  static func |(lhs: Self, rhs: Self) -> Self
  static func ^(lhs: Self, rhs: Self) -> Self
  prefix static func ~(x: Self) -> Self
  static var allZeros: Self { get }
}
struct UInt8 : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int8
  init()
  init(_ _v: Builtin.Int8)
  init(_bits: Builtin.Int8)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt8)
  static var max: Swift.UInt8 {
    get {}
  }
  static var min: Swift.UInt8 {
    get {}
  }
  static var _sizeInBits: Swift.UInt8 {
    get {}
  }
  static var _sizeInBytes: Swift.UInt8 {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt8
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt8 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt8 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt8 {
  static func addWithOverflow(_ lhs: Swift.UInt8, _ rhs: Swift.UInt8) -> (Swift.UInt8, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt8, _ rhs: Swift.UInt8) -> (Swift.UInt8, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt8, _ rhs: Swift.UInt8) -> (Swift.UInt8, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt8, _ rhs: Swift.UInt8) -> (Swift.UInt8, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt8, _ rhs: Swift.UInt8) -> (Swift.UInt8, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt8 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt8 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt8 {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt8 {
  init(_ value: Swift.UInt16)
  init?(exactly value: Swift.UInt16)
  init(truncatingBitPattern: Swift.UInt16)
}
extension UInt8 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
  init(truncatingBitPattern: Swift.Int16)
}
extension UInt8 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
  init(truncatingBitPattern: Swift.UInt32)
}
extension UInt8 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
  init(truncatingBitPattern: Swift.Int32)
}
extension UInt8 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension UInt8 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension UInt8 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension UInt8 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension UInt8 {
  init(bitPattern: Swift.Int8)
}
extension UInt8 : BitwiseOperations {
  static var allZeros: Swift.UInt8 {
    get {}
  }
}
extension UInt8 {
  typealias _DisabledRangeIndex = Swift.UInt8
}
extension UInt8 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt8 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt8 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt8 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Swift.UTF8.CodeUnit : _StringElement {
  static func _toUTF16CodeUnit(_ x: Swift.UTF8.CodeUnit) -> Swift.UTF16.CodeUnit
  static func _fromUTF16CodeUnit(_ utf16: Swift.UTF16.CodeUnit) -> Swift.UTF8.CodeUnit
}
extension UInt8 {
  init(ascii v: Swift.UnicodeScalar)
}
extension UInt8 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension UInt8 {
  init(_ value: CoreGraphics.CGFloat)
}
protocol Strideable : _Strideable, Comparable {
  associatedtype Stride : SignedNumber
  func distance(to other: Self) -> Self.Stride
  func advanced(by n: Self.Stride) -> Self
  static func _step(after current: (index: Swift.Int?, value: Self), from start: Self, by distance: Self.Stride) -> (index: Swift.Int?, value: Self)
  associatedtype _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension Strideable {
  static func _step(after current: (index: Swift.Int?, value: Self), from start: Self, by distance: Self.Stride) -> (index: Swift.Int?, value: Self)
}
extension Strideable where Stride : FloatingPoint {
  static func _step(after current: (index: Swift.Int?, value: Self), from start: Self, by distance: Self.Stride) -> (index: Swift.Int?, value: Self)
}
extension Strideable {
  @available(*, unavailable, message: "Use stride(from:to:by:) free function instead") func stride(to end: Self, by stride: Self.Stride) -> Swift.StrideTo<Self>
  @warn_unqualified_access @available(*, unavailable, message: "Use stride(from:through:by:) free function instead") func stride(through end: Self, by stride: Self.Stride) -> Swift.StrideThrough<Self>
}
@_silgen_name("swift_stdlib_getErrorCode") func _stdlib_getErrorCode<T : Error>(_ x: Swift.UnsafePointer<T>) -> Swift.Int
func _copySequenceToContiguousArray<S : Sequence>(_ source: S) -> Swift.ContiguousArray<S.Iterator.Element>
func _precondition(_ condition: @autoclosure () -> Swift.Bool, _ message: Swift.StaticString = default, file: Swift.StaticString = #file, line: Swift.UInt = #line)
func _forceCreateUniqueMutableBufferImpl<_Buffer : _ArrayBufferProtocol>(_ source: inout _Buffer, countForBuffer: Swift.Int, minNewCapacity: Swift.Int, requiredCapacity: Swift.Int) -> Swift._ContiguousArrayBuffer<_Buffer.Element>
func assert(_ condition: @autoclosure () -> Swift.Bool, _ message: @autoclosure () -> Swift.String = default, file: Swift.StaticString = #file, line: Swift.UInt = #line)
struct AnyCollection<Element> : _AnyCollectionProtocol, Collection {
  init(_box: Swift._AnyCollectionBox<Element>)
  init<C : Collection where C.Iterator.Element == Element, C.SubSequence : Collection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : Collection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : Collection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ base: C)
  init(_ other: Swift.AnyCollection<Element>)
  init<C : BidirectionalCollection where C.Iterator.Element == Element, C.SubSequence : BidirectionalCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : BidirectionalCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : BidirectionalCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ base: C)
  init(_ other: Swift.AnyBidirectionalCollection<Element>)
  init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ base: C)
  init(_ other: Swift.AnyRandomAccessCollection<Element>)
  typealias Index = Swift.AnyIndex
  typealias IndexDistance = Swift.IntMax
  var startIndex: Swift.AnyIndex {
    get {}
  }
  var endIndex: Swift.AnyIndex {
    get {}
  }
  subscript(position: Swift.AnyIndex) -> Element {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.AnyIndex>) -> Swift.AnyCollection<Element> {
    get {}
  }
  func _failEarlyRangeCheck(_ index: Swift.AnyIndex, bounds: Swift.Range<Swift.AnyIndex>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Swift.AnyCollection.Index>, bounds: Swift.Range<Swift.AnyCollection.Index>)
  func index(after i: Swift.AnyIndex) -> Swift.AnyIndex
  func formIndex(after i: inout Swift.AnyIndex)
  func index(_ i: Swift.AnyIndex, offsetBy n: Swift.IntMax) -> Swift.AnyIndex
  func index(_ i: Swift.AnyIndex, offsetBy n: Swift.IntMax, limitedBy limit: Swift.AnyIndex) -> Swift.AnyIndex?
  func formIndex(_ i: inout Swift.AnyIndex, offsetBy n: Swift.IntMax)
  func formIndex(_ i: inout Swift.AnyIndex, offsetBy n: Swift.IntMax, limitedBy limit: Swift.AnyIndex) -> Swift.Bool
  func distance(from start: Swift.AnyIndex, to end: Swift.AnyIndex) -> Swift.IntMax
  var count: Swift.IntMax {
    get {}
  }
  var first: Element? {
    get {}
  }
  var _boxID: Swift.ObjectIdentifier {
    get {}
  }
  let _box: Swift._AnyCollectionBox<Element>
  typealias _Element = Element
  typealias SubSequence = Swift.AnyCollection<Element>
  typealias Iterator = Swift.AnyIterator<Element>
  typealias Indices = Swift.DefaultIndices<Swift.AnyCollection<Element>>
}
extension AnyCollection {
  func makeIterator() -> Swift.AnyIterator<Element>
  var underestimatedCount: Swift.Int {
    get {}
  }
  func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
  func filter(_ isIncluded: (Element) throws -> Swift.Bool) rethrows -> [Element]
  func forEach(_ body: (Element) throws -> Swift.Void) rethrows
  func dropFirst(_ n: Swift.Int) -> Swift.AnyCollection<Element>
  func dropLast(_ n: Swift.Int) -> Swift.AnyCollection<Element>
  func prefix(_ maxLength: Swift.Int) -> Swift.AnyCollection<Element>
  func suffix(_ maxLength: Swift.Int) -> Swift.AnyCollection<Element>
  func split(maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default, whereSeparator isSeparator: (Element) throws -> Swift.Bool) rethrows -> [Swift.AnyCollection<Element>]
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Element>
  func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Element>) -> Swift.UnsafeMutablePointer<Element>
}
extension AnyCollection {
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
}
class _AnyBidirectionalCollectionBox<Element> : Swift._AnyCollectionBox<Element> {
  override func _dropFirst(_ n: Swift.Int) -> Swift._AnyBidirectionalCollectionBox<Element>
  override func _dropLast(_ n: Swift.Int) -> Swift._AnyBidirectionalCollectionBox<Element>
  override func _prefix(_ maxLength: Swift.Int) -> Swift._AnyBidirectionalCollectionBox<Element>
  override func _suffix(_ maxLength: Swift.Int) -> Swift._AnyBidirectionalCollectionBox<Element>
  func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (Element) throws -> Swift.Bool) rethrows -> [Swift.AnyBidirectionalCollection<Element>]
  override subscript(start start: _AnyIndexBox, end end: _AnyIndexBox) -> Swift._AnyBidirectionalCollectionBox<Element> {
    override get {}
  }
  func _index(before i: _AnyIndexBox) -> _AnyIndexBox
  func _formIndex(before i: _AnyIndexBox)
  var _last: Element? {
    get {}
  }
  init(_startIndex: _AnyIndexBox, endIndex: _AnyIndexBox)
  @objc deinit
}
func _dictionaryDownCast<BaseKey, BaseValue, DerivedKey, DerivedValue>(_ source: [BaseKey : BaseValue]) -> [DerivedKey : DerivedValue]
@_silgen_name("swift_EnumMirror_subscript") func _getEnumChild<T>(_: Swift.Int, _: Swift._MagicMirrorData) -> (T, _Mirror)
@_silgen_name("swift_stdlib_NSStringHasPrefixNFD") func _stdlib_NSStringHasPrefixNFD(_ theString: AnyObject, _ prefix: AnyObject) -> Swift.Bool
func numericCast<T : _SignedInteger, U : _SignedInteger>(_ x: T) -> U
func numericCast<T : UnsignedInteger, U : UnsignedInteger>(_ x: T) -> U
func numericCast<T : _SignedInteger, U : UnsignedInteger>(_ x: T) -> U
func numericCast<T : UnsignedInteger, U : _SignedInteger>(_ x: T) -> U
protocol ExpressibleByStringLiteral : ExpressibleByExtendedGraphemeClusterLiteral {
  associatedtype StringLiteralType : _ExpressibleByBuiltinStringLiteral
  init(stringLiteral value: Self.StringLiteralType)
}
struct SetIndex<Element : Hashable> : Comparable {
  typealias _NativeIndex = Swift._NativeSetIndex<Element>
  typealias _CocoaIndex = Swift._CocoaSetIndex
  typealias Key = Element
  typealias Value = Element
  var _value: Swift.SetIndexRepresentation<Element>
  @_versioned static func _native(_ index: Swift._NativeSetIndex<Element>) -> Swift.SetIndex<Element>
  @_versioned static func _cocoa(_ index: Swift.SetIndex._CocoaIndex) -> Swift.SetIndex<Element>
  @_versioned var _guaranteedNative: Swift.Bool {
    get {}
  }
  var _nativeIndex: Swift._NativeSetIndex<Element> {
    get {}
  }
  var _cocoaIndex: Swift.SetIndex._CocoaIndex {
    get {}
  }
  func successor() -> Swift.SetIndex<Element>
  init(_value: Swift.SetIndexRepresentation<Element>)
}
extension SetIndex {
  static func ==(lhs: Swift.SetIndex<Element>, rhs: Swift.SetIndex<Element>) -> Swift.Bool
  static func <(lhs: Swift.SetIndex<Element>, rhs: Swift.SetIndex<Element>) -> Swift.Bool
}
protocol OptionSet : SetAlgebra, RawRepresentable {
  associatedtype Element = Self
  init(rawValue: Self.RawValue)
}
extension OptionSet {
  func union(_ other: Self) -> Self
  func intersection(_ other: Self) -> Self
  func symmetricDifference(_ other: Self) -> Self
}
extension OptionSet where Element == Self {
  func contains(_ member: Self) -> Swift.Bool
  @discardableResult mutating func insert(_ newMember: Self) -> (inserted: Swift.Bool, memberAfterInsert: Self)
  @discardableResult mutating func remove(_ member: Self) -> Self?
  @discardableResult mutating func update(with newMember: Self) -> Self?
}
extension OptionSet where RawValue : BitwiseOperations {
  convenience init()
  mutating func formUnion(_ other: Self)
  mutating func formIntersection(_ other: Self)
  mutating func formSymmetricDifference(_ other: Self)
}
@_versioned @inline(__always) func _isObjCTaggedPointer(_ x: AnyObject) -> Swift.Bool
func _isValidArraySubscript(_ index: Swift.Int, count: Swift.Int) -> Swift.Bool
class _AnyIteratorBoxBase<Element> : IteratorProtocol {
  func next() -> Element?
  init()
  @objc deinit
  typealias Element = Element
}
func _float80ToString(_ value: Swift.Float80, debug: Swift.Bool) -> Swift.String
struct Float {
  var _value: Builtin.FPIEEE32
  init()
  init(_bits v: Builtin.FPIEEE32)
}
extension Float : LosslessStringConvertible {
  init?(_ text: Swift.String)
}
extension Float : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Float : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Float : BinaryFloatingPoint {
  typealias Exponent = Swift.Int
  typealias RawSignificand = Swift.UInt32
  static var exponentBitCount: Swift.Int {
    get {}
  }
  static var significandBitCount: Swift.Int {
    get {}
  }
  @_versioned static var _infinityExponent: Swift.UInt {
    @inline(__always) get {}
  }
  static var _exponentBias: Swift.UInt {
    @inline(__always) get {}
  }
  static var _significandMask: Swift.UInt32 {
    @inline(__always) get {}
  }
  @_versioned static var _quietNaNMask: Swift.UInt32 {
    @inline(__always) get {}
  }
  var bitPattern: Swift.UInt32 {
    get {}
  }
  init(bitPattern: Swift.UInt32)
  var sign: Swift.FloatingPointSign {
    get {}
  }
  @available(*, unavailable, renamed: "sign") var isSignMinus: Swift.Bool {
    get {}
  }
  var exponentBitPattern: Swift.UInt {
    get {}
  }
  var significandBitPattern: Swift.UInt32 {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponentBitPattern: Swift.UInt, significandBitPattern: Swift.UInt32)
  var isCanonical: Swift.Bool {
    get {}
  }
  static var infinity: Swift.Float {
    get {}
  }
  static var nan: Swift.Float {
    get {}
  }
  static var signalingNaN: Swift.Float {
    get {}
  }
  @available(*, unavailable, renamed: "nan") static var quietNaN: Swift.Float {
    get {}
  }
  static var greatestFiniteMagnitude: Swift.Float {
    get {}
  }
  static var pi: Swift.Float {
    get {}
  }
  var ulp: Swift.Float {
    get {}
  }
  static var leastNormalMagnitude: Swift.Float {
    get {}
  }
  static var leastNonzeroMagnitude: Swift.Float {
    get {}
  }
  var exponent: Swift.Int {
    get {}
  }
  var significand: Swift.Float {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponent: Swift.Int, significand: Swift.Float)
  init(nan payload: Swift.Float.RawSignificand, signaling: Swift.Bool)
  var nextUp: Swift.Float {
    get {}
  }
  mutating func round(_ rule: Swift.FloatingPointRoundingRule)
  mutating func negate()
  mutating func add(_ other: Swift.Float)
  mutating func subtract(_ other: Swift.Float)
  mutating func multiply(by other: Swift.Float)
  mutating func divide(by other: Swift.Float)
  mutating func formRemainder(dividingBy other: Swift.Float)
  mutating func formTruncatingRemainder(dividingBy other: Swift.Float)
  mutating func formSquareRoot()
  mutating func addProduct(_ lhs: Swift.Float, _ rhs: Swift.Float)
  func isEqual(to other: Swift.Float) -> Swift.Bool
  func isLess(than other: Swift.Float) -> Swift.Bool
  func isLessThanOrEqualTo(_ other: Swift.Float) -> Swift.Bool
  var isNormal: Swift.Bool {
    get {}
  }
  var isFinite: Swift.Bool {
    get {}
  }
  var isZero: Swift.Bool {
    get {}
  }
  var isSubnormal: Swift.Bool {
    get {}
  }
  var isInfinite: Swift.Bool {
    get {}
  }
  var isNaN: Swift.Bool {
    get {}
  }
  var isSignalingNaN: Swift.Bool {
    get {}
  }
  var binade: Swift.Float {
    get {}
  }
  var significandWidth: Swift.Int {
    get {}
  }
  init(floatLiteral value: Swift.Float)
  typealias FloatLiteralType = Swift.Float
  typealias RawExponent = Swift.UInt
}
extension Float : _ExpressibleByBuiltinIntegerLiteral, ExpressibleByIntegerLiteral {
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  typealias IntegerLiteralType = Swift.Int64
}
extension Float : _ExpressibleByBuiltinFloatLiteral {
  init(_builtinFloatLiteral value: Builtin.FPIEEE80)
}
extension Float : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension Float : AbsoluteValuable {
  static func abs(_ x: Swift.Float) -> Swift.Float
}
extension Float {
  init(_ v: Swift.UInt8)
  init(_ v: Swift.Int8)
  init(_ v: Swift.UInt16)
  init(_ v: Swift.Int16)
  init(_ v: Swift.UInt32)
  init(_ v: Swift.Int32)
  init(_ v: Swift.UInt64)
  init(_ v: Swift.Int64)
  init(_ v: Swift.UInt)
  init(_ v: Swift.Int)
}
extension Float {
  init(_ other: Swift.Float)
  @inline(__always) init?(exactly other: Swift.Float)
  init(_ other: Swift.Double)
  @inline(__always) init?(exactly other: Swift.Double)
  init(_ other: Swift.Float80)
  @inline(__always) init?(exactly other: Swift.Float80)
}
extension Float : Strideable {
  func distance(to other: Swift.Float) -> Swift.Float
  func advanced(by amount: Swift.Float) -> Swift.Float
  typealias Stride = Swift.Float
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension Float : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Float : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Float : _CVarArgPassedAsDouble, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension Float {
  init(_ value: CoreGraphics.CGFloat)
}
extension Float : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Float?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Float?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Float
  typealias _ObjectiveCType = Foundation.NSNumber
}
struct LazyFilterIndex<Base : Collection> {
  let base: Base.Index
  init(base: Base.Index)
}
extension LazyFilterIndex : Comparable {
  static func ==(lhs: Swift.LazyFilterIndex<Base>, rhs: Swift.LazyFilterIndex<Base>) -> Swift.Bool
  static func !=(lhs: Swift.LazyFilterIndex<Base>, rhs: Swift.LazyFilterIndex<Base>) -> Swift.Bool
  static func <(lhs: Swift.LazyFilterIndex<Base>, rhs: Swift.LazyFilterIndex<Base>) -> Swift.Bool
  static func <=(lhs: Swift.LazyFilterIndex<Base>, rhs: Swift.LazyFilterIndex<Base>) -> Swift.Bool
  static func >=(lhs: Swift.LazyFilterIndex<Base>, rhs: Swift.LazyFilterIndex<Base>) -> Swift.Bool
  static func >(lhs: Swift.LazyFilterIndex<Base>, rhs: Swift.LazyFilterIndex<Base>) -> Swift.Bool
}
@available(*, unavailable, renamed: "Repeated") struct Repeat<Element> {
  init()
}
func _setDownCastConditional<BaseValue, DerivedValue>(_ source: Swift.Set<BaseValue>) -> Swift.Set<DerivedValue>?
protocol SignedNumber : Comparable, ExpressibleByIntegerLiteral {
  prefix static func -(x: Self) -> Self
  static func -(lhs: Self, rhs: Self) -> Self
  static func ~>(_: Self, _: (Swift._Abs, ())) -> Self
}
protocol _SignedInteger : _Integer, SignedNumber {
  func toIntMax() -> Swift.IntMax
  init(_: Swift.IntMax)
}
struct MutableRangeReplaceableRandomAccessSlice<Base : MutableIndexable & RandomAccessIndexable & RangeReplaceableIndexable> : RandomAccessCollection, MutableCollection, RangeReplaceableCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
    set(newValue) {}
  }
  typealias SubSequence = Swift.MutableRangeReplaceableRandomAccessSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.MutableRangeReplaceableRandomAccessSlice<Base> {
    get {}
    set(newValue) {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(before i: Base.Index) -> Base.Index
  func formIndex(before i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init()
  init(repeating repeatedValue: Base._Element, count: Swift.Int)
  init<S where S : Sequence, S.Iterator.Element == Base._Element>(_ elements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_ subRange: Swift.Range<Base.Index>, with newElements: C)
  mutating func insert(_ newElement: Base._Element, at i: Base.Index)
  mutating func insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf newElements: S, at i: Base.Index)
  mutating func remove(at i: Base.Index) -> Base._Element
  mutating func removeSubrange(_ bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  var _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.MutableRangeReplaceableRandomAccessSlice<Base>>
  typealias Indices = Swift.DefaultRandomAccessIndices<Swift.MutableRangeReplaceableRandomAccessSlice<Base>>
}
protocol LazySequenceProtocol : Sequence {
  associatedtype Elements : Sequence = Self
  var elements: Self.Elements { get }
}
extension LazySequenceProtocol {
  func filter(_ isIncluded: @escaping (Self.Elements.Iterator.Element) -> Swift.Bool) -> Swift.LazyFilterSequence<Self.Elements>
}
extension LazySequenceProtocol {
  func flatMap<SegmentOfResult : Sequence>(_ transform: @escaping (Self.Elements.Iterator.Element) -> SegmentOfResult) -> Swift.LazySequence<Swift.FlattenSequence<Swift.LazyMapSequence<Self.Elements, SegmentOfResult>>>
  func flatMap<ElementOfResult>(_ transform: @escaping (Self.Elements.Iterator.Element) -> ElementOfResult?) -> Swift.LazyMapSequence<Swift.LazyFilterSequence<Swift.LazyMapSequence<Self.Elements, ElementOfResult?>>, ElementOfResult>
}
extension LazySequenceProtocol where Elements.Iterator.Element == Iterator.Element, Iterator.Element : Sequence {
  func joined() -> Swift.LazySequence<Swift.FlattenSequence<Self.Elements>>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.LazySequence<Swift.FlattenSequence<Self.Elements>>
}
extension LazySequenceProtocol where Elements == Self {
  var elements: Self {
    get {}
  }
}
extension LazySequenceProtocol {
  var lazy: Self {
    get {}
  }
}
extension LazySequenceProtocol {
  @available(*, unavailable, message: "Please use Array initializer instead.") var array: [Self.Iterator.Element] {
    get {}
  }
}
extension LazySequenceProtocol {
  func map<U>(_ transform: @escaping (Self.Elements.Iterator.Element) -> U) -> Swift.LazyMapSequence<Self.Elements, U>
}
@available(*, unavailable, renamed: "isKnownUniquelyReferenced") func isUniquelyReferenced<T>(_ object: inout T) -> Swift.Bool
func _int64ToString(_ value: Swift.Int64, radix: Swift.Int64 = default, uppercase: Swift.Bool = default) -> Swift.String
enum _MirrorDisposition {
  case `struct`
  case `class`
  case `enum`
  case tuple
  case aggregate
  case indexContainer
  case keyContainer
  case membershipContainer
  case container
  case optional
  case objCObject
  infix static func ==(a: Swift._MirrorDisposition, b: Swift._MirrorDisposition) -> Swift.Bool
  var hashValue: Swift.Int {
    get {}
  }
}
func _mixUInt32(_ value: Swift.UInt32) -> Swift.UInt32
struct _ConcreteHashableBox<Base : Hashable> : _AnyHashableBox {
  var _baseHashable: Base
  init(_ base: Base)
  var _typeID: Swift.ObjectIdentifier {
    get {}
  }
  func _unbox<T : Hashable>() -> T?
  func _isEqual(to rhs: _AnyHashableBox) -> Swift.Bool
  var _hashValue: Swift.Int {
    get {}
  }
  var _base: Any {
    get {}
  }
  func _downCastConditional<T>(into result: Swift.UnsafeMutablePointer<T>) -> Swift.Bool
}
class _DropFirstSequence<Base : IteratorProtocol> : Sequence, IteratorProtocol {
  var _iterator: Base
  final let _limit: Swift.Int
  var _dropped: Swift.Int
  init(_iterator: Base, limit: Swift.Int, dropped: Swift.Int = default)
  func makeIterator() -> Swift._DropFirstSequence<Base>
  func next() -> Base.Element?
  func dropFirst(_ n: Swift.Int) -> Swift.AnySequence<Base.Element>
  @objc deinit
  typealias Element = Base.Element
  typealias Iterator = Swift._DropFirstSequence<Base>
  typealias SubSequence = Swift.AnySequence<Base.Element>
}
func _isKnownUniquelyReferencedOrPinned<T : AnyObject>(_ object: inout T) -> Swift.Bool
struct UnsafeMutableRawPointer : Strideable, Hashable, _Pointer {
  let _rawValue: Builtin.RawPointer
  init(_ other: Swift.UnsafeMutableRawPointer)
  init?(_ other: Swift.UnsafeMutableRawPointer?)
  init(_ _rawValue: Builtin.RawPointer)
  init(_ other: Swift.OpaquePointer)
  init?(_ other: Swift.OpaquePointer?)
  init?(bitPattern: Swift.Int)
  init?(bitPattern: Swift.UInt)
  init<T>(_ other: Swift.UnsafeMutablePointer<T>)
  init?<T>(_ other: Swift.UnsafeMutablePointer<T>?)
  init(mutating other: Swift.UnsafeRawPointer)
  init?(mutating other: Swift.UnsafeRawPointer?)
  static func allocate(bytes size: Swift.Int, alignedTo: Swift.Int) -> Swift.UnsafeMutableRawPointer
  func deallocate(bytes: Swift.Int, alignedTo: Swift.Int)
  @discardableResult func bindMemory<T>(to type: T.Type, capacity count: Swift.Int) -> Swift.UnsafeMutablePointer<T>
  func assumingMemoryBound<T>(to: T.Type) -> Swift.UnsafeMutablePointer<T>
  @discardableResult func initializeMemory<T>(as type: T.Type, at index: Swift.Int = default, count: Swift.Int = default, to value: T) -> Swift.UnsafeMutablePointer<T>
  @discardableResult func initializeMemory<T>(as type: T.Type, from source: Swift.UnsafePointer<T>, count: Swift.Int) -> Swift.UnsafeMutablePointer<T>
  @discardableResult func initializeMemory<C : Collection>(as: C.Iterator.Element.Type, from source: C) -> Swift.UnsafeMutablePointer<C.Iterator.Element>
  @discardableResult func moveInitializeMemory<T>(as type: T.Type, from source: Swift.UnsafeMutablePointer<T>, count: Swift.Int) -> Swift.UnsafeMutablePointer<T>
  func load<T>(fromByteOffset offset: Swift.Int = default, as type: T.Type) -> T
  func storeBytes<T>(of value: T, toByteOffset offset: Swift.Int = default, as: T.Type)
  func copyBytes(from source: Swift.UnsafeRawPointer, count: Swift.Int)
  var hashValue: Swift.Int {
    get {}
  }
  func distance(to x: Swift.UnsafeMutableRawPointer) -> Swift.Int
  func advanced(by n: Swift.Int) -> Swift.UnsafeMutableRawPointer
  typealias Stride = Swift.Int
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension UnsafeMutableRawPointer {
  init<T>(_ other: Swift.AutoreleasingUnsafeMutablePointer<T>)
  init?<T>(_ other: Swift.AutoreleasingUnsafeMutablePointer<T>?)
}
extension UnsafeMutableRawPointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension UnsafeMutableRawPointer : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UnsafeMutableRawPointer : CustomPlaygroundQuickLookable {
  var summary: Swift.String {
    get {}
  }
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UnsafeMutableRawPointer {
  @available(*, unavailable, renamed: "init(mutating:)") init(_ from: Swift.UnsafeRawPointer)
  @available(*, unavailable, renamed: "init(mutating:)") init?(_ from: Swift.UnsafeRawPointer?)
  @available(*, unavailable, renamed: "init(mutating:)") init<T>(_ from: Swift.UnsafePointer<T>)
  @available(*, unavailable, renamed: "init(mutating:)") init?<T>(_ from: Swift.UnsafePointer<T>?)
}
func ===(lhs: AnyObject?, rhs: AnyObject?) -> Swift.Bool
@available(*, unavailable) func ===<L : _AnyCollectionProtocol, R : _AnyCollectionProtocol>(lhs: L, rhs: R) -> Swift.Bool
protocol IntegerArithmetic : _IntegerArithmetic, Comparable {
  static func +(lhs: Self, rhs: Self) -> Self
  static func -(lhs: Self, rhs: Self) -> Self
  static func *(lhs: Self, rhs: Self) -> Self
  static func /(lhs: Self, rhs: Self) -> Self
  static func %(lhs: Self, rhs: Self) -> Self
  func toIntMax() -> Swift.IntMax
}
func _stdlib_atomicCompareExchangeStrongInt64(object target: Swift.UnsafeMutablePointer<Swift.Int64>, expected: Swift.UnsafeMutablePointer<Swift.Int64>, desired: Swift.Int64) -> Swift.Bool
@_silgen_name("_swift_stdlib_makeAnyHashableUsingDefaultRepresentation") func _stdlib_makeAnyHashableUsingDefaultRepresentation<H : Hashable>(of value: H, storingResultInto result: Swift.UnsafeMutablePointer<Swift.AnyHashable>)
struct _StructMirror : _Mirror {
  let data: Swift._MagicMirrorData
  var value: Any {
    get {}
  }
  var valueType: Any.Type {
    get {}
  }
  var objectIdentifier: Swift.ObjectIdentifier? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  subscript(i: Swift.Int) -> (Swift.String, _Mirror) {
    get {}
  }
  var summary: Swift.String {
    get {}
  }
  var quickLookObject: Swift.PlaygroundQuickLook? {
    get {}
  }
  var disposition: Swift._MirrorDisposition {
    get {}
  }
  init(data: Swift._MagicMirrorData)
}
@available(*, unavailable, message: "use MemoryLayout<T>.alignment instead.") func alignof<T>(_: T.Type) -> Swift.Int
@_versioned @_semantics("branchhint") func _branchHint(_ actual: Swift.Bool, expected: Swift.Bool) -> Swift.Bool
func _diagnoseUnexpectedNilOptional(_filenameStart: Builtin.RawPointer, _filenameLength: Builtin.Word, _filenameIsASCII: Builtin.Int1, _line: Builtin.Word)
func _swift_stdlib_atomicFetchAddInt(object target: Swift.UnsafeMutablePointer<Swift.Int>, operand: Swift.Int) -> Swift.Int
struct LazyFilterBidirectionalCollection<Base : BidirectionalCollection> : LazyCollectionProtocol, BidirectionalCollection {
  typealias Index = Swift.LazyFilterIndex<Base>
  typealias IndexDistance = Base.IndexDistance
  init(_base: Base, _ isIncluded: @escaping (Base.Iterator.Element) -> Swift.Bool)
  var startIndex: Swift.LazyFilterIndex<Base> {
    get {}
  }
  var endIndex: Swift.LazyFilterIndex<Base> {
    get {}
  }
  func index(after i: Swift.LazyFilterIndex<Base>) -> Swift.LazyFilterIndex<Base>
  func formIndex(after i: inout Swift.LazyFilterIndex<Base>)
  func index(before i: Swift.LazyFilterIndex<Base>) -> Swift.LazyFilterIndex<Base>
  func formIndex(before i: inout Swift.LazyFilterIndex<Base>)
  subscript(position: Swift.LazyFilterIndex<Base>) -> Base.Iterator.Element {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.LazyFilterIndex<Base>>) -> Swift.BidirectionalSlice<Swift.LazyFilterBidirectionalCollection<Base>> {
    get {}
  }
  func makeIterator() -> Swift.LazyFilterIterator<Base.Iterator>
  var _base: Base
  let _predicate: (Base.Iterator.Element) -> Swift.Bool
  typealias _Element = Base.Iterator.Element
  typealias SubSequence = Swift.BidirectionalSlice<Swift.LazyFilterBidirectionalCollection<Base>>
  typealias Indices = Swift.DefaultBidirectionalIndices<Swift.LazyFilterBidirectionalCollection<Base>>
  typealias Elements = Swift.LazyFilterBidirectionalCollection<Base>
  typealias Iterator = Swift.LazyFilterIterator<Base.Iterator>
}
struct UInt32 : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int32
  init()
  init(_ _v: Builtin.Int32)
  init(_bits: Builtin.Int32)
  init(bigEndian value: Swift.UInt32)
  init(littleEndian value: Swift.UInt32)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt32)
  var bigEndian: Swift.UInt32 {
    get {}
  }
  var littleEndian: Swift.UInt32 {
    get {}
  }
  var byteSwapped: Swift.UInt32 {
    get {}
  }
  static var max: Swift.UInt32 {
    get {}
  }
  static var min: Swift.UInt32 {
    get {}
  }
  static var _sizeInBits: Swift.UInt32 {
    get {}
  }
  static var _sizeInBytes: Swift.UInt32 {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt32
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt32 : BitwiseOperations {
  static var allZeros: Swift.UInt32 {
    get {}
  }
}
extension UInt32 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt32 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt32 {
  static func addWithOverflow(_ lhs: Swift.UInt32, _ rhs: Swift.UInt32) -> (Swift.UInt32, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt32, _ rhs: Swift.UInt32) -> (Swift.UInt32, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt32, _ rhs: Swift.UInt32) -> (Swift.UInt32, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt32, _ rhs: Swift.UInt32) -> (Swift.UInt32, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt32, _ rhs: Swift.UInt32) -> (Swift.UInt32, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt32 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt32 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt32 {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt32 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to UInt32 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension UInt32 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
}
extension UInt32 {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to UInt32 will always succeed.") init?(exactly value: Swift.UInt32)
}
extension UInt32 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
}
extension UInt32 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension UInt32 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension UInt32 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension UInt32 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension UInt32 {
  init(bitPattern: Swift.Int32)
}
extension UInt32 {
  typealias _DisabledRangeIndex = Swift.UInt32
}
extension UInt32 {
  var signBitIndex: Swift.Int {
    get {}
  }
  var countTrailingZeros: Swift.Int {
    get {}
  }
}
extension UInt32 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt32 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt32 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt32 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UInt32 {
  init(_ v: Swift.UnicodeScalar)
}
extension UInt32 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension UInt32 {
  init(_ value: CoreGraphics.CGFloat)
}
struct _CocoaFastEnumerationStackBuf {
  var _item0: Swift.UnsafeRawPointer?
  var _item1: Swift.UnsafeRawPointer?
  var _item2: Swift.UnsafeRawPointer?
  var _item3: Swift.UnsafeRawPointer?
  var _item4: Swift.UnsafeRawPointer?
  var _item5: Swift.UnsafeRawPointer?
  var _item6: Swift.UnsafeRawPointer?
  var _item7: Swift.UnsafeRawPointer?
  var _item8: Swift.UnsafeRawPointer?
  var _item9: Swift.UnsafeRawPointer?
  var _item10: Swift.UnsafeRawPointer?
  var _item11: Swift.UnsafeRawPointer?
  var _item12: Swift.UnsafeRawPointer?
  var _item13: Swift.UnsafeRawPointer?
  var _item14: Swift.UnsafeRawPointer?
  var _item15: Swift.UnsafeRawPointer?
  var count: Swift.Int {
    get {}
  }
  init()
}
struct Range<Bound : Comparable> {
  @inline(__always) init(uncheckedBounds bounds: (lower: Bound, upper: Bound))
  let lowerBound: Bound
  let upperBound: Bound
  func contains(_ element: Bound) -> Swift.Bool
  var isEmpty: Swift.Bool {
    get {}
  }
}
extension Range : Equatable {
  static func ==(lhs: Swift.Range<Bound>, rhs: Swift.Range<Bound>) -> Swift.Bool
  static func ~=(pattern: Swift.Range<Bound>, value: Bound) -> Swift.Bool
}
extension Range {
  @inline(__always) init(_ other: Swift.Range<Bound>)
}
extension Range {
  @inline(__always) func overlaps(_ other: Swift.Range<Bound>) -> Swift.Bool
}
extension Range where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.CountableRange<Bound>)
}
extension Range where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.CountableRange<Bound>) -> Swift.Bool
}
extension Range where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.ClosedRange<Bound>)
}
extension Range {
  @inline(__always) func overlaps(_ other: Swift.ClosedRange<Bound>) -> Swift.Bool
}
extension Range where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.CountableClosedRange<Bound>)
}
extension Range where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.CountableClosedRange<Bound>) -> Swift.Bool
}
extension Range {
  @inline(__always) func clamped(to limits: Swift.Range<Bound>) -> Swift.Range<Bound>
}
extension Range : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Range : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Range : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Range where Bound : _Strideable, Bound.Stride : SignedInteger {
  var count: Bound.Stride {
    get {}
  }
}
extension Range {
  @available(*, unavailable, renamed: "lowerBound") var startIndex: Bound {
    get {}
  }
  @available(*, unavailable, renamed: "upperBound") var endIndex: Bound {
    get {}
  }
}
@objc final class _SwiftDeferredNSArray : Swift._SwiftNativeNSArrayWithContiguousStorage {
  @objc final var _heapBufferBridged_DoNotUse: AnyObject?
  @objc final let _nativeStorage: Swift._ContiguousArrayStorageBase
  @objc final var _heapBufferBridgedPtr: Swift.UnsafeMutablePointer<AnyObject?> {
    @objc final get {}
  }
  typealias HeapBufferStorage = Swift._HeapBufferStorage<Swift.Int, AnyObject>
  final var _heapBufferBridged: Swift._SwiftDeferredNSArray.HeapBufferStorage? {
    final get {}
  }
  @objc init(_nativeStorage: Swift._ContiguousArrayStorageBase)
  final func _destroyBridgedStorage(_ hb: Swift._SwiftDeferredNSArray.HeapBufferStorage?)
  @objc deinit
  override final func withUnsafeBufferOfObjects<R>(_ body: (Swift.UnsafeBufferPointer<AnyObject>) throws -> R) rethrows -> R
  @objc override dynamic var count: Swift.Int {
    @objc override dynamic get {}
  }
  @objc init()
}
@_versioned var _objectPointerIsObjCBit: Swift.UInt {
  @inline(__always) get {}
}
func _arrayForceCast<SourceElement, TargetElement>(_ source: [SourceElement]) -> [TargetElement]
struct String {
  init()
  init(_ _core: Swift._StringCore)
  var _core: Swift._StringCore
}
extension String {
  init(_ c: Swift.Character)
}
extension String {
  init(cString: Swift.UnsafePointer<Swift.CChar>)
  init(cString: Swift.UnsafePointer<Swift.UInt8>)
  init?(validatingUTF8 cString: Swift.UnsafePointer<Swift.CChar>)
  static func decodeCString<Encoding : UnicodeCodec>(_ cString: Swift.UnsafePointer<Encoding.CodeUnit>?, as encoding: Encoding.Type, repairingInvalidCodeUnits isRepairing: Swift.Bool = default) -> (result: Swift.String, repairsMade: Swift.Bool)?
}
extension String {
  @available(*, unavailable, message: "Please use String.init?(validatingUTF8:) instead. Note that it no longer accepts NULL as a valid input. Also consider using String(cString:), that will attempt to repair ill-formed code units.") static func fromCString(_ cs: Swift.UnsafePointer<Swift.CChar>) -> Swift.String?
  @available(*, unavailable, message: "Please use String.init(cString:) instead. Note that it no longer accepts NULL as a valid input. See also String.decodeCString if you need more control.") static func fromCStringRepairingIllFormedUTF8(_ cs: Swift.UnsafePointer<Swift.CChar>) -> (Swift.String?, hadError: Swift.Bool)
}
extension String {
  func withCString<Result>(_ body: (Swift.UnsafePointer<Swift.Int8>) throws -> Result) rethrows -> Result
}
extension String : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension String : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension String : TextOutputStream {
  mutating func write(_ other: Swift.String)
}
extension String : TextOutputStreamable {
  func write<Target : TextOutputStream>(to target: inout Target)
}
extension String {
  struct CharacterView {
    var _core: Swift._StringCore
    init(_ text: Swift.String)
    init(_ _core: Swift._StringCore)
  }
  var characters: Swift.String.CharacterView {
    get {}
    set(newValue) {}
  }
  mutating func withMutableCharacters<R>(_ body: (inout Swift.String.CharacterView) -> R) -> R
  init(_ characters: Swift.String.CharacterView)
}
extension String {
  static func _fromWellFormedCodeUnitSequence<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> Swift.String
  static func _fromCodeUnitSequence<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> Swift.String?
  static func _fromCodeUnitSequenceWithRepair<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> (Swift.String, hadError: Swift.Bool)
}
extension String : _ExpressibleByBuiltinUnicodeScalarLiteral {
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
}
extension String : ExpressibleByUnicodeScalarLiteral {
  init(unicodeScalarLiteral value: Swift.String)
  typealias UnicodeScalarLiteralType = Swift.String
}
extension String : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral {
  @_semantics("string.makeUTF8") init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
extension String : ExpressibleByExtendedGraphemeClusterLiteral {
  init(extendedGraphemeClusterLiteral value: Swift.String)
  typealias ExtendedGraphemeClusterLiteralType = Swift.String
}
extension String : _ExpressibleByBuiltinUTF16StringLiteral {
  @_semantics("string.makeUTF16") init(_builtinUTF16StringLiteral start: Builtin.RawPointer, utf16CodeUnitCount: Builtin.Word)
}
extension String : _ExpressibleByBuiltinStringLiteral {
  @_semantics("string.makeUTF8") init(_builtinStringLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
extension String : ExpressibleByStringLiteral {
  init(stringLiteral value: Swift.String)
  typealias StringLiteralType = Swift.String
}
extension String : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension String {
  func _encodedLength<Encoding : UnicodeCodec>(_ encoding: Encoding.Type) -> Swift.Int
  func _encode<Encoding : UnicodeCodec>(_ encoding: Encoding.Type, into processCodeUnit: (Encoding.CodeUnit) -> Swift.Void)
}
extension String : Equatable {
  static func ==(lhs: Swift.String, rhs: Swift.String) -> Swift.Bool
}
extension String : Comparable {
  static func <(lhs: Swift.String, rhs: Swift.String) -> Swift.Bool
}
extension String {
  func _compareASCII(_ rhs: Swift.String) -> Swift.Int
  @inline(never) @_semantics("stdlib_binary_only") func _compareDeterministicUnicodeCollation(_ rhs: Swift.String) -> Swift.Int
  func _compareString(_ rhs: Swift.String) -> Swift.Int
}
extension String {
  mutating func append(_ other: Swift.String)
  @available(*, unavailable, message: "Replaced by append(_: String)") mutating func append(_ x: Swift.UnicodeScalar)
  init(_storage: Swift._StringBuffer)
}
extension String : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension String {
  @_semantics("string.concat") static func +(lhs: Swift.String, rhs: Swift.String) -> Swift.String
  static func +=(lhs: inout Swift.String, rhs: Swift.String)
  @_silgen_name("swift_stringFromUTF8InRawMemory") static func _fromUTF8InRawMemory(_ resultStorage: Swift.UnsafeMutablePointer<Swift.String>, start: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>, utf8CodeUnitCount: Swift.Int)
}
extension String {
  var _asciiLowerCaseTable: Swift.UInt64 {
    @inline(__always) get {}
  }
  var _asciiUpperCaseTable: Swift.UInt64 {
    @inline(__always) get {}
  }
  func lowercased() -> Swift.String
  func uppercased() -> Swift.String
  init<T : LosslessStringConvertible>(_ value: T)
}
extension String : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension String : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension String {
  @available(*, unavailable, renamed: "append(_:)") mutating func appendContentsOf(_ other: Swift.String)
  @available(*, unavailable, renamed: "append(contentsOf:)") mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Character>(_ newElements: S)
  @available(*, unavailable, renamed: "insert(contentsOf:at:)") mutating func insertContentsOf<S : Collection where S.Iterator.Element == Character>(_ newElements: S, at i: Swift.String.Index)
  @available(*, unavailable, renamed: "replaceSubrange") mutating func replaceRange<C : Collection where C.Iterator.Element == Character>(_ subRange: Swift.Range<Swift.String.Index>, with newElements: C)
  @available(*, unavailable, renamed: "replaceSubrange") mutating func replaceRange(_ subRange: Swift.Range<Swift.String.Index>, with newElements: Swift.String)
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ i: Swift.String.Index) -> Swift.Character
  @available(*, unavailable, renamed: "removeSubrange") mutating func removeRange(_ subRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "lowercased()") var lowercaseString: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "uppercased()") var uppercaseString: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "init(describing:)") init<T>(_: T)
}
extension String {
  @inline(never) @_semantics("stdlib_binary_only") init(_cocoaString: AnyObject)
}
extension String {
  func _stdlib_binary_bridgeToObjectiveCImpl() -> AnyObject
  @inline(never) @_semantics("stdlib_binary_only") func _bridgeToObjectiveCImpl() -> AnyObject
}
extension String : ExpressibleByStringInterpolation {
  init(stringInterpolation strings: Swift.String...)
  init<T>(stringInterpolationSegment expr: T)
  init(stringInterpolationSegment expr: Swift.String)
  init(stringInterpolationSegment expr: Swift.Character)
  init(stringInterpolationSegment expr: Swift.UnicodeScalar)
  init(stringInterpolationSegment expr: Swift.Bool)
  init(stringInterpolationSegment expr: Swift.Float32)
  init(stringInterpolationSegment expr: Swift.Float64)
  init(stringInterpolationSegment expr: Swift.UInt8)
  init(stringInterpolationSegment expr: Swift.Int8)
  init(stringInterpolationSegment expr: Swift.UInt16)
  init(stringInterpolationSegment expr: Swift.Int16)
  init(stringInterpolationSegment expr: Swift.UInt32)
  init(stringInterpolationSegment expr: Swift.Int32)
  init(stringInterpolationSegment expr: Swift.UInt64)
  init(stringInterpolationSegment expr: Swift.Int64)
  init(stringInterpolationSegment expr: Swift.UInt)
  init(stringInterpolationSegment expr: Swift.Int)
}
extension String {
  @available(*, unavailable, message: "Replaced by init(repeating: String, count: Int)") init(repeating repeatedValue: Swift.Character, count: Swift.Int)
  @available(*, unavailable, message: "Replaced by init(repeating: String, count: Int)") init(repeating repeatedValue: Swift.UnicodeScalar, count: Swift.Int)
  init(repeating repeatedValue: Swift.String, count: Swift.Int)
  var _lines: [Swift.String] {
    get {}
  }
  func _split(separator: Swift.UnicodeScalar) -> [Swift.String]
  var isEmpty: Swift.Bool {
    get {}
  }
}
extension String {
  init(_ _c: Swift.UnicodeScalar)
}
extension String {
  func hasPrefix(_ prefix: Swift.String) -> Swift.Bool
  func hasSuffix(_ suffix: Swift.String) -> Swift.Bool
}
extension String {
  init<T : _SignedInteger>(_ v: T)
  init<T : UnsignedInteger>(_ v: T)
  init<T : _SignedInteger>(_ value: T, radix: Swift.Int, uppercase: Swift.Bool = default)
  init<T : UnsignedInteger>(_ value: T, radix: Swift.Int, uppercase: Swift.Bool = default)
}
extension String {
  func _splitFirst(separator delim: Swift.UnicodeScalar) -> (before: Swift.String, after: Swift.String, wasFound: Swift.Bool)
  func _splitFirstIf(_ predicate: (Swift.UnicodeScalar) -> Swift.Bool) -> (before: Swift.String, found: Swift.UnicodeScalar, after: Swift.String, wasFound: Swift.Bool)
}
extension String {
  @available(*, unavailable, message: "Renamed to init(repeating:count:) and reordered parameters") init(count: Swift.Int, repeatedValue c: Swift.Character)
  @available(*, unavailable, message: "Renamed to init(repeating:count:) and reordered parameters") init(count: Swift.Int, repeatedValue c: Swift.UnicodeScalar)
}
extension String {
  typealias Index = Swift.String.CharacterView.Index
  typealias IndexDistance = Swift.String.CharacterView.IndexDistance
  var startIndex: Swift.String.Index {
    get {}
  }
  var endIndex: Swift.String.Index {
    get {}
  }
  func index(after i: Swift.String.Index) -> Swift.String.Index
  func index(before i: Swift.String.Index) -> Swift.String.Index
  func index(_ i: Swift.String.Index, offsetBy n: Swift.String.IndexDistance) -> Swift.String.Index
  func index(_ i: Swift.String.Index, offsetBy n: Swift.String.IndexDistance, limitedBy limit: Swift.String.Index) -> Swift.String.Index?
  func distance(from start: Swift.String.Index, to end: Swift.String.Index) -> Swift.String.IndexDistance
  subscript(i: Swift.String.Index) -> Swift.Character {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.String.Index>) -> Swift.String {
    get {}
  }
  subscript(bounds: Swift.ClosedRange<Swift.String.Index>) -> Swift.String {
    get {}
  }
}
extension String {
  init<S : Sequence where S.Iterator.Element == Character>(_ characters: S)
  mutating func reserveCapacity(_ n: Swift.Int)
  mutating func append(_ c: Swift.Character)
  mutating func append<S : Sequence where S.Iterator.Element == Character>(contentsOf newElements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Swift.Range<Swift.String.Index>, with newElements: C)
  mutating func replaceSubrange(_ bounds: Swift.Range<Swift.String.Index>, with newElements: Swift.String)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Swift.ClosedRange<Swift.String.Index>, with newElements: C)
  mutating func replaceSubrange(_ bounds: Swift.ClosedRange<Swift.String.Index>, with newElements: Swift.String)
  mutating func insert(_ newElement: Swift.Character, at i: Swift.String.Index)
  mutating func insert<S : Collection where S.Iterator.Element == Character>(contentsOf newElements: S, at i: Swift.String.Index)
  @discardableResult mutating func remove(at i: Swift.String.Index) -> Swift.Character
  mutating func removeSubrange(_ bounds: Swift.Range<Swift.String.Index>)
  mutating func removeSubrange(_ bounds: Swift.ClosedRange<Swift.String.Index>)
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
}
extension String {
  struct UnicodeScalarView : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
    init(_ _core: Swift._StringCore)
    struct _ScratchIterator : IteratorProtocol {
      var core: Swift._StringCore
      var idx: Swift.Int
      @_versioned init(_ core: Swift._StringCore, _ pos: Swift.Int)
      @inline(__always) mutating func next() -> Swift.UTF16.CodeUnit?
      typealias Element = Swift.UTF16.CodeUnit
    }
    struct Index {
      init(_position: Swift.Int)
      @_versioned var _position: Swift.Int
    }
    var startIndex: Swift.String.UnicodeScalarView.Index {
      get {}
    }
    var endIndex: Swift.String.UnicodeScalarView.Index {
      get {}
    }
    func index(after i: Swift.String.UnicodeScalarView.Index) -> Swift.String.UnicodeScalarView.Index
    func index(before i: Swift.String.UnicodeScalarView.Index) -> Swift.String.UnicodeScalarView.Index
    subscript(position: Swift.String.UnicodeScalarView.Index) -> Swift.UnicodeScalar {
      get {}
    }
    subscript(r: Swift.Range<Swift.String.UnicodeScalarView.Index>) -> Swift.String.UnicodeScalarView {
      get {}
    }
    struct Iterator : IteratorProtocol {
      init(_ _base: Swift._StringCore)
      mutating func next() -> Swift.UnicodeScalar?
      var _decoder: Swift.UTF16
      let _baseSet: Swift.Bool
      let _ascii: Swift.Bool
      var _asciiBase: Swift.UnsafeBufferPointerIterator<Swift.UInt8>!
      var _base: Swift.UnsafeBufferPointerIterator<Swift.UInt16>!
      var _iterator: Swift.IndexingIterator<Swift._StringCore>!
      typealias Element = Swift.UnicodeScalar
    }
    func makeIterator() -> Swift.String.UnicodeScalarView.Iterator
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    var _core: Swift._StringCore
    typealias _Element = Swift.UnicodeScalar
    typealias SubSequence = Swift.String.UnicodeScalarView
    typealias IndexDistance = Swift.Int
    typealias Indices = Swift.DefaultBidirectionalIndices<Swift.String.UnicodeScalarView>
  }
  init(_ unicodeScalars: Swift.String.UnicodeScalarView)
  typealias UnicodeScalarIndex = Swift.String.UnicodeScalarView.Index
}
extension String {
  var unicodeScalars: Swift.String.UnicodeScalarView {
    get {}
    set(newValue) {}
  }
}
extension String {
  struct UTF16View : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
    struct Index {
      init(_offset: Swift.Int)
      let _offset: Swift.Int
    }
    typealias IndexDistance = Swift.Int
    var startIndex: Swift.String.UTF16View.Index {
      get {}
    }
    var endIndex: Swift.String.UTF16View.Index {
      get {}
    }
    struct Indices {
      var _elements: Swift.String.UTF16View
      var _startIndex: Swift.String.UTF16View.Indices.Index
      var _endIndex: Swift.String.UTF16View.Indices.Index
      init(_elements: Swift.String.UTF16View, _startIndex: Swift.String.UTF16View.Indices.Index, _endIndex: Swift.String.UTF16View.Indices.Index)
    }
    var indices: Swift.String.UTF16View.Indices {
      get {}
    }
    func index(after i: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index
    func index(before i: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index
    func index(_ i: Swift.String.UTF16View.Index, offsetBy n: Swift.String.UTF16View.IndexDistance) -> Swift.String.UTF16View.Index
    func index(_ i: Swift.String.UTF16View.Index, offsetBy n: Swift.String.UTF16View.IndexDistance, limitedBy limit: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index?
    func distance(from start: Swift.String.UTF16View.Index, to end: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.IndexDistance
    func _internalIndex(at i: Swift.Int) -> Swift.Int
    subscript(i: Swift.String.UTF16View.Index) -> Swift.UTF16.CodeUnit {
      get {}
    }
    @available(*, unavailable, message: "Indexing a String's UTF16View requires a String.UTF16View.Index, which can be constructed from Int when Foundation is imported") subscript(i: Swift.Int) -> Swift.UTF16.CodeUnit {
      get {}
    }
    @available(*, unavailable, message: "Slicing a String's UTF16View requires a Range<String.UTF16View.Index>, String.UTF16View.Index can be constructed from Int when Foundation is imported") subscript(bounds: Swift.Range<Swift.Int>) -> Swift.String.UTF16View {
      get {}
    }
    subscript(bounds: Swift.Range<Swift.String.UTF16View.Index>) -> Swift.String.UTF16View {
      get {}
    }
    init(_ _core: Swift._StringCore)
    init(_ _core: Swift._StringCore, offset: Swift.Int, length: Swift.Int)
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    var _offset: Swift.Int
    var _length: Swift.Int
    let _core: Swift._StringCore
    typealias _Element = Swift.UTF16.CodeUnit
    typealias SubSequence = Swift.String.UTF16View
    typealias Iterator = Swift.IndexingIterator<Swift.String.UTF16View>
  }
  var utf16: Swift.String.UTF16View {
    get {}
    set(newValue) {}
  }
  init?(_ utf16: Swift.String.UTF16View)
  typealias UTF16Index = Swift.String.UTF16View.Index
}
extension String {
  struct UTF8View : Collection, CustomStringConvertible, CustomDebugStringConvertible {
    let _core: Swift._StringCore
    let _startIndex: Swift.String.UTF8View.Index
    let _endIndex: Swift.String.UTF8View.Index
    init(_ _core: Swift._StringCore)
    init(_ _core: Swift._StringCore, _ s: Swift.String.UTF8View.Index, _ e: Swift.String.UTF8View.Index)
    struct Index {
      typealias Buffer = Swift._StringCore._UTF8Chunk
      init(_coreIndex: Swift.Int, _ _buffer: Swift.String.UTF8View.Index.Buffer)
      func _isOnUnicodeScalarBoundary(in core: Swift._StringCore) -> Swift.Bool
      func _isEndIndex(of core: Swift._StringCore) -> Swift.Bool
      var _utf8ContinuationBytesUntilNextUnicodeScalar: Swift.Int {
        get {}
      }
      static var _emptyBuffer: Swift.String.UTF8View.Index.Buffer {
        get {}
      }
      static var _bufferHiByte: Swift.String.UTF8View.Index.Buffer {
        get {}
      }
      static func _nextBuffer(after thisBuffer: Swift.String.UTF8View.Index.Buffer) -> Swift.String.UTF8View.Index.Buffer
      let _coreIndex: Swift.Int
      let _buffer: Swift.String.UTF8View.Index.Buffer
    }
    typealias IndexDistance = Swift.Int
    var startIndex: Swift.String.UTF8View.Index {
      get {}
    }
    var endIndex: Swift.String.UTF8View.Index {
      get {}
    }
    func index(after i: Swift.String.UTF8View.Index) -> Swift.String.UTF8View.Index
    subscript(position: Swift.String.UTF8View.Index) -> Swift.UTF8.CodeUnit {
      get {}
    }
    subscript(bounds: Swift.Range<Swift.String.UTF8View.Index>) -> Swift.String.UTF8View {
      get {}
    }
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    typealias _Element = Swift.UTF8.CodeUnit
    typealias SubSequence = Swift.String.UTF8View
    typealias Iterator = Swift.IndexingIterator<Swift.String.UTF8View>
    typealias Indices = Swift.DefaultIndices<Swift.String.UTF8View>
  }
  var utf8: Swift.String.UTF8View {
    get {}
    set(newValue) {}
  }
  var _contiguousUTF8: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>? {
    get {}
  }
  var utf8CString: Swift.ContiguousArray<Swift.CChar> {
    get {}
  }
  func _withUnsafeBufferPointerToUTF8<R>(_ body: (Swift.UnsafeBufferPointer<Swift.UTF8.CodeUnit>) throws -> R) rethrows -> R
  init?(_ utf8: Swift.String.UTF8View)
  typealias UTF8Index = Swift.String.UTF8View.Index
}
extension String {
  @available(*, unavailable, message: "Please use String.utf8CString instead.") var nulTerminatedUTF8: Swift.ContiguousArray<Swift.UTF8.CodeUnit> {
    get {}
  }
}
extension String {
  @available(*, unavailable, message: "cannot subscript String with an Int, see the documentation comment for discussion") subscript(i: Swift.Int) -> Swift.Character {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a Range<Int>, see the documentation comment for discussion") subscript(bounds: Swift.Range<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a ClosedRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.ClosedRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a CountableRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.CountableRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a CountableClosedRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.CountableClosedRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "there is no universally good answer, see the documentation comment for discussion") var count: Swift.Int {
    get {}
  }
}
extension String : MirrorPath {
}
extension String {
  init<Subject>(describing instance: Subject)
  init<Subject>(reflecting subject: Subject)
}
extension String {
  init(_sel: ObjectiveC.Selector)
}
extension String {
  init(_ cocoaString: Foundation.NSString)
}
extension String : _ObjectiveCBridgeable {
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSString
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSString, result: inout Swift.String?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSString, result: inout Swift.String?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSString?) -> Swift.String
  typealias _ObjectiveCType = Foundation.NSString
}
extension String : CVarArg {
}
extension String {
  var _ns: Foundation.NSString {
    get {}
  }
  func _index(_ utf16Index: Swift.Int) -> Swift.String.Index
  func _range(_ r: Foundation.NSRange) -> Swift.Range<Swift.String.Index>
  func _optionalRange(_ r: Foundation.NSRange) -> Swift.Range<Swift.String.Index>?
  func _withOptionalOutParameter<Result>(_ index: Swift.UnsafeMutablePointer<Swift.String.Index>?, _ body: (Swift.UnsafeMutablePointer<Swift.Int>?) -> Result) -> Result
  func _withOptionalOutParameter<Result>(_ range: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>?, _ body: (Swift.UnsafeMutablePointer<Foundation.NSRange>?) -> Result) -> Result
  static var availableStringEncodings: [Swift.String.Encoding] {
    get {}
  }
  static var defaultCStringEncoding: Swift.String.Encoding {
    get {}
  }
  static func localizedName(of encoding: Swift.String.Encoding) -> Swift.String
  static func localizedStringWithFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, message: "Use fileURL(withPathComponents:) on URL instead.") static func path(withComponents components: [Swift.String]) -> Swift.String
  init?(utf8String bytes: Swift.UnsafePointer<Swift.CChar>)
  func canBeConverted(to encoding: Swift.String.Encoding) -> Swift.Bool
  var capitalized: Swift.String {
    get {}
  }
  @available(OSX 10.11, iOS 9.0, *)
  var localizedCapitalized: Swift.String {
    get {}
  }
  func capitalized(with locale: Foundation.Locale?) -> Swift.String
  func caseInsensitiveCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func commonPrefix(with aString: Swift.String, options: Swift.String.CompareOptions = default) -> Swift.String
  func compare(_ aString: Swift.String, options mask: Swift.String.CompareOptions = default, range: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Foundation.ComparisonResult
  func completePath(into outputName: Swift.UnsafeMutablePointer<Swift.String>? = default, caseSensitive: Swift.Bool, matchesInto outputArray: Swift.UnsafeMutablePointer<[Swift.String]>? = default, filterTypes: [Swift.String]? = default) -> Swift.Int
  func components(separatedBy separator: Foundation.CharacterSet) -> [Swift.String]
  func components(separatedBy separator: Swift.String) -> [Swift.String]
  func cString(using encoding: Swift.String.Encoding) -> [Swift.CChar]?
  func data(using encoding: Swift.String.Encoding, allowLossyConversion: Swift.Bool = default) -> Foundation.Data?
  var decomposedStringWithCanonicalMapping: Swift.String {
    get {}
  }
  var decomposedStringWithCompatibilityMapping: Swift.String {
    get {}
  }
  func enumerateLines(invoking body: @escaping (Swift.String, inout Swift.Bool) -> ())
  func enumerateLinguisticTags(in range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, invoking body: (Swift.String, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  func enumerateSubstrings(in range: Swift.Range<Swift.String.Index>, options opts: Swift.String.EnumerationOptions = default, _ body: @escaping (Swift.String?, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  var fastestEncoding: Swift.String.Encoding {
    get {}
  }
  @available(*, unavailable, message: "Use getFileSystemRepresentation on URL instead.") var fileSystemRepresentation: [Swift.CChar] {
    get {}
  }
  func getBytes(_ buffer: inout [Swift.UInt8], maxLength maxBufferCount: Swift.Int, usedLength usedBufferCount: Swift.UnsafeMutablePointer<Swift.Int>, encoding: Swift.String.Encoding, options: Swift.String.EncodingConversionOptions = default, range: Swift.Range<Swift.String.Index>, remaining leftover: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>) -> Swift.Bool
  func getCString(_ buffer: inout [Swift.CChar], maxLength: Swift.Int, encoding: Swift.String.Encoding) -> Swift.Bool
  @available(*, unavailable, message: "Use getFileSystemRepresentation on URL instead.") func getFileSystemRepresentation(_ buffer: inout [Swift.CChar], maxLength: Swift.Int) -> Swift.Bool
  func getLineStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, for range: Swift.Range<Swift.String.Index>)
  func getParagraphStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, for range: Swift.Range<Swift.String.Index>)
  var hash: Swift.Int {
    get {}
  }
  init?<S : Sequence where S.Iterator.Element == UInt8>(bytes: S, encoding: Swift.String.Encoding)
  init?(bytesNoCopy bytes: Swift.UnsafeMutableRawPointer, length: Swift.Int, encoding: Swift.String.Encoding, freeWhenDone flag: Swift.Bool)
  init(utf16CodeUnits: Swift.UnsafePointer<Foundation.unichar>, count: Swift.Int)
  init(utf16CodeUnitsNoCopy: Swift.UnsafePointer<Foundation.unichar>, count: Swift.Int, freeWhenDone flag: Swift.Bool)
  init(contentsOfFile path: Swift.String, encoding enc: Swift.String.Encoding) throws
  init(contentsOfFile path: Swift.String, usedEncoding: inout Swift.String.Encoding) throws
  init(contentsOfFile path: Swift.String) throws
  init(contentsOf url: Foundation.URL, encoding enc: Swift.String.Encoding) throws
  init(contentsOf url: Foundation.URL, usedEncoding: inout Swift.String.Encoding) throws
  init(contentsOf url: Foundation.URL) throws
  init?(cString: Swift.UnsafePointer<Swift.CChar>, encoding enc: Swift.String.Encoding)
  init?(data: Foundation.Data, encoding: Swift.String.Encoding)
  init(format: Swift.String, _ arguments: CVarArg...)
  init(format: Swift.String, arguments: [CVarArg])
  init(format: Swift.String, locale: Foundation.Locale?, _ args: CVarArg...)
  init(format: Swift.String, locale: Foundation.Locale?, arguments: [CVarArg])
  @available(*, unavailable, message: "Use lastPathComponent on URL instead.") var lastPathComponent: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Take the count of a UTF-16 view instead, i.e. str.utf16.count") var utf16Count: Swift.Int {
    get {}
  }
  func lengthOfBytes(using encoding: Swift.String.Encoding) -> Swift.Int
  func lineRange(for aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  func linguisticTags(in range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, tokenRanges: Swift.UnsafeMutablePointer<[Swift.Range<Swift.String.Index>]>? = default) -> [Swift.String]
  func localizedCaseInsensitiveCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func localizedCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func localizedStandardCompare(_ string: Swift.String) -> Foundation.ComparisonResult
  @available(OSX 10.11, iOS 9.0, *)
  var localizedLowercase: Swift.String {
    get {}
  }
  func lowercased(with locale: Foundation.Locale?) -> Swift.String
  func maximumLengthOfBytes(using encoding: Swift.String.Encoding) -> Swift.Int
  func paragraphRange(for aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, message: "Use pathComponents on URL instead.") var pathComponents: [Swift.String] {
    get {}
  }
  @available(*, unavailable, message: "Use pathExtension on URL instead.") var pathExtension: Swift.String {
    get {}
  }
  var precomposedStringWithCanonicalMapping: Swift.String {
    get {}
  }
  var precomposedStringWithCompatibilityMapping: Swift.String {
    get {}
  }
  func propertyList() -> Any
  func propertyListFromStringsFileFormat() -> [Swift.String : Swift.String]
  func rangeOfCharacter(from aSet: Foundation.CharacterSet, options mask: Swift.String.CompareOptions = default, range aRange: Swift.Range<Swift.String.Index>? = default) -> Swift.Range<Swift.String.Index>?
  func rangeOfComposedCharacterSequence(at anIndex: Swift.String.Index) -> Swift.Range<Swift.String.Index>
  func rangeOfComposedCharacterSequences(for range: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  func range(of aString: Swift.String, options mask: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Swift.Range<Swift.String.Index>?
  @available(OSX 10.11, iOS 9.0, *)
  func localizedStandardContains(_ string: Swift.String) -> Swift.Bool
  @available(OSX 10.11, iOS 9.0, *)
  func localizedStandardRange(of string: Swift.String) -> Swift.Range<Swift.String.Index>?
  var smallestEncoding: Swift.String.Encoding {
    get {}
  }
  @available(*, unavailable, message: "Use abbreviatingWithTildeInPath on NSString instead.") var abbreviatingWithTildeInPath: Swift.String {
    get {}
  }
  func addingPercentEncoding(withAllowedCharacters allowedCharacters: Foundation.CharacterSet) -> Swift.String?
  @available(*, deprecated, message: "Use addingPercentEncoding(withAllowedCharacters:) instead, which always uses the recommended UTF-8 encoding, and which encodes for a specific URL component or subcomponent since each URL component or subcomponent has different rules for what characters are valid.") func addingPercentEscapes(using encoding: Swift.String.Encoding) -> Swift.String?
  func appendingFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, message: "Use appendingPathComponent on URL instead.") func appendingPathComponent(_ aString: Swift.String) -> Swift.String
  @available(*, unavailable, message: "Use appendingPathExtension on URL instead.") func appendingPathExtension(_ ext: Swift.String) -> Swift.String?
  func appending(_ aString: Swift.String) -> Swift.String
  @available(*, unavailable, message: "Use deletingLastPathComponent on URL instead.") var deletingLastPathComponent: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use deletingPathExtension on URL instead.") var deletingPathExtension: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use expandingTildeInPath on NSString instead.") var expandingTildeInPath: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "folding(options:locale:)") func folding(_ options: Swift.String.CompareOptions = default, locale: Foundation.Locale?) -> Swift.String
  func folding(options: Swift.String.CompareOptions = default, locale: Foundation.Locale?) -> Swift.String
  func padding(toLength newLength: Swift.Int, withPad padString: Swift.String, startingAt padIndex: Swift.Int) -> Swift.String
  var removingPercentEncoding: Swift.String? {
    get {}
  }
  func replacingCharacters(in range: Swift.Range<Swift.String.Index>, with replacement: Swift.String) -> Swift.String
  func replacingOccurrences(of target: Swift.String, with replacement: Swift.String, options: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default) -> Swift.String
  @available(*, deprecated, message: "Use removingPercentEncoding instead, which always uses the recommended UTF-8 encoding.") func replacingPercentEscapes(using encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, message: "Use resolvingSymlinksInPath on URL instead.") var resolvingSymlinksInPath: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use standardizingPath on URL instead.") var standardizingPath: Swift.String {
    get {}
  }
  func trimmingCharacters(in set: Foundation.CharacterSet) -> Swift.String
  @available(*, unavailable, message: "Map over paths with appendingPathComponent instead.") func strings(byAppendingPaths paths: [Swift.String]) -> [Swift.String]
  func substring(from index: Swift.String.Index) -> Swift.String
  func substring(to index: Swift.String.Index) -> Swift.String
  func substring(with aRange: Swift.Range<Swift.String.Index>) -> Swift.String
  @available(OSX 10.11, iOS 9.0, *)
  var localizedUppercase: Swift.String {
    get {}
  }
  func uppercased(with locale: Foundation.Locale?) -> Swift.String
  func write(toFile path: Swift.String, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  func write(to url: Foundation.URL, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  @available(OSX 10.11, iOS 9.0, *)
  func applyingTransform(_ transform: Foundation.StringTransform, reverse: Swift.Bool) -> Swift.String?
  func contains(_ other: Swift.String) -> Swift.Bool
  func localizedCaseInsensitiveContains(_ other: Swift.String) -> Swift.Bool
}
extension String {
  @available(*, unavailable, renamed: "localizedName(of:)") static func localizedNameOfStringEncoding(_ encoding: Swift.String.Encoding) -> Swift.String
  @available(*, unavailable, message: "Use fileURL(withPathComponents:) on URL instead.") static func pathWithComponents(_ components: [Swift.String]) -> Swift.String
  @available(*, unavailable, renamed: "canBeConverted(to:)") func canBeConvertedToEncoding(_ encoding: Swift.String.Encoding) -> Swift.Bool
  @available(*, unavailable, renamed: "capitalizedString(with:)") func capitalizedStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "commonPrefix(with:options:)") func commonPrefixWith(_ aString: Swift.String, options: Swift.String.CompareOptions) -> Swift.String
  @available(*, unavailable, renamed: "completePath(into:outputName:caseSensitive:matchesInto:filterTypes:)") func completePathInto(_ outputName: Swift.UnsafeMutablePointer<Swift.String>? = default, caseSensitive: Swift.Bool, matchesInto matchesIntoArray: Swift.UnsafeMutablePointer<[Swift.String]>? = default, filterTypes: [Swift.String]? = default) -> Swift.Int
  @available(*, unavailable, renamed: "components(separatedBy:)") func componentsSeparatedByCharactersIn(_ separator: Foundation.CharacterSet) -> [Swift.String]
  @available(*, unavailable, renamed: "componentsSeparated(by:)") func componentsSeparatedBy(_ separator: Swift.String) -> [Swift.String]
  @available(*, unavailable, renamed: "cString(usingEncoding:)") func cStringUsingEncoding(_ encoding: Swift.String.Encoding) -> [Swift.CChar]?
  @available(*, unavailable, renamed: "data(usingEncoding:allowLossyConversion:)") func dataUsingEncoding(_ encoding: Swift.String.Encoding, allowLossyConversion: Swift.Bool = default) -> Foundation.Data?
  @available(*, unavailable, renamed: "enumerateLinguisticTags(in:scheme:options:orthography:_:)") func enumerateLinguisticTagsIn(_ range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options, orthography: Foundation.NSOrthography?, _ body: (Swift.String, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  @available(*, unavailable, renamed: "enumerateSubstrings(in:options:_:)") func enumerateSubstringsIn(_ range: Swift.Range<Swift.String.Index>, options opts: Swift.String.EnumerationOptions = default, _ body: (Swift.String?, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  @available(*, unavailable, renamed: "getBytes(_:maxLength:usedLength:encoding:options:range:remaining:)") func getBytes(_ buffer: inout [Swift.UInt8], maxLength maxBufferCount: Swift.Int, usedLength usedBufferCount: Swift.UnsafeMutablePointer<Swift.Int>, encoding: Swift.String.Encoding, options: Swift.String.EncodingConversionOptions = default, range: Swift.Range<Swift.String.Index>, remainingRange leftover: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>) -> Swift.Bool
  @available(*, unavailable, renamed: "getLineStart(_:end:contentsEnd:for:)") func getLineStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, forRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "getParagraphStart(_:end:contentsEnd:for:)") func getParagraphStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, forRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "lengthOfBytes(using:)") func lengthOfBytesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.Int
  @available(*, unavailable, renamed: "lineRange(for:)") func lineRangeFor(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "linguisticTags(in:scheme:options:orthography:tokenRanges:)") func linguisticTagsIn(_ range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, tokenRanges: Swift.UnsafeMutablePointer<[Swift.Range<Swift.String.Index>]>? = default) -> [Swift.String]
  @available(*, unavailable, renamed: "lowercased(with:)") func lowercaseStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "maximumLengthOfBytes(using:)") func maximumLengthOfBytesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.Int
  @available(*, unavailable, renamed: "paragraphRange(for:)") func paragraphRangeFor(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "rangeOfCharacter(from:options:range:)") func rangeOfCharacterFrom(_ aSet: Foundation.CharacterSet, options mask: Swift.String.CompareOptions = default, range aRange: Swift.Range<Swift.String.Index>? = default) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "rangeOfComposedCharacterSequence(at:)") func rangeOfComposedCharacterSequenceAt(_ anIndex: Swift.String.Index) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "rangeOfComposedCharacterSequences(for:)") func rangeOfComposedCharacterSequencesFor(_ range: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "range(of:options:range:locale:)") func rangeOf(_ aString: Swift.String, options mask: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "localizedStandardRange(of:)") func localizedStandardRangeOf(_ string: Swift.String) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "addingPercentEncoding(withAllowedCharacters:)") func addingPercentEncodingWithAllowedCharacters(_ allowedCharacters: Foundation.CharacterSet) -> Swift.String?
  @available(*, unavailable, renamed: "addingPercentEscapes(using:)") func addingPercentEscapesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, renamed: "appendingFormat") func stringByAppendingFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, renamed: "padding(toLength:with:startingAt:)") func byPaddingToLength(_ newLength: Swift.Int, withString padString: Swift.String, startingAt padIndex: Swift.Int) -> Swift.String
  @available(*, unavailable, renamed: "replacingCharacters(in:with:)") func replacingCharactersIn(_ range: Swift.Range<Swift.String.Index>, withString replacement: Swift.String) -> Swift.String
  @available(*, unavailable, renamed: "replacingOccurrences(of:with:options:range:)") func replacingOccurrencesOf(_ target: Swift.String, withString replacement: Swift.String, options: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default) -> Swift.String
  @available(*, unavailable, renamed: "replacingPercentEscapes(usingEncoding:)") func replacingPercentEscapesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, renamed: "trimmingCharacters(in:)") func byTrimmingCharactersIn(_ set: Foundation.CharacterSet) -> Swift.String
  @available(*, unavailable, renamed: "strings(byAppendingPaths:)") func stringsByAppendingPaths(_ paths: [Swift.String]) -> [Swift.String]
  @available(*, unavailable, renamed: "substring(from:)") func substringFrom(_ index: Swift.String.Index) -> Swift.String
  @available(*, unavailable, renamed: "substring(to:)") func substringTo(_ index: Swift.String.Index) -> Swift.String
  @available(*, unavailable, renamed: "substring(with:)") func substringWith(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.String
  @available(*, unavailable, renamed: "uppercased(with:)") func uppercaseStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "write(toFile:atomically:encoding:)") func writeToFile(_ path: Swift.String, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  @available(*, unavailable, renamed: "write(to:atomically:encoding:)") func writeToURL(_ url: Foundation.URL, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
}
extension String {
  struct Encoding : RawRepresentable {
    var rawValue: Swift.UInt
    init(rawValue: Swift.UInt)
    static var ascii: Swift.String.Encoding
    static var nextstep: Swift.String.Encoding
    static var japaneseEUC: Swift.String.Encoding
    static var utf8: Swift.String.Encoding
    static var isoLatin1: Swift.String.Encoding
    static var symbol: Swift.String.Encoding
    static var nonLossyASCII: Swift.String.Encoding
    static var shiftJIS: Swift.String.Encoding
    static var isoLatin2: Swift.String.Encoding
    static var unicode: Swift.String.Encoding
    static var windowsCP1251: Swift.String.Encoding
    static var windowsCP1252: Swift.String.Encoding
    static var windowsCP1253: Swift.String.Encoding
    static var windowsCP1254: Swift.String.Encoding
    static var windowsCP1250: Swift.String.Encoding
    static var iso2022JP: Swift.String.Encoding
    static var macOSRoman: Swift.String.Encoding
    static var utf16: Swift.String.Encoding
    static var utf16BigEndian: Swift.String.Encoding
    static var utf16LittleEndian: Swift.String.Encoding
    static var utf32: Swift.String.Encoding
    static var utf32BigEndian: Swift.String.Encoding
    static var utf32LittleEndian: Swift.String.Encoding
    typealias RawValue = Swift.UInt
  }
  typealias EncodingConversionOptions = Foundation.NSString.EncodingConversionOptions
  typealias EnumerationOptions = Foundation.NSString.EnumerationOptions
  typealias CompareOptions = Foundation.NSString.CompareOptions
}
extension String : Toastable {
  func mainMessage() -> Swift.String
  func detailMessage() -> Swift.String
}
struct AutoreleasingUnsafeMutablePointer<Pointee> : Equatable, _Pointer {
  let _rawValue: Builtin.RawPointer
  init(_ _rawValue: Builtin.RawPointer)
  var pointee: Pointee {
    get {}
    set(newValue) {}
  }
  subscript(i: Swift.Int) -> Pointee {
    get {}
  }
  init<U>(_ from: Swift.UnsafeMutablePointer<U>)
  init?<U>(_ from: Swift.UnsafeMutablePointer<U>?)
  init<U>(_ from: Swift.UnsafePointer<U>)
  init?<U>(_ from: Swift.UnsafePointer<U>?)
}
extension AutoreleasingUnsafeMutablePointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension AutoreleasingUnsafeMutablePointer {
  @available(*, unavailable, renamed: "Pointee") typealias Memory = Pointee
  @available(*, unavailable, renamed: "pointee") var memory: Pointee {
    get {}
  }
  @available(*, unavailable, message: "Removed in Swift 3. Please use nil literal instead.") init()
}
extension AutoreleasingUnsafeMutablePointer : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
func _stdlib_binary_CFStringGetLength(_ source: Swift._CocoaString) -> Swift.Int
func _nearbyint(_ x: Swift.Float) -> Swift.Float
func _nearbyint(_ x: Swift.Double) -> Swift.Double
protocol Collection : Indexable, Sequence {
  associatedtype IndexDistance : SignedInteger = Swift.Int
  associatedtype Iterator : IteratorProtocol = Swift.IndexingIterator<Self>
  func makeIterator() -> Self.Iterator
  associatedtype SubSequence : IndexableBase, Sequence = Swift.Slice<Self>
  subscript(position: Self.Index) -> Self.Iterator.Element { get }
  subscript(bounds: Swift.Range<Self.Index>) -> Self.SubSequence { get }
  associatedtype Indices : IndexableBase, Sequence = Swift.DefaultIndices<Self>
  var indices: Self.Indices { get }
  func prefix(upTo end: Self.Index) -> Self.SubSequence
  func suffix(from start: Self.Index) -> Self.SubSequence
  func prefix(through position: Self.Index) -> Self.SubSequence
  var isEmpty: Swift.Bool { get }
  var count: Self.IndexDistance { get }
  func _customIndexOfEquatableElement(_ element: Self.Iterator.Element) -> Self.Index??
  var first: Self.Iterator.Element? { get }
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance) -> Self.Index
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Self.Index?
  func distance(from start: Self.Index, to end: Self.Index) -> Self.IndexDistance
}
extension Collection {
  func map<T>(_ transform: (Self.Iterator.Element) throws -> T) rethrows -> [T]
  func dropFirst(_ n: Swift.Int) -> Self.SubSequence
  func dropLast(_ n: Swift.Int) -> Self.SubSequence
  func prefix(_ maxLength: Swift.Int) -> Self.SubSequence
  func suffix(_ maxLength: Swift.Int) -> Self.SubSequence
  func prefix(upTo end: Self.Index) -> Self.SubSequence
  func suffix(from start: Self.Index) -> Self.SubSequence
  func prefix(through position: Self.Index) -> Self.SubSequence
  func split(maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default, whereSeparator isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.SubSequence]
}
extension Collection {
  var isEmpty: Swift.Bool {
    get {}
  }
  var first: Self.Iterator.Element? {
    get {}
  }
  var underestimatedCount: Swift.Int {
    get {}
  }
  var count: Self.IndexDistance {
    get {}
  }
  func _customIndexOfEquatableElement(_: Self.Iterator.Element) -> Self.Index??
}
extension Collection where Iterator == IndexingIterator<Self> {
  func makeIterator() -> Swift.IndexingIterator<Self>
}
extension Collection where SubSequence == Slice<Self> {
  subscript(bounds: Swift.Range<Self.Index>) -> Swift.Slice<Self> {
    get {}
  }
}
extension Collection where SubSequence == Self {
  mutating func popFirst() -> Self.Iterator.Element?
}
extension Collection where Iterator.Element : Equatable {
  func split(separator: Self.Iterator.Element, maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default) -> [Self.SubSequence]
}
extension Collection where SubSequence == Self {
  @discardableResult mutating func removeFirst() -> Self.Iterator.Element
  mutating func removeFirst(_ n: Swift.Int)
}
extension Collection {
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
}
extension Collection {
  @available(*, unavailable, renamed: "Iterator") typealias Generator = Self.Iterator
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Self.Iterator
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
  @available(*, unavailable, message: "Please use split(maxSplits:omittingEmptySubsequences:whereSeparator:) instead") func split(_ maxSplit: Swift.Int = default, allowEmptySlices: Swift.Bool = default, whereSeparator isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.SubSequence]
}
extension Collection where Iterator.Element : Equatable {
  @available(*, unavailable, message: "Please use split(separator:maxSplits:omittingEmptySubsequences:) instead") func split(_ separator: Self.Iterator.Element, maxSplit: Swift.Int = default, allowEmptySlices: Swift.Bool = default) -> [Self.SubSequence]
}
extension Collection where Iterator.Element : Equatable {
  func index(of element: Self.Iterator.Element) -> Self.Index?
}
extension Collection {
  func index(where predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index?
}
extension Collection where Iterator.Element : Equatable {
  @available(*, unavailable, renamed: "index(of:)") func indexOf(_ element: Self.Iterator.Element) -> Self.Index?
}
extension Collection {
  @available(*, unavailable, renamed: "index(where:)") func indexOf(_ predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index?
}
extension Collection {
  func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Iterator.Element>
}
extension Collection where Iterator.Element : Collection {
  func joined() -> Swift.FlattenCollection<Self>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.FlattenCollection<Self>
}
extension Collection where Indices == DefaultIndices<Self> {
  var indices: Swift.DefaultIndices<Self> {
    get {}
  }
}
extension Collection {
  var lazy: Swift.LazyCollection<Self> {
    get {}
  }
}
extension Collection where Self : LazyCollectionProtocol {
  var lazy: Self {
    get {}
  }
}
final class _IteratorBox<Base : IteratorProtocol> : Swift._AnyIteratorBoxBase<Base.Element> {
  init(_ base: Base)
  override final func next() -> Base.Element?
  final var _base: Base
  @objc deinit
  init()
}
func _setBridgeFromObjectiveCConditional<ObjCValue, SwiftValue>(_ source: Swift.Set<ObjCValue>) -> Swift.Set<SwiftValue>?
@_silgen_name("swift_MagicMirrorData_summary") func _swift_MagicMirrorData_summaryImpl(_ metadata: Any.Type, _ result: Swift.UnsafeMutablePointer<Swift.String>)
@inline(__always) func _getUnsafePointerToStoredProperties(_ x: AnyObject) -> Swift.UnsafeMutableRawPointer
func transcode<Input, InputEncoding, OutputEncoding where Input : IteratorProtocol, InputEncoding : UnicodeCodec, OutputEncoding : UnicodeCodec, InputEncoding.CodeUnit == Input.Element>(_ input: Input, from inputEncoding: InputEncoding.Type, to outputEncoding: OutputEncoding.Type, stoppingOnError stopOnError: Swift.Bool, into processCodeUnit: (OutputEncoding.CodeUnit) -> Swift.Void) -> Swift.Bool
@available(*, unavailable, message: "use 'transcode(_:from:to:stoppingOnError:into:)'") func transcode<Input, InputEncoding, OutputEncoding where Input : IteratorProtocol, InputEncoding : UnicodeCodec, OutputEncoding : UnicodeCodec, InputEncoding.CodeUnit == Input.Element>(_ inputEncoding: InputEncoding.Type, _ outputEncoding: OutputEncoding.Type, _ input: Input, _ output: (OutputEncoding.CodeUnit) -> Swift.Void, stopOnError: Swift.Bool) -> Swift.Bool
func _cos(_ x: Swift.Float) -> Swift.Float
func _cos(_ x: Swift.Double) -> Swift.Double
protocol _CVarArgPassedAsDouble : CVarArg {
}
func _mixUInt64(_ value: Swift.UInt64) -> Swift.UInt64
enum _JoinIteratorState {
  case start
  case generatingElements
  case generatingSeparator
  case end
  infix static func ==(a: Swift._JoinIteratorState, b: Swift._JoinIteratorState) -> Swift.Bool
  var hashValue: Swift.Int {
    get {}
  }
}
func _stdlib_binary_CFStringGetCharactersPtr(_ source: Swift._CocoaString) -> Swift.UnsafeMutablePointer<Swift.UTF16.CodeUnit>?
struct _GraphemeClusterBreakPropertyRawValue {
  init(_ rawValue: Swift.UInt8)
  var rawValue: Swift.UInt8
  var cookedValue: Swift._GraphemeClusterBreakPropertyValue {
    get {}
  }
}
func _debugPreconditionFailure(_ message: Swift.StaticString = default, file: Swift.StaticString = #file, line: Swift.UInt = #line) -> Swift.Never
@inline(never) @_semantics("stdlib_binary_only") func _replDebugPrintln<T>(_ value: T)
@available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'BidirectionalCollection' instead") protocol BidirectionalIndexable : Indexable {
  func index(before i: Self.Index) -> Self.Index
  func formIndex(before i: inout Self.Index)
}
extension BidirectionalIndexable {
  @inline(__always) func formIndex(before i: inout Self.Index)
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance) -> Self.Index
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Self.Index?
  func distance(from start: Self.Index, to end: Self.Index) -> Self.IndexDistance
}
struct _OptionalNilComparisonType : ExpressibleByNilLiteral {
  init(nilLiteral: ())
}
struct _ObjCSuperMirror : _Mirror {
  let data: Swift._MagicMirrorData
  var value: Any {
    get {}
  }
  var valueType: Any.Type {
    get {}
  }
  var objectIdentifier: Swift.ObjectIdentifier? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  subscript(i: Swift.Int) -> (Swift.String, _Mirror) {
    get {}
  }
  var summary: Swift.String {
    get {}
  }
  var quickLookObject: Swift.PlaygroundQuickLook? {
    get {}
  }
  var disposition: Swift._MirrorDisposition {
    get {}
  }
  init(data: Swift._MagicMirrorData)
}
protocol MirrorPath {
}
struct _SliceBuffer<Element> : _ArrayBufferProtocol, RandomAccessCollection {
  typealias NativeStorage = Swift._ContiguousArrayStorage<Element>
  typealias NativeBuffer = Swift._ContiguousArrayBuffer<Element>
  init(owner: AnyObject, subscriptBaseAddress: Swift.UnsafeMutablePointer<Element>, indices: Swift.Range<Swift.Int>, hasNativeBuffer: Swift.Bool)
  init()
  init(_ buffer: Swift._ContiguousArrayBuffer<Element>, shiftedToStartIndex: Swift.Int)
  func _invariantCheck()
  var _hasNativeBuffer: Swift.Bool {
    get {}
  }
  var nativeBuffer: Swift._ContiguousArrayBuffer<Element> {
    get {}
  }
  var nativeOwner: AnyObject {
    get {}
  }
  mutating func replace<C where C : Collection, C.Iterator.Element == Element>(subRange: Swift.Range<Swift.Int>, with insertCount: Swift.Int, elementsOf newValues: C)
  var identity: Swift.UnsafeRawPointer {
    get {}
  }
  var owner: AnyObject
  let subscriptBaseAddress: Swift.UnsafeMutablePointer<Element>
  var firstElementAddress: Swift.UnsafeMutablePointer<Element> {
    get {}
  }
  var firstElementAddressIfContiguous: Swift.UnsafeMutablePointer<Element>? {
    get {}
  }
  var endIndexAndFlags: Swift.UInt
  mutating func requestUniqueMutableBackingBuffer(minimumCapacity: Swift.Int) -> Swift._ContiguousArrayBuffer<Element>?
  mutating func isMutableAndUniquelyReferenced() -> Swift.Bool
  mutating func isMutableAndUniquelyReferencedOrPinned() -> Swift.Bool
  func requestNativeBuffer() -> Swift._ContiguousArrayBuffer<Element>?
  @discardableResult func _copyContents(subRange bounds: Swift.Range<Swift.Int>, initializing target: Swift.UnsafeMutablePointer<Element>) -> Swift.UnsafeMutablePointer<Element>
  var arrayPropertyIsNativeTypeChecked: Swift.Bool {
    get {}
  }
  var count: Swift.Int {
    get {}
    set(newValue) {}
  }
  func _checkValidSubscript(_ index: Swift.Int)
  var capacity: Swift.Int {
    get {}
  }
  mutating func isUniquelyReferenced() -> Swift.Bool
  mutating func isUniquelyReferencedOrPinned() -> Swift.Bool
  @_versioned func getElement(_ i: Swift.Int) -> Element
  subscript(position: Swift.Int) -> Element {
    get {}
    set(newValue) {}
  }
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift._SliceBuffer<Element> {
    get {}
    set(newValue) {}
  }
  var startIndex: Swift.Int
  var endIndex: Swift.Int {
    get {}
    set(newValue) {}
  }
  typealias Indices = Swift.CountableRange<Swift.Int>
  func withUnsafeBufferPointer<R>(_ body: (Swift.UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
  mutating func withUnsafeMutableBufferPointer<R>(_ body: (Swift.UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
  typealias Index = Swift.Int
  typealias _Element = Element
  typealias SubSequence = Swift._SliceBuffer<Element>
  typealias Element = Element
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift._SliceBuffer<Element>>
}
extension _SliceBuffer {
  func _copyToContiguousArray() -> Swift.ContiguousArray<Element>
}
func unsafeBitCast<T, U>(_ x: T, to: U.Type) -> U
protocol UnsignedInteger : _DisallowMixedSignArithmetic, Integer {
  func toUIntMax() -> Swift.UIntMax
  init(_: Swift.UIntMax)
}
extension UnsignedInteger {
  func distance(to other: Self) -> Swift.Int
  func advanced(by n: Swift.Int) -> Self
}
let _x86_64RegisterSaveWords: Swift.Int
struct LazyFilterCollection<Base : Collection> : LazyCollectionProtocol, Collection {
  typealias Index = Swift.LazyFilterIndex<Base>
  typealias IndexDistance = Base.IndexDistance
  init(_base: Base, _ isIncluded: @escaping (Base.Iterator.Element) -> Swift.Bool)
  var startIndex: Swift.LazyFilterIndex<Base> {
    get {}
  }
  var endIndex: Swift.LazyFilterIndex<Base> {
    get {}
  }
  func index(after i: Swift.LazyFilterIndex<Base>) -> Swift.LazyFilterIndex<Base>
  func formIndex(after i: inout Swift.LazyFilterIndex<Base>)
  subscript(position: Swift.LazyFilterIndex<Base>) -> Base.Iterator.Element {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.LazyFilterIndex<Base>>) -> Swift.Slice<Swift.LazyFilterCollection<Base>> {
    get {}
  }
  func makeIterator() -> Swift.LazyFilterIterator<Base.Iterator>
  var _base: Base
  let _predicate: (Base.Iterator.Element) -> Swift.Bool
  typealias _Element = Base.Iterator.Element
  typealias SubSequence = Swift.Slice<Swift.LazyFilterCollection<Base>>
  typealias Elements = Swift.LazyFilterCollection<Base>
  typealias Iterator = Swift.LazyFilterIterator<Base.Iterator>
  typealias Indices = Swift.DefaultIndices<Swift.LazyFilterCollection<Base>>
}
extension LazyFilterCollection {
  @available(*, unavailable, message: "use '.lazy.filter' on the collection") init(_ base: Base, whereElementsSatisfy predicate: (Base.Iterator.Element) -> Swift.Bool)
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.LazyFilterIterator<Base.Iterator>
}
struct SetIterator<Element : Hashable> : IteratorProtocol {
  typealias _NativeStorageOwner = Swift._NativeSetStorageOwner<Element>
  typealias _NativeIndex = Swift._NativeSetIndex<Element>
  @_versioned var _state: Swift.SetIteratorRepresentation<Element>
  @_versioned static func _native(start: Swift._NativeSetIndex<Element>, end: Swift._NativeSetIndex<Element>, owner: Swift._NativeSetStorageOwner<Element>) -> Swift.SetIterator<Element>
  @_versioned static func _cocoa(_ iterator: Swift._CocoaSetIterator) -> Swift.SetIterator<Element>
  @_versioned var _guaranteedNative: Swift.Bool {
    get {}
  }
  @_versioned mutating func _nativeNext() -> Element?
  @inline(__always) mutating func next() -> Element?
  typealias Element = Element
  init(_state: Swift.SetIteratorRepresentation<Element>)
}
extension SetIterator : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
@inline(never) func _toStringReadOnlyStreamable<T : TextOutputStreamable>(_ x: T) -> Swift.String
struct LazySequence<Base : Sequence> : LazySequenceProtocol, _SequenceWrapper {
  init(_base: Base)
  var _base: Base
  var elements: Base {
    get {}
  }
  typealias Base = Base
  typealias Iterator = Base.Iterator
  typealias Elements = Base
  typealias SubSequence = Swift.AnySequence<Base.Iterator.Element>
}
protocol _ExpressibleByFileReferenceLiteral {
  init(fileReferenceLiteralResourceName path: Swift.String)
}
@available(*, unavailable, message: "Removed in Swift 3. Please use Optional.unsafelyUnwrapped instead.") func unsafeUnwrap<T>(_ nonEmpty: T?) -> T
@_silgen_name("swift_ObjCMirror_subscript") func _getObjCChild<T>(_: Swift.Int, _: Swift._MagicMirrorData) -> (T, _Mirror)
@_silgen_name("swift_reflectAny") func _reflect<T>(_ x: T) -> _Mirror
protocol UnicodeCodec {
  associatedtype CodeUnit
  init()
  mutating func decode<I : IteratorProtocol where I.Element == CodeUnit>(_ input: inout I) -> Swift.UnicodeDecodingResult
  static func encode(_ input: Swift.UnicodeScalar, into processCodeUnit: (Self.CodeUnit) -> Swift.Void)
  static func _nullCodeUnitOffset(in input: Swift.UnsafePointer<Self.CodeUnit>) -> Swift.Int
}
extension UnicodeCodec where CodeUnit : UnsignedInteger {
  static func _nullCodeUnitOffset(in input: Swift.UnsafePointer<Self.CodeUnit>) -> Swift.Int
}
extension UnicodeCodec {
  static func _nullCodeUnitOffset(in input: Swift.UnsafePointer<Self.CodeUnit>) -> Swift.Int
}
extension UnicodeCodec {
  @available(*, unavailable, renamed: "encode(_:into:)") static func encode(_ input: Swift.UnicodeScalar, output put: (Self.CodeUnit) -> Swift.Void)
}
@available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'Collection' instead") protocol IndexableBase {
  associatedtype Index : Comparable
  var startIndex: Self.Index { get }
  var endIndex: Self.Index { get }
  associatedtype _Element
  subscript(position: Self.Index) -> Self._Element { get }
  associatedtype SubSequence
  subscript(bounds: Swift.Range<Self.Index>) -> Self.SubSequence { get }
  func _failEarlyRangeCheck(_ index: Self.Index, bounds: Swift.Range<Self.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Self.Index>, bounds: Swift.Range<Self.Index>)
  func index(after i: Self.Index) -> Self.Index
  func formIndex(after i: inout Self.Index)
}
protocol ExpressibleByArrayLiteral {
  associatedtype Element
  init(arrayLiteral elements: Self.Element...)
}
protocol _ExpressibleByBuiltinUTF16StringLiteral : _ExpressibleByBuiltinStringLiteral {
  init(_builtinUTF16StringLiteral start: Builtin.RawPointer, utf16CodeUnitCount: Builtin.Word)
}
@_silgen_name("swift_TupleMirror_subscript") func _getTupleChild<T>(_: Swift.Int, _: Swift._MagicMirrorData) -> (T, _Mirror)
protocol _DestructorSafeContainer {
}
@inline(never) @_semantics("stdlib_binary_only") func _cocoaStringReadAll(_ source: Swift._CocoaString, _ destination: Swift.UnsafeMutablePointer<Swift.UTF16.CodeUnit>)
struct _SetBuilder<Element : Hashable> {
  typealias Key = Element
  typealias Value = Element
  var _result: Swift.Set<Element>
  var _nativeStorage: Swift._NativeSetStorage<Element>
  let _requestedCount: Swift.Int
  var _actualCount: Swift.Int
  init(count: Swift.Int)
  mutating func add(member newKey: Element)
  mutating func take() -> Swift.Set<Element>
}
func _dictionaryBridgeFromObjectiveC<ObjCKey, ObjCValue, SwiftKey, SwiftValue>(_ source: [ObjCKey : ObjCValue]) -> [SwiftKey : SwiftValue]
func _swift_stdlib_atomicLoadInt(object target: Swift.UnsafeMutablePointer<Swift.Int>) -> Swift.Int
struct Mirror {
  enum _DefaultDescendantRepresentation {
    case generated
    case suppressed
    infix static func ==(a: Swift.Mirror._DefaultDescendantRepresentation, b: Swift.Mirror._DefaultDescendantRepresentation) -> Swift.Bool
    var hashValue: Swift.Int {
      get {}
    }
  }
  enum AncestorRepresentation {
    case generated
    case customized(() -> Swift.Mirror)
    case suppressed
  }
  init(reflecting subject: Any)
  typealias Child = (label: Swift.String?, value: Any)
  typealias Children = Swift.AnyCollection<Swift.Mirror.Child>
  enum DisplayStyle {
    case `struct`
    case `class`
    case `enum`
    case tuple
    case optional
    case collection
    case dictionary
    case set
    infix static func ==(a: Swift.Mirror.DisplayStyle, b: Swift.Mirror.DisplayStyle) -> Swift.Bool
    var hashValue: Swift.Int {
      get {}
    }
  }
  static func _noSuperclassMirror() -> Swift.Mirror?
  static func _legacyMirror(_ subject: AnyObject, asClass targetSuperclass: Swift.AnyClass) -> _Mirror?
  static func _superclassIterator<Subject>(_ subject: Subject, _ ancestorRepresentation: Swift.Mirror.AncestorRepresentation) -> () -> Swift.Mirror?
  init<Subject, C : Collection where C.Iterator.Element == Child, C.SubSequence : Collection, C.SubSequence.Iterator.Element == Child, C.SubSequence.Index == C.Index, C.SubSequence.Indices : Collection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : Collection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ subject: Subject, children: C, displayStyle: Swift.Mirror.DisplayStyle? = default, ancestorRepresentation: Swift.Mirror.AncestorRepresentation = default)
  init<Subject, C : Collection where C.SubSequence : Collection, C.SubSequence.SubSequence == C.SubSequence, C.Indices : Collection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ subject: Subject, unlabeledChildren: C, displayStyle: Swift.Mirror.DisplayStyle? = default, ancestorRepresentation: Swift.Mirror.AncestorRepresentation = default)
  init<Subject>(_ subject: Subject, children: Swift.DictionaryLiteral<Swift.String, Any>, displayStyle: Swift.Mirror.DisplayStyle? = default, ancestorRepresentation: Swift.Mirror.AncestorRepresentation = default)
  let subjectType: Any.Type
  let children: Swift.Mirror.Children
  let displayStyle: Swift.Mirror.DisplayStyle?
  var superclassMirror: Swift.Mirror? {
    get {}
  }
  let _makeSuperclassMirror: () -> Swift.Mirror?
  let _defaultDescendantRepresentation: Swift.Mirror._DefaultDescendantRepresentation
}
extension Mirror {
  struct _Dummy : CustomReflectable {
    var mirror: Swift.Mirror
    var customMirror: Swift.Mirror {
      get {}
    }
    init(mirror: Swift.Mirror)
  }
  func descendant(_ first: MirrorPath, _ rest: MirrorPath...) -> Any?
}
extension Mirror {
  struct LegacyChildren : RandomAccessCollection {
    typealias Indices = Swift.CountableRange<Swift.Int>
    init(_ oldMirror: _Mirror)
    var startIndex: Swift.Int {
      get {}
    }
    var endIndex: Swift.Int {
      get {}
    }
    subscript(position: Swift.Int) -> Swift.Mirror.Child {
      get {}
    }
    let _oldMirror: _Mirror
    typealias Index = Swift.Int
    typealias _Element = Swift.Mirror.Child
    typealias SubSequence = Swift.RandomAccessSlice<Swift.Mirror.LegacyChildren>
    typealias IndexDistance = Swift.Int
    typealias Iterator = Swift.IndexingIterator<Swift.Mirror.LegacyChildren>
  }
  init(_ subject: AnyObject, subjectClass: Swift.AnyClass, ancestor: Swift.Mirror, legacy legacyMirror: _Mirror? = default)
  init(legacy legacyMirror: _Mirror, subjectType: Any.Type, makeSuperclassMirror: (@escaping () -> Swift.Mirror?)? = default)
}
extension Mirror : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Mirror : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
var kCFStringEncodingASCII: SwiftShims._swift_shims_CFStringEncoding {
  get {}
}
struct AnyHashable {
  var _box: _AnyHashableBox
  init<H : Hashable>(_ base: H)
  init<H : Hashable>(_usingDefaultRepresentationOf base: H)
  var base: Any {
    get {}
  }
  func _downCastConditional<T>(into result: Swift.UnsafeMutablePointer<T>) -> Swift.Bool
}
extension AnyHashable : Equatable {
  static func ==(lhs: Swift.AnyHashable, rhs: Swift.AnyHashable) -> Swift.Bool
}
extension AnyHashable : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension AnyHashable : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension AnyHashable : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension AnyHashable : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension AnyHashable : _AnyHashableProtocol {
}
extension AnyHashable : _ObjectiveCBridgeable {
  func _bridgeToObjectiveC() -> ObjectiveC.NSObject
  static func _forceBridgeFromObjectiveC(_ x: ObjectiveC.NSObject, result: inout Swift.AnyHashable?)
  static func _conditionallyBridgeFromObjectiveC(_ x: ObjectiveC.NSObject, result: inout Swift.AnyHashable?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: ObjectiveC.NSObject?) -> Swift.AnyHashable
  typealias _ObjectiveCType = ObjectiveC.NSObject
}
protocol _ExpressibleByBuiltinUnicodeScalarLiteral {
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
}
protocol CVarArg {
  var _cVarArgEncoding: [Swift.Int] { get }
}
extension CVarArg where Self : _ObjectiveCBridgeable {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
@_silgen_name("swift_StructMirror_subscript") func _getStructChild<T>(_: Swift.Int, _: Swift._MagicMirrorData) -> (T, _Mirror)
@_silgen_name("_swift_dictionaryDownCastIndirect") func _dictionaryDownCastIndirect<SourceKey, SourceValue, TargetKey, TargetValue>(_ source: Swift.UnsafePointer<[SourceKey : SourceValue]>, _ target: Swift.UnsafeMutablePointer<[TargetKey : TargetValue]>)
@objc @_swift_native_objc_runtime_base(_SwiftNativeNSDictionaryBase) class _SwiftNativeNSDictionary {
  @objc init()
  @objc deinit
}
struct OpaquePointer : Hashable {
  var _rawValue: Builtin.RawPointer
  @_versioned init(_ v: Builtin.RawPointer)
  init?(bitPattern: Swift.Int)
  init?(bitPattern: Swift.UInt)
  init<T>(_ from: Swift.UnsafePointer<T>)
  init?<T>(_ from: Swift.UnsafePointer<T>?)
  init<T>(_ from: Swift.UnsafeMutablePointer<T>)
  init?<T>(_ from: Swift.UnsafeMutablePointer<T>?)
  var hashValue: Swift.Int {
    get {}
  }
}
extension OpaquePointer : Equatable {
  static func ==(lhs: Swift.OpaquePointer, rhs: Swift.OpaquePointer) -> Swift.Bool
}
extension OpaquePointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension OpaquePointer {
  @available(*, unavailable, message: "use 'Unmanaged.toOpaque()' instead") init<T>(bitPattern bits: Swift.Unmanaged<T>)
}
extension OpaquePointer {
  init(_ from: Swift.UnsafeMutableRawPointer)
  init?(_ from: Swift.UnsafeMutableRawPointer?)
}
extension OpaquePointer {
  init(_ from: Swift.UnsafeRawPointer)
  init?(_ from: Swift.UnsafeRawPointer?)
}
extension OpaquePointer : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
let _x86_64CountSSERegisters: Swift.Int
func ^=(lhs: inout Swift.UInt8, rhs: Swift.UInt8)
func ^=(lhs: inout Swift.Int8, rhs: Swift.Int8)
func ^=(lhs: inout Swift.UInt16, rhs: Swift.UInt16)
func ^=(lhs: inout Swift.Int16, rhs: Swift.Int16)
func ^=(lhs: inout Swift.UInt32, rhs: Swift.UInt32)
func ^=(lhs: inout Swift.Int32, rhs: Swift.Int32)
func ^=(lhs: inout Swift.UInt64, rhs: Swift.UInt64)
func ^=(lhs: inout Swift.Int64, rhs: Swift.Int64)
func ^=(lhs: inout Swift.UInt, rhs: Swift.UInt)
func ^=(lhs: inout Swift.Int, rhs: Swift.Int)
func ^=<T : BitwiseOperations>(lhs: inout T, rhs: T)
protocol _ExpressibleByBuiltinStringLiteral : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral {
  init(_builtinStringLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
protocol BitwiseOperations {
  static func &(lhs: Self, rhs: Self) -> Self
  static func |(lhs: Self, rhs: Self) -> Self
  static func ^(lhs: Self, rhs: Self) -> Self
  prefix static func ~(x: Self) -> Self
  static var allZeros: Self { get }
}
func _parseAsciiAsUIntMax(_ utf16: Swift.String.UTF16View, _ radix: Swift.Int, _ maximum: Swift.UIntMax) -> Swift.UIntMax?
enum _DebuggerSupport {
  enum CollectionStatus {
    case NotACollection
    case CollectionOfElements
    case CollectionOfPairs
    case Element
    case Pair
    case ElementOfPair
    var isCollection: Swift.Bool {
      get {}
    }
    func getChildStatus(child: Swift.Mirror) -> Swift._DebuggerSupport.CollectionStatus
    infix static func ==(a: Swift._DebuggerSupport.CollectionStatus, b: Swift._DebuggerSupport.CollectionStatus) -> Swift.Bool
    var hashValue: Swift.Int {
      get {}
    }
  }
  static func isClass(_ value: Any) -> Swift.Bool
  static func checkValue<T>(_ value: Any, ifClass: (AnyObject) -> T, otherwise: () -> T) -> T
  static func asObjectIdentifier(_ value: Any) -> Swift.ObjectIdentifier?
  static func asNumericValue(_ value: Any) -> Swift.Int
  static func asStringRepresentation(value: Any?, mirror: Swift.Mirror, count: Swift.Int) -> Swift.String?
  static func ivarCount(mirror: Swift.Mirror) -> Swift.Int
  static func shouldExpand(mirror: Swift.Mirror, collectionStatus: Swift._DebuggerSupport.CollectionStatus, isRoot: Swift.Bool) -> Swift.Bool
  static func printForDebuggerImpl<StreamType : TextOutputStream>(value: Any?, mirror: Swift.Mirror, name: Swift.String?, indent: Swift.Int, maxDepth: Swift.Int, isRoot: Swift.Bool, parentCollectionStatus: Swift._DebuggerSupport.CollectionStatus, refsAlreadySeen: inout Swift.Set<Swift.ObjectIdentifier>, maxItemCounter: inout Swift.Int, targetStream: inout StreamType)
  @_semantics("stdlib_binary_only") static func stringForPrintObject(_ value: Any) -> Swift.String
}
struct Bool {
  var _value: Builtin.Int1
  init()
  @_versioned init(_ v: Builtin.Int1)
  init(_ value: Swift.Bool)
}
extension Bool : Equatable, Hashable {
  var hashValue: Swift.Int {
    get {}
  }
  static func ==(lhs: Swift.Bool, rhs: Swift.Bool) -> Swift.Bool
}
extension Bool : _ExpressibleByBuiltinBooleanLiteral, ExpressibleByBooleanLiteral {
  init(_builtinBooleanLiteral value: Builtin.Int1)
  init(booleanLiteral value: Swift.Bool)
  typealias BooleanLiteralType = Swift.Bool
}
extension Bool {
  func _getBuiltinLogicValue() -> Builtin.Int1
}
extension Bool : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Bool : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension Bool {
  prefix static func !(a: Swift.Bool) -> Swift.Bool
}
extension Bool {
  @inline(__always) static func &&(lhs: Swift.Bool, rhs: @autoclosure () throws -> Swift.Bool) rethrows -> Swift.Bool
  @inline(__always) static func ||(lhs: Swift.Bool, rhs: @autoclosure () throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Bool : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Bool : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Bool : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Bool?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Bool?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Bool
  typealias _ObjectiveCType = Foundation.NSNumber
}
func _swift_stdlib_atomicStoreInt32(object target: Swift.UnsafeMutablePointer<Swift.Int32>, desired: Swift.Int32)
func _memcpy(dest destination: Swift.UnsafeMutableRawPointer, src: Swift.UnsafeMutableRawPointer, size: Swift.UInt)
@available(*, unavailable, renamed: "EnumeratedIterator") struct EnumerateGenerator<Base : IteratorProtocol> {
  init()
}
func precondition(_ condition: @autoclosure () -> Swift.Bool, _ message: @autoclosure () -> Swift.String = default, file: Swift.StaticString = #file, line: Swift.UInt = #line)
func _swift_stdlib_atomicFetchXorUInt32(object target: Swift.UnsafeMutablePointer<Swift.UInt32>, operand: Swift.UInt32) -> Swift.UInt32
@_silgen_name("_swift_convertToAnyHashableIndirect") func _convertToAnyHashableIndirect<H : Hashable>(_ value: H, _ target: Swift.UnsafeMutablePointer<Swift.AnyHashable>)
@available(*, unavailable, renamed: "StrideToIterator") struct StrideToGenerator<Element : Strideable> {
  init()
}
struct EmptyIterator<Element> : IteratorProtocol, Sequence {
  init()
  mutating func next() -> Element?
  typealias Element = Element
  typealias Iterator = Swift.EmptyIterator<Element>
  typealias SubSequence = Swift.AnySequence<Element>
}
extension EmptyIterator {
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.EmptyIterator<Element>
}
func _isClassSuperMirror(_ t: Any.Type) -> Swift.Bool
func !==(lhs: AnyObject?, rhs: AnyObject?) -> Swift.Bool
@available(*, unavailable) func !==<L : _AnyCollectionProtocol, R : _AnyCollectionProtocol>(lhs: L, rhs: R) -> Swift.Bool
func _mixInt32(_ value: Swift.Int32) -> Swift.Int32
func !=<Element : Equatable>(lhs: Swift.ContiguousArray<Element>, rhs: Swift.ContiguousArray<Element>) -> Swift.Bool
func !=<Element : Equatable>(lhs: Swift.ArraySlice<Element>, rhs: Swift.ArraySlice<Element>) -> Swift.Bool
func !=<Element : Equatable>(lhs: [Element], rhs: [Element]) -> Swift.Bool
func !=(lhs: Builtin.NativeObject, rhs: Builtin.NativeObject) -> Swift.Bool
func !=(lhs: Builtin.RawPointer, rhs: Builtin.RawPointer) -> Swift.Bool
func !=(t0: Any.Type?, t1: Any.Type?) -> Swift.Bool
func !=<T : RawRepresentable where T.RawValue : Equatable>(lhs: T, rhs: T) -> Swift.Bool
func !=<T : Equatable where T : RawRepresentable, T.RawValue : Equatable>(lhs: T, rhs: T) -> Swift.Bool
func !=<T : Equatable>(lhs: T, rhs: T) -> Swift.Bool
func !=(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.Bool
func !=(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Bool
func !=(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.Bool
func !=(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Bool
func !=(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.Bool
func !=(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Bool
func !=(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.Bool
func !=(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Bool
func !=(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.Bool
func !=(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Bool
func !=<T : Equatable>(lhs: T?, rhs: T?) -> Swift.Bool
func !=<T>(lhs: T?, rhs: Swift._OptionalNilComparisonType) -> Swift.Bool
func !=<T>(lhs: Swift._OptionalNilComparisonType, rhs: T?) -> Swift.Bool
func !=<A : Equatable, B : Equatable>(lhs: (A, B), rhs: (A, B)) -> Swift.Bool
func !=<A : Equatable, B : Equatable, C : Equatable>(lhs: (A, B, C), rhs: (A, B, C)) -> Swift.Bool
func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Swift.Bool
func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Swift.Bool
func !=<A : Equatable, B : Equatable, C : Equatable, D : Equatable, E : Equatable, F : Equatable>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Swift.Bool
struct UnfoldSequence<Element, State> : Sequence, IteratorProtocol {
  mutating func next() -> Element?
  init(_state: State, _next: @escaping (inout State) -> Element?)
  var _state: State
  let _next: (inout State) -> Element?
  var _done: Swift.Bool
  typealias Element = Element
  typealias Iterator = Swift.UnfoldSequence<Element, State>
  typealias SubSequence = Swift.AnySequence<Element>
}
func _compareSets<Element>(_ lhs: Swift.Set<Element>, _ rhs: Swift.Set<Element>) -> (isSubset: Swift.Bool, isEqual: Swift.Bool)
struct String {
  init()
  init(_ _core: Swift._StringCore)
  var _core: Swift._StringCore
}
extension String {
  init(_ c: Swift.Character)
}
extension String {
  init(cString: Swift.UnsafePointer<Swift.CChar>)
  init(cString: Swift.UnsafePointer<Swift.UInt8>)
  init?(validatingUTF8 cString: Swift.UnsafePointer<Swift.CChar>)
  static func decodeCString<Encoding : UnicodeCodec>(_ cString: Swift.UnsafePointer<Encoding.CodeUnit>?, as encoding: Encoding.Type, repairingInvalidCodeUnits isRepairing: Swift.Bool = default) -> (result: Swift.String, repairsMade: Swift.Bool)?
}
extension String {
  @available(*, unavailable, message: "Please use String.init?(validatingUTF8:) instead. Note that it no longer accepts NULL as a valid input. Also consider using String(cString:), that will attempt to repair ill-formed code units.") static func fromCString(_ cs: Swift.UnsafePointer<Swift.CChar>) -> Swift.String?
  @available(*, unavailable, message: "Please use String.init(cString:) instead. Note that it no longer accepts NULL as a valid input. See also String.decodeCString if you need more control.") static func fromCStringRepairingIllFormedUTF8(_ cs: Swift.UnsafePointer<Swift.CChar>) -> (Swift.String?, hadError: Swift.Bool)
}
extension String {
  func withCString<Result>(_ body: (Swift.UnsafePointer<Swift.Int8>) throws -> Result) rethrows -> Result
}
extension String : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension String : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension String : TextOutputStream {
  mutating func write(_ other: Swift.String)
}
extension String : TextOutputStreamable {
  func write<Target : TextOutputStream>(to target: inout Target)
}
extension String {
  struct CharacterView {
    var _core: Swift._StringCore
    init(_ text: Swift.String)
    init(_ _core: Swift._StringCore)
  }
  var characters: Swift.String.CharacterView {
    get {}
    set(newValue) {}
  }
  mutating func withMutableCharacters<R>(_ body: (inout Swift.String.CharacterView) -> R) -> R
  init(_ characters: Swift.String.CharacterView)
}
extension String {
  static func _fromWellFormedCodeUnitSequence<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> Swift.String
  static func _fromCodeUnitSequence<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> Swift.String?
  static func _fromCodeUnitSequenceWithRepair<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> (Swift.String, hadError: Swift.Bool)
}
extension String : _ExpressibleByBuiltinUnicodeScalarLiteral {
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
}
extension String : ExpressibleByUnicodeScalarLiteral {
  init(unicodeScalarLiteral value: Swift.String)
  typealias UnicodeScalarLiteralType = Swift.String
}
extension String : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral {
  @_semantics("string.makeUTF8") init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
extension String : ExpressibleByExtendedGraphemeClusterLiteral {
  init(extendedGraphemeClusterLiteral value: Swift.String)
  typealias ExtendedGraphemeClusterLiteralType = Swift.String
}
extension String : _ExpressibleByBuiltinUTF16StringLiteral {
  @_semantics("string.makeUTF16") init(_builtinUTF16StringLiteral start: Builtin.RawPointer, utf16CodeUnitCount: Builtin.Word)
}
extension String : _ExpressibleByBuiltinStringLiteral {
  @_semantics("string.makeUTF8") init(_builtinStringLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
extension String : ExpressibleByStringLiteral {
  init(stringLiteral value: Swift.String)
  typealias StringLiteralType = Swift.String
}
extension String : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension String {
  func _encodedLength<Encoding : UnicodeCodec>(_ encoding: Encoding.Type) -> Swift.Int
  func _encode<Encoding : UnicodeCodec>(_ encoding: Encoding.Type, into processCodeUnit: (Encoding.CodeUnit) -> Swift.Void)
}
extension String : Equatable {
  static func ==(lhs: Swift.String, rhs: Swift.String) -> Swift.Bool
}
extension String : Comparable {
  static func <(lhs: Swift.String, rhs: Swift.String) -> Swift.Bool
}
extension String {
  func _compareASCII(_ rhs: Swift.String) -> Swift.Int
  @inline(never) @_semantics("stdlib_binary_only") func _compareDeterministicUnicodeCollation(_ rhs: Swift.String) -> Swift.Int
  func _compareString(_ rhs: Swift.String) -> Swift.Int
}
extension String {
  mutating func append(_ other: Swift.String)
  @available(*, unavailable, message: "Replaced by append(_: String)") mutating func append(_ x: Swift.UnicodeScalar)
  init(_storage: Swift._StringBuffer)
}
extension String : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension String {
  @_semantics("string.concat") static func +(lhs: Swift.String, rhs: Swift.String) -> Swift.String
  static func +=(lhs: inout Swift.String, rhs: Swift.String)
  @_silgen_name("swift_stringFromUTF8InRawMemory") static func _fromUTF8InRawMemory(_ resultStorage: Swift.UnsafeMutablePointer<Swift.String>, start: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>, utf8CodeUnitCount: Swift.Int)
}
extension String {
  var _asciiLowerCaseTable: Swift.UInt64 {
    @inline(__always) get {}
  }
  var _asciiUpperCaseTable: Swift.UInt64 {
    @inline(__always) get {}
  }
  func lowercased() -> Swift.String
  func uppercased() -> Swift.String
  init<T : LosslessStringConvertible>(_ value: T)
}
extension String : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension String : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension String {
  @available(*, unavailable, renamed: "append(_:)") mutating func appendContentsOf(_ other: Swift.String)
  @available(*, unavailable, renamed: "append(contentsOf:)") mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Character>(_ newElements: S)
  @available(*, unavailable, renamed: "insert(contentsOf:at:)") mutating func insertContentsOf<S : Collection where S.Iterator.Element == Character>(_ newElements: S, at i: Swift.String.Index)
  @available(*, unavailable, renamed: "replaceSubrange") mutating func replaceRange<C : Collection where C.Iterator.Element == Character>(_ subRange: Swift.Range<Swift.String.Index>, with newElements: C)
  @available(*, unavailable, renamed: "replaceSubrange") mutating func replaceRange(_ subRange: Swift.Range<Swift.String.Index>, with newElements: Swift.String)
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ i: Swift.String.Index) -> Swift.Character
  @available(*, unavailable, renamed: "removeSubrange") mutating func removeRange(_ subRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "lowercased()") var lowercaseString: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "uppercased()") var uppercaseString: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "init(describing:)") init<T>(_: T)
}
extension String {
  @inline(never) @_semantics("stdlib_binary_only") init(_cocoaString: AnyObject)
}
extension String {
  func _stdlib_binary_bridgeToObjectiveCImpl() -> AnyObject
  @inline(never) @_semantics("stdlib_binary_only") func _bridgeToObjectiveCImpl() -> AnyObject
}
extension String : ExpressibleByStringInterpolation {
  init(stringInterpolation strings: Swift.String...)
  init<T>(stringInterpolationSegment expr: T)
  init(stringInterpolationSegment expr: Swift.String)
  init(stringInterpolationSegment expr: Swift.Character)
  init(stringInterpolationSegment expr: Swift.UnicodeScalar)
  init(stringInterpolationSegment expr: Swift.Bool)
  init(stringInterpolationSegment expr: Swift.Float32)
  init(stringInterpolationSegment expr: Swift.Float64)
  init(stringInterpolationSegment expr: Swift.UInt8)
  init(stringInterpolationSegment expr: Swift.Int8)
  init(stringInterpolationSegment expr: Swift.UInt16)
  init(stringInterpolationSegment expr: Swift.Int16)
  init(stringInterpolationSegment expr: Swift.UInt32)
  init(stringInterpolationSegment expr: Swift.Int32)
  init(stringInterpolationSegment expr: Swift.UInt64)
  init(stringInterpolationSegment expr: Swift.Int64)
  init(stringInterpolationSegment expr: Swift.UInt)
  init(stringInterpolationSegment expr: Swift.Int)
}
extension String {
  @available(*, unavailable, message: "Replaced by init(repeating: String, count: Int)") init(repeating repeatedValue: Swift.Character, count: Swift.Int)
  @available(*, unavailable, message: "Replaced by init(repeating: String, count: Int)") init(repeating repeatedValue: Swift.UnicodeScalar, count: Swift.Int)
  init(repeating repeatedValue: Swift.String, count: Swift.Int)
  var _lines: [Swift.String] {
    get {}
  }
  func _split(separator: Swift.UnicodeScalar) -> [Swift.String]
  var isEmpty: Swift.Bool {
    get {}
  }
}
extension String {
  init(_ _c: Swift.UnicodeScalar)
}
extension String {
  func hasPrefix(_ prefix: Swift.String) -> Swift.Bool
  func hasSuffix(_ suffix: Swift.String) -> Swift.Bool
}
extension String {
  init<T : _SignedInteger>(_ v: T)
  init<T : UnsignedInteger>(_ v: T)
  init<T : _SignedInteger>(_ value: T, radix: Swift.Int, uppercase: Swift.Bool = default)
  init<T : UnsignedInteger>(_ value: T, radix: Swift.Int, uppercase: Swift.Bool = default)
}
extension String {
  func _splitFirst(separator delim: Swift.UnicodeScalar) -> (before: Swift.String, after: Swift.String, wasFound: Swift.Bool)
  func _splitFirstIf(_ predicate: (Swift.UnicodeScalar) -> Swift.Bool) -> (before: Swift.String, found: Swift.UnicodeScalar, after: Swift.String, wasFound: Swift.Bool)
}
extension String {
  @available(*, unavailable, message: "Renamed to init(repeating:count:) and reordered parameters") init(count: Swift.Int, repeatedValue c: Swift.Character)
  @available(*, unavailable, message: "Renamed to init(repeating:count:) and reordered parameters") init(count: Swift.Int, repeatedValue c: Swift.UnicodeScalar)
}
extension String {
  typealias Index = Swift.String.CharacterView.Index
  typealias IndexDistance = Swift.String.CharacterView.IndexDistance
  var startIndex: Swift.String.Index {
    get {}
  }
  var endIndex: Swift.String.Index {
    get {}
  }
  func index(after i: Swift.String.Index) -> Swift.String.Index
  func index(before i: Swift.String.Index) -> Swift.String.Index
  func index(_ i: Swift.String.Index, offsetBy n: Swift.String.IndexDistance) -> Swift.String.Index
  func index(_ i: Swift.String.Index, offsetBy n: Swift.String.IndexDistance, limitedBy limit: Swift.String.Index) -> Swift.String.Index?
  func distance(from start: Swift.String.Index, to end: Swift.String.Index) -> Swift.String.IndexDistance
  subscript(i: Swift.String.Index) -> Swift.Character {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.String.Index>) -> Swift.String {
    get {}
  }
  subscript(bounds: Swift.ClosedRange<Swift.String.Index>) -> Swift.String {
    get {}
  }
}
extension String {
  init<S : Sequence where S.Iterator.Element == Character>(_ characters: S)
  mutating func reserveCapacity(_ n: Swift.Int)
  mutating func append(_ c: Swift.Character)
  mutating func append<S : Sequence where S.Iterator.Element == Character>(contentsOf newElements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Swift.Range<Swift.String.Index>, with newElements: C)
  mutating func replaceSubrange(_ bounds: Swift.Range<Swift.String.Index>, with newElements: Swift.String)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Swift.ClosedRange<Swift.String.Index>, with newElements: C)
  mutating func replaceSubrange(_ bounds: Swift.ClosedRange<Swift.String.Index>, with newElements: Swift.String)
  mutating func insert(_ newElement: Swift.Character, at i: Swift.String.Index)
  mutating func insert<S : Collection where S.Iterator.Element == Character>(contentsOf newElements: S, at i: Swift.String.Index)
  @discardableResult mutating func remove(at i: Swift.String.Index) -> Swift.Character
  mutating func removeSubrange(_ bounds: Swift.Range<Swift.String.Index>)
  mutating func removeSubrange(_ bounds: Swift.ClosedRange<Swift.String.Index>)
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
}
extension String {
  struct UnicodeScalarView : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
    init(_ _core: Swift._StringCore)
    struct _ScratchIterator : IteratorProtocol {
      var core: Swift._StringCore
      var idx: Swift.Int
      @_versioned init(_ core: Swift._StringCore, _ pos: Swift.Int)
      @inline(__always) mutating func next() -> Swift.UTF16.CodeUnit?
      typealias Element = Swift.UTF16.CodeUnit
    }
    struct Index {
      init(_position: Swift.Int)
      @_versioned var _position: Swift.Int
    }
    var startIndex: Swift.String.UnicodeScalarView.Index {
      get {}
    }
    var endIndex: Swift.String.UnicodeScalarView.Index {
      get {}
    }
    func index(after i: Swift.String.UnicodeScalarView.Index) -> Swift.String.UnicodeScalarView.Index
    func index(before i: Swift.String.UnicodeScalarView.Index) -> Swift.String.UnicodeScalarView.Index
    subscript(position: Swift.String.UnicodeScalarView.Index) -> Swift.UnicodeScalar {
      get {}
    }
    subscript(r: Swift.Range<Swift.String.UnicodeScalarView.Index>) -> Swift.String.UnicodeScalarView {
      get {}
    }
    struct Iterator : IteratorProtocol {
      init(_ _base: Swift._StringCore)
      mutating func next() -> Swift.UnicodeScalar?
      var _decoder: Swift.UTF16
      let _baseSet: Swift.Bool
      let _ascii: Swift.Bool
      var _asciiBase: Swift.UnsafeBufferPointerIterator<Swift.UInt8>!
      var _base: Swift.UnsafeBufferPointerIterator<Swift.UInt16>!
      var _iterator: Swift.IndexingIterator<Swift._StringCore>!
      typealias Element = Swift.UnicodeScalar
    }
    func makeIterator() -> Swift.String.UnicodeScalarView.Iterator
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    var _core: Swift._StringCore
    typealias _Element = Swift.UnicodeScalar
    typealias SubSequence = Swift.String.UnicodeScalarView
    typealias IndexDistance = Swift.Int
    typealias Indices = Swift.DefaultBidirectionalIndices<Swift.String.UnicodeScalarView>
  }
  init(_ unicodeScalars: Swift.String.UnicodeScalarView)
  typealias UnicodeScalarIndex = Swift.String.UnicodeScalarView.Index
}
extension String {
  var unicodeScalars: Swift.String.UnicodeScalarView {
    get {}
    set(newValue) {}
  }
}
extension String {
  struct UTF16View : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
    struct Index {
      init(_offset: Swift.Int)
      let _offset: Swift.Int
    }
    typealias IndexDistance = Swift.Int
    var startIndex: Swift.String.UTF16View.Index {
      get {}
    }
    var endIndex: Swift.String.UTF16View.Index {
      get {}
    }
    struct Indices {
      var _elements: Swift.String.UTF16View
      var _startIndex: Swift.String.UTF16View.Indices.Index
      var _endIndex: Swift.String.UTF16View.Indices.Index
      init(_elements: Swift.String.UTF16View, _startIndex: Swift.String.UTF16View.Indices.Index, _endIndex: Swift.String.UTF16View.Indices.Index)
    }
    var indices: Swift.String.UTF16View.Indices {
      get {}
    }
    func index(after i: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index
    func index(before i: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index
    func index(_ i: Swift.String.UTF16View.Index, offsetBy n: Swift.String.UTF16View.IndexDistance) -> Swift.String.UTF16View.Index
    func index(_ i: Swift.String.UTF16View.Index, offsetBy n: Swift.String.UTF16View.IndexDistance, limitedBy limit: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index?
    func distance(from start: Swift.String.UTF16View.Index, to end: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.IndexDistance
    func _internalIndex(at i: Swift.Int) -> Swift.Int
    subscript(i: Swift.String.UTF16View.Index) -> Swift.UTF16.CodeUnit {
      get {}
    }
    @available(*, unavailable, message: "Indexing a String's UTF16View requires a String.UTF16View.Index, which can be constructed from Int when Foundation is imported") subscript(i: Swift.Int) -> Swift.UTF16.CodeUnit {
      get {}
    }
    @available(*, unavailable, message: "Slicing a String's UTF16View requires a Range<String.UTF16View.Index>, String.UTF16View.Index can be constructed from Int when Foundation is imported") subscript(bounds: Swift.Range<Swift.Int>) -> Swift.String.UTF16View {
      get {}
    }
    subscript(bounds: Swift.Range<Swift.String.UTF16View.Index>) -> Swift.String.UTF16View {
      get {}
    }
    init(_ _core: Swift._StringCore)
    init(_ _core: Swift._StringCore, offset: Swift.Int, length: Swift.Int)
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    var _offset: Swift.Int
    var _length: Swift.Int
    let _core: Swift._StringCore
    typealias _Element = Swift.UTF16.CodeUnit
    typealias SubSequence = Swift.String.UTF16View
    typealias Iterator = Swift.IndexingIterator<Swift.String.UTF16View>
  }
  var utf16: Swift.String.UTF16View {
    get {}
    set(newValue) {}
  }
  init?(_ utf16: Swift.String.UTF16View)
  typealias UTF16Index = Swift.String.UTF16View.Index
}
extension String {
  struct UTF8View : Collection, CustomStringConvertible, CustomDebugStringConvertible {
    let _core: Swift._StringCore
    let _startIndex: Swift.String.UTF8View.Index
    let _endIndex: Swift.String.UTF8View.Index
    init(_ _core: Swift._StringCore)
    init(_ _core: Swift._StringCore, _ s: Swift.String.UTF8View.Index, _ e: Swift.String.UTF8View.Index)
    struct Index {
      typealias Buffer = Swift._StringCore._UTF8Chunk
      init(_coreIndex: Swift.Int, _ _buffer: Swift.String.UTF8View.Index.Buffer)
      func _isOnUnicodeScalarBoundary(in core: Swift._StringCore) -> Swift.Bool
      func _isEndIndex(of core: Swift._StringCore) -> Swift.Bool
      var _utf8ContinuationBytesUntilNextUnicodeScalar: Swift.Int {
        get {}
      }
      static var _emptyBuffer: Swift.String.UTF8View.Index.Buffer {
        get {}
      }
      static var _bufferHiByte: Swift.String.UTF8View.Index.Buffer {
        get {}
      }
      static func _nextBuffer(after thisBuffer: Swift.String.UTF8View.Index.Buffer) -> Swift.String.UTF8View.Index.Buffer
      let _coreIndex: Swift.Int
      let _buffer: Swift.String.UTF8View.Index.Buffer
    }
    typealias IndexDistance = Swift.Int
    var startIndex: Swift.String.UTF8View.Index {
      get {}
    }
    var endIndex: Swift.String.UTF8View.Index {
      get {}
    }
    func index(after i: Swift.String.UTF8View.Index) -> Swift.String.UTF8View.Index
    subscript(position: Swift.String.UTF8View.Index) -> Swift.UTF8.CodeUnit {
      get {}
    }
    subscript(bounds: Swift.Range<Swift.String.UTF8View.Index>) -> Swift.String.UTF8View {
      get {}
    }
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    typealias _Element = Swift.UTF8.CodeUnit
    typealias SubSequence = Swift.String.UTF8View
    typealias Iterator = Swift.IndexingIterator<Swift.String.UTF8View>
    typealias Indices = Swift.DefaultIndices<Swift.String.UTF8View>
  }
  var utf8: Swift.String.UTF8View {
    get {}
    set(newValue) {}
  }
  var _contiguousUTF8: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>? {
    get {}
  }
  var utf8CString: Swift.ContiguousArray<Swift.CChar> {
    get {}
  }
  func _withUnsafeBufferPointerToUTF8<R>(_ body: (Swift.UnsafeBufferPointer<Swift.UTF8.CodeUnit>) throws -> R) rethrows -> R
  init?(_ utf8: Swift.String.UTF8View)
  typealias UTF8Index = Swift.String.UTF8View.Index
}
extension String {
  @available(*, unavailable, message: "Please use String.utf8CString instead.") var nulTerminatedUTF8: Swift.ContiguousArray<Swift.UTF8.CodeUnit> {
    get {}
  }
}
extension String {
  @available(*, unavailable, message: "cannot subscript String with an Int, see the documentation comment for discussion") subscript(i: Swift.Int) -> Swift.Character {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a Range<Int>, see the documentation comment for discussion") subscript(bounds: Swift.Range<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a ClosedRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.ClosedRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a CountableRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.CountableRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a CountableClosedRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.CountableClosedRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "there is no universally good answer, see the documentation comment for discussion") var count: Swift.Int {
    get {}
  }
}
extension String : MirrorPath {
}
extension String {
  init<Subject>(describing instance: Subject)
  init<Subject>(reflecting subject: Subject)
}
extension String {
  init(_sel: ObjectiveC.Selector)
}
extension String {
  init(_ cocoaString: Foundation.NSString)
}
extension String : _ObjectiveCBridgeable {
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSString
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSString, result: inout Swift.String?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSString, result: inout Swift.String?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSString?) -> Swift.String
  typealias _ObjectiveCType = Foundation.NSString
}
extension String : CVarArg {
}
extension String {
  var _ns: Foundation.NSString {
    get {}
  }
  func _index(_ utf16Index: Swift.Int) -> Swift.String.Index
  func _range(_ r: Foundation.NSRange) -> Swift.Range<Swift.String.Index>
  func _optionalRange(_ r: Foundation.NSRange) -> Swift.Range<Swift.String.Index>?
  func _withOptionalOutParameter<Result>(_ index: Swift.UnsafeMutablePointer<Swift.String.Index>?, _ body: (Swift.UnsafeMutablePointer<Swift.Int>?) -> Result) -> Result
  func _withOptionalOutParameter<Result>(_ range: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>?, _ body: (Swift.UnsafeMutablePointer<Foundation.NSRange>?) -> Result) -> Result
  static var availableStringEncodings: [Swift.String.Encoding] {
    get {}
  }
  static var defaultCStringEncoding: Swift.String.Encoding {
    get {}
  }
  static func localizedName(of encoding: Swift.String.Encoding) -> Swift.String
  static func localizedStringWithFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, message: "Use fileURL(withPathComponents:) on URL instead.") static func path(withComponents components: [Swift.String]) -> Swift.String
  init?(utf8String bytes: Swift.UnsafePointer<Swift.CChar>)
  func canBeConverted(to encoding: Swift.String.Encoding) -> Swift.Bool
  var capitalized: Swift.String {
    get {}
  }
  @available(OSX 10.11, iOS 9.0, *)
  var localizedCapitalized: Swift.String {
    get {}
  }
  func capitalized(with locale: Foundation.Locale?) -> Swift.String
  func caseInsensitiveCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func commonPrefix(with aString: Swift.String, options: Swift.String.CompareOptions = default) -> Swift.String
  func compare(_ aString: Swift.String, options mask: Swift.String.CompareOptions = default, range: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Foundation.ComparisonResult
  func completePath(into outputName: Swift.UnsafeMutablePointer<Swift.String>? = default, caseSensitive: Swift.Bool, matchesInto outputArray: Swift.UnsafeMutablePointer<[Swift.String]>? = default, filterTypes: [Swift.String]? = default) -> Swift.Int
  func components(separatedBy separator: Foundation.CharacterSet) -> [Swift.String]
  func components(separatedBy separator: Swift.String) -> [Swift.String]
  func cString(using encoding: Swift.String.Encoding) -> [Swift.CChar]?
  func data(using encoding: Swift.String.Encoding, allowLossyConversion: Swift.Bool = default) -> Foundation.Data?
  var decomposedStringWithCanonicalMapping: Swift.String {
    get {}
  }
  var decomposedStringWithCompatibilityMapping: Swift.String {
    get {}
  }
  func enumerateLines(invoking body: @escaping (Swift.String, inout Swift.Bool) -> ())
  func enumerateLinguisticTags(in range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, invoking body: (Swift.String, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  func enumerateSubstrings(in range: Swift.Range<Swift.String.Index>, options opts: Swift.String.EnumerationOptions = default, _ body: @escaping (Swift.String?, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  var fastestEncoding: Swift.String.Encoding {
    get {}
  }
  @available(*, unavailable, message: "Use getFileSystemRepresentation on URL instead.") var fileSystemRepresentation: [Swift.CChar] {
    get {}
  }
  func getBytes(_ buffer: inout [Swift.UInt8], maxLength maxBufferCount: Swift.Int, usedLength usedBufferCount: Swift.UnsafeMutablePointer<Swift.Int>, encoding: Swift.String.Encoding, options: Swift.String.EncodingConversionOptions = default, range: Swift.Range<Swift.String.Index>, remaining leftover: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>) -> Swift.Bool
  func getCString(_ buffer: inout [Swift.CChar], maxLength: Swift.Int, encoding: Swift.String.Encoding) -> Swift.Bool
  @available(*, unavailable, message: "Use getFileSystemRepresentation on URL instead.") func getFileSystemRepresentation(_ buffer: inout [Swift.CChar], maxLength: Swift.Int) -> Swift.Bool
  func getLineStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, for range: Swift.Range<Swift.String.Index>)
  func getParagraphStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, for range: Swift.Range<Swift.String.Index>)
  var hash: Swift.Int {
    get {}
  }
  init?<S : Sequence where S.Iterator.Element == UInt8>(bytes: S, encoding: Swift.String.Encoding)
  init?(bytesNoCopy bytes: Swift.UnsafeMutableRawPointer, length: Swift.Int, encoding: Swift.String.Encoding, freeWhenDone flag: Swift.Bool)
  init(utf16CodeUnits: Swift.UnsafePointer<Foundation.unichar>, count: Swift.Int)
  init(utf16CodeUnitsNoCopy: Swift.UnsafePointer<Foundation.unichar>, count: Swift.Int, freeWhenDone flag: Swift.Bool)
  init(contentsOfFile path: Swift.String, encoding enc: Swift.String.Encoding) throws
  init(contentsOfFile path: Swift.String, usedEncoding: inout Swift.String.Encoding) throws
  init(contentsOfFile path: Swift.String) throws
  init(contentsOf url: Foundation.URL, encoding enc: Swift.String.Encoding) throws
  init(contentsOf url: Foundation.URL, usedEncoding: inout Swift.String.Encoding) throws
  init(contentsOf url: Foundation.URL) throws
  init?(cString: Swift.UnsafePointer<Swift.CChar>, encoding enc: Swift.String.Encoding)
  init?(data: Foundation.Data, encoding: Swift.String.Encoding)
  init(format: Swift.String, _ arguments: CVarArg...)
  init(format: Swift.String, arguments: [CVarArg])
  init(format: Swift.String, locale: Foundation.Locale?, _ args: CVarArg...)
  init(format: Swift.String, locale: Foundation.Locale?, arguments: [CVarArg])
  @available(*, unavailable, message: "Use lastPathComponent on URL instead.") var lastPathComponent: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Take the count of a UTF-16 view instead, i.e. str.utf16.count") var utf16Count: Swift.Int {
    get {}
  }
  func lengthOfBytes(using encoding: Swift.String.Encoding) -> Swift.Int
  func lineRange(for aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  func linguisticTags(in range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, tokenRanges: Swift.UnsafeMutablePointer<[Swift.Range<Swift.String.Index>]>? = default) -> [Swift.String]
  func localizedCaseInsensitiveCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func localizedCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func localizedStandardCompare(_ string: Swift.String) -> Foundation.ComparisonResult
  @available(OSX 10.11, iOS 9.0, *)
  var localizedLowercase: Swift.String {
    get {}
  }
  func lowercased(with locale: Foundation.Locale?) -> Swift.String
  func maximumLengthOfBytes(using encoding: Swift.String.Encoding) -> Swift.Int
  func paragraphRange(for aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, message: "Use pathComponents on URL instead.") var pathComponents: [Swift.String] {
    get {}
  }
  @available(*, unavailable, message: "Use pathExtension on URL instead.") var pathExtension: Swift.String {
    get {}
  }
  var precomposedStringWithCanonicalMapping: Swift.String {
    get {}
  }
  var precomposedStringWithCompatibilityMapping: Swift.String {
    get {}
  }
  func propertyList() -> Any
  func propertyListFromStringsFileFormat() -> [Swift.String : Swift.String]
  func rangeOfCharacter(from aSet: Foundation.CharacterSet, options mask: Swift.String.CompareOptions = default, range aRange: Swift.Range<Swift.String.Index>? = default) -> Swift.Range<Swift.String.Index>?
  func rangeOfComposedCharacterSequence(at anIndex: Swift.String.Index) -> Swift.Range<Swift.String.Index>
  func rangeOfComposedCharacterSequences(for range: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  func range(of aString: Swift.String, options mask: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Swift.Range<Swift.String.Index>?
  @available(OSX 10.11, iOS 9.0, *)
  func localizedStandardContains(_ string: Swift.String) -> Swift.Bool
  @available(OSX 10.11, iOS 9.0, *)
  func localizedStandardRange(of string: Swift.String) -> Swift.Range<Swift.String.Index>?
  var smallestEncoding: Swift.String.Encoding {
    get {}
  }
  @available(*, unavailable, message: "Use abbreviatingWithTildeInPath on NSString instead.") var abbreviatingWithTildeInPath: Swift.String {
    get {}
  }
  func addingPercentEncoding(withAllowedCharacters allowedCharacters: Foundation.CharacterSet) -> Swift.String?
  @available(*, deprecated, message: "Use addingPercentEncoding(withAllowedCharacters:) instead, which always uses the recommended UTF-8 encoding, and which encodes for a specific URL component or subcomponent since each URL component or subcomponent has different rules for what characters are valid.") func addingPercentEscapes(using encoding: Swift.String.Encoding) -> Swift.String?
  func appendingFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, message: "Use appendingPathComponent on URL instead.") func appendingPathComponent(_ aString: Swift.String) -> Swift.String
  @available(*, unavailable, message: "Use appendingPathExtension on URL instead.") func appendingPathExtension(_ ext: Swift.String) -> Swift.String?
  func appending(_ aString: Swift.String) -> Swift.String
  @available(*, unavailable, message: "Use deletingLastPathComponent on URL instead.") var deletingLastPathComponent: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use deletingPathExtension on URL instead.") var deletingPathExtension: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use expandingTildeInPath on NSString instead.") var expandingTildeInPath: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "folding(options:locale:)") func folding(_ options: Swift.String.CompareOptions = default, locale: Foundation.Locale?) -> Swift.String
  func folding(options: Swift.String.CompareOptions = default, locale: Foundation.Locale?) -> Swift.String
  func padding(toLength newLength: Swift.Int, withPad padString: Swift.String, startingAt padIndex: Swift.Int) -> Swift.String
  var removingPercentEncoding: Swift.String? {
    get {}
  }
  func replacingCharacters(in range: Swift.Range<Swift.String.Index>, with replacement: Swift.String) -> Swift.String
  func replacingOccurrences(of target: Swift.String, with replacement: Swift.String, options: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default) -> Swift.String
  @available(*, deprecated, message: "Use removingPercentEncoding instead, which always uses the recommended UTF-8 encoding.") func replacingPercentEscapes(using encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, message: "Use resolvingSymlinksInPath on URL instead.") var resolvingSymlinksInPath: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use standardizingPath on URL instead.") var standardizingPath: Swift.String {
    get {}
  }
  func trimmingCharacters(in set: Foundation.CharacterSet) -> Swift.String
  @available(*, unavailable, message: "Map over paths with appendingPathComponent instead.") func strings(byAppendingPaths paths: [Swift.String]) -> [Swift.String]
  func substring(from index: Swift.String.Index) -> Swift.String
  func substring(to index: Swift.String.Index) -> Swift.String
  func substring(with aRange: Swift.Range<Swift.String.Index>) -> Swift.String
  @available(OSX 10.11, iOS 9.0, *)
  var localizedUppercase: Swift.String {
    get {}
  }
  func uppercased(with locale: Foundation.Locale?) -> Swift.String
  func write(toFile path: Swift.String, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  func write(to url: Foundation.URL, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  @available(OSX 10.11, iOS 9.0, *)
  func applyingTransform(_ transform: Foundation.StringTransform, reverse: Swift.Bool) -> Swift.String?
  func contains(_ other: Swift.String) -> Swift.Bool
  func localizedCaseInsensitiveContains(_ other: Swift.String) -> Swift.Bool
}
extension String {
  @available(*, unavailable, renamed: "localizedName(of:)") static func localizedNameOfStringEncoding(_ encoding: Swift.String.Encoding) -> Swift.String
  @available(*, unavailable, message: "Use fileURL(withPathComponents:) on URL instead.") static func pathWithComponents(_ components: [Swift.String]) -> Swift.String
  @available(*, unavailable, renamed: "canBeConverted(to:)") func canBeConvertedToEncoding(_ encoding: Swift.String.Encoding) -> Swift.Bool
  @available(*, unavailable, renamed: "capitalizedString(with:)") func capitalizedStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "commonPrefix(with:options:)") func commonPrefixWith(_ aString: Swift.String, options: Swift.String.CompareOptions) -> Swift.String
  @available(*, unavailable, renamed: "completePath(into:outputName:caseSensitive:matchesInto:filterTypes:)") func completePathInto(_ outputName: Swift.UnsafeMutablePointer<Swift.String>? = default, caseSensitive: Swift.Bool, matchesInto matchesIntoArray: Swift.UnsafeMutablePointer<[Swift.String]>? = default, filterTypes: [Swift.String]? = default) -> Swift.Int
  @available(*, unavailable, renamed: "components(separatedBy:)") func componentsSeparatedByCharactersIn(_ separator: Foundation.CharacterSet) -> [Swift.String]
  @available(*, unavailable, renamed: "componentsSeparated(by:)") func componentsSeparatedBy(_ separator: Swift.String) -> [Swift.String]
  @available(*, unavailable, renamed: "cString(usingEncoding:)") func cStringUsingEncoding(_ encoding: Swift.String.Encoding) -> [Swift.CChar]?
  @available(*, unavailable, renamed: "data(usingEncoding:allowLossyConversion:)") func dataUsingEncoding(_ encoding: Swift.String.Encoding, allowLossyConversion: Swift.Bool = default) -> Foundation.Data?
  @available(*, unavailable, renamed: "enumerateLinguisticTags(in:scheme:options:orthography:_:)") func enumerateLinguisticTagsIn(_ range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options, orthography: Foundation.NSOrthography?, _ body: (Swift.String, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  @available(*, unavailable, renamed: "enumerateSubstrings(in:options:_:)") func enumerateSubstringsIn(_ range: Swift.Range<Swift.String.Index>, options opts: Swift.String.EnumerationOptions = default, _ body: (Swift.String?, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  @available(*, unavailable, renamed: "getBytes(_:maxLength:usedLength:encoding:options:range:remaining:)") func getBytes(_ buffer: inout [Swift.UInt8], maxLength maxBufferCount: Swift.Int, usedLength usedBufferCount: Swift.UnsafeMutablePointer<Swift.Int>, encoding: Swift.String.Encoding, options: Swift.String.EncodingConversionOptions = default, range: Swift.Range<Swift.String.Index>, remainingRange leftover: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>) -> Swift.Bool
  @available(*, unavailable, renamed: "getLineStart(_:end:contentsEnd:for:)") func getLineStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, forRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "getParagraphStart(_:end:contentsEnd:for:)") func getParagraphStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, forRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "lengthOfBytes(using:)") func lengthOfBytesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.Int
  @available(*, unavailable, renamed: "lineRange(for:)") func lineRangeFor(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "linguisticTags(in:scheme:options:orthography:tokenRanges:)") func linguisticTagsIn(_ range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, tokenRanges: Swift.UnsafeMutablePointer<[Swift.Range<Swift.String.Index>]>? = default) -> [Swift.String]
  @available(*, unavailable, renamed: "lowercased(with:)") func lowercaseStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "maximumLengthOfBytes(using:)") func maximumLengthOfBytesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.Int
  @available(*, unavailable, renamed: "paragraphRange(for:)") func paragraphRangeFor(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "rangeOfCharacter(from:options:range:)") func rangeOfCharacterFrom(_ aSet: Foundation.CharacterSet, options mask: Swift.String.CompareOptions = default, range aRange: Swift.Range<Swift.String.Index>? = default) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "rangeOfComposedCharacterSequence(at:)") func rangeOfComposedCharacterSequenceAt(_ anIndex: Swift.String.Index) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "rangeOfComposedCharacterSequences(for:)") func rangeOfComposedCharacterSequencesFor(_ range: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "range(of:options:range:locale:)") func rangeOf(_ aString: Swift.String, options mask: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "localizedStandardRange(of:)") func localizedStandardRangeOf(_ string: Swift.String) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "addingPercentEncoding(withAllowedCharacters:)") func addingPercentEncodingWithAllowedCharacters(_ allowedCharacters: Foundation.CharacterSet) -> Swift.String?
  @available(*, unavailable, renamed: "addingPercentEscapes(using:)") func addingPercentEscapesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, renamed: "appendingFormat") func stringByAppendingFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, renamed: "padding(toLength:with:startingAt:)") func byPaddingToLength(_ newLength: Swift.Int, withString padString: Swift.String, startingAt padIndex: Swift.Int) -> Swift.String
  @available(*, unavailable, renamed: "replacingCharacters(in:with:)") func replacingCharactersIn(_ range: Swift.Range<Swift.String.Index>, withString replacement: Swift.String) -> Swift.String
  @available(*, unavailable, renamed: "replacingOccurrences(of:with:options:range:)") func replacingOccurrencesOf(_ target: Swift.String, withString replacement: Swift.String, options: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default) -> Swift.String
  @available(*, unavailable, renamed: "replacingPercentEscapes(usingEncoding:)") func replacingPercentEscapesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, renamed: "trimmingCharacters(in:)") func byTrimmingCharactersIn(_ set: Foundation.CharacterSet) -> Swift.String
  @available(*, unavailable, renamed: "strings(byAppendingPaths:)") func stringsByAppendingPaths(_ paths: [Swift.String]) -> [Swift.String]
  @available(*, unavailable, renamed: "substring(from:)") func substringFrom(_ index: Swift.String.Index) -> Swift.String
  @available(*, unavailable, renamed: "substring(to:)") func substringTo(_ index: Swift.String.Index) -> Swift.String
  @available(*, unavailable, renamed: "substring(with:)") func substringWith(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.String
  @available(*, unavailable, renamed: "uppercased(with:)") func uppercaseStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "write(toFile:atomically:encoding:)") func writeToFile(_ path: Swift.String, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  @available(*, unavailable, renamed: "write(to:atomically:encoding:)") func writeToURL(_ url: Foundation.URL, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
}
extension String {
  struct Encoding : RawRepresentable {
    var rawValue: Swift.UInt
    init(rawValue: Swift.UInt)
    static var ascii: Swift.String.Encoding
    static var nextstep: Swift.String.Encoding
    static var japaneseEUC: Swift.String.Encoding
    static var utf8: Swift.String.Encoding
    static var isoLatin1: Swift.String.Encoding
    static var symbol: Swift.String.Encoding
    static var nonLossyASCII: Swift.String.Encoding
    static var shiftJIS: Swift.String.Encoding
    static var isoLatin2: Swift.String.Encoding
    static var unicode: Swift.String.Encoding
    static var windowsCP1251: Swift.String.Encoding
    static var windowsCP1252: Swift.String.Encoding
    static var windowsCP1253: Swift.String.Encoding
    static var windowsCP1254: Swift.String.Encoding
    static var windowsCP1250: Swift.String.Encoding
    static var iso2022JP: Swift.String.Encoding
    static var macOSRoman: Swift.String.Encoding
    static var utf16: Swift.String.Encoding
    static var utf16BigEndian: Swift.String.Encoding
    static var utf16LittleEndian: Swift.String.Encoding
    static var utf32: Swift.String.Encoding
    static var utf32BigEndian: Swift.String.Encoding
    static var utf32LittleEndian: Swift.String.Encoding
    typealias RawValue = Swift.UInt
  }
  typealias EncodingConversionOptions = Foundation.NSString.EncodingConversionOptions
  typealias EnumerationOptions = Foundation.NSString.EnumerationOptions
  typealias CompareOptions = Foundation.NSString.CompareOptions
}
extension String : Toastable {
  func mainMessage() -> Swift.String
  func detailMessage() -> Swift.String
}
struct ReversedRandomAccessIndex<Base : RandomAccessCollection> : Comparable {
  init(_ base: Base.Index)
  let base: Base.Index
  static func ==(lhs: Swift.ReversedRandomAccessIndex<Base>, rhs: Swift.ReversedRandomAccessIndex<Base>) -> Swift.Bool
  static func <(lhs: Swift.ReversedRandomAccessIndex<Base>, rhs: Swift.ReversedRandomAccessIndex<Base>) -> Swift.Bool
}
@_semantics("availability.osversion") func _stdlib_isOSVersionAtLeast(_ major: Builtin.Word, _ minor: Builtin.Word, _ patch: Builtin.Word) -> Builtin.Int1
@_versioned func _conditionallyUnreachable() -> Swift.Never
@_versioned @inline(never) @_semantics("stdlib_binary_only") @_semantics("arc.programtermination_point") func _fatalErrorMessage(_ prefix: Swift.StaticString, _ message: Swift.StaticString, _ file: Swift.StaticString, _ line: Swift.UInt, flags: Swift.UInt32) -> Swift.Never
enum PlaygroundQuickLook {
  case text(Swift.String)
  case int(Swift.Int64)
  case uInt(Swift.UInt64)
  case float(Swift.Float32)
  case double(Swift.Float64)
  case image(Any)
  case sound(Any)
  case color(Any)
  case bezierPath(Any)
  case attributedString(Any)
  case rectangle(Swift.Float64, Swift.Float64, Swift.Float64, Swift.Float64)
  case point(Swift.Float64, Swift.Float64)
  case size(Swift.Float64, Swift.Float64)
  case bool(Swift.Bool)
  case range(Swift.Int64, Swift.Int64)
  case view(Any)
  case sprite(Any)
  case url(Swift.String)
  case _raw([Swift.UInt8], Swift.String)
}
extension PlaygroundQuickLook {
  init(reflecting subject: Any)
}
protocol ExpressibleByIntegerLiteral {
  associatedtype IntegerLiteralType : _ExpressibleByBuiltinIntegerLiteral
  init(integerLiteral value: Self.IntegerLiteralType)
}
func _decodeCString<Encoding : UnicodeCodec>(_ cString: Swift.UnsafePointer<Encoding.CodeUnit>, as encoding: Encoding.Type, length: Swift.Int, repairingInvalidCodeUnits isRepairing: Swift.Bool = default) -> (result: Swift.String, repairsMade: Swift.Bool)?
enum _VariantDictionaryStorage<Key : Hashable, Value> : _HashStorage {
  typealias NativeStorage = Swift._NativeDictionaryStorage<Key, Value>
  typealias NativeStorageOwner = Swift._NativeDictionaryStorageOwner<Key, Value>
  typealias NativeIndex = Swift._NativeDictionaryIndex<Key, Value>
  typealias CocoaStorage = Swift._CocoaDictionaryStorage
  typealias SequenceElement = (key: Key, value: Value)
  typealias SequenceElementWithoutLabels = (key: Key, value: Value)
  typealias SelfType = Swift._VariantDictionaryStorage<Key, Value>
  case native(Swift._NativeDictionaryStorageOwner<Key, Value>)
  case cocoa(Swift._VariantDictionaryStorage.CocoaStorage)
  @_versioned var guaranteedNative: Swift.Bool {
    get {}
  }
  mutating func isUniquelyReferenced() -> Swift.Bool
  @_versioned var asNative: Swift._NativeDictionaryStorage<Key, Value> {
    get {}
  }
  var asCocoa: Swift._VariantDictionaryStorage.CocoaStorage {
    get {}
  }
  mutating func ensureUniqueNativeStorage(_ minimumCapacity: Swift.Int) -> (reallocated: Swift.Bool, capacityChanged: Swift.Bool)
  @inline(never) mutating func migrateDataToNativeStorage(_ cocoaStorage: Swift._CocoaDictionaryStorage)
  typealias Index = Swift.DictionaryIndex<Key, Value>
  var startIndex: Swift.DictionaryIndex<Key, Value> {
    get {}
  }
  var endIndex: Swift.DictionaryIndex<Key, Value> {
    get {}
  }
  @_versioned func index(after i: Swift.DictionaryIndex<Key, Value>) -> Swift.DictionaryIndex<Key, Value>
  func formIndex(after i: inout Swift.DictionaryIndex<Key, Value>)
  @_versioned @inline(__always) func index(forKey key: Key) -> Swift.DictionaryIndex<Key, Value>?
  func assertingGet(_ i: Swift.DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
  func assertingGet(_ key: Key) -> Value
  @_versioned @inline(never) static func maybeGetFromCocoaStorage(_ cocoaStorage: Swift._VariantDictionaryStorage.CocoaStorage, forKey key: Key) -> Value?
  @_versioned @inline(__always) func maybeGet(_ key: Key) -> Value?
  mutating func nativeUpdateValue(_ value: Value, forKey key: Key) -> Value?
  @discardableResult mutating func updateValue(_ value: Value, forKey key: Key) -> Value?
  mutating func nativeInsert(_ value: Value, forKey key: Key) -> (inserted: Swift.Bool, memberAfterInsert: Value)
  @discardableResult mutating func insert(_ value: Value, forKey key: Key) -> (inserted: Swift.Bool, memberAfterInsert: Value)
  mutating func nativeDeleteImpl(_ nativeStorage: Swift._NativeDictionaryStorage<Key, Value>, idealBucket: Swift.Int, offset: Swift.Int)
  mutating func nativeRemoveObject(forKey key: Key) -> Value?
  mutating func nativeRemove(at nativeIndex: Swift._NativeDictionaryIndex<Key, Value>) -> (key: Key, value: Value)
  @discardableResult mutating func remove(at index: Swift.DictionaryIndex<Key, Value>) -> (key: Key, value: Value)
  @discardableResult mutating func removeValue(forKey key: Key) -> Value?
  mutating func nativeRemoveAll()
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool)
  var count: Swift.Int {
    get {}
  }
  @_versioned @inline(__always) func makeIterator() -> Swift.DictionaryIterator<Key, Value>
  static func fromArray(_ elements: [(key: Key, value: Value)]) -> Swift._VariantDictionaryStorage<Key, Value>
  typealias Key = Key
  typealias Value = Value
}
func withUnsafePointer<T, Result>(to arg: inout T, _ body: (Swift.UnsafePointer<T>) throws -> Result) rethrows -> Result
@available(*, unavailable, renamed: "withUnsafePointer(to:_:)") func withUnsafePointer<T, Result>(_ arg: inout T, _ body: (Swift.UnsafePointer<T>) throws -> Result) rethrows -> Result
struct _IgnorePointer<T> : _PointerFunction {
  func call(_: Swift.UnsafeMutablePointer<T>, count: Swift.Int)
  init()
  typealias Element = T
}
struct UnsafeMutablePointer<Pointee> : Strideable, Hashable, _Pointer {
  typealias Distance = Swift.Int
  let _rawValue: Builtin.RawPointer
  init(_ _rawValue: Builtin.RawPointer)
  init(_ from: Swift.OpaquePointer)
  init?(_ from: Swift.OpaquePointer?)
  init?(bitPattern: Swift.Int)
  init?(bitPattern: Swift.UInt)
  init(_ other: Swift.UnsafeMutablePointer<Pointee>)
  init?(_ other: Swift.UnsafeMutablePointer<Pointee>?)
  init(mutating other: Swift.UnsafePointer<Pointee>)
  init?(mutating other: Swift.UnsafePointer<Pointee>?)
  static func allocate(capacity count: Swift.Int) -> Swift.UnsafeMutablePointer<Pointee>
  func deallocate(capacity: Swift.Int)
  var pointee: Pointee
  var pointee: Pointee {
    unsafeAddress {}
    unsafeMutableAddress {}
  }
  func initialize(to newValue: Pointee, count: Swift.Int = default)
  func move() -> Pointee
  func assign(from source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  func moveInitialize(from source: Swift.UnsafeMutablePointer<Pointee>, count: Swift.Int)
  func initialize(from source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  func initialize<C : Collection where C.Iterator.Element == Pointee>(from source: C)
  func moveAssign(from source: Swift.UnsafeMutablePointer<Pointee>, count: Swift.Int)
  @discardableResult func deinitialize(count: Swift.Int = default) -> Swift.UnsafeMutableRawPointer
  func withMemoryRebound<T, Result>(to: T.Type, capacity count: Swift.Int, _ body: (Swift.UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result
  subscript(i: Swift.Int) -> Pointee {
    unsafeAddress {}
    unsafeMutableAddress {}
  }
  var hashValue: Swift.Int {
    get {}
  }
  func successor() -> Swift.UnsafeMutablePointer<Pointee>
  func predecessor() -> Swift.UnsafeMutablePointer<Pointee>
  func distance(to x: Swift.UnsafeMutablePointer<Pointee>) -> Swift.Int
  func advanced(by n: Swift.Int) -> Swift.UnsafeMutablePointer<Pointee>
  typealias Stride = Swift.Int
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension UnsafeMutablePointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension UnsafeMutablePointer : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UnsafeMutablePointer : CustomPlaygroundQuickLookable {
  var summary: Swift.String {
    get {}
  }
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UnsafeMutablePointer {
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init<U>(_ from: Swift.UnsafeMutablePointer<U>)
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init?<U>(_ from: Swift.UnsafeMutablePointer<U>?)
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init<U>(_ from: Swift.UnsafePointer<U>)
  @available(*, unavailable, message: "use 'withMemoryRebound(to:capacity:_)' to temporarily view memory as another layout-compatible type.") init?<U>(_ from: Swift.UnsafePointer<U>?)
  @available(*, unavailable, renamed: "init(mutating:)") init(_ from: Swift.UnsafePointer<Pointee>)
  @available(*, unavailable, renamed: "init(mutating:)") init?(_ from: Swift.UnsafePointer<Pointee>?)
  @available(*, unavailable, renamed: "Pointee") typealias Memory = Pointee
  @available(*, unavailable, message: "use 'nil' literal") init()
  @available(*, unavailable, renamed: "allocate(capacity:)") static func alloc(_ num: Swift.Int) -> Swift.UnsafeMutablePointer<Pointee>
  @available(*, unavailable, message: "use 'UnsafeMutablePointer.allocate(capacity:)'") init(allocatingCapacity: Swift.Int)
  @available(*, unavailable, renamed: "deallocate(capacity:)") func dealloc(_ num: Swift.Int)
  @available(*, unavailable, renamed: "deallocate(capacity:)") func deallocateCapacity(_ num: Swift.Int)
  @available(*, unavailable, renamed: "pointee") var memory: Pointee {
    get {}
    set(newValue) {}
  }
  @available(*, unavailable, renamed: "initialize(to:)") func initialize(_ newvalue: Pointee)
  @available(*, unavailable, renamed: "initialize(to:count:)") func initialize(with newvalue: Pointee, count: Swift.Int = default)
  @available(*, unavailable, renamed: "deinitialize(count:)") func destroy()
  @available(*, unavailable, renamed: "deinitialize(count:)") func destroy(_ count: Swift.Int)
  @available(*, unavailable, renamed: "initialize(from:)") func initializeFrom<C : Collection>(_ source: C)
  @available(*, unavailable, renamed: "initialize(from:count:)") func initializeFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  @available(*, unavailable, renamed: "assign(from:count:)") func assignFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  @available(*, unavailable, renamed: "assign(from:count:)") func assignBackwardFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  @available(*, unavailable, renamed: "moveInitialize(from:count:)") func moveInitializeFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  @available(*, unavailable, renamed: "moveInitialize(from:count:)") func moveInitializeBackwardFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
  @available(*, unavailable, renamed: "moveAssign(from:count:)") func moveAssignFrom(_ source: Swift.UnsafePointer<Pointee>, count: Swift.Int)
}
extension UnsafeMutablePointer : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
func max<T : Comparable>(_ x: T, _ y: T) -> T
func max<T : Comparable>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T
@_silgen_name("swift_bufferAllocate") func _swift_bufferAllocate(bufferType type: Swift.AnyClass, size: Swift.Int, alignmentMask: Swift.Int) -> AnyObject
@_versioned func _roundUp(_ offset: Swift.UInt, toAlignment alignment: Swift.Int) -> Swift.UInt
@_versioned func _roundUp(_ offset: Swift.Int, toAlignment alignment: Swift.Int) -> Swift.Int
@_versioned func _roundUp<DestinationType>(_ pointer: Swift.UnsafeMutableRawPointer, toAlignmentOf destinationType: DestinationType.Type) -> Swift.UnsafeMutablePointer<DestinationType>
@_versioned @inline(never) @_semantics("stdlib_binary_only") func _print<Target : TextOutputStream>(_ items: [Any], separator: Swift.String = default, terminator: Swift.String = default, to output: inout Target)
func _dumpSuperclass_unlocked<TargetStream : TextOutputStream>(mirror: Swift.Mirror, to target: inout TargetStream, indent: Swift.Int, maxDepth: Swift.Int, maxItemCounter: inout Swift.Int, visitedItems: inout [Swift.ObjectIdentifier : Swift.Int])
func _countLeadingZeros(_ value: Swift.Int64) -> Swift.Int64
struct _EnumMirror : _Mirror {
  let data: Swift._MagicMirrorData
  var value: Any {
    get {}
  }
  var valueType: Any.Type {
    get {}
  }
  var objectIdentifier: Swift.ObjectIdentifier? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  var caseName: Swift.UnsafePointer<Swift.CChar> {
    get {}
  }
  subscript(i: Swift.Int) -> (Swift.String, _Mirror) {
    get {}
  }
  var summary: Swift.String {
    get {}
  }
  var quickLookObject: Swift.PlaygroundQuickLook? {
    get {}
  }
  var disposition: Swift._MirrorDisposition {
    get {}
  }
  init(data: Swift._MagicMirrorData)
}
func _stdlib_atomicCompareExchangeStrongInt(object target: Swift.UnsafeMutablePointer<Swift.Int>, expected: Swift.UnsafeMutablePointer<Swift.Int>, desired: Swift.Int) -> Swift.Bool
struct AnyIterator<Element> : IteratorProtocol {
  init<I : IteratorProtocol where I.Element == Element>(_ base: I)
  init(_ body: @escaping () -> Element?)
  init(_box: Swift._AnyIteratorBoxBase<Element>)
  func next() -> Element?
  let _box: Swift._AnyIteratorBoxBase<Element>
  typealias Element = Element
}
extension AnyIterator : Sequence {
  typealias Iterator = Swift.AnyIterator<Element>
  typealias SubSequence = Swift.AnySequence<Element>
}
extension AnyIterator {
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.AnyIterator<Element>
}
struct FlattenBidirectionalCollection<Base where Base : BidirectionalCollection, Base.Iterator.Element : BidirectionalCollection> : BidirectionalCollection {
  typealias Index = Swift.FlattenBidirectionalCollectionIndex<Base>
  typealias IndexDistance = Base.IndexDistance
  init(_ base: Base)
  func makeIterator() -> Swift.FlattenIterator<Base.Iterator>
  var startIndex: Swift.FlattenBidirectionalCollectionIndex<Base> {
    get {}
  }
  var endIndex: Swift.FlattenBidirectionalCollectionIndex<Base> {
    get {}
  }
  func index(after i: Swift.FlattenBidirectionalCollectionIndex<Base>) -> Swift.FlattenBidirectionalCollectionIndex<Base>
  func index(before i: Swift.FlattenBidirectionalCollectionIndex<Base>) -> Swift.FlattenBidirectionalCollectionIndex<Base>
  subscript(position: Swift.FlattenBidirectionalCollectionIndex<Base>) -> Base.Iterator.Element.Iterator.Element {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.FlattenBidirectionalCollectionIndex<Base>>) -> Swift.BidirectionalSlice<Swift.FlattenBidirectionalCollection<Base>> {
    get {}
  }
  var underestimatedCount: Swift.Int {
    get {}
  }
  func _copyToContiguousArray() -> Swift.ContiguousArray<Base.Iterator.Element.Iterator.Element>
  func forEach(_ body: (Base.Iterator.Element.Iterator.Element) throws -> Swift.Void) rethrows
  var _base: Base
  typealias _Element = Base.Iterator.Element.Iterator.Element
  typealias SubSequence = Swift.BidirectionalSlice<Swift.FlattenBidirectionalCollection<Base>>
  typealias Indices = Swift.DefaultBidirectionalIndices<Swift.FlattenBidirectionalCollection<Base>>
  typealias Iterator = Swift.FlattenIterator<Base.Iterator>
}
extension FlattenBidirectionalCollection {
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
}
func _bridgeAnyObjectToAny(_ possiblyNullObject: AnyObject?) -> Any
protocol MutableCollection : MutableIndexable, Collection {
  associatedtype SubSequence : Collection = Swift.MutableSlice<Self>
  subscript(position: Self.Index) -> Self.Iterator.Element { get set }
  subscript(bounds: Swift.Range<Self.Index>) -> Self.SubSequence { get set }
  mutating func partition(by belongsInSecondPartition: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index
  mutating func _withUnsafeMutableBufferPointerIfSupported<R>(_ body: (Swift.UnsafeMutablePointer<Self.Iterator.Element>, Swift.Int) throws -> R) rethrows -> R?
}
extension MutableCollection {
  mutating func partition(by belongsInSecondPartition: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index
}
extension MutableCollection where Self : BidirectionalCollection {
  mutating func partition(by belongsInSecondPartition: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index
}
extension MutableCollection where Self.Iterator.Element : Comparable {
  func sorted() -> [Self.Iterator.Element]
}
extension MutableCollection {
  func sorted(by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool) -> [Self.Iterator.Element]
}
extension MutableCollection where Self : RandomAccessCollection, Self.Iterator.Element : Comparable {
  mutating func sort()
}
extension MutableCollection where Self : RandomAccessCollection {
  mutating func sort(by areInIncreasingOrder: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool)
}
extension MutableCollection where Self : RandomAccessCollection {
  @available(*, unavailable, message: "call partition(by:)") mutating func partition(isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool) -> Self.Index
  @available(*, unavailable, message: "slice the collection using the range, and call partition(by:)") mutating func partition(_ range: Swift.Range<Self.Index>, isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool) -> Self.Index
}
extension MutableCollection where Self : RandomAccessCollection, Iterator.Element : Comparable {
  @available(*, unavailable, message: "call partition(by:)") mutating func partition() -> Self.Index
  @available(*, unavailable, message: "slice the collection using the range, and call partition(by:)") mutating func partition(_ range: Swift.Range<Self.Index>) -> Self.Index
}
extension MutableCollection where Self : RandomAccessCollection, Self.Iterator.Element : Comparable {
  @available(*, unavailable, renamed: "sort()") mutating func sortInPlace()
}
extension MutableCollection where Self : RandomAccessCollection {
  @available(*, unavailable, renamed: "sort(by:)") mutating func sortInPlace(_ isOrderedBefore: (Self.Iterator.Element, Self.Iterator.Element) -> Swift.Bool)
}
extension MutableCollection {
  mutating func _withUnsafeMutableBufferPointerIfSupported<R>(_ body: (Swift.UnsafeMutablePointer<Self.Iterator.Element>, Swift.Int) throws -> R) rethrows -> R?
  subscript(bounds: Swift.Range<Self.Index>) -> Swift.MutableSlice<Self> {
    get {}
    set(newValue) {}
  }
}
extension MutableCollection where Self : BidirectionalCollection {
  mutating func reverse()
}
func _convertInOutToPointerArgument<ToPointer : _Pointer>(_ from: Builtin.RawPointer) -> ToPointer
struct DefaultRandomAccessIndices<Elements : RandomAccessIndexable> : RandomAccessCollection {
  typealias Index = Elements.Index
  init(_elements: Elements, startIndex: Elements.Index, endIndex: Elements.Index)
  var startIndex: Elements.Index {
    get {}
  }
  var endIndex: Elements.Index {
    get {}
  }
  subscript(i: Elements.Index) -> Elements.Index {
    get {}
  }
  typealias SubSequence = Swift.DefaultRandomAccessIndices<Elements>
  subscript(bounds: Swift.Range<Elements.Index>) -> Swift.DefaultRandomAccessIndices<Elements> {
    get {}
  }
  func index(after i: Elements.Index) -> Elements.Index
  func formIndex(after i: inout Elements.Index)
  func index(before i: Elements.Index) -> Elements.Index
  func formIndex(before i: inout Elements.Index)
  typealias Indices = Swift.DefaultRandomAccessIndices<Elements>
  var indices: Swift.DefaultRandomAccessIndices<Elements> {
    get {}
  }
  var _elements: Elements
  var _startIndex: Elements.Index
  var _endIndex: Elements.Index
  typealias _Element = Elements.Index
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift.DefaultRandomAccessIndices<Elements>>
}
func _autorelease(_ x: AnyObject)
protocol _ExpressibleByBuiltinExtendedGraphemeClusterLiteral : _ExpressibleByBuiltinUnicodeScalarLiteral {
  init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
func _replPrintLiteralString(_ text: Swift.String)
struct ManagedBufferPointer<Header, Element> : Equatable {
  init(bufferClass: Swift.AnyClass, minimumCapacity: Swift.Int, makingHeaderWith factory: (AnyObject, (AnyObject) -> Swift.Int) throws -> Header) rethrows
  init(unsafeBufferObject buffer: AnyObject)
  @_versioned init(_uncheckedUnsafeBufferObject buffer: AnyObject)
  var header: Header
  var header: Header {
    addressWithNativeOwner {}
    mutableAddressWithNativeOwner {}
  }
  var buffer: AnyObject {
    get {}
  }
  var capacity: Swift.Int {
    get {}
  }
  func withUnsafeMutablePointerToHeader<R>(_ body: (Swift.UnsafeMutablePointer<Header>) throws -> R) rethrows -> R
  func withUnsafeMutablePointerToElements<R>(_ body: (Swift.UnsafeMutablePointer<Element>) throws -> R) rethrows -> R
  func withUnsafeMutablePointers<R>(_ body: (Swift.UnsafeMutablePointer<Header>, Swift.UnsafeMutablePointer<Element>) throws -> R) rethrows -> R
  mutating func isUniqueReference() -> Swift.Bool
  init(bufferClass: Swift.AnyClass, minimumCapacity: Swift.Int)
  @_versioned init(_uncheckedBufferClass: Swift.AnyClass, minimumCapacity: Swift.Int)
  init(_ buffer: Swift.ManagedBuffer<Header, Element>)
  typealias _My = Swift.ManagedBufferPointer<Header, Element>
  static func _checkValidBufferClass(_ bufferClass: Swift.AnyClass, creating: Swift.Bool = default)
  static func _sanityCheckValidBufferClass(_ bufferClass: Swift.AnyClass, creating: Swift.Bool = default)
  static var _alignmentMask: Swift.Int {
    get {}
  }
  var _capacityInBytes: Swift.Int {
    get {}
  }
  var _address: Swift.UnsafeMutableRawPointer {
    get {}
  }
  static var _headerOffset: Swift.Int {
    get {}
  }
  var _headerPointer: Swift.UnsafeMutablePointer<Header> {
    get {}
  }
  var _elementPointer: Swift.UnsafeMutablePointer<Element> {
    get {}
  }
  static var _elementOffset: Swift.Int {
    get {}
  }
  mutating func _isUniqueOrPinnedReference() -> Swift.Bool
  var _nativeBuffer: Builtin.NativeObject
}
extension ManagedBufferPointer {
  @available(*, unavailable, renamed: "init(bufferClass:minimumCapacity:makingHeaderWith:)") init(bufferClass: Swift.AnyClass, minimumCapacity: Swift.Int, initialValue: (AnyObject, (AnyObject) -> Swift.Int) -> Header)
  @available(*, unavailable, renamed: "capacity") var allocatedElementCount: Swift.Int {
    get {}
  }
  @available(*, unavailable, renamed: "isUniqueReference") mutating func holdsUniqueReference() -> Swift.Bool
  @available(*, unavailable, message: "this API is no longer available") mutating func holdsUniqueOrPinnedReference() -> Swift.Bool
}
struct BidirectionalSlice<Base : BidirectionalIndexable> : BidirectionalCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
  }
  typealias SubSequence = Swift.BidirectionalSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.BidirectionalSlice<Base> {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(before i: Base.Index) -> Base.Index
  func formIndex(before i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  let _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.BidirectionalSlice<Base>>
  typealias Indices = Swift.DefaultBidirectionalIndices<Swift.BidirectionalSlice<Base>>
}
func _swift_stdlib_atomicStoreInt64(object target: Swift.UnsafeMutablePointer<Swift.Int64>, desired: Swift.Int64)
func _convertConstArrayToPointerArgument<FromElement, ToPointer : _Pointer>(_ arr: [FromElement]) -> (AnyObject?, ToPointer)
func _canBeClass<T>(_: T.Type) -> Swift.Int8
struct Bool {
  var _value: Builtin.Int1
  init()
  @_versioned init(_ v: Builtin.Int1)
  init(_ value: Swift.Bool)
}
extension Bool : Equatable, Hashable {
  var hashValue: Swift.Int {
    get {}
  }
  static func ==(lhs: Swift.Bool, rhs: Swift.Bool) -> Swift.Bool
}
extension Bool : _ExpressibleByBuiltinBooleanLiteral, ExpressibleByBooleanLiteral {
  init(_builtinBooleanLiteral value: Builtin.Int1)
  init(booleanLiteral value: Swift.Bool)
  typealias BooleanLiteralType = Swift.Bool
}
extension Bool {
  func _getBuiltinLogicValue() -> Builtin.Int1
}
extension Bool : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Bool : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension Bool {
  prefix static func !(a: Swift.Bool) -> Swift.Bool
}
extension Bool {
  @inline(__always) static func &&(lhs: Swift.Bool, rhs: @autoclosure () throws -> Swift.Bool) rethrows -> Swift.Bool
  @inline(__always) static func ||(lhs: Swift.Bool, rhs: @autoclosure () throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Bool : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Bool : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Bool : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Bool?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Bool?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Bool
  typealias _ObjectiveCType = Foundation.NSNumber
}
func _undefined<T>(_ message: @autoclosure () -> Swift.String = default, file: Swift.StaticString = #file, line: Swift.UInt = #line) -> T
struct _InitializePointer<T> : _PointerFunction {
  func call(_ rawMemory: Swift.UnsafeMutablePointer<T>, count: Swift.Int)
  init(_ newValue: T)
  var newValue: T
  typealias Element = T
}
func _isFastAssertConfiguration() -> Swift.Bool
@_versioned struct _StringBufferIVars {
  init(_elementWidth: Swift.Int)
  init(_usedEnd: Swift.UnsafeMutableRawPointer, byteCapacity: Swift.Int, elementWidth: Swift.Int)
  var usedEnd: Swift.UnsafeMutableRawPointer?
  var capacityAndElementShift: Swift.Int
  var byteCapacity: Swift.Int {
    get {}
  }
  var elementShift: Swift.Int {
    get {}
  }
}
func _swift_stdlib_atomicFetchXorUInt64(object target: Swift.UnsafeMutablePointer<Swift.UInt64>, operand: Swift.UInt64) -> Swift.UInt64
func _arrayConditionalCast<SourceElement, TargetElement>(_ source: [SourceElement]) -> [TargetElement]?
@_silgen_name("_swift_dictionaryDownCastConditionalIndirect") func _dictionaryDownCastConditionalIndirect<SourceKey, SourceValue, TargetKey, TargetValue>(_ source: Swift.UnsafePointer<[SourceKey : SourceValue]>, _ target: Swift.UnsafeMutablePointer<[TargetKey : TargetValue]>) -> Swift.Bool
func _log10(_ x: Swift.Float) -> Swift.Float
func _log10(_ x: Swift.Double) -> Swift.Double
func _mixInt64(_ value: Swift.Int64) -> Swift.Int64
struct _CocoaArrayWrapper : RandomAccessCollection {
  typealias Indices = Swift.CountableRange<Swift.Int>
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  subscript(i: Swift.Int) -> AnyObject {
    get {}
  }
  func contiguousStorage(_ subRange: Swift.Range<Swift.Int>) -> Swift.UnsafeMutablePointer<AnyObject>?
  init(_ buffer: _NSArrayCore)
  var buffer: _NSArrayCore
  typealias Index = Swift.Int
  typealias _Element = AnyObject
  typealias SubSequence = Swift.RandomAccessSlice<Swift._CocoaArrayWrapper>
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift._CocoaArrayWrapper>
}
struct _ClosureBasedIterator<Element> : IteratorProtocol {
  init(_ body: @escaping () -> Element?)
  func next() -> Element?
  let _body: () -> Element?
  typealias Element = Element
}
()
builtin integer type of width 2048 bits
struct Unmanaged<Instance : AnyObject> {
  unowned(unsafe) var _value: Instance
  @_versioned init(_private: Instance)
  static func fromOpaque(_ value: Swift.UnsafeRawPointer) -> Swift.Unmanaged<Instance>
  func toOpaque() -> Swift.UnsafeMutableRawPointer
  static func passRetained(_ value: Instance) -> Swift.Unmanaged<Instance>
  static func passUnretained(_ value: Instance) -> Swift.Unmanaged<Instance>
  func takeUnretainedValue() -> Instance
  func takeRetainedValue() -> Instance
  func _withUnsafeGuaranteedRef<Result>(_ body: (Instance) throws -> Result) rethrows -> Result
  func retain() -> Swift.Unmanaged<Instance>
  func release()
  func autorelease() -> Swift.Unmanaged<Instance>
}
extension Unmanaged {
  @available(*, unavailable, message: "use 'fromOpaque(_: UnsafeRawPointer)' instead") static func fromOpaque(_ value: Swift.OpaquePointer) -> Swift.Unmanaged<Instance>
  @available(*, unavailable, message: "use 'toOpaque() -> UnsafeRawPointer' instead") func toOpaque() -> Swift.OpaquePointer
}
enum _ClosedRangeIndexRepresentation<Bound where Bound : _Strideable & Comparable, Bound.Stride : Integer> {
  case pastEnd
  case inRange(Bound)
}
func zip<Sequence1 : Sequence, Sequence2 : Sequence>(_ sequence1: Sequence1, _ sequence2: Sequence2) -> Swift.Zip2Sequence<Sequence1, Sequence2>
func _swift_stdlib_atomicFetchXorInt(object target: Swift.UnsafeMutablePointer<Swift.Int>, operand: Swift.Int) -> Swift.Int
struct MutableRangeReplaceableSlice<Base : MutableIndexable & RangeReplaceableIndexable> : Collection, MutableCollection, RangeReplaceableCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
    set(newValue) {}
  }
  typealias SubSequence = Swift.MutableRangeReplaceableSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.MutableRangeReplaceableSlice<Base> {
    get {}
    set(newValue) {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init()
  init(repeating repeatedValue: Base._Element, count: Swift.Int)
  init<S where S : Sequence, S.Iterator.Element == Base._Element>(_ elements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_ subRange: Swift.Range<Base.Index>, with newElements: C)
  mutating func insert(_ newElement: Base._Element, at i: Base.Index)
  mutating func insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf newElements: S, at i: Base.Index)
  mutating func remove(at i: Base.Index) -> Base._Element
  mutating func removeSubrange(_ bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  var _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.MutableRangeReplaceableSlice<Base>>
  typealias Indices = Swift.DefaultIndices<Swift.MutableRangeReplaceableSlice<Base>>
}
@_silgen_name("swift_stdlib_NSStringUppercaseString") func _stdlib_NSStringUppercaseString(_ str: AnyObject) -> Swift._CocoaString
@_versioned final class _CocoaSetIterator : IteratorProtocol {
  typealias Element = AnyObject
  final var _fastEnumerationState: SwiftShims._SwiftNSFastEnumerationState
  final var _fastEnumerationStackBuf: Swift._CocoaFastEnumerationStackBuf
  final let cocoaSet: _NSSet
  final var _fastEnumerationStatePtr: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState> {
    final get {}
  }
  final var _fastEnumerationStackBufPtr: Swift.UnsafeMutablePointer<Swift._CocoaFastEnumerationStackBuf> {
    final get {}
  }
  final var itemIndex: Swift.Int
  final var itemCount: Swift.Int
  @_versioned init(_ cocoaSet: _NSSet)
  @_versioned final func next() -> Swift._CocoaSetIterator.Element?
  @objc deinit
}
var _minASCIICharReprBuiltin: Builtin.Int63 {
  @inline(__always) get {}
}
struct DefaultBidirectionalIndices<Elements : BidirectionalIndexable> : BidirectionalCollection {
  typealias Index = Elements.Index
  init(_elements: Elements, startIndex: Elements.Index, endIndex: Elements.Index)
  var startIndex: Elements.Index {
    get {}
  }
  var endIndex: Elements.Index {
    get {}
  }
  subscript(i: Elements.Index) -> Elements.Index {
    get {}
  }
  typealias SubSequence = Swift.DefaultBidirectionalIndices<Elements>
  subscript(bounds: Swift.Range<Elements.Index>) -> Swift.DefaultBidirectionalIndices<Elements> {
    get {}
  }
  func index(after i: Elements.Index) -> Elements.Index
  func formIndex(after i: inout Elements.Index)
  func index(before i: Elements.Index) -> Elements.Index
  func formIndex(before i: inout Elements.Index)
  typealias Indices = Swift.DefaultBidirectionalIndices<Elements>
  var indices: Swift.DefaultBidirectionalIndices<Elements> {
    get {}
  }
  var _elements: Elements
  var _startIndex: Elements.Index
  var _endIndex: Elements.Index
  typealias _Element = Elements.Index
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift.DefaultBidirectionalIndices<Elements>>
}
@available(*, deprecated, message: "it will be replaced or redesigned in Swift 4.0.  Instead of conforming to 'ExpressibleByStringInterpolation', consider adding an 'init(_:String)'") protocol ExpressibleByStringInterpolation {
  init(stringInterpolation strings: Self...)
  init<T>(stringInterpolationSegment expr: T)
}
enum Never {
}
@available(*, unavailable, message: "Use formTruncatingRemainder instead") func %=(lhs: inout Swift.Float, rhs: Swift.Float)
@available(*, unavailable, message: "Use formTruncatingRemainder instead") func %=(lhs: inout Swift.Double, rhs: Swift.Double)
@available(*, unavailable, message: "Use formTruncatingRemainder instead") func %=(lhs: inout Swift.Float80, rhs: Swift.Float80)
func %=<T : _IntegerArithmetic>(lhs: inout T, rhs: T)
var _playgroundPrintHook: ((Swift.String) -> Swift.Void)?
func _heapify<C where C : MutableCollection & RandomAccessCollection>(_ elements: inout C, subRange range: Swift.Range<C.Index>, by areInIncreasingOrder: inout @escaping (C.Iterator.Element, C.Iterator.Element) -> Swift.Bool)
func _heapify<C where C : MutableCollection & RandomAccessCollection, C.Iterator.Element : Comparable>(_ elements: inout C, subRange range: Swift.Range<C.Index>)
protocol ExpressibleByExtendedGraphemeClusterLiteral : ExpressibleByUnicodeScalarLiteral {
  associatedtype ExtendedGraphemeClusterLiteralType : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral
  init(extendedGraphemeClusterLiteral value: Self.ExtendedGraphemeClusterLiteralType)
}
@inline(never) func _arrayOutOfPlaceReplace<B, C where B : _ArrayBufferProtocol, C : Collection, C.Iterator.Element == B.Element, B.Index == Int>(_ source: inout B, _ bounds: Swift.Range<Swift.Int>, _ newValues: C, _ insertCount: Swift.Int)
@unsafe_no_objc_tagged_pointer @objc protocol _NSSet : _NSSetCore {
}
@available(*, unavailable, renamed: "AnyIterator") struct AnyGenerator<Element> {
  init()
}
struct ContiguousArray<Element> : RandomAccessCollection, MutableCollection, _DestructorSafeContainer {
  typealias Index = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift.ContiguousArray<Element>>
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  func index(after i: Swift.Int) -> Swift.Int
  func formIndex(after i: inout Swift.Int)
  func index(before i: Swift.Int) -> Swift.Int
  func formIndex(before i: inout Swift.Int)
  func index(_ i: Swift.Int, offsetBy n: Swift.Int) -> Swift.Int
  func index(_ i: Swift.Int, offsetBy n: Swift.Int, limitedBy limit: Swift.Int) -> Swift.Int?
  func distance(from start: Swift.Int, to end: Swift.Int) -> Swift.Int
  func _failEarlyRangeCheck(_ index: Swift.Int, bounds: Swift.Range<Swift.Int>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Swift.Int>, bounds: Swift.Range<Swift.Int>)
  typealias Indices = Swift.CountableRange<Swift.Int>
  subscript(index: Swift.Int) -> Element {
    get {}
    mutableAddressWithPinnedNativeOwner {}
  }
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift.ArraySlice<Element> {
    get {}
    set(rhs) {}
  }
  @_semantics("array.props.isNativeTypeChecked") func _hoistableIsNativeTypeChecked() -> Swift.Bool
  @_semantics("array.get_count") func _getCount() -> Swift.Int
  @_semantics("array.get_capacity") func _getCapacity() -> Swift.Int
  @_semantics("array.owner") func _getOwnerWithSemanticLabel_native() -> Builtin.NativeObject
  @inline(__always) func _getOwner_native() -> Builtin.NativeObject
  static func _copyBuffer(_ buffer: inout Swift._ContiguousArrayBuffer<Element>)
  @_semantics("array.make_mutable") mutating func _makeMutableAndUnique()
  @_semantics("array.make_mutable") mutating func _makeMutableAndUniqueOrPinned()
  @inline(__always) func _checkSubscript_native(_ index: Swift.Int)
  @_semantics("array.check_subscript") func _checkSubscript(_ index: Swift.Int, wasNativeTypeChecked: Swift.Bool) -> Swift._DependenceToken
  @_semantics("array.check_index") func _checkIndex(_ index: Swift.Int)
  @_semantics("array.get_element") @inline(__always) func _getElement(_ index: Swift.Int, wasNativeTypeChecked: Swift.Bool, matchingSubscriptCheck: Swift._DependenceToken) -> Element
  @_semantics("array.get_element_address") func _getElementAddress(_ index: Swift.Int) -> Swift.UnsafeMutablePointer<Element>
  typealias _Buffer = Swift._ContiguousArrayBuffer<Element>
  init(_buffer: Swift._ContiguousArrayBuffer<Element>)
  var _buffer: Swift._ContiguousArrayBuffer<Element>
  typealias _Element = Element
  typealias SubSequence = Swift.ArraySlice<Element>
  typealias IndexDistance = Swift.Int
}
extension ContiguousArray : ExpressibleByArrayLiteral {
  init(arrayLiteral elements: Element...)
  typealias Element = Element
}
extension ContiguousArray : RangeReplaceableCollection, _ArrayProtocol {
  @_semantics("array.init") init()
  init<S : Sequence where S.Iterator.Element == Element>(_ s: S)
  @_semantics("array.init") init(repeating repeatedValue: Element, count: Swift.Int)
  @inline(never) static func _allocateBufferUninitialized(minimumCapacity: Swift.Int) -> Swift._ContiguousArrayBuffer<Element>
  init(_uninitializedCount count: Swift.Int)
  @_versioned @_semantics("array.uninitialized") static func _allocateUninitialized(_ count: Swift.Int) -> (Swift.ContiguousArray<Element>, Swift.UnsafeMutablePointer<Element>)
  var count: Swift.Int {
    get {}
  }
  var capacity: Swift.Int {
    get {}
  }
  var _owner: AnyObject? {
    get {}
  }
  var _baseAddressIfContiguous: Swift.UnsafeMutablePointer<Element>? {
    get {}
  }
  var _baseAddress: Swift.UnsafeMutablePointer<Element> {
    get {}
  }
  @_semantics("array.mutate_unknown") mutating func reserveCapacity(_ minimumCapacity: Swift.Int)
  @inline(never) mutating func _copyToNewBuffer(oldCount: Swift.Int)
  @_semantics("array.make_mutable") mutating func _makeUniqueAndReserveCapacityIfNotUnique()
  @_semantics("array.mutate_unknown") mutating func _reserveCapacityAssumingUniqueBuffer(oldCount: Swift.Int)
  @_semantics("array.mutate_unknown") mutating func _appendElementAssumeUniqueAndCapacity(_ oldCount: Swift.Int, newElement: Element)
  mutating func append(_ newElement: Element)
  mutating func append<S : Sequence where S.Iterator.Element == Element>(contentsOf newElements: S)
  mutating func append<C : Collection where C.Iterator.Element == Element>(contentsOf newElements: C)
  mutating func insert(_ newElement: Element, at i: Swift.Int)
  @discardableResult mutating func remove(at index: Swift.Int) -> Element
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
  mutating func _withUnsafeMutableBufferPointerIfSupported<R>(_ body: (Swift.UnsafeMutablePointer<Element>, Swift.Int) throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Element>
}
extension ContiguousArray : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension ContiguousArray : CustomStringConvertible, CustomDebugStringConvertible {
  func _makeDescription(isDebug: Swift.Bool) -> Swift.String
  var description: Swift.String {
    get {}
  }
  var debugDescription: Swift.String {
    get {}
  }
}
extension ContiguousArray {
  @_versioned func _cPointerArgs() -> (AnyObject?, Swift.UnsafeRawPointer?)
}
extension ContiguousArray {
  func withUnsafeBufferPointer<R>(_ body: (Swift.UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
  @_semantics("array.withUnsafeMutableBufferPointer") @inline(__always) mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout Swift.UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension ContiguousArray {
  @_semantics("array.mutate_unknown") mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subrange: Swift.Range<Swift.Int>, with newElements: C)
}
extension ContiguousArray {
  mutating func popLast() -> Element?
}
extension ContiguousArray {
  @available(*, unavailable, message: "Please use init(repeating:count:) instead") init(count: Swift.Int, repeatedValue: Element)
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ index: Swift.Int) -> Element
  @available(*, unavailable, renamed: "replaceSubrange(_:with:)") mutating func replaceRange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subRange: Swift.Range<Swift.Int>, with newElements: C)
  @available(*, unavailable, renamed: "append(contentsOf:)") mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Element>(_ newElements: S)
}
func &*<T : _IntegerArithmetic>(lhs: T, rhs: T) -> T
func &+<T : _IntegerArithmetic>(lhs: T, rhs: T) -> T
func &-<T : _IntegerArithmetic>(lhs: T, rhs: T) -> T
func preconditionFailure(_ message: @autoclosure () -> Swift.String = default, file: Swift.StaticString = #file, line: Swift.UInt = #line) -> Swift.Never
@available(*, unavailable, renamed: "JoinedIterator") struct JoinGenerator<Base : IteratorProtocol where Base.Element : Sequence> {
  init()
}
final class _VaListBuilder {
  struct Header {
    var gp_offset: Swift.CUnsignedInt
    var fp_offset: Swift.CUnsignedInt
    var overflow_arg_area: Swift.UnsafeMutablePointer<Swift.Int>?
    var reg_save_area: Swift.UnsafeMutablePointer<Swift.Int>?
    init(gp_offset: Swift.CUnsignedInt, fp_offset: Swift.CUnsignedInt, overflow_arg_area: Swift.UnsafeMutablePointer<Swift.Int>?, reg_save_area: Swift.UnsafeMutablePointer<Swift.Int>?)
    init()
  }
  init()
  final func append(_ arg: CVarArg)
  final func va_list() -> Swift.CVaListPointer
  final var gpRegistersUsed: Swift.Int
  final var sseRegistersUsed: Swift.Int
  final var header: Swift._VaListBuilder.Header
  final var storage: Swift.ContiguousArray<Swift.Int>
  @objc deinit
}
func _unsafeReferenceCast<T, U>(_ x: T, to: U.Type) -> U
@_versioned @inline(__always) func _makeBridgeObject(_ object: AnyObject, _ bits: Swift.UInt) -> Builtin.BridgeObject
func _swift_stdlib_atomicFetchAddUInt32(object target: Swift.UnsafeMutablePointer<Swift.UInt32>, operand: Swift.UInt32) -> Swift.UInt32
func &=(lhs: inout Swift.UInt8, rhs: Swift.UInt8)
func &=(lhs: inout Swift.Int8, rhs: Swift.Int8)
func &=(lhs: inout Swift.UInt16, rhs: Swift.UInt16)
func &=(lhs: inout Swift.Int16, rhs: Swift.Int16)
func &=(lhs: inout Swift.UInt32, rhs: Swift.UInt32)
func &=(lhs: inout Swift.Int32, rhs: Swift.Int32)
func &=(lhs: inout Swift.UInt64, rhs: Swift.UInt64)
func &=(lhs: inout Swift.Int64, rhs: Swift.Int64)
func &=(lhs: inout Swift.UInt, rhs: Swift.UInt)
func &=(lhs: inout Swift.Int, rhs: Swift.Int)
func &=<T : BitwiseOperations>(lhs: inout T, rhs: T)
struct ClosedRange<Bound : Comparable> {
  @inline(__always) init(uncheckedBounds bounds: (lower: Bound, upper: Bound))
  let lowerBound: Bound
  let upperBound: Bound
  func contains(_ element: Bound) -> Swift.Bool
  var isEmpty: Swift.Bool {
    get {}
  }
}
extension ClosedRange : Equatable {
  static func ==(lhs: Swift.ClosedRange<Bound>, rhs: Swift.ClosedRange<Bound>) -> Swift.Bool
  static func ~=(pattern: Swift.ClosedRange<Bound>, value: Bound) -> Swift.Bool
}
extension ClosedRange {
  @available(*, unavailable, renamed: "lowerBound") var startIndex: Bound {
    get {}
  }
  @available(*, unavailable, renamed: "upperBound") var endIndex: Bound {
    get {}
  }
}
extension ClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.Range<Bound>)
}
extension ClosedRange {
  @inline(__always) func overlaps(_ other: Swift.Range<Bound>) -> Swift.Bool
}
extension ClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.CountableRange<Bound>)
}
extension ClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.CountableRange<Bound>) -> Swift.Bool
}
extension ClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.ClosedRange<Bound>)
}
extension ClosedRange {
  @inline(__always) func overlaps(_ other: Swift.ClosedRange<Bound>) -> Swift.Bool
}
extension ClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.CountableClosedRange<Bound>)
}
extension ClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.CountableClosedRange<Bound>) -> Swift.Bool
}
extension ClosedRange {
  @inline(__always) func clamped(to limits: Swift.ClosedRange<Bound>) -> Swift.ClosedRange<Bound>
}
extension ClosedRange : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension ClosedRange : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension ClosedRange : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension ClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  var count: Bound.Stride {
    get {}
  }
}
extension ClosedRange {
  @available(*, unavailable, message: "Call clamped(to:) and swap the argument and the receiver.  For example, x.clamp(y) becomes y.clamped(to: x) in Swift 3.") func clamp(_ intervalToClamp: Swift.ClosedRange<Bound>) -> Swift.ClosedRange<Bound>
}
final class _stdlib_AtomicInt {
  final var _value: Swift.Int
  final var _valuePtr: Swift.UnsafeMutablePointer<Swift.Int> {
    final get {}
  }
  init(_ value: Swift.Int = default)
  final func store(_ desired: Swift.Int)
  final func load() -> Swift.Int
  @discardableResult final func fetchAndAdd(_ operand: Swift.Int) -> Swift.Int
  final func addAndFetch(_ operand: Swift.Int) -> Swift.Int
  @discardableResult final func fetchAndAnd(_ operand: Swift.Int) -> Swift.Int
  final func andAndFetch(_ operand: Swift.Int) -> Swift.Int
  @discardableResult final func fetchAndOr(_ operand: Swift.Int) -> Swift.Int
  final func orAndFetch(_ operand: Swift.Int) -> Swift.Int
  @discardableResult final func fetchAndXor(_ operand: Swift.Int) -> Swift.Int
  final func xorAndFetch(_ operand: Swift.Int) -> Swift.Int
  final func compareExchange(expected: inout Swift.Int, desired: Swift.Int) -> Swift.Bool
  @objc deinit
}
@_silgen_name("swift_float80ToString") func _float80ToStringImpl(_ buffer: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>, _ bufferLength: Swift.UInt, _ value: Swift.Float80, _ debug: Swift.Bool) -> Swift.UInt
struct Repeated<Element> : RandomAccessCollection {
  typealias Indices = Swift.CountableRange<Swift.Int>
  typealias Index = Swift.Int
  init(_repeating repeatedValue: Element, count: Swift.Int)
  var startIndex: Swift.Repeated.Index {
    get {}
  }
  var endIndex: Swift.Repeated.Index {
    get {}
  }
  subscript(position: Swift.Int) -> Element {
    get {}
  }
  let count: Swift.Int
  let repeatedValue: Element
  typealias _Element = Element
  typealias SubSequence = Swift.RandomAccessSlice<Swift.Repeated<Element>>
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift.Repeated<Element>>
}
extension Repeated {
  @available(*, unavailable, message: "Please use repeatElement(_:count:) function instead") init(count: Swift.Int, repeatedValue: Element)
}
struct Int : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(_ _v: Builtin.Word)
  var _builtinWordValue: Builtin.Word {
    get {}
  }
  init(bigEndian value: Swift.Int)
  init(littleEndian value: Swift.Int)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int)
  var bigEndian: Swift.Int {
    get {}
  }
  var littleEndian: Swift.Int {
    get {}
  }
  var byteSwapped: Swift.Int {
    get {}
  }
  static var max: Swift.Int {
    get {}
  }
  static var min: Swift.Int {
    get {}
  }
  static var _sizeInBits: Swift.Int {
    get {}
  }
  static var _sizeInBytes: Swift.Int {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int
  typealias Stride = Swift.Int
}
extension Int : SignedNumber {
}
extension Int : BitwiseOperations {
  static var allZeros: Swift.Int {
    get {}
  }
}
extension Int : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int {
  init(bitPattern pointer: Swift.OpaquePointer?)
}
extension Int {
  static func addWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to Int will always succeed.") init?(exactly value: Swift.UInt8)
}
extension Int {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to Int will always succeed.") init?(exactly value: Swift.UInt16)
}
extension Int {
  init(_ value: Swift.Int16)
  @available(*, message: "Converting Int16 to Int will always succeed.") init?(exactly value: Swift.Int16)
}
extension Int {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to Int will always succeed.") init?(exactly value: Swift.UInt32)
}
extension Int {
  init(_ value: Swift.Int32)
  @available(*, message: "Converting Int32 to Int will always succeed.") init?(exactly value: Swift.Int32)
}
extension Int {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension Int {
  init(_ value: Swift.Int64)
  @available(*, message: "Converting Int64 to Int will always succeed.") init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension Int {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
}
extension Int {
  init(_ value: Swift.Int)
  @available(*, message: "Converting Int to Int will always succeed.") init?(exactly value: Swift.Int)
}
extension Int {
  init(bitPattern: Swift.UInt)
}
extension Int {
  typealias _DisabledRangeIndex = Swift.Int
}
extension Int {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Int {
  init(bitPattern objectID: Swift.ObjectIdentifier)
}
extension Int {
  @available(*, unavailable, renamed: "init(bitPattern:)") init(_ objectID: Swift.ObjectIdentifier)
}
extension Int {
  init<U>(bitPattern: Swift.UnsafeMutablePointer<U>?)
}
extension Int {
  init<U>(bitPattern: Swift.UnsafePointer<U>?)
}
extension Int {
  init(bitPattern: Swift.UnsafeMutableRawPointer?)
}
extension Int {
  init(bitPattern: Swift.UnsafeRawPointer?)
}
extension Int : MirrorPath {
}
extension Int : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension Int {
  init(_ value: CoreGraphics.CGFloat)
}
extension Int : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Int?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Int?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Int
  typealias _ObjectiveCType = Foundation.NSNumber
}
protocol UnsignedInteger : _DisallowMixedSignArithmetic, Integer {
  func toUIntMax() -> Swift.UIntMax
  init(_: Swift.UIntMax)
}
extension UnsignedInteger {
  func distance(to other: Self) -> Swift.Int
  func advanced(by n: Swift.Int) -> Self
}
@_versioned @inline(never) func _outlinedMakeUniqueBuffer<_Buffer where _Buffer : _ArrayBufferProtocol, _Buffer.Index == Int>(_ buffer: inout _Buffer, bufferCount: Swift.Int)
func fatalError(_ message: @autoclosure () -> Swift.String = default, file: Swift.StaticString = #file, line: Swift.UInt = #line) -> Swift.Never
func _dumpPrint_unlocked<T, TargetStream : TextOutputStream>(_ value: T, _ mirror: Swift.Mirror, _ target: inout TargetStream)
func _float64ToString(_ value: Swift.Float64, debug: Swift.Bool) -> Swift.String
struct ReversedRandomAccessCollection<Base : RandomAccessCollection> : RandomAccessCollection {
  init(_base: Base)
  typealias Index = Swift.ReversedRandomAccessIndex<Base>
  typealias IndexDistance = Base.IndexDistance
  typealias Iterator = Swift.IndexingIterator<Swift.ReversedRandomAccessCollection<Base>>
  var startIndex: Swift.ReversedRandomAccessIndex<Base> {
    get {}
  }
  var endIndex: Swift.ReversedRandomAccessIndex<Base> {
    get {}
  }
  func index(after i: Swift.ReversedRandomAccessIndex<Base>) -> Swift.ReversedRandomAccessIndex<Base>
  func index(before i: Swift.ReversedRandomAccessIndex<Base>) -> Swift.ReversedRandomAccessIndex<Base>
  func index(_ i: Swift.ReversedRandomAccessIndex<Base>, offsetBy n: Base.IndexDistance) -> Swift.ReversedRandomAccessIndex<Base>
  func index(_ i: Swift.ReversedRandomAccessIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: Swift.ReversedRandomAccessIndex<Base>) -> Swift.ReversedRandomAccessIndex<Base>?
  func distance(from start: Swift.ReversedRandomAccessIndex<Base>, to end: Swift.ReversedRandomAccessIndex<Base>) -> Base.IndexDistance
  typealias _Element = Base.Iterator.Element
  subscript(position: Swift.ReversedRandomAccessIndex<Base>) -> Base.Iterator.Element {
    get {}
  }
  let _base: Base
  typealias SubSequence = Swift.RandomAccessSlice<Swift.ReversedRandomAccessCollection<Base>>
  typealias Indices = Swift.DefaultRandomAccessIndices<Swift.ReversedRandomAccessCollection<Base>>
}
extension ReversedRandomAccessCollection {
  @available(*, unavailable, renamed: "RandomAccessCollection.reversed(self:)") init(_ base: Base)
}
final class _IndexBox<BaseIndex : Comparable> : _AnyIndexBox {
  final var _base: BaseIndex
  init(_base: BaseIndex)
  final func _unsafeUnbox(_ other: _AnyIndexBox) -> BaseIndex
  final var _typeID: Swift.ObjectIdentifier {
    final get {}
  }
  final func _unbox<T : Comparable>() -> T?
  final func _isEqual(to rhs: _AnyIndexBox) -> Swift.Bool
  final func _isLess(than rhs: _AnyIndexBox) -> Swift.Bool
  @objc deinit
}
@inline(never) @_semantics("stdlib_binary_only") func _print_unlocked<T, TargetStream : TextOutputStream>(_ value: T, _ target: inout TargetStream)
@objc @_swift_native_objc_runtime_base(_SwiftNativeNSSetBase) class _SwiftNativeNSSet {
  @objc init()
  @objc deinit
}
struct DictionaryLiteral<Key, Value> : ExpressibleByDictionaryLiteral {
  init(dictionaryLiteral elements: (Key, Value)...)
  let _elements: [(Key, Value)]
  typealias Key = Key
  typealias Value = Value
}
extension DictionaryLiteral : RandomAccessCollection {
  typealias Indices = Swift.CountableRange<Swift.Int>
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  typealias Element = (key: Key, value: Value)
  subscript(position: Swift.Int) -> (key: Key, value: Value) {
    get {}
  }
  typealias Index = Swift.Int
  typealias _Element = (key: Key, value: Value)
  typealias SubSequence = Swift.RandomAccessSlice<Swift.DictionaryLiteral<Key, Value>>
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift.DictionaryLiteral<Key, Value>>
}
protocol _PointerFunction {
  associatedtype Element
  func call(_: Swift.UnsafeMutablePointer<Self.Element>, count: Swift.Int)
}
enum CommandLine {
  static @_versioned var _argc: Swift.Int32
  static @_versioned var _unsafeArgv: Swift.UnsafeMutablePointer<Swift.UnsafeMutablePointer<Swift.Int8>?>
  static var argc: Swift.Int32 {
    get {}
  }
  static var unsafeArgv: Swift.UnsafeMutablePointer<Swift.UnsafeMutablePointer<Swift.Int8>?> {
    get {}
  }
  static var arguments: [Swift.String]
}
struct UnsafeBufferPointerIterator<Element> : IteratorProtocol, Sequence {
  mutating func next() -> Element?
  var _position: Swift.UnsafePointer<Element>?, _end: Swift.UnsafePointer<Element>?
  typealias Element = Element
  init(_position: Swift.UnsafePointer<Element>?, _end: Swift.UnsafePointer<Element>?)
  init()
  typealias Iterator = Swift.UnsafeBufferPointerIterator<Element>
  typealias SubSequence = Swift.AnySequence<Element>
}
struct ReversedCollection<Base : BidirectionalCollection> : BidirectionalCollection {
  init(_base: Base)
  typealias Index = Swift.ReversedIndex<Base>
  typealias IndexDistance = Base.IndexDistance
  typealias Iterator = Swift.IndexingIterator<Swift.ReversedCollection<Base>>
  var startIndex: Swift.ReversedIndex<Base> {
    get {}
  }
  var endIndex: Swift.ReversedIndex<Base> {
    get {}
  }
  func index(after i: Swift.ReversedIndex<Base>) -> Swift.ReversedIndex<Base>
  func index(before i: Swift.ReversedIndex<Base>) -> Swift.ReversedIndex<Base>
  func index(_ i: Swift.ReversedIndex<Base>, offsetBy n: Base.IndexDistance) -> Swift.ReversedIndex<Base>
  func index(_ i: Swift.ReversedIndex<Base>, offsetBy n: Base.IndexDistance, limitedBy limit: Swift.ReversedIndex<Base>) -> Swift.ReversedIndex<Base>?
  func distance(from start: Swift.ReversedIndex<Base>, to end: Swift.ReversedIndex<Base>) -> Base.IndexDistance
  typealias _Element = Base.Iterator.Element
  subscript(position: Swift.ReversedIndex<Base>) -> Base.Iterator.Element {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.ReversedIndex<Base>>) -> Swift.BidirectionalSlice<Swift.ReversedCollection<Base>> {
    get {}
  }
  let _base: Base
  typealias SubSequence = Swift.BidirectionalSlice<Swift.ReversedCollection<Base>>
  typealias Indices = Swift.DefaultBidirectionalIndices<Swift.ReversedCollection<Base>>
}
extension ReversedCollection {
  @available(*, unavailable, renamed: "BidirectionalCollection.reversed(self:)") init(_ base: Base)
}
func getVaList(_ args: [CVarArg]) -> Swift.CVaListPointer
struct Int : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(_ _v: Builtin.Word)
  var _builtinWordValue: Builtin.Word {
    get {}
  }
  init(bigEndian value: Swift.Int)
  init(littleEndian value: Swift.Int)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int)
  var bigEndian: Swift.Int {
    get {}
  }
  var littleEndian: Swift.Int {
    get {}
  }
  var byteSwapped: Swift.Int {
    get {}
  }
  static var max: Swift.Int {
    get {}
  }
  static var min: Swift.Int {
    get {}
  }
  static var _sizeInBits: Swift.Int {
    get {}
  }
  static var _sizeInBytes: Swift.Int {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int
  typealias Stride = Swift.Int
}
extension Int : SignedNumber {
}
extension Int : BitwiseOperations {
  static var allZeros: Swift.Int {
    get {}
  }
}
extension Int : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int {
  init(bitPattern pointer: Swift.OpaquePointer?)
}
extension Int {
  static func addWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to Int will always succeed.") init?(exactly value: Swift.UInt8)
}
extension Int {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to Int will always succeed.") init?(exactly value: Swift.UInt16)
}
extension Int {
  init(_ value: Swift.Int16)
  @available(*, message: "Converting Int16 to Int will always succeed.") init?(exactly value: Swift.Int16)
}
extension Int {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to Int will always succeed.") init?(exactly value: Swift.UInt32)
}
extension Int {
  init(_ value: Swift.Int32)
  @available(*, message: "Converting Int32 to Int will always succeed.") init?(exactly value: Swift.Int32)
}
extension Int {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension Int {
  init(_ value: Swift.Int64)
  @available(*, message: "Converting Int64 to Int will always succeed.") init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension Int {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
}
extension Int {
  init(_ value: Swift.Int)
  @available(*, message: "Converting Int to Int will always succeed.") init?(exactly value: Swift.Int)
}
extension Int {
  init(bitPattern: Swift.UInt)
}
extension Int {
  typealias _DisabledRangeIndex = Swift.Int
}
extension Int {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Int {
  init(bitPattern objectID: Swift.ObjectIdentifier)
}
extension Int {
  @available(*, unavailable, renamed: "init(bitPattern:)") init(_ objectID: Swift.ObjectIdentifier)
}
extension Int {
  init<U>(bitPattern: Swift.UnsafeMutablePointer<U>?)
}
extension Int {
  init<U>(bitPattern: Swift.UnsafePointer<U>?)
}
extension Int {
  init(bitPattern: Swift.UnsafeMutableRawPointer?)
}
extension Int {
  init(bitPattern: Swift.UnsafeRawPointer?)
}
extension Int : MirrorPath {
}
extension Int : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension Int {
  init(_ value: CoreGraphics.CGFloat)
}
extension Int : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Int?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Int?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Int
  typealias _ObjectiveCType = Foundation.NSNumber
}
@_versioned @inline(never) @_semantics("stdlib_binary_only") func _debugPrint<Target : TextOutputStream>(_ items: [Any], separator: Swift.String = default, terminator: Swift.String = default, to output: inout Target)
struct MutableBidirectionalSlice<Base : BidirectionalIndexable & MutableIndexable> : BidirectionalCollection, MutableCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
    set(newValue) {}
  }
  typealias SubSequence = Swift.MutableBidirectionalSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.MutableBidirectionalSlice<Base> {
    get {}
    set(newValue) {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(before i: Base.Index) -> Base.Index
  func formIndex(before i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  var _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.MutableBidirectionalSlice<Base>>
  typealias Indices = Swift.DefaultBidirectionalIndices<Swift.MutableBidirectionalSlice<Base>>
}
@_silgen_name("swift_EnumMirror_count") func _getEnumCount(_: Swift._MagicMirrorData) -> Swift.Int
func _parseAsciiAsIntMax(_ utf16: Swift.String.UTF16View, _ radix: Swift.Int, _ maximum: Swift.IntMax) -> Swift.IntMax?
struct UnicodeScalar : _ExpressibleByBuiltinUnicodeScalarLiteral, ExpressibleByUnicodeScalarLiteral {
  var _value: Swift.UInt32
  var value: Swift.UInt32 {
    get {}
  }
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
  init(unicodeScalarLiteral value: Swift.UnicodeScalar)
  init?(_ v: Swift.UInt32)
  init?(_ v: Swift.UInt16)
  init(_ v: Swift.UInt8)
  init(_ v: Swift.UnicodeScalar)
  func escaped(asASCII forceASCII: Swift.Bool) -> Swift.String
  var isASCII: Swift.Bool {
    get {}
  }
  var _isASCIIDigit: Swift.Bool {
    get {}
  }
  var _isPrintableASCII: Swift.Bool {
    get {}
  }
  typealias UnicodeScalarLiteralType = Swift.UnicodeScalar
}
extension UnicodeScalar : Equatable {
  static func ==(lhs: Swift.UnicodeScalar, rhs: Swift.UnicodeScalar) -> Swift.Bool
}
extension UnicodeScalar : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UnicodeScalar : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UnicodeScalar : TextOutputStreamable {
  func write<Target : TextOutputStream>(to target: inout Target)
}
extension UnicodeScalar {
  init(_unchecked value: Swift.UInt32)
}
extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible {
  var description: Swift.String {
    get {}
  }
  var debugDescription: Swift.String {
    get {}
  }
}
extension UnicodeScalar : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension UnicodeScalar : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension UnicodeScalar {
  init?(_ v: Swift.Int)
}
extension UnicodeScalar : Comparable {
  static func <(lhs: Swift.UnicodeScalar, rhs: Swift.UnicodeScalar) -> Swift.Bool
}
extension UnicodeScalar {
  struct UTF16View {
    var value: Swift.UnicodeScalar
    init(value: Swift.UnicodeScalar)
  }
  var utf16: Swift.UnicodeScalar.UTF16View {
    get {}
  }
}
extension UnicodeScalar {
  @available(*, unavailable, message: "use 'UnicodeScalar(0)'") init()
  @available(*, unavailable, renamed: "escaped(asASCII:)") func escape(asASCII forceASCII: Swift.Bool) -> Swift.String
}
func _getObjCSummary(_ data: Swift._MagicMirrorData) -> Swift.String
protocol _ExpressibleByBuiltinIntegerLiteral {
  init(_builtinIntegerLiteral value: Swift._MaxBuiltinIntegerType)
}
func _bridgeAnythingToObjectiveC<T>(_ x: T) -> AnyObject
()
@available(*, unavailable, renamed: "StrideThroughIterator") struct StrideThroughGenerator<Element : Strideable> {
  init()
}
struct EnumeratedIterator<Base : IteratorProtocol> : IteratorProtocol, Sequence {
  var _base: Base
  var _count: Swift.Int
  init(_base: Base)
  typealias Element = (offset: Swift.Int, element: Base.Element)
  mutating func next() -> (offset: Swift.Int, element: Base.Element)?
  typealias Iterator = Swift.EnumeratedIterator<Base>
  typealias SubSequence = Swift.AnySequence<(offset: Swift.Int, element: Base.Element)>
}
extension EnumeratedIterator {
  @available(*, unavailable, message: "use the 'enumerated()' method on the sequence") init(_ base: Base)
}
enum _RuntimeHelpers {
}
extension _RuntimeHelpers {
  @_silgen_name("swift_stdlib_Hashable_isEqual_indirect") static func Hashable_isEqual_indirect<T : Hashable>(_ lhs: Swift.UnsafePointer<T>, _ rhs: Swift.UnsafePointer<T>) -> Swift.Bool
  @_silgen_name("swift_stdlib_Hashable_hashValue_indirect") static func Hashable_hashValue_indirect<T : Hashable>(_ value: Swift.UnsafePointer<T>) -> Swift.Int
}
func _parseOptionalAsciiSign(_ utf16: Swift.String.UTF16View) -> (digitsUTF16: Swift.String.UTF16View, isMinus: Swift.Bool)
func _swift_stdlib_atomicFetchXorInt32(object target: Swift.UnsafeMutablePointer<Swift.Int32>, operand: Swift.Int32) -> Swift.Int32
struct String {
  init()
  init(_ _core: Swift._StringCore)
  var _core: Swift._StringCore
}
extension String {
  init(_ c: Swift.Character)
}
extension String {
  init(cString: Swift.UnsafePointer<Swift.CChar>)
  init(cString: Swift.UnsafePointer<Swift.UInt8>)
  init?(validatingUTF8 cString: Swift.UnsafePointer<Swift.CChar>)
  static func decodeCString<Encoding : UnicodeCodec>(_ cString: Swift.UnsafePointer<Encoding.CodeUnit>?, as encoding: Encoding.Type, repairingInvalidCodeUnits isRepairing: Swift.Bool = default) -> (result: Swift.String, repairsMade: Swift.Bool)?
}
extension String {
  @available(*, unavailable, message: "Please use String.init?(validatingUTF8:) instead. Note that it no longer accepts NULL as a valid input. Also consider using String(cString:), that will attempt to repair ill-formed code units.") static func fromCString(_ cs: Swift.UnsafePointer<Swift.CChar>) -> Swift.String?
  @available(*, unavailable, message: "Please use String.init(cString:) instead. Note that it no longer accepts NULL as a valid input. See also String.decodeCString if you need more control.") static func fromCStringRepairingIllFormedUTF8(_ cs: Swift.UnsafePointer<Swift.CChar>) -> (Swift.String?, hadError: Swift.Bool)
}
extension String {
  func withCString<Result>(_ body: (Swift.UnsafePointer<Swift.Int8>) throws -> Result) rethrows -> Result
}
extension String : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension String : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension String : TextOutputStream {
  mutating func write(_ other: Swift.String)
}
extension String : TextOutputStreamable {
  func write<Target : TextOutputStream>(to target: inout Target)
}
extension String {
  struct CharacterView {
    var _core: Swift._StringCore
    init(_ text: Swift.String)
    init(_ _core: Swift._StringCore)
  }
  var characters: Swift.String.CharacterView {
    get {}
    set(newValue) {}
  }
  mutating func withMutableCharacters<R>(_ body: (inout Swift.String.CharacterView) -> R) -> R
  init(_ characters: Swift.String.CharacterView)
}
extension String {
  static func _fromWellFormedCodeUnitSequence<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> Swift.String
  static func _fromCodeUnitSequence<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> Swift.String?
  static func _fromCodeUnitSequenceWithRepair<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> (Swift.String, hadError: Swift.Bool)
}
extension String : _ExpressibleByBuiltinUnicodeScalarLiteral {
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
}
extension String : ExpressibleByUnicodeScalarLiteral {
  init(unicodeScalarLiteral value: Swift.String)
  typealias UnicodeScalarLiteralType = Swift.String
}
extension String : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral {
  @_semantics("string.makeUTF8") init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
extension String : ExpressibleByExtendedGraphemeClusterLiteral {
  init(extendedGraphemeClusterLiteral value: Swift.String)
  typealias ExtendedGraphemeClusterLiteralType = Swift.String
}
extension String : _ExpressibleByBuiltinUTF16StringLiteral {
  @_semantics("string.makeUTF16") init(_builtinUTF16StringLiteral start: Builtin.RawPointer, utf16CodeUnitCount: Builtin.Word)
}
extension String : _ExpressibleByBuiltinStringLiteral {
  @_semantics("string.makeUTF8") init(_builtinStringLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
extension String : ExpressibleByStringLiteral {
  init(stringLiteral value: Swift.String)
  typealias StringLiteralType = Swift.String
}
extension String : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension String {
  func _encodedLength<Encoding : UnicodeCodec>(_ encoding: Encoding.Type) -> Swift.Int
  func _encode<Encoding : UnicodeCodec>(_ encoding: Encoding.Type, into processCodeUnit: (Encoding.CodeUnit) -> Swift.Void)
}
extension String : Equatable {
  static func ==(lhs: Swift.String, rhs: Swift.String) -> Swift.Bool
}
extension String : Comparable {
  static func <(lhs: Swift.String, rhs: Swift.String) -> Swift.Bool
}
extension String {
  func _compareASCII(_ rhs: Swift.String) -> Swift.Int
  @inline(never) @_semantics("stdlib_binary_only") func _compareDeterministicUnicodeCollation(_ rhs: Swift.String) -> Swift.Int
  func _compareString(_ rhs: Swift.String) -> Swift.Int
}
extension String {
  mutating func append(_ other: Swift.String)
  @available(*, unavailable, message: "Replaced by append(_: String)") mutating func append(_ x: Swift.UnicodeScalar)
  init(_storage: Swift._StringBuffer)
}
extension String : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension String {
  @_semantics("string.concat") static func +(lhs: Swift.String, rhs: Swift.String) -> Swift.String
  static func +=(lhs: inout Swift.String, rhs: Swift.String)
  @_silgen_name("swift_stringFromUTF8InRawMemory") static func _fromUTF8InRawMemory(_ resultStorage: Swift.UnsafeMutablePointer<Swift.String>, start: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>, utf8CodeUnitCount: Swift.Int)
}
extension String {
  var _asciiLowerCaseTable: Swift.UInt64 {
    @inline(__always) get {}
  }
  var _asciiUpperCaseTable: Swift.UInt64 {
    @inline(__always) get {}
  }
  func lowercased() -> Swift.String
  func uppercased() -> Swift.String
  init<T : LosslessStringConvertible>(_ value: T)
}
extension String : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension String : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension String {
  @available(*, unavailable, renamed: "append(_:)") mutating func appendContentsOf(_ other: Swift.String)
  @available(*, unavailable, renamed: "append(contentsOf:)") mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Character>(_ newElements: S)
  @available(*, unavailable, renamed: "insert(contentsOf:at:)") mutating func insertContentsOf<S : Collection where S.Iterator.Element == Character>(_ newElements: S, at i: Swift.String.Index)
  @available(*, unavailable, renamed: "replaceSubrange") mutating func replaceRange<C : Collection where C.Iterator.Element == Character>(_ subRange: Swift.Range<Swift.String.Index>, with newElements: C)
  @available(*, unavailable, renamed: "replaceSubrange") mutating func replaceRange(_ subRange: Swift.Range<Swift.String.Index>, with newElements: Swift.String)
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ i: Swift.String.Index) -> Swift.Character
  @available(*, unavailable, renamed: "removeSubrange") mutating func removeRange(_ subRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "lowercased()") var lowercaseString: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "uppercased()") var uppercaseString: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "init(describing:)") init<T>(_: T)
}
extension String {
  @inline(never) @_semantics("stdlib_binary_only") init(_cocoaString: AnyObject)
}
extension String {
  func _stdlib_binary_bridgeToObjectiveCImpl() -> AnyObject
  @inline(never) @_semantics("stdlib_binary_only") func _bridgeToObjectiveCImpl() -> AnyObject
}
extension String : ExpressibleByStringInterpolation {
  init(stringInterpolation strings: Swift.String...)
  init<T>(stringInterpolationSegment expr: T)
  init(stringInterpolationSegment expr: Swift.String)
  init(stringInterpolationSegment expr: Swift.Character)
  init(stringInterpolationSegment expr: Swift.UnicodeScalar)
  init(stringInterpolationSegment expr: Swift.Bool)
  init(stringInterpolationSegment expr: Swift.Float32)
  init(stringInterpolationSegment expr: Swift.Float64)
  init(stringInterpolationSegment expr: Swift.UInt8)
  init(stringInterpolationSegment expr: Swift.Int8)
  init(stringInterpolationSegment expr: Swift.UInt16)
  init(stringInterpolationSegment expr: Swift.Int16)
  init(stringInterpolationSegment expr: Swift.UInt32)
  init(stringInterpolationSegment expr: Swift.Int32)
  init(stringInterpolationSegment expr: Swift.UInt64)
  init(stringInterpolationSegment expr: Swift.Int64)
  init(stringInterpolationSegment expr: Swift.UInt)
  init(stringInterpolationSegment expr: Swift.Int)
}
extension String {
  @available(*, unavailable, message: "Replaced by init(repeating: String, count: Int)") init(repeating repeatedValue: Swift.Character, count: Swift.Int)
  @available(*, unavailable, message: "Replaced by init(repeating: String, count: Int)") init(repeating repeatedValue: Swift.UnicodeScalar, count: Swift.Int)
  init(repeating repeatedValue: Swift.String, count: Swift.Int)
  var _lines: [Swift.String] {
    get {}
  }
  func _split(separator: Swift.UnicodeScalar) -> [Swift.String]
  var isEmpty: Swift.Bool {
    get {}
  }
}
extension String {
  init(_ _c: Swift.UnicodeScalar)
}
extension String {
  func hasPrefix(_ prefix: Swift.String) -> Swift.Bool
  func hasSuffix(_ suffix: Swift.String) -> Swift.Bool
}
extension String {
  init<T : _SignedInteger>(_ v: T)
  init<T : UnsignedInteger>(_ v: T)
  init<T : _SignedInteger>(_ value: T, radix: Swift.Int, uppercase: Swift.Bool = default)
  init<T : UnsignedInteger>(_ value: T, radix: Swift.Int, uppercase: Swift.Bool = default)
}
extension String {
  func _splitFirst(separator delim: Swift.UnicodeScalar) -> (before: Swift.String, after: Swift.String, wasFound: Swift.Bool)
  func _splitFirstIf(_ predicate: (Swift.UnicodeScalar) -> Swift.Bool) -> (before: Swift.String, found: Swift.UnicodeScalar, after: Swift.String, wasFound: Swift.Bool)
}
extension String {
  @available(*, unavailable, message: "Renamed to init(repeating:count:) and reordered parameters") init(count: Swift.Int, repeatedValue c: Swift.Character)
  @available(*, unavailable, message: "Renamed to init(repeating:count:) and reordered parameters") init(count: Swift.Int, repeatedValue c: Swift.UnicodeScalar)
}
extension String {
  typealias Index = Swift.String.CharacterView.Index
  typealias IndexDistance = Swift.String.CharacterView.IndexDistance
  var startIndex: Swift.String.Index {
    get {}
  }
  var endIndex: Swift.String.Index {
    get {}
  }
  func index(after i: Swift.String.Index) -> Swift.String.Index
  func index(before i: Swift.String.Index) -> Swift.String.Index
  func index(_ i: Swift.String.Index, offsetBy n: Swift.String.IndexDistance) -> Swift.String.Index
  func index(_ i: Swift.String.Index, offsetBy n: Swift.String.IndexDistance, limitedBy limit: Swift.String.Index) -> Swift.String.Index?
  func distance(from start: Swift.String.Index, to end: Swift.String.Index) -> Swift.String.IndexDistance
  subscript(i: Swift.String.Index) -> Swift.Character {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.String.Index>) -> Swift.String {
    get {}
  }
  subscript(bounds: Swift.ClosedRange<Swift.String.Index>) -> Swift.String {
    get {}
  }
}
extension String {
  init<S : Sequence where S.Iterator.Element == Character>(_ characters: S)
  mutating func reserveCapacity(_ n: Swift.Int)
  mutating func append(_ c: Swift.Character)
  mutating func append<S : Sequence where S.Iterator.Element == Character>(contentsOf newElements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Swift.Range<Swift.String.Index>, with newElements: C)
  mutating func replaceSubrange(_ bounds: Swift.Range<Swift.String.Index>, with newElements: Swift.String)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Swift.ClosedRange<Swift.String.Index>, with newElements: C)
  mutating func replaceSubrange(_ bounds: Swift.ClosedRange<Swift.String.Index>, with newElements: Swift.String)
  mutating func insert(_ newElement: Swift.Character, at i: Swift.String.Index)
  mutating func insert<S : Collection where S.Iterator.Element == Character>(contentsOf newElements: S, at i: Swift.String.Index)
  @discardableResult mutating func remove(at i: Swift.String.Index) -> Swift.Character
  mutating func removeSubrange(_ bounds: Swift.Range<Swift.String.Index>)
  mutating func removeSubrange(_ bounds: Swift.ClosedRange<Swift.String.Index>)
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
}
extension String {
  struct UnicodeScalarView : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
    init(_ _core: Swift._StringCore)
    struct _ScratchIterator : IteratorProtocol {
      var core: Swift._StringCore
      var idx: Swift.Int
      @_versioned init(_ core: Swift._StringCore, _ pos: Swift.Int)
      @inline(__always) mutating func next() -> Swift.UTF16.CodeUnit?
      typealias Element = Swift.UTF16.CodeUnit
    }
    struct Index {
      init(_position: Swift.Int)
      @_versioned var _position: Swift.Int
    }
    var startIndex: Swift.String.UnicodeScalarView.Index {
      get {}
    }
    var endIndex: Swift.String.UnicodeScalarView.Index {
      get {}
    }
    func index(after i: Swift.String.UnicodeScalarView.Index) -> Swift.String.UnicodeScalarView.Index
    func index(before i: Swift.String.UnicodeScalarView.Index) -> Swift.String.UnicodeScalarView.Index
    subscript(position: Swift.String.UnicodeScalarView.Index) -> Swift.UnicodeScalar {
      get {}
    }
    subscript(r: Swift.Range<Swift.String.UnicodeScalarView.Index>) -> Swift.String.UnicodeScalarView {
      get {}
    }
    struct Iterator : IteratorProtocol {
      init(_ _base: Swift._StringCore)
      mutating func next() -> Swift.UnicodeScalar?
      var _decoder: Swift.UTF16
      let _baseSet: Swift.Bool
      let _ascii: Swift.Bool
      var _asciiBase: Swift.UnsafeBufferPointerIterator<Swift.UInt8>!
      var _base: Swift.UnsafeBufferPointerIterator<Swift.UInt16>!
      var _iterator: Swift.IndexingIterator<Swift._StringCore>!
      typealias Element = Swift.UnicodeScalar
    }
    func makeIterator() -> Swift.String.UnicodeScalarView.Iterator
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    var _core: Swift._StringCore
    typealias _Element = Swift.UnicodeScalar
    typealias SubSequence = Swift.String.UnicodeScalarView
    typealias IndexDistance = Swift.Int
    typealias Indices = Swift.DefaultBidirectionalIndices<Swift.String.UnicodeScalarView>
  }
  init(_ unicodeScalars: Swift.String.UnicodeScalarView)
  typealias UnicodeScalarIndex = Swift.String.UnicodeScalarView.Index
}
extension String {
  var unicodeScalars: Swift.String.UnicodeScalarView {
    get {}
    set(newValue) {}
  }
}
extension String {
  struct UTF16View : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
    struct Index {
      init(_offset: Swift.Int)
      let _offset: Swift.Int
    }
    typealias IndexDistance = Swift.Int
    var startIndex: Swift.String.UTF16View.Index {
      get {}
    }
    var endIndex: Swift.String.UTF16View.Index {
      get {}
    }
    struct Indices {
      var _elements: Swift.String.UTF16View
      var _startIndex: Swift.String.UTF16View.Indices.Index
      var _endIndex: Swift.String.UTF16View.Indices.Index
      init(_elements: Swift.String.UTF16View, _startIndex: Swift.String.UTF16View.Indices.Index, _endIndex: Swift.String.UTF16View.Indices.Index)
    }
    var indices: Swift.String.UTF16View.Indices {
      get {}
    }
    func index(after i: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index
    func index(before i: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index
    func index(_ i: Swift.String.UTF16View.Index, offsetBy n: Swift.String.UTF16View.IndexDistance) -> Swift.String.UTF16View.Index
    func index(_ i: Swift.String.UTF16View.Index, offsetBy n: Swift.String.UTF16View.IndexDistance, limitedBy limit: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index?
    func distance(from start: Swift.String.UTF16View.Index, to end: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.IndexDistance
    func _internalIndex(at i: Swift.Int) -> Swift.Int
    subscript(i: Swift.String.UTF16View.Index) -> Swift.UTF16.CodeUnit {
      get {}
    }
    @available(*, unavailable, message: "Indexing a String's UTF16View requires a String.UTF16View.Index, which can be constructed from Int when Foundation is imported") subscript(i: Swift.Int) -> Swift.UTF16.CodeUnit {
      get {}
    }
    @available(*, unavailable, message: "Slicing a String's UTF16View requires a Range<String.UTF16View.Index>, String.UTF16View.Index can be constructed from Int when Foundation is imported") subscript(bounds: Swift.Range<Swift.Int>) -> Swift.String.UTF16View {
      get {}
    }
    subscript(bounds: Swift.Range<Swift.String.UTF16View.Index>) -> Swift.String.UTF16View {
      get {}
    }
    init(_ _core: Swift._StringCore)
    init(_ _core: Swift._StringCore, offset: Swift.Int, length: Swift.Int)
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    var _offset: Swift.Int
    var _length: Swift.Int
    let _core: Swift._StringCore
    typealias _Element = Swift.UTF16.CodeUnit
    typealias SubSequence = Swift.String.UTF16View
    typealias Iterator = Swift.IndexingIterator<Swift.String.UTF16View>
  }
  var utf16: Swift.String.UTF16View {
    get {}
    set(newValue) {}
  }
  init?(_ utf16: Swift.String.UTF16View)
  typealias UTF16Index = Swift.String.UTF16View.Index
}
extension String {
  struct UTF8View : Collection, CustomStringConvertible, CustomDebugStringConvertible {
    let _core: Swift._StringCore
    let _startIndex: Swift.String.UTF8View.Index
    let _endIndex: Swift.String.UTF8View.Index
    init(_ _core: Swift._StringCore)
    init(_ _core: Swift._StringCore, _ s: Swift.String.UTF8View.Index, _ e: Swift.String.UTF8View.Index)
    struct Index {
      typealias Buffer = Swift._StringCore._UTF8Chunk
      init(_coreIndex: Swift.Int, _ _buffer: Swift.String.UTF8View.Index.Buffer)
      func _isOnUnicodeScalarBoundary(in core: Swift._StringCore) -> Swift.Bool
      func _isEndIndex(of core: Swift._StringCore) -> Swift.Bool
      var _utf8ContinuationBytesUntilNextUnicodeScalar: Swift.Int {
        get {}
      }
      static var _emptyBuffer: Swift.String.UTF8View.Index.Buffer {
        get {}
      }
      static var _bufferHiByte: Swift.String.UTF8View.Index.Buffer {
        get {}
      }
      static func _nextBuffer(after thisBuffer: Swift.String.UTF8View.Index.Buffer) -> Swift.String.UTF8View.Index.Buffer
      let _coreIndex: Swift.Int
      let _buffer: Swift.String.UTF8View.Index.Buffer
    }
    typealias IndexDistance = Swift.Int
    var startIndex: Swift.String.UTF8View.Index {
      get {}
    }
    var endIndex: Swift.String.UTF8View.Index {
      get {}
    }
    func index(after i: Swift.String.UTF8View.Index) -> Swift.String.UTF8View.Index
    subscript(position: Swift.String.UTF8View.Index) -> Swift.UTF8.CodeUnit {
      get {}
    }
    subscript(bounds: Swift.Range<Swift.String.UTF8View.Index>) -> Swift.String.UTF8View {
      get {}
    }
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    typealias _Element = Swift.UTF8.CodeUnit
    typealias SubSequence = Swift.String.UTF8View
    typealias Iterator = Swift.IndexingIterator<Swift.String.UTF8View>
    typealias Indices = Swift.DefaultIndices<Swift.String.UTF8View>
  }
  var utf8: Swift.String.UTF8View {
    get {}
    set(newValue) {}
  }
  var _contiguousUTF8: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>? {
    get {}
  }
  var utf8CString: Swift.ContiguousArray<Swift.CChar> {
    get {}
  }
  func _withUnsafeBufferPointerToUTF8<R>(_ body: (Swift.UnsafeBufferPointer<Swift.UTF8.CodeUnit>) throws -> R) rethrows -> R
  init?(_ utf8: Swift.String.UTF8View)
  typealias UTF8Index = Swift.String.UTF8View.Index
}
extension String {
  @available(*, unavailable, message: "Please use String.utf8CString instead.") var nulTerminatedUTF8: Swift.ContiguousArray<Swift.UTF8.CodeUnit> {
    get {}
  }
}
extension String {
  @available(*, unavailable, message: "cannot subscript String with an Int, see the documentation comment for discussion") subscript(i: Swift.Int) -> Swift.Character {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a Range<Int>, see the documentation comment for discussion") subscript(bounds: Swift.Range<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a ClosedRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.ClosedRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a CountableRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.CountableRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a CountableClosedRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.CountableClosedRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "there is no universally good answer, see the documentation comment for discussion") var count: Swift.Int {
    get {}
  }
}
extension String : MirrorPath {
}
extension String {
  init<Subject>(describing instance: Subject)
  init<Subject>(reflecting subject: Subject)
}
extension String {
  init(_sel: ObjectiveC.Selector)
}
extension String {
  init(_ cocoaString: Foundation.NSString)
}
extension String : _ObjectiveCBridgeable {
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSString
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSString, result: inout Swift.String?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSString, result: inout Swift.String?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSString?) -> Swift.String
  typealias _ObjectiveCType = Foundation.NSString
}
extension String : CVarArg {
}
extension String {
  var _ns: Foundation.NSString {
    get {}
  }
  func _index(_ utf16Index: Swift.Int) -> Swift.String.Index
  func _range(_ r: Foundation.NSRange) -> Swift.Range<Swift.String.Index>
  func _optionalRange(_ r: Foundation.NSRange) -> Swift.Range<Swift.String.Index>?
  func _withOptionalOutParameter<Result>(_ index: Swift.UnsafeMutablePointer<Swift.String.Index>?, _ body: (Swift.UnsafeMutablePointer<Swift.Int>?) -> Result) -> Result
  func _withOptionalOutParameter<Result>(_ range: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>?, _ body: (Swift.UnsafeMutablePointer<Foundation.NSRange>?) -> Result) -> Result
  static var availableStringEncodings: [Swift.String.Encoding] {
    get {}
  }
  static var defaultCStringEncoding: Swift.String.Encoding {
    get {}
  }
  static func localizedName(of encoding: Swift.String.Encoding) -> Swift.String
  static func localizedStringWithFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, message: "Use fileURL(withPathComponents:) on URL instead.") static func path(withComponents components: [Swift.String]) -> Swift.String
  init?(utf8String bytes: Swift.UnsafePointer<Swift.CChar>)
  func canBeConverted(to encoding: Swift.String.Encoding) -> Swift.Bool
  var capitalized: Swift.String {
    get {}
  }
  @available(OSX 10.11, iOS 9.0, *)
  var localizedCapitalized: Swift.String {
    get {}
  }
  func capitalized(with locale: Foundation.Locale?) -> Swift.String
  func caseInsensitiveCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func commonPrefix(with aString: Swift.String, options: Swift.String.CompareOptions = default) -> Swift.String
  func compare(_ aString: Swift.String, options mask: Swift.String.CompareOptions = default, range: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Foundation.ComparisonResult
  func completePath(into outputName: Swift.UnsafeMutablePointer<Swift.String>? = default, caseSensitive: Swift.Bool, matchesInto outputArray: Swift.UnsafeMutablePointer<[Swift.String]>? = default, filterTypes: [Swift.String]? = default) -> Swift.Int
  func components(separatedBy separator: Foundation.CharacterSet) -> [Swift.String]
  func components(separatedBy separator: Swift.String) -> [Swift.String]
  func cString(using encoding: Swift.String.Encoding) -> [Swift.CChar]?
  func data(using encoding: Swift.String.Encoding, allowLossyConversion: Swift.Bool = default) -> Foundation.Data?
  var decomposedStringWithCanonicalMapping: Swift.String {
    get {}
  }
  var decomposedStringWithCompatibilityMapping: Swift.String {
    get {}
  }
  func enumerateLines(invoking body: @escaping (Swift.String, inout Swift.Bool) -> ())
  func enumerateLinguisticTags(in range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, invoking body: (Swift.String, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  func enumerateSubstrings(in range: Swift.Range<Swift.String.Index>, options opts: Swift.String.EnumerationOptions = default, _ body: @escaping (Swift.String?, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  var fastestEncoding: Swift.String.Encoding {
    get {}
  }
  @available(*, unavailable, message: "Use getFileSystemRepresentation on URL instead.") var fileSystemRepresentation: [Swift.CChar] {
    get {}
  }
  func getBytes(_ buffer: inout [Swift.UInt8], maxLength maxBufferCount: Swift.Int, usedLength usedBufferCount: Swift.UnsafeMutablePointer<Swift.Int>, encoding: Swift.String.Encoding, options: Swift.String.EncodingConversionOptions = default, range: Swift.Range<Swift.String.Index>, remaining leftover: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>) -> Swift.Bool
  func getCString(_ buffer: inout [Swift.CChar], maxLength: Swift.Int, encoding: Swift.String.Encoding) -> Swift.Bool
  @available(*, unavailable, message: "Use getFileSystemRepresentation on URL instead.") func getFileSystemRepresentation(_ buffer: inout [Swift.CChar], maxLength: Swift.Int) -> Swift.Bool
  func getLineStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, for range: Swift.Range<Swift.String.Index>)
  func getParagraphStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, for range: Swift.Range<Swift.String.Index>)
  var hash: Swift.Int {
    get {}
  }
  init?<S : Sequence where S.Iterator.Element == UInt8>(bytes: S, encoding: Swift.String.Encoding)
  init?(bytesNoCopy bytes: Swift.UnsafeMutableRawPointer, length: Swift.Int, encoding: Swift.String.Encoding, freeWhenDone flag: Swift.Bool)
  init(utf16CodeUnits: Swift.UnsafePointer<Foundation.unichar>, count: Swift.Int)
  init(utf16CodeUnitsNoCopy: Swift.UnsafePointer<Foundation.unichar>, count: Swift.Int, freeWhenDone flag: Swift.Bool)
  init(contentsOfFile path: Swift.String, encoding enc: Swift.String.Encoding) throws
  init(contentsOfFile path: Swift.String, usedEncoding: inout Swift.String.Encoding) throws
  init(contentsOfFile path: Swift.String) throws
  init(contentsOf url: Foundation.URL, encoding enc: Swift.String.Encoding) throws
  init(contentsOf url: Foundation.URL, usedEncoding: inout Swift.String.Encoding) throws
  init(contentsOf url: Foundation.URL) throws
  init?(cString: Swift.UnsafePointer<Swift.CChar>, encoding enc: Swift.String.Encoding)
  init?(data: Foundation.Data, encoding: Swift.String.Encoding)
  init(format: Swift.String, _ arguments: CVarArg...)
  init(format: Swift.String, arguments: [CVarArg])
  init(format: Swift.String, locale: Foundation.Locale?, _ args: CVarArg...)
  init(format: Swift.String, locale: Foundation.Locale?, arguments: [CVarArg])
  @available(*, unavailable, message: "Use lastPathComponent on URL instead.") var lastPathComponent: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Take the count of a UTF-16 view instead, i.e. str.utf16.count") var utf16Count: Swift.Int {
    get {}
  }
  func lengthOfBytes(using encoding: Swift.String.Encoding) -> Swift.Int
  func lineRange(for aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  func linguisticTags(in range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, tokenRanges: Swift.UnsafeMutablePointer<[Swift.Range<Swift.String.Index>]>? = default) -> [Swift.String]
  func localizedCaseInsensitiveCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func localizedCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func localizedStandardCompare(_ string: Swift.String) -> Foundation.ComparisonResult
  @available(OSX 10.11, iOS 9.0, *)
  var localizedLowercase: Swift.String {
    get {}
  }
  func lowercased(with locale: Foundation.Locale?) -> Swift.String
  func maximumLengthOfBytes(using encoding: Swift.String.Encoding) -> Swift.Int
  func paragraphRange(for aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, message: "Use pathComponents on URL instead.") var pathComponents: [Swift.String] {
    get {}
  }
  @available(*, unavailable, message: "Use pathExtension on URL instead.") var pathExtension: Swift.String {
    get {}
  }
  var precomposedStringWithCanonicalMapping: Swift.String {
    get {}
  }
  var precomposedStringWithCompatibilityMapping: Swift.String {
    get {}
  }
  func propertyList() -> Any
  func propertyListFromStringsFileFormat() -> [Swift.String : Swift.String]
  func rangeOfCharacter(from aSet: Foundation.CharacterSet, options mask: Swift.String.CompareOptions = default, range aRange: Swift.Range<Swift.String.Index>? = default) -> Swift.Range<Swift.String.Index>?
  func rangeOfComposedCharacterSequence(at anIndex: Swift.String.Index) -> Swift.Range<Swift.String.Index>
  func rangeOfComposedCharacterSequences(for range: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  func range(of aString: Swift.String, options mask: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Swift.Range<Swift.String.Index>?
  @available(OSX 10.11, iOS 9.0, *)
  func localizedStandardContains(_ string: Swift.String) -> Swift.Bool
  @available(OSX 10.11, iOS 9.0, *)
  func localizedStandardRange(of string: Swift.String) -> Swift.Range<Swift.String.Index>?
  var smallestEncoding: Swift.String.Encoding {
    get {}
  }
  @available(*, unavailable, message: "Use abbreviatingWithTildeInPath on NSString instead.") var abbreviatingWithTildeInPath: Swift.String {
    get {}
  }
  func addingPercentEncoding(withAllowedCharacters allowedCharacters: Foundation.CharacterSet) -> Swift.String?
  @available(*, deprecated, message: "Use addingPercentEncoding(withAllowedCharacters:) instead, which always uses the recommended UTF-8 encoding, and which encodes for a specific URL component or subcomponent since each URL component or subcomponent has different rules for what characters are valid.") func addingPercentEscapes(using encoding: Swift.String.Encoding) -> Swift.String?
  func appendingFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, message: "Use appendingPathComponent on URL instead.") func appendingPathComponent(_ aString: Swift.String) -> Swift.String
  @available(*, unavailable, message: "Use appendingPathExtension on URL instead.") func appendingPathExtension(_ ext: Swift.String) -> Swift.String?
  func appending(_ aString: Swift.String) -> Swift.String
  @available(*, unavailable, message: "Use deletingLastPathComponent on URL instead.") var deletingLastPathComponent: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use deletingPathExtension on URL instead.") var deletingPathExtension: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use expandingTildeInPath on NSString instead.") var expandingTildeInPath: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "folding(options:locale:)") func folding(_ options: Swift.String.CompareOptions = default, locale: Foundation.Locale?) -> Swift.String
  func folding(options: Swift.String.CompareOptions = default, locale: Foundation.Locale?) -> Swift.String
  func padding(toLength newLength: Swift.Int, withPad padString: Swift.String, startingAt padIndex: Swift.Int) -> Swift.String
  var removingPercentEncoding: Swift.String? {
    get {}
  }
  func replacingCharacters(in range: Swift.Range<Swift.String.Index>, with replacement: Swift.String) -> Swift.String
  func replacingOccurrences(of target: Swift.String, with replacement: Swift.String, options: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default) -> Swift.String
  @available(*, deprecated, message: "Use removingPercentEncoding instead, which always uses the recommended UTF-8 encoding.") func replacingPercentEscapes(using encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, message: "Use resolvingSymlinksInPath on URL instead.") var resolvingSymlinksInPath: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use standardizingPath on URL instead.") var standardizingPath: Swift.String {
    get {}
  }
  func trimmingCharacters(in set: Foundation.CharacterSet) -> Swift.String
  @available(*, unavailable, message: "Map over paths with appendingPathComponent instead.") func strings(byAppendingPaths paths: [Swift.String]) -> [Swift.String]
  func substring(from index: Swift.String.Index) -> Swift.String
  func substring(to index: Swift.String.Index) -> Swift.String
  func substring(with aRange: Swift.Range<Swift.String.Index>) -> Swift.String
  @available(OSX 10.11, iOS 9.0, *)
  var localizedUppercase: Swift.String {
    get {}
  }
  func uppercased(with locale: Foundation.Locale?) -> Swift.String
  func write(toFile path: Swift.String, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  func write(to url: Foundation.URL, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  @available(OSX 10.11, iOS 9.0, *)
  func applyingTransform(_ transform: Foundation.StringTransform, reverse: Swift.Bool) -> Swift.String?
  func contains(_ other: Swift.String) -> Swift.Bool
  func localizedCaseInsensitiveContains(_ other: Swift.String) -> Swift.Bool
}
extension String {
  @available(*, unavailable, renamed: "localizedName(of:)") static func localizedNameOfStringEncoding(_ encoding: Swift.String.Encoding) -> Swift.String
  @available(*, unavailable, message: "Use fileURL(withPathComponents:) on URL instead.") static func pathWithComponents(_ components: [Swift.String]) -> Swift.String
  @available(*, unavailable, renamed: "canBeConverted(to:)") func canBeConvertedToEncoding(_ encoding: Swift.String.Encoding) -> Swift.Bool
  @available(*, unavailable, renamed: "capitalizedString(with:)") func capitalizedStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "commonPrefix(with:options:)") func commonPrefixWith(_ aString: Swift.String, options: Swift.String.CompareOptions) -> Swift.String
  @available(*, unavailable, renamed: "completePath(into:outputName:caseSensitive:matchesInto:filterTypes:)") func completePathInto(_ outputName: Swift.UnsafeMutablePointer<Swift.String>? = default, caseSensitive: Swift.Bool, matchesInto matchesIntoArray: Swift.UnsafeMutablePointer<[Swift.String]>? = default, filterTypes: [Swift.String]? = default) -> Swift.Int
  @available(*, unavailable, renamed: "components(separatedBy:)") func componentsSeparatedByCharactersIn(_ separator: Foundation.CharacterSet) -> [Swift.String]
  @available(*, unavailable, renamed: "componentsSeparated(by:)") func componentsSeparatedBy(_ separator: Swift.String) -> [Swift.String]
  @available(*, unavailable, renamed: "cString(usingEncoding:)") func cStringUsingEncoding(_ encoding: Swift.String.Encoding) -> [Swift.CChar]?
  @available(*, unavailable, renamed: "data(usingEncoding:allowLossyConversion:)") func dataUsingEncoding(_ encoding: Swift.String.Encoding, allowLossyConversion: Swift.Bool = default) -> Foundation.Data?
  @available(*, unavailable, renamed: "enumerateLinguisticTags(in:scheme:options:orthography:_:)") func enumerateLinguisticTagsIn(_ range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options, orthography: Foundation.NSOrthography?, _ body: (Swift.String, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  @available(*, unavailable, renamed: "enumerateSubstrings(in:options:_:)") func enumerateSubstringsIn(_ range: Swift.Range<Swift.String.Index>, options opts: Swift.String.EnumerationOptions = default, _ body: (Swift.String?, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  @available(*, unavailable, renamed: "getBytes(_:maxLength:usedLength:encoding:options:range:remaining:)") func getBytes(_ buffer: inout [Swift.UInt8], maxLength maxBufferCount: Swift.Int, usedLength usedBufferCount: Swift.UnsafeMutablePointer<Swift.Int>, encoding: Swift.String.Encoding, options: Swift.String.EncodingConversionOptions = default, range: Swift.Range<Swift.String.Index>, remainingRange leftover: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>) -> Swift.Bool
  @available(*, unavailable, renamed: "getLineStart(_:end:contentsEnd:for:)") func getLineStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, forRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "getParagraphStart(_:end:contentsEnd:for:)") func getParagraphStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, forRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "lengthOfBytes(using:)") func lengthOfBytesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.Int
  @available(*, unavailable, renamed: "lineRange(for:)") func lineRangeFor(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "linguisticTags(in:scheme:options:orthography:tokenRanges:)") func linguisticTagsIn(_ range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, tokenRanges: Swift.UnsafeMutablePointer<[Swift.Range<Swift.String.Index>]>? = default) -> [Swift.String]
  @available(*, unavailable, renamed: "lowercased(with:)") func lowercaseStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "maximumLengthOfBytes(using:)") func maximumLengthOfBytesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.Int
  @available(*, unavailable, renamed: "paragraphRange(for:)") func paragraphRangeFor(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "rangeOfCharacter(from:options:range:)") func rangeOfCharacterFrom(_ aSet: Foundation.CharacterSet, options mask: Swift.String.CompareOptions = default, range aRange: Swift.Range<Swift.String.Index>? = default) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "rangeOfComposedCharacterSequence(at:)") func rangeOfComposedCharacterSequenceAt(_ anIndex: Swift.String.Index) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "rangeOfComposedCharacterSequences(for:)") func rangeOfComposedCharacterSequencesFor(_ range: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "range(of:options:range:locale:)") func rangeOf(_ aString: Swift.String, options mask: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "localizedStandardRange(of:)") func localizedStandardRangeOf(_ string: Swift.String) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "addingPercentEncoding(withAllowedCharacters:)") func addingPercentEncodingWithAllowedCharacters(_ allowedCharacters: Foundation.CharacterSet) -> Swift.String?
  @available(*, unavailable, renamed: "addingPercentEscapes(using:)") func addingPercentEscapesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, renamed: "appendingFormat") func stringByAppendingFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, renamed: "padding(toLength:with:startingAt:)") func byPaddingToLength(_ newLength: Swift.Int, withString padString: Swift.String, startingAt padIndex: Swift.Int) -> Swift.String
  @available(*, unavailable, renamed: "replacingCharacters(in:with:)") func replacingCharactersIn(_ range: Swift.Range<Swift.String.Index>, withString replacement: Swift.String) -> Swift.String
  @available(*, unavailable, renamed: "replacingOccurrences(of:with:options:range:)") func replacingOccurrencesOf(_ target: Swift.String, withString replacement: Swift.String, options: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default) -> Swift.String
  @available(*, unavailable, renamed: "replacingPercentEscapes(usingEncoding:)") func replacingPercentEscapesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, renamed: "trimmingCharacters(in:)") func byTrimmingCharactersIn(_ set: Foundation.CharacterSet) -> Swift.String
  @available(*, unavailable, renamed: "strings(byAppendingPaths:)") func stringsByAppendingPaths(_ paths: [Swift.String]) -> [Swift.String]
  @available(*, unavailable, renamed: "substring(from:)") func substringFrom(_ index: Swift.String.Index) -> Swift.String
  @available(*, unavailable, renamed: "substring(to:)") func substringTo(_ index: Swift.String.Index) -> Swift.String
  @available(*, unavailable, renamed: "substring(with:)") func substringWith(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.String
  @available(*, unavailable, renamed: "uppercased(with:)") func uppercaseStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "write(toFile:atomically:encoding:)") func writeToFile(_ path: Swift.String, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  @available(*, unavailable, renamed: "write(to:atomically:encoding:)") func writeToURL(_ url: Foundation.URL, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
}
extension String {
  struct Encoding : RawRepresentable {
    var rawValue: Swift.UInt
    init(rawValue: Swift.UInt)
    static var ascii: Swift.String.Encoding
    static var nextstep: Swift.String.Encoding
    static var japaneseEUC: Swift.String.Encoding
    static var utf8: Swift.String.Encoding
    static var isoLatin1: Swift.String.Encoding
    static var symbol: Swift.String.Encoding
    static var nonLossyASCII: Swift.String.Encoding
    static var shiftJIS: Swift.String.Encoding
    static var isoLatin2: Swift.String.Encoding
    static var unicode: Swift.String.Encoding
    static var windowsCP1251: Swift.String.Encoding
    static var windowsCP1252: Swift.String.Encoding
    static var windowsCP1253: Swift.String.Encoding
    static var windowsCP1254: Swift.String.Encoding
    static var windowsCP1250: Swift.String.Encoding
    static var iso2022JP: Swift.String.Encoding
    static var macOSRoman: Swift.String.Encoding
    static var utf16: Swift.String.Encoding
    static var utf16BigEndian: Swift.String.Encoding
    static var utf16LittleEndian: Swift.String.Encoding
    static var utf32: Swift.String.Encoding
    static var utf32BigEndian: Swift.String.Encoding
    static var utf32LittleEndian: Swift.String.Encoding
    typealias RawValue = Swift.UInt
  }
  typealias EncodingConversionOptions = Foundation.NSString.EncodingConversionOptions
  typealias EnumerationOptions = Foundation.NSString.EnumerationOptions
  typealias CompareOptions = Foundation.NSString.CompareOptions
}
extension String : Toastable {
  func mainMessage() -> Swift.String
  func detailMessage() -> Swift.String
}
func _swift_stdlib_atomicFetchAddUInt64(object target: Swift.UnsafeMutablePointer<Swift.UInt64>, operand: Swift.UInt64) -> Swift.UInt64
func _transcodeSomeUTF16AsUTF8<Input where Input : Collection, Input.Iterator.Element == UInt16>(_ input: Input, _ startIndex: Input.Index) -> (Input.Index, Swift._StringCore._UTF8Chunk)
@_versioned @inline(__always) func _makeNativeBridgeObject(_ nativeObject: AnyObject, _ bits: Swift.UInt) -> Builtin.BridgeObject
func _exp(_ x: Swift.Float) -> Swift.Float
func _exp(_ x: Swift.Double) -> Swift.Double
@_versioned @_silgen_name("_swift_stdlib_reportUnimplementedInitializerInFile") func _reportUnimplementedInitializerInFile(_ className: Swift.UnsafePointer<Swift.UInt8>, _ classNameLength: Swift.UInt, _ initName: Swift.UnsafePointer<Swift.UInt8>, _ initNameLength: Swift.UInt, _ file: Swift.UnsafePointer<Swift.UInt8>, _ fileLength: Swift.UInt, _ line: Swift.UInt, _ column: Swift.UInt, flags: Swift.UInt32)
func _mixUInt(_ value: Swift.UInt) -> Swift.UInt
protocol Collection : Indexable, Sequence {
  associatedtype IndexDistance : SignedInteger = Swift.Int
  associatedtype Iterator : IteratorProtocol = Swift.IndexingIterator<Self>
  func makeIterator() -> Self.Iterator
  associatedtype SubSequence : IndexableBase, Sequence = Swift.Slice<Self>
  subscript(position: Self.Index) -> Self.Iterator.Element { get }
  subscript(bounds: Swift.Range<Self.Index>) -> Self.SubSequence { get }
  associatedtype Indices : IndexableBase, Sequence = Swift.DefaultIndices<Self>
  var indices: Self.Indices { get }
  func prefix(upTo end: Self.Index) -> Self.SubSequence
  func suffix(from start: Self.Index) -> Self.SubSequence
  func prefix(through position: Self.Index) -> Self.SubSequence
  var isEmpty: Swift.Bool { get }
  var count: Self.IndexDistance { get }
  func _customIndexOfEquatableElement(_ element: Self.Iterator.Element) -> Self.Index??
  var first: Self.Iterator.Element? { get }
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance) -> Self.Index
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Self.Index?
  func distance(from start: Self.Index, to end: Self.Index) -> Self.IndexDistance
}
extension Collection {
  func map<T>(_ transform: (Self.Iterator.Element) throws -> T) rethrows -> [T]
  func dropFirst(_ n: Swift.Int) -> Self.SubSequence
  func dropLast(_ n: Swift.Int) -> Self.SubSequence
  func prefix(_ maxLength: Swift.Int) -> Self.SubSequence
  func suffix(_ maxLength: Swift.Int) -> Self.SubSequence
  func prefix(upTo end: Self.Index) -> Self.SubSequence
  func suffix(from start: Self.Index) -> Self.SubSequence
  func prefix(through position: Self.Index) -> Self.SubSequence
  func split(maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default, whereSeparator isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.SubSequence]
}
extension Collection {
  var isEmpty: Swift.Bool {
    get {}
  }
  var first: Self.Iterator.Element? {
    get {}
  }
  var underestimatedCount: Swift.Int {
    get {}
  }
  var count: Self.IndexDistance {
    get {}
  }
  func _customIndexOfEquatableElement(_: Self.Iterator.Element) -> Self.Index??
}
extension Collection where Iterator == IndexingIterator<Self> {
  func makeIterator() -> Swift.IndexingIterator<Self>
}
extension Collection where SubSequence == Slice<Self> {
  subscript(bounds: Swift.Range<Self.Index>) -> Swift.Slice<Self> {
    get {}
  }
}
extension Collection where SubSequence == Self {
  mutating func popFirst() -> Self.Iterator.Element?
}
extension Collection where Iterator.Element : Equatable {
  func split(separator: Self.Iterator.Element, maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default) -> [Self.SubSequence]
}
extension Collection where SubSequence == Self {
  @discardableResult mutating func removeFirst() -> Self.Iterator.Element
  mutating func removeFirst(_ n: Swift.Int)
}
extension Collection {
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
}
extension Collection {
  @available(*, unavailable, renamed: "Iterator") typealias Generator = Self.Iterator
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Self.Iterator
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
  @available(*, unavailable, message: "Please use split(maxSplits:omittingEmptySubsequences:whereSeparator:) instead") func split(_ maxSplit: Swift.Int = default, allowEmptySlices: Swift.Bool = default, whereSeparator isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.SubSequence]
}
extension Collection where Iterator.Element : Equatable {
  @available(*, unavailable, message: "Please use split(separator:maxSplits:omittingEmptySubsequences:) instead") func split(_ separator: Self.Iterator.Element, maxSplit: Swift.Int = default, allowEmptySlices: Swift.Bool = default) -> [Self.SubSequence]
}
extension Collection where Iterator.Element : Equatable {
  func index(of element: Self.Iterator.Element) -> Self.Index?
}
extension Collection {
  func index(where predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index?
}
extension Collection where Iterator.Element : Equatable {
  @available(*, unavailable, renamed: "index(of:)") func indexOf(_ element: Self.Iterator.Element) -> Self.Index?
}
extension Collection {
  @available(*, unavailable, renamed: "index(where:)") func indexOf(_ predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index?
}
extension Collection {
  func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Iterator.Element>
}
extension Collection where Iterator.Element : Collection {
  func joined() -> Swift.FlattenCollection<Self>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.FlattenCollection<Self>
}
extension Collection where Indices == DefaultIndices<Self> {
  var indices: Swift.DefaultIndices<Self> {
    get {}
  }
}
extension Collection {
  var lazy: Swift.LazyCollection<Self> {
    get {}
  }
}
extension Collection where Self : LazyCollectionProtocol {
  var lazy: Self {
    get {}
  }
}
@_silgen_name("_swift_stdlib_NSObject_isKindOfClass") func _swift_NSObject_isImpl(_ object: AnyObject, kindOf: AnyObject) -> Swift.Bool
@available(*, unavailable, renamed: "Range") struct HalfOpenInterval<Bound> {
  init()
}
struct HeapObject {
  var metadata: Swift.OpaquePointer!
  var refCount: SwiftShims.StrongRefCount
  var weakRefCount: SwiftShims.WeakRefCount
  init() {

  }
  init(metadata: Swift.OpaquePointer!, refCount: SwiftShims.StrongRefCount, weakRefCount: SwiftShims.WeakRefCount)
}
func _isUniqueOrPinned_native<T>(_ object: inout T) -> Swift.Bool
struct UInt8 : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int8
  init()
  init(_ _v: Builtin.Int8)
  init(_bits: Builtin.Int8)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt8)
  static var max: Swift.UInt8 {
    get {}
  }
  static var min: Swift.UInt8 {
    get {}
  }
  static var _sizeInBits: Swift.UInt8 {
    get {}
  }
  static var _sizeInBytes: Swift.UInt8 {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt8
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt8 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt8 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt8 {
  static func addWithOverflow(_ lhs: Swift.UInt8, _ rhs: Swift.UInt8) -> (Swift.UInt8, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt8, _ rhs: Swift.UInt8) -> (Swift.UInt8, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt8, _ rhs: Swift.UInt8) -> (Swift.UInt8, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt8, _ rhs: Swift.UInt8) -> (Swift.UInt8, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt8, _ rhs: Swift.UInt8) -> (Swift.UInt8, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt8 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt8 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt8 {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt8 {
  init(_ value: Swift.UInt16)
  init?(exactly value: Swift.UInt16)
  init(truncatingBitPattern: Swift.UInt16)
}
extension UInt8 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
  init(truncatingBitPattern: Swift.Int16)
}
extension UInt8 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
  init(truncatingBitPattern: Swift.UInt32)
}
extension UInt8 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
  init(truncatingBitPattern: Swift.Int32)
}
extension UInt8 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension UInt8 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension UInt8 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension UInt8 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension UInt8 {
  init(bitPattern: Swift.Int8)
}
extension UInt8 : BitwiseOperations {
  static var allZeros: Swift.UInt8 {
    get {}
  }
}
extension UInt8 {
  typealias _DisabledRangeIndex = Swift.UInt8
}
extension UInt8 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt8 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt8 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt8 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Swift.UTF8.CodeUnit : _StringElement {
  static func _toUTF16CodeUnit(_ x: Swift.UTF8.CodeUnit) -> Swift.UTF16.CodeUnit
  static func _fromUTF16CodeUnit(_ utf16: Swift.UTF16.CodeUnit) -> Swift.UTF8.CodeUnit
}
extension UInt8 {
  init(ascii v: Swift.UnicodeScalar)
}
extension UInt8 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension UInt8 {
  init(_ value: CoreGraphics.CGFloat)
}
func _swift_stdlib_atomicFetchOrUInt32(object target: Swift.UnsafeMutablePointer<Swift.UInt32>, operand: Swift.UInt32) -> Swift.UInt32
struct Float {
  var _value: Builtin.FPIEEE32
  init()
  init(_bits v: Builtin.FPIEEE32)
}
extension Float : LosslessStringConvertible {
  init?(_ text: Swift.String)
}
extension Float : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Float : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Float : BinaryFloatingPoint {
  typealias Exponent = Swift.Int
  typealias RawSignificand = Swift.UInt32
  static var exponentBitCount: Swift.Int {
    get {}
  }
  static var significandBitCount: Swift.Int {
    get {}
  }
  @_versioned static var _infinityExponent: Swift.UInt {
    @inline(__always) get {}
  }
  static var _exponentBias: Swift.UInt {
    @inline(__always) get {}
  }
  static var _significandMask: Swift.UInt32 {
    @inline(__always) get {}
  }
  @_versioned static var _quietNaNMask: Swift.UInt32 {
    @inline(__always) get {}
  }
  var bitPattern: Swift.UInt32 {
    get {}
  }
  init(bitPattern: Swift.UInt32)
  var sign: Swift.FloatingPointSign {
    get {}
  }
  @available(*, unavailable, renamed: "sign") var isSignMinus: Swift.Bool {
    get {}
  }
  var exponentBitPattern: Swift.UInt {
    get {}
  }
  var significandBitPattern: Swift.UInt32 {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponentBitPattern: Swift.UInt, significandBitPattern: Swift.UInt32)
  var isCanonical: Swift.Bool {
    get {}
  }
  static var infinity: Swift.Float {
    get {}
  }
  static var nan: Swift.Float {
    get {}
  }
  static var signalingNaN: Swift.Float {
    get {}
  }
  @available(*, unavailable, renamed: "nan") static var quietNaN: Swift.Float {
    get {}
  }
  static var greatestFiniteMagnitude: Swift.Float {
    get {}
  }
  static var pi: Swift.Float {
    get {}
  }
  var ulp: Swift.Float {
    get {}
  }
  static var leastNormalMagnitude: Swift.Float {
    get {}
  }
  static var leastNonzeroMagnitude: Swift.Float {
    get {}
  }
  var exponent: Swift.Int {
    get {}
  }
  var significand: Swift.Float {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponent: Swift.Int, significand: Swift.Float)
  init(nan payload: Swift.Float.RawSignificand, signaling: Swift.Bool)
  var nextUp: Swift.Float {
    get {}
  }
  mutating func round(_ rule: Swift.FloatingPointRoundingRule)
  mutating func negate()
  mutating func add(_ other: Swift.Float)
  mutating func subtract(_ other: Swift.Float)
  mutating func multiply(by other: Swift.Float)
  mutating func divide(by other: Swift.Float)
  mutating func formRemainder(dividingBy other: Swift.Float)
  mutating func formTruncatingRemainder(dividingBy other: Swift.Float)
  mutating func formSquareRoot()
  mutating func addProduct(_ lhs: Swift.Float, _ rhs: Swift.Float)
  func isEqual(to other: Swift.Float) -> Swift.Bool
  func isLess(than other: Swift.Float) -> Swift.Bool
  func isLessThanOrEqualTo(_ other: Swift.Float) -> Swift.Bool
  var isNormal: Swift.Bool {
    get {}
  }
  var isFinite: Swift.Bool {
    get {}
  }
  var isZero: Swift.Bool {
    get {}
  }
  var isSubnormal: Swift.Bool {
    get {}
  }
  var isInfinite: Swift.Bool {
    get {}
  }
  var isNaN: Swift.Bool {
    get {}
  }
  var isSignalingNaN: Swift.Bool {
    get {}
  }
  var binade: Swift.Float {
    get {}
  }
  var significandWidth: Swift.Int {
    get {}
  }
  init(floatLiteral value: Swift.Float)
  typealias FloatLiteralType = Swift.Float
  typealias RawExponent = Swift.UInt
}
extension Float : _ExpressibleByBuiltinIntegerLiteral, ExpressibleByIntegerLiteral {
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  typealias IntegerLiteralType = Swift.Int64
}
extension Float : _ExpressibleByBuiltinFloatLiteral {
  init(_builtinFloatLiteral value: Builtin.FPIEEE80)
}
extension Float : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension Float : AbsoluteValuable {
  static func abs(_ x: Swift.Float) -> Swift.Float
}
extension Float {
  init(_ v: Swift.UInt8)
  init(_ v: Swift.Int8)
  init(_ v: Swift.UInt16)
  init(_ v: Swift.Int16)
  init(_ v: Swift.UInt32)
  init(_ v: Swift.Int32)
  init(_ v: Swift.UInt64)
  init(_ v: Swift.Int64)
  init(_ v: Swift.UInt)
  init(_ v: Swift.Int)
}
extension Float {
  init(_ other: Swift.Float)
  @inline(__always) init?(exactly other: Swift.Float)
  init(_ other: Swift.Double)
  @inline(__always) init?(exactly other: Swift.Double)
  init(_ other: Swift.Float80)
  @inline(__always) init?(exactly other: Swift.Float80)
}
extension Float : Strideable {
  func distance(to other: Swift.Float) -> Swift.Float
  func advanced(by amount: Swift.Float) -> Swift.Float
  typealias Stride = Swift.Float
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension Float : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Float : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Float : _CVarArgPassedAsDouble, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension Float {
  init(_ value: CoreGraphics.CGFloat)
}
extension Float : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Float?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Float?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Float
  typealias _ObjectiveCType = Foundation.NSNumber
}
@_versioned @inline(__always) func _bitPattern(_ x: Builtin.BridgeObject) -> Swift.UInt
struct _DictionaryBuilder<Key : Hashable, Value> {
  var _result: [Key : Value]
  var _nativeStorage: Swift._NativeDictionaryStorage<Key, Value>
  let _requestedCount: Swift.Int
  var _actualCount: Swift.Int
  init(count: Swift.Int)
  mutating func add(key newKey: Key, value: Value)
  mutating func take() -> [Key : Value]
}
struct Int : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(_ _v: Builtin.Word)
  var _builtinWordValue: Builtin.Word {
    get {}
  }
  init(bigEndian value: Swift.Int)
  init(littleEndian value: Swift.Int)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int)
  var bigEndian: Swift.Int {
    get {}
  }
  var littleEndian: Swift.Int {
    get {}
  }
  var byteSwapped: Swift.Int {
    get {}
  }
  static var max: Swift.Int {
    get {}
  }
  static var min: Swift.Int {
    get {}
  }
  static var _sizeInBits: Swift.Int {
    get {}
  }
  static var _sizeInBytes: Swift.Int {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int
  typealias Stride = Swift.Int
}
extension Int : SignedNumber {
}
extension Int : BitwiseOperations {
  static var allZeros: Swift.Int {
    get {}
  }
}
extension Int : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int {
  init(bitPattern pointer: Swift.OpaquePointer?)
}
extension Int {
  static func addWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int, _ rhs: Swift.Int) -> (Swift.Int, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to Int will always succeed.") init?(exactly value: Swift.UInt8)
}
extension Int {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to Int will always succeed.") init?(exactly value: Swift.UInt16)
}
extension Int {
  init(_ value: Swift.Int16)
  @available(*, message: "Converting Int16 to Int will always succeed.") init?(exactly value: Swift.Int16)
}
extension Int {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to Int will always succeed.") init?(exactly value: Swift.UInt32)
}
extension Int {
  init(_ value: Swift.Int32)
  @available(*, message: "Converting Int32 to Int will always succeed.") init?(exactly value: Swift.Int32)
}
extension Int {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension Int {
  init(_ value: Swift.Int64)
  @available(*, message: "Converting Int64 to Int will always succeed.") init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension Int {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
}
extension Int {
  init(_ value: Swift.Int)
  @available(*, message: "Converting Int to Int will always succeed.") init?(exactly value: Swift.Int)
}
extension Int {
  init(bitPattern: Swift.UInt)
}
extension Int {
  typealias _DisabledRangeIndex = Swift.Int
}
extension Int {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Int {
  init(bitPattern objectID: Swift.ObjectIdentifier)
}
extension Int {
  @available(*, unavailable, renamed: "init(bitPattern:)") init(_ objectID: Swift.ObjectIdentifier)
}
extension Int {
  init<U>(bitPattern: Swift.UnsafeMutablePointer<U>?)
}
extension Int {
  init<U>(bitPattern: Swift.UnsafePointer<U>?)
}
extension Int {
  init(bitPattern: Swift.UnsafeMutableRawPointer?)
}
extension Int {
  init(bitPattern: Swift.UnsafeRawPointer?)
}
extension Int : MirrorPath {
}
extension Int : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension Int {
  init(_ value: CoreGraphics.CGFloat)
}
extension Int : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Int?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Int?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Int
  typealias _ObjectiveCType = Foundation.NSNumber
}
struct UnicodeScalar : _ExpressibleByBuiltinUnicodeScalarLiteral, ExpressibleByUnicodeScalarLiteral {
  var _value: Swift.UInt32
  var value: Swift.UInt32 {
    get {}
  }
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
  init(unicodeScalarLiteral value: Swift.UnicodeScalar)
  init?(_ v: Swift.UInt32)
  init?(_ v: Swift.UInt16)
  init(_ v: Swift.UInt8)
  init(_ v: Swift.UnicodeScalar)
  func escaped(asASCII forceASCII: Swift.Bool) -> Swift.String
  var isASCII: Swift.Bool {
    get {}
  }
  var _isASCIIDigit: Swift.Bool {
    get {}
  }
  var _isPrintableASCII: Swift.Bool {
    get {}
  }
  typealias UnicodeScalarLiteralType = Swift.UnicodeScalar
}
extension UnicodeScalar : Equatable {
  static func ==(lhs: Swift.UnicodeScalar, rhs: Swift.UnicodeScalar) -> Swift.Bool
}
extension UnicodeScalar : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UnicodeScalar : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UnicodeScalar : TextOutputStreamable {
  func write<Target : TextOutputStream>(to target: inout Target)
}
extension UnicodeScalar {
  init(_unchecked value: Swift.UInt32)
}
extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible {
  var description: Swift.String {
    get {}
  }
  var debugDescription: Swift.String {
    get {}
  }
}
extension UnicodeScalar : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension UnicodeScalar : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension UnicodeScalar {
  init?(_ v: Swift.Int)
}
extension UnicodeScalar : Comparable {
  static func <(lhs: Swift.UnicodeScalar, rhs: Swift.UnicodeScalar) -> Swift.Bool
}
extension UnicodeScalar {
  struct UTF16View {
    var value: Swift.UnicodeScalar
    init(value: Swift.UnicodeScalar)
  }
  var utf16: Swift.UnicodeScalar.UTF16View {
    get {}
  }
}
extension UnicodeScalar {
  @available(*, unavailable, message: "use 'UnicodeScalar(0)'") init()
  @available(*, unavailable, renamed: "escaped(asASCII:)") func escape(asASCII forceASCII: Swift.Bool) -> Swift.String
}
struct UInt64 : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(bigEndian value: Swift.UInt64)
  init(littleEndian value: Swift.UInt64)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt64)
  var bigEndian: Swift.UInt64 {
    get {}
  }
  var littleEndian: Swift.UInt64 {
    get {}
  }
  var byteSwapped: Swift.UInt64 {
    get {}
  }
  static var max: Swift.UInt64 {
    get {}
  }
  static var min: Swift.UInt64 {
    get {}
  }
  static var _sizeInBits: Swift.UInt64 {
    get {}
  }
  static var _sizeInBytes: Swift.UInt64 {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt64
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt64 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt64 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt64 {
  static func addWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt64, _ rhs: Swift.UInt64) -> (Swift.UInt64, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt64 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt64 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt64 {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt64 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to UInt64 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension UInt64 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
}
extension UInt64 {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to UInt64 will always succeed.") init?(exactly value: Swift.UInt32)
}
extension UInt64 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
}
extension UInt64 {
  init(_ value: Swift.UInt64)
  @available(*, message: "Converting UInt64 to UInt64 will always succeed.") init?(exactly value: Swift.UInt64)
}
extension UInt64 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
}
extension UInt64 {
  init(_ value: Swift.UInt)
  @available(*, message: "Converting UInt to UInt64 will always succeed.") init?(exactly value: Swift.UInt)
}
extension UInt64 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
}
extension UInt64 {
  init(bitPattern: Swift.Int64)
}
extension UInt64 : BitwiseOperations {
  static var allZeros: Swift.UInt64 {
    get {}
  }
}
extension UInt64 {
  typealias _DisabledRangeIndex = Swift.UInt64
}
extension UInt64 {
  var signBitIndex: Swift.Int {
    get {}
  }
  var countTrailingZeros: Swift.Int {
    get {}
  }
}
extension UInt64 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt64 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt64 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt64 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension UInt64 {
  init(_ v: Swift.UnicodeScalar)
}
extension UInt64 : CVarArg, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension UInt64 {
  init(_ value: CoreGraphics.CGFloat)
}
struct AnySequence<Element> : Sequence {
  init<S : Sequence where S.Iterator.Element == Element, S.SubSequence : Sequence, S.SubSequence.Iterator.Element == Element, S.SubSequence.SubSequence == S.SubSequence>(_ base: S)
  init<I : IteratorProtocol where I.Element == Element>(_ makeUnderlyingIterator: @escaping () -> I)
  init(_box: Swift._AnySequenceBox<Element>)
  let _box: Swift._AnySequenceBox<Element>
  typealias Iterator = Swift.AnyIterator<Element>
  typealias SubSequence = Swift.AnySequence<Element>
}
extension AnySequence {
  func makeIterator() -> Swift.AnyIterator<Element>
  var underestimatedCount: Swift.Int {
    get {}
  }
  func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
  func filter(_ isIncluded: (Element) throws -> Swift.Bool) rethrows -> [Element]
  func forEach(_ body: (Element) throws -> Swift.Void) rethrows
  func dropFirst(_ n: Swift.Int) -> Swift.AnySequence<Element>
  func dropLast(_ n: Swift.Int) -> Swift.AnySequence<Element>
  func prefix(_ maxLength: Swift.Int) -> Swift.AnySequence<Element>
  func suffix(_ maxLength: Swift.Int) -> Swift.AnySequence<Element>
  func split(maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default, whereSeparator isSeparator: (Element) throws -> Swift.Bool) rethrows -> [Swift.AnySequence<Element>]
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Element>
  func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Element>) -> Swift.UnsafeMutablePointer<Element>
}
extension AnySequence {
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
}
@_silgen_name("swift_getTypeName") func _getTypeName(_ type: Any.Type, qualified: Swift.Bool) -> (Swift.UnsafePointer<Swift.UInt8>, Swift.Int)
struct CountableClosedRange<Bound where Bound : _Strideable & Comparable, Bound.Stride : SignedInteger> : RandomAccessCollection {
  let lowerBound: Bound
  let upperBound: Bound
  typealias Element = Bound
  typealias Index = Swift.ClosedRangeIndex<Bound>
  typealias IndexDistance = Bound.Stride
  typealias Iterator = Swift.ClosedRangeIterator<Bound>
  func makeIterator() -> Swift.ClosedRangeIterator<Bound>
  var startIndex: Swift.ClosedRangeIndex<Bound> {
    get {}
  }
  var endIndex: Swift.ClosedRangeIndex<Bound> {
    get {}
  }
  func index(after i: Swift.ClosedRangeIndex<Bound>) -> Swift.ClosedRangeIndex<Bound>
  func index(before i: Swift.ClosedRangeIndex<Bound>) -> Swift.ClosedRangeIndex<Bound>
  func index(_ i: Swift.ClosedRangeIndex<Bound>, offsetBy n: Bound.Stride) -> Swift.ClosedRangeIndex<Bound>
  func distance(from start: Swift.ClosedRangeIndex<Bound>, to end: Swift.ClosedRangeIndex<Bound>) -> Bound.Stride
  subscript(position: Swift.ClosedRangeIndex<Bound>) -> Bound {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.ClosedRangeIndex<Bound>>) -> Swift.RandomAccessSlice<Swift.CountableClosedRange<Bound>> {
    get {}
  }
  var indices: Swift.DefaultRandomAccessIndices<Swift.CountableClosedRange<Bound>> {
    get {}
  }
  init(uncheckedBounds bounds: (lower: Bound, upper: Bound))
  func _customContainsEquatableElement(_ element: Bound) -> Swift.Bool?
  var isEmpty: Swift.Bool {
    get {}
  }
  typealias _Element = Bound
  typealias SubSequence = Swift.RandomAccessSlice<Swift.CountableClosedRange<Bound>>
  typealias Indices = Swift.DefaultRandomAccessIndices<Swift.CountableClosedRange<Bound>>
}
extension CountableClosedRange : Equatable {
  static func ==(lhs: Swift.CountableClosedRange<Bound>, rhs: Swift.CountableClosedRange<Bound>) -> Swift.Bool
  static func ~=(pattern: Swift.CountableClosedRange<Bound>, value: Bound) -> Swift.Bool
}
extension CountableClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.Range<Bound>)
}
extension CountableClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.Range<Bound>) -> Swift.Bool
}
extension CountableClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.CountableRange<Bound>)
}
extension CountableClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.CountableRange<Bound>) -> Swift.Bool
}
extension CountableClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.ClosedRange<Bound>)
}
extension CountableClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.ClosedRange<Bound>) -> Swift.Bool
}
extension CountableClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) init(_ other: Swift.CountableClosedRange<Bound>)
}
extension CountableClosedRange where Bound : _Strideable, Bound.Stride : SignedInteger {
  @inline(__always) func overlaps(_ other: Swift.CountableClosedRange<Bound>) -> Swift.Bool
}
extension CountableClosedRange {
  @inline(__always) func clamped(to limits: Swift.CountableClosedRange<Bound>) -> Swift.CountableClosedRange<Bound>
}
extension CountableClosedRange : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension CountableClosedRange : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension CountableClosedRange : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension CountableClosedRange {
  @available(*, unavailable, message: "Call clamped(to:) and swap the argument and the receiver.  For example, x.clamp(y) becomes y.clamped(to: x) in Swift 3.") func clamp(_ intervalToClamp: Swift.CountableClosedRange<Bound>) -> Swift.CountableClosedRange<Bound>
}
func min<T : Comparable>(_ x: T, _ y: T) -> T
func min<T : Comparable>(_ x: T, _ y: T, _ z: T, _ rest: T...) -> T
struct LazyBidirectionalCollection<Base : BidirectionalCollection> : LazyCollectionProtocol {
  typealias Elements = Base
  var elements: Base {
    get {}
  }
  typealias Index = Base.Index
  init(_base: Base)
  var _base: Base
  typealias _Element = Base.Iterator.Element
  typealias SubSequence = Swift.LazyBidirectionalCollection<Swift.BidirectionalSlice<Base>>
  typealias IndexDistance = Base.IndexDistance
  typealias Indices = Base.Indices
}
extension LazyBidirectionalCollection : Sequence {
  func makeIterator() -> Base.Iterator
  var underestimatedCount: Swift.Int {
    get {}
  }
  func _copyToContiguousArray() -> Swift.ContiguousArray<Base.Iterator.Element>
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Base.Iterator.Element>) -> Swift.UnsafeMutablePointer<Base.Iterator.Element>
  func _customContainsEquatableElement(_ element: Base.Iterator.Element) -> Swift.Bool?
  typealias Iterator = Base.Iterator
}
extension LazyBidirectionalCollection : BidirectionalCollection {
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  var indices: Base.Indices {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  subscript(position: Base.Index) -> Base.Iterator.Element {
    get {}
  }
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.LazyBidirectionalCollection<Swift.BidirectionalSlice<Base>> {
    get {}
  }
  var isEmpty: Swift.Bool {
    get {}
  }
  var count: Base.IndexDistance {
    get {}
  }
  func _customIndexOfEquatableElement(_ element: Base.Iterator.Element) -> Base.Index??
  var first: Base.Iterator.Element? {
    get {}
  }
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func index(before i: Base.Index) -> Base.Index
  var last: Base.Iterator.Element? {
    get {}
  }
}
func *=(lhs: inout Swift.UInt8, rhs: Swift.UInt8)
func *=(lhs: inout Swift.Int8, rhs: Swift.Int8)
func *=(lhs: inout Swift.UInt16, rhs: Swift.UInt16)
func *=(lhs: inout Swift.Int16, rhs: Swift.Int16)
func *=(lhs: inout Swift.UInt32, rhs: Swift.UInt32)
func *=(lhs: inout Swift.Int32, rhs: Swift.Int32)
func *=(lhs: inout Swift.UInt64, rhs: Swift.UInt64)
func *=(lhs: inout Swift.Int64, rhs: Swift.Int64)
func *=(lhs: inout Swift.UInt, rhs: Swift.UInt)
func *=(lhs: inout Swift.Int, rhs: Swift.Int)
func *=<T : FloatingPoint>(lhs: inout T, rhs: T)
func *=(lhs: inout Swift.Float, rhs: Swift.Float)
func *=(lhs: inout Swift.Double, rhs: Swift.Double)
func *=(lhs: inout Swift.Float80, rhs: Swift.Float80)
func *=<T : _IntegerArithmetic>(lhs: inout T, rhs: T)
@_silgen_name("_swift_arrayDownCastConditionalIndirect") func _arrayDownCastConditionalIndirect<SourceValue, TargetValue>(_ source: Swift.UnsafePointer<[SourceValue]>, _ target: Swift.UnsafeMutablePointer<[TargetValue]>) -> Swift.Bool
@_silgen_name("swift_objc_class_usesNativeSwiftReferenceCounting") func _usesNativeSwiftReferenceCounting(_ theClass: Swift.AnyClass) -> Swift.Bool
func withUnsafeMutablePointer<T, Result>(to arg: inout T, _ body: (Swift.UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result
@available(*, unavailable, renamed: "withUnsafeMutablePointer(to:_:)") func withUnsafeMutablePointer<T, Result>(_ arg: inout T, _ body: (Swift.UnsafeMutablePointer<T>) throws -> Result) rethrows -> Result
protocol CustomStringConvertible {
  var description: Swift.String { get }
}
struct _StringBuffer {
  typealias _Storage = Swift._HeapBuffer<Swift._StringBufferIVars, Swift.UTF16.CodeUnit>
  typealias HeapBufferStorage = Swift._HeapBufferStorage<Swift._StringBufferIVars, Swift.UTF16.CodeUnit>
  init(_ storage: Swift._StringBuffer._Storage)
  init(capacity: Swift.Int, initialSize: Swift.Int, elementWidth: Swift.Int)
  static func fromCodeUnits<Input, Encoding where Input : Collection, Encoding : UnicodeCodec, Input.Iterator.Element == Encoding.CodeUnit>(_ input: Input, encoding: Encoding.Type, repairIllFormedSequences: Swift.Bool, minimumCapacity: Swift.Int = default) -> (Swift._StringBuffer?, hadError: Swift.Bool)
  var start: Swift.UnsafeMutableRawPointer {
    get {}
  }
  var usedEnd: Swift.UnsafeMutableRawPointer {
    get {}
    set(newValue) {}
  }
  var usedCount: Swift.Int {
    get {}
  }
  var capacityEnd: Swift.UnsafeMutableRawPointer {
    get {}
  }
  var capacity: Swift.Int {
    get {}
  }
  var elementShift: Swift.Int {
    get {}
  }
  var elementWidth: Swift.Int {
    get {}
  }
  func hasCapacity(_ cap: Swift.Int, forSubRange r: Swift.Range<Swift.UnsafeRawPointer>) -> Swift.Bool
  @discardableResult @inline(__always) mutating func grow(oldBounds bounds: Swift.Range<Swift.UnsafeRawPointer>, newUsedCount: Swift.Int) -> Swift.Bool
  var _anyObject: AnyObject? {
    get {}
  }
  var _storage: Swift._StringBuffer._Storage
}
struct ClosedRangeIterator<Bound where Bound : _Strideable & Comparable, Bound.Stride : SignedInteger> : IteratorProtocol, Sequence {
  init(_range r: Swift.CountableClosedRange<Bound>)
  func makeIterator() -> Swift.ClosedRangeIterator<Bound>
  mutating func next() -> Bound?
  var _nextResult: Bound?
  let _upperBound: Bound
  typealias Element = Bound
  typealias Iterator = Swift.ClosedRangeIterator<Bound>
  typealias SubSequence = Swift.AnySequence<Bound>
}
struct FlattenCollectionIndex<BaseElements where BaseElements : Collection, BaseElements.Iterator.Element : Collection> {
  init(_ _outer: BaseElements.Index, _ inner: BaseElements.Iterator.Element.Index?)
  let _outer: BaseElements.Index
  let _inner: BaseElements.Iterator.Element.Index?
}
extension FlattenCollectionIndex : Comparable {
  static func ==(lhs: Swift.FlattenCollectionIndex<BaseElements>, rhs: Swift.FlattenCollectionIndex<BaseElements>) -> Swift.Bool
  static func <(lhs: Swift.FlattenCollectionIndex<BaseElements>, rhs: Swift.FlattenCollectionIndex<BaseElements>) -> Swift.Bool
}
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func ++(x: inout Swift.UInt8) -> Swift.UInt8
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func ++(x: inout Swift.UInt8) -> Swift.UInt8
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func ++(x: inout Swift.Int8) -> Swift.Int8
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func ++(x: inout Swift.Int8) -> Swift.Int8
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func ++(x: inout Swift.UInt16) -> Swift.UInt16
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func ++(x: inout Swift.UInt16) -> Swift.UInt16
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func ++(x: inout Swift.Int16) -> Swift.Int16
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func ++(x: inout Swift.Int16) -> Swift.Int16
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func ++(x: inout Swift.UInt32) -> Swift.UInt32
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func ++(x: inout Swift.UInt32) -> Swift.UInt32
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func ++(x: inout Swift.Int32) -> Swift.Int32
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func ++(x: inout Swift.Int32) -> Swift.Int32
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func ++(x: inout Swift.UInt64) -> Swift.UInt64
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func ++(x: inout Swift.UInt64) -> Swift.UInt64
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func ++(x: inout Swift.Int64) -> Swift.Int64
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func ++(x: inout Swift.Int64) -> Swift.Int64
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func ++(x: inout Swift.UInt) -> Swift.UInt
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func ++(x: inout Swift.UInt) -> Swift.UInt
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func ++(x: inout Swift.Int) -> Swift.Int
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func ++(x: inout Swift.Int) -> Swift.Int
@available(*, unavailable, message: "use += 1") @discardableResult prefix func ++(rhs: inout Swift.Float) -> Swift.Float
@available(*, unavailable, message: "use += 1") @discardableResult postfix func ++(lhs: inout Swift.Float) -> Swift.Float
@available(*, unavailable, message: "use += 1") @discardableResult prefix func ++(rhs: inout Swift.Double) -> Swift.Double
@available(*, unavailable, message: "use += 1") @discardableResult postfix func ++(lhs: inout Swift.Double) -> Swift.Double
@available(*, unavailable, message: "use += 1") @discardableResult prefix func ++(rhs: inout Swift.Float80) -> Swift.Float80
@available(*, unavailable, message: "use += 1") @discardableResult postfix func ++(lhs: inout Swift.Float80) -> Swift.Float80
@available(*, unavailable, message: "Use \'+= 1\' or call 'collection.index(after: Index)") @discardableResult prefix func ++<T : _Incrementable>(i: inout T) -> T
@available(*, unavailable, message: "Use \'+= 1\' or call 'collection.index(after: Index)") @discardableResult postfix func ++<T : _Incrementable>(i: inout T) -> T
@available(*, unavailable, renamed: "EmptyIterator") struct EmptyGenerator<Element> {
  init()
}
@_silgen_name("swift_stdlib_getErrorDomainNSString") func _stdlib_getErrorDomainNSString<T : Error>(_ x: Swift.UnsafePointer<T>) -> AnyObject
@_silgen_name("swift_stdlib_NSStringHasPrefixNFDPointer") func _stdlib_NSStringHasPrefixNFDPointer(_ theString: Swift.OpaquePointer, _ prefix: Swift.OpaquePointer) -> Swift.Bool
final class _NativeDictionaryStorageOwner<Key : Hashable, Value> : Swift._SwiftNativeNSDictionary, _NSDictionaryCore {
  typealias NativeStorage = Swift._NativeDictionaryStorage<Key, Value>
  typealias BridgedNativeStorage = Swift._BridgedNativeDictionaryStorage
  @objc init(minimumCapacity: Swift.Int = default)
  init(nativeStorage: Swift._NativeDictionaryStorage<Key, Value>)
  @objc final var _heapBufferBridged_DoNotUse: AnyObject?
  final var nativeStorage: Swift._NativeDictionaryStorage<Key, Value>
  @objc required init(objects: Swift.UnsafePointer<AnyObject?>, forKeys: Swift.UnsafeRawPointer, count: Swift.Int)
  @objc(objectForKey:) final func objectFor(_ aKey: AnyObject) -> AnyObject?
  @objc final func keyEnumerator() -> _NSEnumerator
  @objc(copyWithZone:) final func copy(with zone: Swift._SwiftNSZone?) -> AnyObject
  @objc final func getObjects(_ objects: Swift.UnsafeMutablePointer<AnyObject>?, andKeys keys: Swift.UnsafeMutablePointer<AnyObject>?)
  @objc final var _heapBufferBridgedPtr: Swift.UnsafeMutablePointer<AnyObject?> {
    @objc final get {}
  }
  final var _bridgedBuffer: Swift._BridgedNativeDictionaryStorage.StorageImpl? {
    final get {}
  }
  @objc final func _initializeHeapBufferBridged(_ newBuffer: AnyObject)
  @objc final func deinitializeHeapBufferBridged()
  final var bridgedNativeStorage: Swift._NativeDictionaryStorageOwner.BridgedNativeStorage {
    final get {}
  }
  final func _createBridgedNativeStorage(_ capacity: Swift.Int) -> Swift._NativeDictionaryStorageOwner.BridgedNativeStorage
  @objc final func bridgeEverything()
  final func _getBridgedKey(_ i: Swift._NativeDictionaryIndex<Key, Value>) -> AnyObject
  final func _getBridgedValue(_ i: Swift._NativeDictionaryIndex<Key, Value>) -> AnyObject
  @objc final func bridgedAllKeysAndValues(_ objects: Swift.UnsafeMutablePointer<AnyObject>?, _ keys: Swift.UnsafeMutablePointer<AnyObject>?)
  @objc final var count: Swift.Int {
    @objc final get {}
  }
  @objc final func bridgingObjectForKey(_ aKey: AnyObject) -> AnyObject?
  @objc final func bridgingKeyEnumerator() -> _NSEnumerator
  @objc(countByEnumeratingWithState:objects:count:) final func countByEnumerating(with state: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState>, objects: Swift.UnsafeMutablePointer<AnyObject>?, count: Swift.Int) -> Swift.Int
  @objc init()
  @objc deinit
}
@objc protocol _NSStringCore : _NSCopying, _NSFastEnumeration {
  @objc func length() -> Swift.Int
  @objc func characterAtIndex(_ index: Swift.Int) -> Swift.UInt16
}
func readLine(strippingNewline: Swift.Bool = default) -> Swift.String?
@available(*, unavailable, renamed: "readLine(strippingNewline:)") func readLine(stripNewline: Swift.Bool = default) -> Swift.String?
protocol _AnyCollectionProtocol : Collection {
  var _boxID: Swift.ObjectIdentifier { get }
}
extension _AnyCollectionProtocol {
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.AnyIterator<Self.Iterator.Element>
}
protocol _ExpressibleByColorLiteral {
  init(colorLiteralRed red: Swift.Float, green: Swift.Float, blue: Swift.Float, alpha: Swift.Float)
}
func +=<S : Sequence>(lhs: inout Swift.ContiguousArray<S.Iterator.Element>, rhs: S)
func +=<C : Collection>(lhs: inout Swift.ContiguousArray<C.Iterator.Element>, rhs: C)
func +=<S : Sequence>(lhs: inout Swift.ArraySlice<S.Iterator.Element>, rhs: S)
func +=<C : Collection>(lhs: inout Swift.ArraySlice<C.Iterator.Element>, rhs: C)
func +=<S : Sequence>(lhs: inout [S.Iterator.Element], rhs: S)
func +=<C : Collection>(lhs: inout [C.Iterator.Element], rhs: C)
func +=<Element, C : Collection where C.Iterator.Element == Element>(lhs: inout Swift._ContiguousArrayBuffer<Element>, rhs: C)
func +=(lhs: inout Swift.UInt8, rhs: Swift.UInt8)
func +=(lhs: inout Swift.Int8, rhs: Swift.Int8)
func +=(lhs: inout Swift.UInt16, rhs: Swift.UInt16)
func +=(lhs: inout Swift.Int16, rhs: Swift.Int16)
func +=(lhs: inout Swift.UInt32, rhs: Swift.UInt32)
func +=(lhs: inout Swift.Int32, rhs: Swift.Int32)
func +=(lhs: inout Swift.UInt64, rhs: Swift.UInt64)
func +=(lhs: inout Swift.Int64, rhs: Swift.Int64)
func +=(lhs: inout Swift.UInt, rhs: Swift.UInt)
func +=(lhs: inout Swift.Int, rhs: Swift.Int)
func +=<T : FloatingPoint>(lhs: inout T, rhs: T)
func +=(lhs: inout Swift.Float, rhs: Swift.Float)
func +=(lhs: inout Swift.Double, rhs: Swift.Double)
func +=(lhs: inout Swift.Float80, rhs: Swift.Float80)
func +=<T : _IntegerArithmetic>(lhs: inout T, rhs: T)
func +=<T : Strideable>(lhs: inout T, rhs: T.Stride)
func +=<T : UnsignedInteger>(lhs: inout T, rhs: T._DisallowMixedSignArithmetic)
func +=<Pointee>(lhs: inout Swift.UnsafeMutablePointer<Pointee>, rhs: Swift.Int)
func +=<Pointee>(lhs: inout Swift.UnsafePointer<Pointee>, rhs: Swift.Int)
struct LazyMapCollection<Base : Collection, Element> : LazyCollectionProtocol, Collection {
  typealias Index = Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  subscript(position: Base.Index) -> Element {
    get {}
  }
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.Slice<Swift.LazyMapCollection<Base, Element>> {
    get {}
  }
  typealias IndexDistance = Base.IndexDistance
  typealias Indices = Base.Indices
  var indices: Base.Indices {
    get {}
  }
  var isEmpty: Swift.Bool {
    get {}
  }
  var count: Base.IndexDistance {
    get {}
  }
  var first: Element? {
    get {}
  }
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func makeIterator() -> Swift.LazyMapIterator<Base.Iterator, Element>
  var underestimatedCount: Swift.Int {
    get {}
  }
  init(_base: Base, transform: @escaping (Base.Iterator.Element) -> Element)
  var _base: Base
  let _transform: (Base.Iterator.Element) -> Element
  typealias _Element = Element
  typealias SubSequence = Swift.Slice<Swift.LazyMapCollection<Base, Element>>
  typealias Elements = Swift.LazyMapCollection<Base, Element>
  typealias Iterator = Swift.LazyMapIterator<Base.Iterator, Element>
}
extension LazyMapCollection {
  @available(*, unavailable, message: "use '.lazy.map' on the collection") init(_ base: Base, transform: (Base.Iterator.Element) -> Element)
}
func withVaList<R>(_ args: [CVarArg], _ body: (Swift.CVaListPointer) -> R) -> R
enum FloatingPointSign : Swift.Int {
  case plus
  case minus
  typealias RawValue = Swift.Int
  var hashValue: Swift.Int {
    get {}
  }
  init?(rawValue: Swift.Int)
  var rawValue: Swift.Int {
    get {}
  }
}
struct Int64 : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int64
  init()
  init(_ _v: Builtin.Int64)
  init(_bits: Builtin.Int64)
  init(bigEndian value: Swift.Int64)
  init(littleEndian value: Swift.Int64)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  var bigEndian: Swift.Int64 {
    get {}
  }
  var littleEndian: Swift.Int64 {
    get {}
  }
  var byteSwapped: Swift.Int64 {
    get {}
  }
  static var max: Swift.Int64 {
    get {}
  }
  static var min: Swift.Int64 {
    get {}
  }
  static var _sizeInBits: Swift.Int64 {
    get {}
  }
  static var _sizeInBytes: Swift.Int64 {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int64
  typealias Stride = Swift.Int
}
extension Int64 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int64 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int64 {
  static func addWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int64, _ rhs: Swift.Int64) -> (Swift.Int64, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int64 : SignedNumber {
}
extension Int64 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to Int64 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension Int64 {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int64 will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int64 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to Int64 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension Int64 {
  init(_ value: Swift.Int16)
  @available(*, message: "Converting Int16 to Int64 will always succeed.") init?(exactly value: Swift.Int16)
}
extension Int64 {
  init(_ value: Swift.UInt32)
  @available(*, message: "Converting UInt32 to Int64 will always succeed.") init?(exactly value: Swift.UInt32)
}
extension Int64 {
  init(_ value: Swift.Int32)
  @available(*, message: "Converting Int32 to Int64 will always succeed.") init?(exactly value: Swift.Int32)
}
extension Int64 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
}
extension Int64 {
  init(_ value: Swift.Int64)
  @available(*, message: "Converting Int64 to Int64 will always succeed.") init?(exactly value: Swift.Int64)
}
extension Int64 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
}
extension Int64 {
  init(_ value: Swift.Int)
  @available(*, message: "Converting Int to Int64 will always succeed.") init?(exactly value: Swift.Int)
}
extension Int64 {
  init(bitPattern: Swift.UInt64)
}
extension Int64 : BitwiseOperations {
  static var allZeros: Swift.Int64 {
    get {}
  }
}
extension Int64 {
  typealias _DisabledRangeIndex = Swift.Int64
}
extension Int64 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int64 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int64 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int64 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Swift.IntMax : MirrorPath {
}
extension Int64 : CVarArg, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension Int64 {
  init(_ value: CoreGraphics.CGFloat)
}
struct _ClosureBasedSequence<Iterator : IteratorProtocol> : Sequence {
  init(_ makeUnderlyingIterator: @escaping () -> Iterator)
  func makeIterator() -> Iterator
  var _makeUnderlyingIterator: () -> Iterator
  typealias Iterator = Iterator
  typealias SubSequence = Swift.AnySequence<Iterator.Element>
}
@_silgen_name("_swift_bridgeNonVerbatimFromObjectiveCConditional") func _bridgeNonVerbatimFromObjectiveCConditional<T>(_ x: AnyObject, _ nativeType: T.Type, _ result: inout T?) -> Swift.Bool
protocol _IntegerArithmetic {
  static func addWithOverflow(_ lhs: Self, _ rhs: Self) -> (Self, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Self, _ rhs: Self) -> (Self, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Self, _ rhs: Self) -> (Self, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Self, _ rhs: Self) -> (Self, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Self, _ rhs: Self) -> (Self, overflow: Swift.Bool)
}
struct _UnsafeBitMap {
  let values: Swift.UnsafeMutablePointer<Swift.UInt>
  let bitCount: Swift.Int
  static func wordIndex(_ i: Swift.Int) -> Swift.Int
  static func bitIndex(_ i: Swift.Int) -> Swift.UInt
  static func sizeInWords(forSizeInBits bitCount: Swift.Int) -> Swift.Int
  init(storage: Swift.UnsafeMutablePointer<Swift.UInt>, bitCount: Swift.Int)
  var numberOfWords: Swift.Int {
    get {}
  }
  func initializeToZero()
  subscript(i: Swift.Int) -> Swift.Bool {
    get {}
    set(newValue) {}
  }
}
struct Array<Element> : RandomAccessCollection, MutableCollection, _DestructorSafeContainer {
  typealias Index = Swift.Int
  typealias Iterator = Swift.IndexingIterator<[Element]>
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  func index(after i: Swift.Int) -> Swift.Int
  func formIndex(after i: inout Swift.Int)
  func index(before i: Swift.Int) -> Swift.Int
  func formIndex(before i: inout Swift.Int)
  func index(_ i: Swift.Int, offsetBy n: Swift.Int) -> Swift.Int
  func index(_ i: Swift.Int, offsetBy n: Swift.Int, limitedBy limit: Swift.Int) -> Swift.Int?
  func distance(from start: Swift.Int, to end: Swift.Int) -> Swift.Int
  func _failEarlyRangeCheck(_ index: Swift.Int, bounds: Swift.Range<Swift.Int>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Swift.Int>, bounds: Swift.Range<Swift.Int>)
  typealias Indices = Swift.CountableRange<Swift.Int>
  subscript(index: Swift.Int) -> Element {
    get {}
    mutableAddressWithPinnedNativeOwner {}
  }
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift.ArraySlice<Element> {
    get {}
    set(rhs) {}
  }
  @_semantics("array.props.isNativeTypeChecked") func _hoistableIsNativeTypeChecked() -> Swift.Bool
  @_semantics("array.get_count") func _getCount() -> Swift.Int
  @_semantics("array.get_capacity") func _getCapacity() -> Swift.Int
  @_semantics("array.owner") func _getOwnerWithSemanticLabel_native() -> Builtin.NativeObject
  @inline(__always) func _getOwner_native() -> Builtin.NativeObject
  static func _copyBuffer(_ buffer: inout Swift._ArrayBuffer<Element>)
  @_semantics("array.make_mutable") mutating func _makeMutableAndUnique()
  @_semantics("array.make_mutable") mutating func _makeMutableAndUniqueOrPinned()
  @inline(__always) func _checkSubscript_native(_ index: Swift.Int)
  @_semantics("array.check_subscript") func _checkSubscript(_ index: Swift.Int, wasNativeTypeChecked: Swift.Bool) -> Swift._DependenceToken
  @_semantics("array.check_index") func _checkIndex(_ index: Swift.Int)
  @_semantics("array.get_element") @inline(__always) func _getElement(_ index: Swift.Int, wasNativeTypeChecked: Swift.Bool, matchingSubscriptCheck: Swift._DependenceToken) -> Element
  @_semantics("array.get_element_address") func _getElementAddress(_ index: Swift.Int) -> Swift.UnsafeMutablePointer<Element>
  typealias _Buffer = Swift._ArrayBuffer<Element>
  init(_buffer: Swift._ArrayBuffer<Element>)
  var _buffer: Swift._ArrayBuffer<Element>
  typealias _Element = Element
  typealias SubSequence = Swift.ArraySlice<Element>
  typealias IndexDistance = Swift.Int
}
extension Array : ExpressibleByArrayLiteral {
  init(arrayLiteral elements: Element...)
  typealias Element = Element
}
extension Array : RangeReplaceableCollection, _ArrayProtocol {
  @_semantics("array.init") init()
  init<S : Sequence where S.Iterator.Element == Element>(_ s: S)
  @_semantics("array.init") init(repeating repeatedValue: Element, count: Swift.Int)
  @inline(never) static func _allocateBufferUninitialized(minimumCapacity: Swift.Int) -> Swift._ArrayBuffer<Element>
  init(_uninitializedCount count: Swift.Int)
  @_versioned @_semantics("array.uninitialized") static func _allocateUninitialized(_ count: Swift.Int) -> ([Element], Swift.UnsafeMutablePointer<Element>)
  @_versioned @_semantics("array.uninitialized") static func _adoptStorage(_ storage: AnyObject, count: Swift.Int) -> ([Element], Swift.UnsafeMutablePointer<Element>)
  mutating func _deallocateUninitialized()
  var count: Swift.Int {
    get {}
  }
  var capacity: Swift.Int {
    get {}
  }
  var _owner: AnyObject? {
    get {}
  }
  var _baseAddressIfContiguous: Swift.UnsafeMutablePointer<Element>? {
    get {}
  }
  @_semantics("array.mutate_unknown") mutating func reserveCapacity(_ minimumCapacity: Swift.Int)
  @inline(never) mutating func _copyToNewBuffer(oldCount: Swift.Int)
  @_semantics("array.make_mutable") mutating func _makeUniqueAndReserveCapacityIfNotUnique()
  @_semantics("array.mutate_unknown") mutating func _reserveCapacityAssumingUniqueBuffer(oldCount: Swift.Int)
  @_semantics("array.mutate_unknown") mutating func _appendElementAssumeUniqueAndCapacity(_ oldCount: Swift.Int, newElement: Element)
  mutating func append(_ newElement: Element)
  mutating func append<S : Sequence where S.Iterator.Element == Element>(contentsOf newElements: S)
  mutating func append<C : Collection where C.Iterator.Element == Element>(contentsOf newElements: C)
  mutating func insert(_ newElement: Element, at i: Swift.Int)
  @discardableResult mutating func remove(at index: Swift.Int) -> Element
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
  mutating func _withUnsafeMutableBufferPointerIfSupported<R>(_ body: (Swift.UnsafeMutablePointer<Element>, Swift.Int) throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Element>
}
extension Array : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Array : CustomStringConvertible, CustomDebugStringConvertible {
  func _makeDescription(isDebug: Swift.Bool) -> Swift.String
  var description: Swift.String {
    get {}
  }
  var debugDescription: Swift.String {
    get {}
  }
}
extension Array {
  @_versioned func _cPointerArgs() -> (AnyObject?, Swift.UnsafeRawPointer?)
}
extension Array {
  func withUnsafeBufferPointer<R>(_ body: (Swift.UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
  @_semantics("array.withUnsafeMutableBufferPointer") @inline(__always) mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout Swift.UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension Array {
  @_semantics("array.mutate_unknown") mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subrange: Swift.Range<Swift.Int>, with newElements: C)
}
extension Array {
  static func _bridgeFromObjectiveCAdoptingNativeStorageOf(_ source: AnyObject) -> [Element]?
  init(_immutableCocoaArray: _NSArrayCore)
}
extension Array {
  mutating func popLast() -> Element?
}
extension Array {
  @available(*, unavailable, message: "Please use init(repeating:count:) instead") init(count: Swift.Int, repeatedValue: Element)
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ index: Swift.Int) -> Element
  @available(*, unavailable, renamed: "replaceSubrange(_:with:)") mutating func replaceRange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subRange: Swift.Range<Swift.Int>, with newElements: C)
  @available(*, unavailable, renamed: "append(contentsOf:)") mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Element>(_ newElements: S)
}
extension Array : _ObjectiveCBridgeable {
  init(_cocoaArray: Foundation.NSArray)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSArray
  static func _forceBridgeFromObjectiveC(_ source: Foundation.NSArray, result: inout [Element]?)
  static func _conditionallyBridgeFromObjectiveC(_ source: Foundation.NSArray, result: inout [Element]?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSArray?) -> [Element]
  typealias _ObjectiveCType = Foundation.NSArray
}
extension Array : CVarArg {
}
func _swift_stdlib_atomicFetchXorInt64(object target: Swift.UnsafeMutablePointer<Swift.Int64>, operand: Swift.Int64) -> Swift.Int64
protocol ExpressibleByDictionaryLiteral {
  associatedtype Key
  associatedtype Value
  init(dictionaryLiteral elements: (Self.Key, Self.Value)...)
}
func _unsafeDowncastToAnyObject(fromAny any: Any) -> AnyObject
struct _InitializeMemoryFromCollection<C : Collection> : _PointerFunction {
  func call(_ rawMemory: Swift.UnsafeMutablePointer<C.Iterator.Element>, count: Swift.Int)
  init(_ newValues: C)
  var newValues: C
  typealias Element = C.Iterator.Element
}
func _stdlib_NSDictionary_allKeys(_ nsd: _NSDictionary) -> Swift._HeapBuffer<Swift.Int, AnyObject>
protocol ExpressibleByUnicodeScalarLiteral {
  associatedtype UnicodeScalarLiteralType : _ExpressibleByBuiltinUnicodeScalarLiteral
  init(unicodeScalarLiteral value: Self.UnicodeScalarLiteralType)
}
func _swift_stdlib_atomicFetchAndUInt32(object target: Swift.UnsafeMutablePointer<Swift.UInt32>, operand: Swift.UInt32) -> Swift.UInt32
struct Zip2Iterator<Iterator1 : IteratorProtocol, Iterator2 : IteratorProtocol> : IteratorProtocol {
  typealias Element = (Iterator1.Element, Iterator2.Element)
  init(_ iterator1: Iterator1, _ iterator2: Iterator2)
  mutating func next() -> (Iterator1.Element, Iterator2.Element)?
  var _baseStream1: Iterator1
  var _baseStream2: Iterator2
  var _reachedEnd: Swift.Bool
}
struct _UnicodeGraphemeClusterBreakPropertyTrie {
  static func _checkParameters()
  let _trieData: Swift.UnsafePointer<Swift.UInt8>
  var _bmpLookup: Swift.UnsafePointer<Swift.UInt8> {
    get {}
  }
  var _bmpData: Swift.UnsafePointer<Swift.UInt8> {
    get {}
  }
  var _suppLookup1: Swift.UnsafePointer<Swift.UInt8> {
    get {}
  }
  var _suppLookup2: Swift.UnsafePointer<Swift.UInt8> {
    get {}
  }
  var _suppData: Swift.UnsafePointer<Swift.UInt8> {
    get {}
  }
  init()
  func _getBMPFirstLevelIndex(_ cp: Swift.UInt32) -> Swift.Int
  func _getBMPDataOffset(_ cp: Swift.UInt32) -> Swift.Int
  func _getSuppFirstLevelIndex(_ cp: Swift.UInt32) -> Swift.Int
  func _getSuppSecondLevelIndex(_ cp: Swift.UInt32) -> Swift.Int
  func _getSuppDataOffset(_ cp: Swift.UInt32) -> Swift.Int
  func getPropertyRawValue(_ codePoint: Swift.UInt32) -> Swift._GraphemeClusterBreakPropertyRawValue
  func getPropertyValue(_ codePoint: Swift.UInt32) -> Swift._GraphemeClusterBreakPropertyValue
}
struct LazyFilterIterator<Base : IteratorProtocol> : IteratorProtocol, Sequence {
  mutating func next() -> Base.Element?
  init(_base: Base, _ isIncluded: @escaping (Base.Element) -> Swift.Bool)
  var base: Base {
    get {}
  }
  var _base: Base
  let _predicate: (Base.Element) -> Swift.Bool
  typealias Element = Base.Element
  typealias Iterator = Swift.LazyFilterIterator<Base>
  typealias SubSequence = Swift.AnySequence<Base.Element>
}
extension LazyFilterIterator {
  @available(*, unavailable, message: "use '.lazy.filter' on the sequence") init(_ base: Base, whereElementsSatisfy predicate: (Base.Element) -> Swift.Bool)
}
@_semantics("slowpath") func _slowPath(_ x: Swift.Bool) -> Swift.Bool
@_silgen_name("swift_EnumMirror_caseName") func _swift_EnumMirror_caseName(_ data: Swift._MagicMirrorData) -> Swift.UnsafePointer<Swift.CChar>
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func --(x: inout Swift.UInt8) -> Swift.UInt8
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func --(x: inout Swift.UInt8) -> Swift.UInt8
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func --(x: inout Swift.Int8) -> Swift.Int8
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func --(x: inout Swift.Int8) -> Swift.Int8
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func --(x: inout Swift.UInt16) -> Swift.UInt16
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func --(x: inout Swift.UInt16) -> Swift.UInt16
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func --(x: inout Swift.Int16) -> Swift.Int16
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func --(x: inout Swift.Int16) -> Swift.Int16
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func --(x: inout Swift.UInt32) -> Swift.UInt32
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func --(x: inout Swift.UInt32) -> Swift.UInt32
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func --(x: inout Swift.Int32) -> Swift.Int32
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func --(x: inout Swift.Int32) -> Swift.Int32
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func --(x: inout Swift.UInt64) -> Swift.UInt64
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func --(x: inout Swift.UInt64) -> Swift.UInt64
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func --(x: inout Swift.Int64) -> Swift.Int64
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func --(x: inout Swift.Int64) -> Swift.Int64
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func --(x: inout Swift.UInt) -> Swift.UInt
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func --(x: inout Swift.UInt) -> Swift.UInt
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult prefix func --(x: inout Swift.Int) -> Swift.Int
@available(*, unavailable, message: "it has been removed in Swift 3") @discardableResult postfix func --(x: inout Swift.Int) -> Swift.Int
@available(*, unavailable, message: "use -= 1") @discardableResult prefix func --(rhs: inout Swift.Float) -> Swift.Float
@available(*, unavailable, message: "use -= 1") @discardableResult postfix func --(lhs: inout Swift.Float) -> Swift.Float
@available(*, unavailable, message: "use -= 1") @discardableResult prefix func --(rhs: inout Swift.Double) -> Swift.Double
@available(*, unavailable, message: "use -= 1") @discardableResult postfix func --(lhs: inout Swift.Double) -> Swift.Double
@available(*, unavailable, message: "use -= 1") @discardableResult prefix func --(rhs: inout Swift.Float80) -> Swift.Float80
@available(*, unavailable, message: "use -= 1") @discardableResult postfix func --(lhs: inout Swift.Float80) -> Swift.Float80
@available(*, unavailable, message: "Use \'-= 1\' or call collection.prior(Index)") @discardableResult prefix func --<T : _Incrementable>(i: inout T) -> T
@available(*, unavailable, message: "Use \'-= 1\' or call collection.prior(Index)") @discardableResult postfix func --<T : _Incrementable>(i: inout T) -> T
struct ObjectIdentifier : Hashable {
  let _value: Builtin.RawPointer
  var hashValue: Swift.Int {
    get {}
  }
  init(_ x: AnyObject)
  init(_ x: Any.Type)
}
extension ObjectIdentifier : Comparable {
  static func <(lhs: Swift.ObjectIdentifier, rhs: Swift.ObjectIdentifier) -> Swift.Bool
  static func ==(x: Swift.ObjectIdentifier, y: Swift.ObjectIdentifier) -> Swift.Bool
}
extension ObjectIdentifier : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension ObjectIdentifier {
  @available(*, unavailable, message: "use the 'UInt(_:)' initializer") var uintValue: Swift.UInt {
    get {}
  }
}
func _swift_stdlib_atomicFetchOrUInt64(object target: Swift.UnsafeMutablePointer<Swift.UInt64>, operand: Swift.UInt64) -> Swift.UInt64
struct Double {
  var _value: Builtin.FPIEEE64
  init()
  init(_bits v: Builtin.FPIEEE64)
}
extension Double : LosslessStringConvertible {
  init?(_ text: Swift.String)
}
extension Double : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Double : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Double : BinaryFloatingPoint {
  typealias Exponent = Swift.Int
  typealias RawSignificand = Swift.UInt64
  static var exponentBitCount: Swift.Int {
    get {}
  }
  static var significandBitCount: Swift.Int {
    get {}
  }
  @_versioned static var _infinityExponent: Swift.UInt {
    @inline(__always) get {}
  }
  static var _exponentBias: Swift.UInt {
    @inline(__always) get {}
  }
  static var _significandMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  @_versioned static var _quietNaNMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  var bitPattern: Swift.UInt64 {
    get {}
  }
  init(bitPattern: Swift.UInt64)
  var sign: Swift.FloatingPointSign {
    get {}
  }
  @available(*, unavailable, renamed: "sign") var isSignMinus: Swift.Bool {
    get {}
  }
  var exponentBitPattern: Swift.UInt {
    get {}
  }
  var significandBitPattern: Swift.UInt64 {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponentBitPattern: Swift.UInt, significandBitPattern: Swift.UInt64)
  var isCanonical: Swift.Bool {
    get {}
  }
  static var infinity: Swift.Double {
    get {}
  }
  static var nan: Swift.Double {
    get {}
  }
  static var signalingNaN: Swift.Double {
    get {}
  }
  @available(*, unavailable, renamed: "nan") static var quietNaN: Swift.Double {
    get {}
  }
  static var greatestFiniteMagnitude: Swift.Double {
    get {}
  }
  static var pi: Swift.Double {
    get {}
  }
  var ulp: Swift.Double {
    get {}
  }
  static var leastNormalMagnitude: Swift.Double {
    get {}
  }
  static var leastNonzeroMagnitude: Swift.Double {
    get {}
  }
  var exponent: Swift.Int {
    get {}
  }
  var significand: Swift.Double {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponent: Swift.Int, significand: Swift.Double)
  init(nan payload: Swift.Double.RawSignificand, signaling: Swift.Bool)
  var nextUp: Swift.Double {
    get {}
  }
  mutating func round(_ rule: Swift.FloatingPointRoundingRule)
  mutating func negate()
  mutating func add(_ other: Swift.Double)
  mutating func subtract(_ other: Swift.Double)
  mutating func multiply(by other: Swift.Double)
  mutating func divide(by other: Swift.Double)
  mutating func formRemainder(dividingBy other: Swift.Double)
  mutating func formTruncatingRemainder(dividingBy other: Swift.Double)
  mutating func formSquareRoot()
  mutating func addProduct(_ lhs: Swift.Double, _ rhs: Swift.Double)
  func isEqual(to other: Swift.Double) -> Swift.Bool
  func isLess(than other: Swift.Double) -> Swift.Bool
  func isLessThanOrEqualTo(_ other: Swift.Double) -> Swift.Bool
  var isNormal: Swift.Bool {
    get {}
  }
  var isFinite: Swift.Bool {
    get {}
  }
  var isZero: Swift.Bool {
    get {}
  }
  var isSubnormal: Swift.Bool {
    get {}
  }
  var isInfinite: Swift.Bool {
    get {}
  }
  var isNaN: Swift.Bool {
    get {}
  }
  var isSignalingNaN: Swift.Bool {
    get {}
  }
  var binade: Swift.Double {
    get {}
  }
  var significandWidth: Swift.Int {
    get {}
  }
  init(floatLiteral value: Swift.Double)
  typealias FloatLiteralType = Swift.Double
  typealias RawExponent = Swift.UInt
}
extension Double : _ExpressibleByBuiltinIntegerLiteral, ExpressibleByIntegerLiteral {
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  typealias IntegerLiteralType = Swift.Int64
}
extension Double : _ExpressibleByBuiltinFloatLiteral {
  init(_builtinFloatLiteral value: Builtin.FPIEEE80)
}
extension Double : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension Double : AbsoluteValuable {
  static func abs(_ x: Swift.Double) -> Swift.Double
}
extension Double {
  init(_ v: Swift.UInt8)
  init(_ v: Swift.Int8)
  init(_ v: Swift.UInt16)
  init(_ v: Swift.Int16)
  init(_ v: Swift.UInt32)
  init(_ v: Swift.Int32)
  init(_ v: Swift.UInt64)
  init(_ v: Swift.Int64)
  init(_ v: Swift.UInt)
  init(_ v: Swift.Int)
}
extension Double {
  init(_ other: Swift.Float)
  @inline(__always) init?(exactly other: Swift.Float)
  init(_ other: Swift.Double)
  @inline(__always) init?(exactly other: Swift.Double)
  init(_ other: Swift.Float80)
  @inline(__always) init?(exactly other: Swift.Float80)
}
extension Double : Strideable {
  func distance(to other: Swift.Double) -> Swift.Double
  func advanced(by amount: Swift.Double) -> Swift.Double
  typealias Stride = Swift.Double
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension Double : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Double : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Double : _CVarArgPassedAsDouble, _CVarArgAligned {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
  var _cVarArgAlignment: Swift.Int {
    get {}
  }
}
extension Double {
  init(_ value: CoreGraphics.CGFloat)
}
extension Double : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Double?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Double?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Double
  typealias _ObjectiveCType = Foundation.NSNumber
}
struct IteratorSequence<Base : IteratorProtocol> : IteratorProtocol, Sequence {
  init(_ base: Base)
  mutating func next() -> Base.Element?
  var _base: Base
  typealias Element = Base.Element
  typealias Iterator = Swift.IteratorSequence<Base>
  typealias SubSequence = Swift.AnySequence<Base.Element>
}
@_silgen_name("swift_bridgeErrorToNSError") func _bridgeErrorToNSError(_ error: Error) -> AnyObject
struct RangeReplaceableBidirectionalSlice<Base : BidirectionalIndexable & RangeReplaceableIndexable> : BidirectionalCollection, RangeReplaceableCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
  }
  typealias SubSequence = Swift.RangeReplaceableBidirectionalSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.RangeReplaceableBidirectionalSlice<Base> {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(before i: Base.Index) -> Base.Index
  func formIndex(before i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init()
  init(repeating repeatedValue: Base._Element, count: Swift.Int)
  init<S where S : Sequence, S.Iterator.Element == Base._Element>(_ elements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Base._Element>(_ subRange: Swift.Range<Base.Index>, with newElements: C)
  mutating func insert(_ newElement: Base._Element, at i: Base.Index)
  mutating func insert<S where S : Collection, S.Iterator.Element == Base._Element>(contentsOf newElements: S, at i: Base.Index)
  mutating func remove(at i: Base.Index) -> Base._Element
  mutating func removeSubrange(_ bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  var _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.RangeReplaceableBidirectionalSlice<Base>>
  typealias Indices = Swift.DefaultBidirectionalIndices<Swift.RangeReplaceableBidirectionalSlice<Base>>
}
func -=(lhs: inout Swift.UInt8, rhs: Swift.UInt8)
func -=(lhs: inout Swift.Int8, rhs: Swift.Int8)
func -=(lhs: inout Swift.UInt16, rhs: Swift.UInt16)
func -=(lhs: inout Swift.Int16, rhs: Swift.Int16)
func -=(lhs: inout Swift.UInt32, rhs: Swift.UInt32)
func -=(lhs: inout Swift.Int32, rhs: Swift.Int32)
func -=(lhs: inout Swift.UInt64, rhs: Swift.UInt64)
func -=(lhs: inout Swift.Int64, rhs: Swift.Int64)
func -=(lhs: inout Swift.UInt, rhs: Swift.UInt)
func -=(lhs: inout Swift.Int, rhs: Swift.Int)
func -=<T : FloatingPoint>(lhs: inout T, rhs: T)
func -=(lhs: inout Swift.Float, rhs: Swift.Float)
func -=(lhs: inout Swift.Double, rhs: Swift.Double)
func -=(lhs: inout Swift.Float80, rhs: Swift.Float80)
func -=<T : _IntegerArithmetic>(lhs: inout T, rhs: T)
func -=<T : Strideable>(lhs: inout T, rhs: T.Stride)
func -=<T : UnsignedInteger>(lhs: inout T, rhs: T._DisallowMixedSignArithmetic)
func -=<Pointee>(lhs: inout Swift.UnsafeMutablePointer<Pointee>, rhs: Swift.Int)
func -=<Pointee>(lhs: inout Swift.UnsafePointer<Pointee>, rhs: Swift.Int)
struct _DependenceToken {
  init()
}
func _isDebugAssertConfiguration() -> Swift.Bool
@available(*, unavailable, renamed: "LazyFilterIterator") struct LazyFilterGenerator<Base : IteratorProtocol> {
  init()
}
protocol _ArrayProtocol : RangeReplaceableCollection, ExpressibleByArrayLiteral {
  var count: Swift.Int { get }
  var capacity: Swift.Int { get }
  var isEmpty: Swift.Bool { get }
  var _owner: AnyObject? { get }
  var _baseAddressIfContiguous: Swift.UnsafeMutablePointer<Self.Element>? { get }
  subscript(index: Swift.Int) -> Self.Iterator.Element { get set }
  mutating func reserveCapacity(_ minimumCapacity: Swift.Int)
  static func +=<S : Sequence where S.Iterator.Element == Iterator.Element>(lhs: inout Self, rhs: S)
  mutating func insert(_ newElement: Self.Iterator.Element, at i: Swift.Int)
  @discardableResult mutating func remove(at index: Swift.Int) -> Self.Iterator.Element
  associatedtype _Buffer : _ArrayBufferProtocol
  init(_ buffer: Self._Buffer)
  var _buffer: Self._Buffer { get }
}
protocol ExpressibleByNilLiteral {
  init(nilLiteral: ())
}
@_versioned struct _CocoaDictionaryIndex : Comparable {
  let cocoaDictionary: _NSDictionary
  var allKeys: Swift._HeapBuffer<Swift.Int, AnyObject>
  var currentKeyIndex: Swift.Int
  init(_ cocoaDictionary: _NSDictionary, startIndex: ())
  init(_ cocoaDictionary: _NSDictionary, endIndex: ())
  init(_ cocoaDictionary: _NSDictionary, _ allKeys: Swift._HeapBuffer<Swift.Int, AnyObject>, _ currentKeyIndex: Swift.Int)
  func successor() -> Swift._CocoaDictionaryIndex
}
extension _CocoaDictionaryIndex {
  static func ==(lhs: Swift._CocoaDictionaryIndex, rhs: Swift._CocoaDictionaryIndex) -> Swift.Bool
  static func <(lhs: Swift._CocoaDictionaryIndex, rhs: Swift._CocoaDictionaryIndex) -> Swift.Bool
}
@discardableResult func dump<T, TargetStream : TextOutputStream>(_ value: T, to target: inout TargetStream, name: Swift.String? = default, indent: Swift.Int = default, maxDepth: Swift.Int = default, maxItems: Swift.Int = default) -> T
@discardableResult func dump<T>(_ value: T, name: Swift.String? = default, indent: Swift.Int = default, maxDepth: Swift.Int = default, maxItems: Swift.Int = default) -> T
@inline(never) func _toStringReadOnlyPrintable<T : CustomStringConvertible>(_ x: T) -> Swift.String
func _arrayReserve<_Buffer where _Buffer : _ArrayBufferProtocol, _Buffer.Index == Int>(_ buffer: inout _Buffer, _ minimumCapacity: Swift.Int)
protocol RandomAccessCollection : RandomAccessIndexable, BidirectionalCollection {
  associatedtype SubSequence : RandomAccessIndexable, BidirectionalCollection = Swift.RandomAccessSlice<Self>
  associatedtype Indices : RandomAccessIndexable, BidirectionalCollection = Swift.DefaultRandomAccessIndices<Self>
}
extension RandomAccessCollection where Indices == DefaultRandomAccessIndices<Self> {
  var indices: Swift.DefaultRandomAccessIndices<Self> {
    get {}
  }
}
extension RandomAccessCollection {
  var lazy: Swift.LazyRandomAccessCollection<Self> {
    get {}
  }
}
extension RandomAccessCollection where Self : LazyCollectionProtocol {
  var lazy: Self {
    get {}
  }
}
extension RandomAccessCollection where SubSequence == RandomAccessSlice<Self> {
  subscript(bounds: Swift.Range<Self.Index>) -> Swift.RandomAccessSlice<Self> {
    get {}
  }
}
extension RandomAccessCollection where Index : Strideable, Index.Stride == IndexDistance, Indices == CountableRange<Index> {
  var indices: Swift.CountableRange<Self.Index> {
    get {}
  }
  func _validityChecked(_ i: Self.Index) -> Self.Index
  func index(after i: Self.Index) -> Self.Index
  func index(before i: Self.Index) -> Self.Index
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance) -> Self.Index
  func distance(from start: Self.Index, to end: Self.Index) -> Self.IndexDistance
}
extension RandomAccessCollection {
  func reversed() -> Swift.ReversedRandomAccessCollection<Self>
}
extension RandomAccessCollection {
  @available(*, unavailable, renamed: "reversed()") func reverse() -> Swift.ReversedRandomAccessCollection<Self>
}
@_silgen_name("swift_stdlib_compareNSStringDeterministicUnicodeCollation") func _stdlib_compareNSStringDeterministicUnicodeCollation(_ lhs: AnyObject, _ rhs: AnyObject) -> Swift.Int32
protocol ExpressibleByDictionaryLiteral {
  associatedtype Key
  associatedtype Value
  init(dictionaryLiteral elements: (Self.Key, Self.Value)...)
}
@_silgen_name("_swift_bridgeNonVerbatimFromObjectiveC") func _bridgeNonVerbatimFromObjectiveC<T>(_ x: AnyObject, _ nativeType: T.Type, _ result: inout T?)
struct JoinedIterator<Base : IteratorProtocol where Base.Element : Sequence> : IteratorProtocol {
  init<Separator : Sequence where Separator.Iterator.Element == Base.Element.Iterator.Element>(base: Base, separator: Separator)
  mutating func next() -> Base.Element.Iterator.Element?
  var _base: Base
  var _inner: Base.Element.Iterator?
  var _separatorData: Swift.ContiguousArray<Base.Element.Iterator.Element>
  var _separator: Swift.IndexingIterator<Swift.ContiguousArray<Base.Element.Iterator.Element>>?
  var _state: Swift._JoinIteratorState
  typealias Element = Base.Element.Iterator.Element
}
@_silgen_name("swift_ObjCMirror_count") func _getObjCCount(_: Swift._MagicMirrorData) -> Swift.Int
@objc protocol _NSNumber {
  @objc var doubleValue: Swift.Double { get }
  @objc var floatValue: Swift.Float { get }
  @objc var unsignedLongLongValue: Swift.UInt64 { get }
  @objc var longLongValue: Swift.Int64 { get }
  @objc var objCType: Swift.UnsafePointer<Swift.Int8> { get }
}
protocol SignedInteger : _SignedInteger, Integer {
  func toIntMax() -> Swift.IntMax
  init(_: Swift.IntMax)
}
extension SignedInteger {
  func distance(to other: Self) -> Swift.Int
  func advanced(by n: Swift.Int) -> Self
}
protocol Collection : Indexable, Sequence {
  associatedtype IndexDistance : SignedInteger = Swift.Int
  associatedtype Iterator : IteratorProtocol = Swift.IndexingIterator<Self>
  func makeIterator() -> Self.Iterator
  associatedtype SubSequence : IndexableBase, Sequence = Swift.Slice<Self>
  subscript(position: Self.Index) -> Self.Iterator.Element { get }
  subscript(bounds: Swift.Range<Self.Index>) -> Self.SubSequence { get }
  associatedtype Indices : IndexableBase, Sequence = Swift.DefaultIndices<Self>
  var indices: Self.Indices { get }
  func prefix(upTo end: Self.Index) -> Self.SubSequence
  func suffix(from start: Self.Index) -> Self.SubSequence
  func prefix(through position: Self.Index) -> Self.SubSequence
  var isEmpty: Swift.Bool { get }
  var count: Self.IndexDistance { get }
  func _customIndexOfEquatableElement(_ element: Self.Iterator.Element) -> Self.Index??
  var first: Self.Iterator.Element? { get }
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance) -> Self.Index
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Self.Index?
  func distance(from start: Self.Index, to end: Self.Index) -> Self.IndexDistance
}
extension Collection {
  func map<T>(_ transform: (Self.Iterator.Element) throws -> T) rethrows -> [T]
  func dropFirst(_ n: Swift.Int) -> Self.SubSequence
  func dropLast(_ n: Swift.Int) -> Self.SubSequence
  func prefix(_ maxLength: Swift.Int) -> Self.SubSequence
  func suffix(_ maxLength: Swift.Int) -> Self.SubSequence
  func prefix(upTo end: Self.Index) -> Self.SubSequence
  func suffix(from start: Self.Index) -> Self.SubSequence
  func prefix(through position: Self.Index) -> Self.SubSequence
  func split(maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default, whereSeparator isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.SubSequence]
}
extension Collection {
  var isEmpty: Swift.Bool {
    get {}
  }
  var first: Self.Iterator.Element? {
    get {}
  }
  var underestimatedCount: Swift.Int {
    get {}
  }
  var count: Self.IndexDistance {
    get {}
  }
  func _customIndexOfEquatableElement(_: Self.Iterator.Element) -> Self.Index??
}
extension Collection where Iterator == IndexingIterator<Self> {
  func makeIterator() -> Swift.IndexingIterator<Self>
}
extension Collection where SubSequence == Slice<Self> {
  subscript(bounds: Swift.Range<Self.Index>) -> Swift.Slice<Self> {
    get {}
  }
}
extension Collection where SubSequence == Self {
  mutating func popFirst() -> Self.Iterator.Element?
}
extension Collection where Iterator.Element : Equatable {
  func split(separator: Self.Iterator.Element, maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default) -> [Self.SubSequence]
}
extension Collection where SubSequence == Self {
  @discardableResult mutating func removeFirst() -> Self.Iterator.Element
  mutating func removeFirst(_ n: Swift.Int)
}
extension Collection {
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
}
extension Collection {
  @available(*, unavailable, renamed: "Iterator") typealias Generator = Self.Iterator
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Self.Iterator
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
  @available(*, unavailable, message: "Please use split(maxSplits:omittingEmptySubsequences:whereSeparator:) instead") func split(_ maxSplit: Swift.Int = default, allowEmptySlices: Swift.Bool = default, whereSeparator isSeparator: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> [Self.SubSequence]
}
extension Collection where Iterator.Element : Equatable {
  @available(*, unavailable, message: "Please use split(separator:maxSplits:omittingEmptySubsequences:) instead") func split(_ separator: Self.Iterator.Element, maxSplit: Swift.Int = default, allowEmptySlices: Swift.Bool = default) -> [Self.SubSequence]
}
extension Collection where Iterator.Element : Equatable {
  func index(of element: Self.Iterator.Element) -> Self.Index?
}
extension Collection {
  func index(where predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index?
}
extension Collection where Iterator.Element : Equatable {
  @available(*, unavailable, renamed: "index(of:)") func indexOf(_ element: Self.Iterator.Element) -> Self.Index?
}
extension Collection {
  @available(*, unavailable, renamed: "index(where:)") func indexOf(_ predicate: (Self.Iterator.Element) throws -> Swift.Bool) rethrows -> Self.Index?
}
extension Collection {
  func _copyToContiguousArray() -> Swift.ContiguousArray<Self.Iterator.Element>
}
extension Collection where Iterator.Element : Collection {
  func joined() -> Swift.FlattenCollection<Self>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.FlattenCollection<Self>
}
extension Collection where Indices == DefaultIndices<Self> {
  var indices: Swift.DefaultIndices<Self> {
    get {}
  }
}
extension Collection {
  var lazy: Swift.LazyCollection<Self> {
    get {}
  }
}
extension Collection where Self : LazyCollectionProtocol {
  var lazy: Self {
    get {}
  }
}
struct AnyBidirectionalCollection<Element> : _AnyCollectionProtocol, BidirectionalCollection {
  init(_box: Swift._AnyBidirectionalCollectionBox<Element>)
  init<C : BidirectionalCollection where C.Iterator.Element == Element, C.SubSequence : BidirectionalCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : BidirectionalCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : BidirectionalCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ base: C)
  init(_ other: Swift.AnyBidirectionalCollection<Element>)
  init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ base: C)
  init(_ other: Swift.AnyRandomAccessCollection<Element>)
  init?(_ other: Swift.AnyCollection<Element>)
  typealias Index = Swift.AnyIndex
  typealias IndexDistance = Swift.IntMax
  var startIndex: Swift.AnyIndex {
    get {}
  }
  var endIndex: Swift.AnyIndex {
    get {}
  }
  subscript(position: Swift.AnyIndex) -> Element {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.AnyIndex>) -> Swift.AnyBidirectionalCollection<Element> {
    get {}
  }
  func _failEarlyRangeCheck(_ index: Swift.AnyIndex, bounds: Swift.Range<Swift.AnyIndex>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Swift.AnyBidirectionalCollection.Index>, bounds: Swift.Range<Swift.AnyBidirectionalCollection.Index>)
  func index(after i: Swift.AnyIndex) -> Swift.AnyIndex
  func formIndex(after i: inout Swift.AnyIndex)
  func index(_ i: Swift.AnyIndex, offsetBy n: Swift.IntMax) -> Swift.AnyIndex
  func index(_ i: Swift.AnyIndex, offsetBy n: Swift.IntMax, limitedBy limit: Swift.AnyIndex) -> Swift.AnyIndex?
  func formIndex(_ i: inout Swift.AnyIndex, offsetBy n: Swift.IntMax)
  func formIndex(_ i: inout Swift.AnyIndex, offsetBy n: Swift.IntMax, limitedBy limit: Swift.AnyIndex) -> Swift.Bool
  func distance(from start: Swift.AnyIndex, to end: Swift.AnyIndex) -> Swift.IntMax
  var count: Swift.IntMax {
    get {}
  }
  var first: Element? {
    get {}
  }
  func index(before i: Swift.AnyIndex) -> Swift.AnyIndex
  func formIndex(before i: inout Swift.AnyIndex)
  var last: Element? {
    get {}
  }
  var _boxID: Swift.ObjectIdentifier {
    get {}
  }
  let _box: Swift._AnyBidirectionalCollectionBox<Element>
  typealias _Element = Element
  typealias SubSequence = Swift.AnyBidirectionalCollection<Element>
  typealias Indices = Swift.DefaultBidirectionalIndices<Swift.AnyBidirectionalCollection<Element>>
  typealias Iterator = Swift.AnyIterator<Element>
}
extension AnyBidirectionalCollection {
  func makeIterator() -> Swift.AnyIterator<Element>
  var underestimatedCount: Swift.Int {
    get {}
  }
  func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
  func filter(_ isIncluded: (Element) throws -> Swift.Bool) rethrows -> [Element]
  func forEach(_ body: (Element) throws -> Swift.Void) rethrows
  func dropFirst(_ n: Swift.Int) -> Swift.AnyBidirectionalCollection<Element>
  func dropLast(_ n: Swift.Int) -> Swift.AnyBidirectionalCollection<Element>
  func prefix(_ maxLength: Swift.Int) -> Swift.AnyBidirectionalCollection<Element>
  func suffix(_ maxLength: Swift.Int) -> Swift.AnyBidirectionalCollection<Element>
  func split(maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default, whereSeparator isSeparator: (Element) throws -> Swift.Bool) rethrows -> [Swift.AnyBidirectionalCollection<Element>]
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Element>
  func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Element>) -> Swift.UnsafeMutablePointer<Element>
}
extension AnyBidirectionalCollection {
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
}
@_silgen_name("swift_TupleMirror_count") func _getTupleCount(_: Swift._MagicMirrorData) -> Swift.Int
struct _NativeDictionaryIndex<Key : Hashable, Value> : Comparable {
  typealias NativeStorage = Swift._NativeDictionaryStorage<Key, Value>
  typealias NativeIndex = Swift._NativeDictionaryIndex<Key, Value>
  @_versioned var nativeStorage: Swift._NativeDictionaryStorage<Key, Value>
  var offset: Swift.Int
  @_versioned init(nativeStorage: Swift._NativeDictionaryStorage<Key, Value>, offset: Swift.Int)
  func successor() -> Swift._NativeDictionaryIndex<Key, Value>
}
extension _NativeDictionaryIndex {
  static func ==(lhs: Swift._NativeDictionaryIndex<Key, Value>, rhs: Swift._NativeDictionaryIndex<Key, Value>) -> Swift.Bool
  static func <(lhs: Swift._NativeDictionaryIndex<Key, Value>, rhs: Swift._NativeDictionaryIndex<Key, Value>) -> Swift.Bool
}
@objc protocol _NSFastEnumeration : _ShadowProtocol {
  @objc(countByEnumeratingWithState:objects:count:) func countByEnumerating(with state: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState>, objects: Swift.UnsafeMutablePointer<AnyObject>?, count: Swift.Int) -> Swift.Int
}
func _conditionallyBridgeFromObjectiveC<T>(_ x: AnyObject, _: T.Type) -> T?
struct Float80 {
  var _value: Builtin.FPIEEE80
  init()
  init(_bits v: Builtin.FPIEEE80)
}
extension Float80 : LosslessStringConvertible {
  init?(_ text: Swift.String)
}
extension Float80 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Float80 : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension Float80 : BinaryFloatingPoint {
  typealias Exponent = Swift.Int
  typealias RawSignificand = Swift.UInt64
  static var exponentBitCount: Swift.Int {
    get {}
  }
  static var significandBitCount: Swift.Int {
    get {}
  }
  @_versioned static var _infinityExponent: Swift.UInt {
    @inline(__always) get {}
  }
  static var _exponentBias: Swift.UInt {
    @inline(__always) get {}
  }
  static var _significandMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  @_versioned static var _quietNaNMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  struct _Float80Representation {
    var explicitSignificand: Swift.UInt64
    var signAndExponent: Swift.UInt16
    var _padding: (Swift.UInt16, Swift.UInt16, Swift.UInt16)
    var sign: Swift.FloatingPointSign {
      get {}
    }
    var exponentBitPattern: Swift.UInt {
      get {}
    }
    init(explicitSignificand: Swift.UInt64, signAndExponent: Swift.UInt16)
  }
  var _representation: Swift.Float80._Float80Representation {
    get {}
  }
  var sign: Swift.FloatingPointSign {
    get {}
  }
  static var _explicitBitMask: Swift.UInt64 {
    @inline(__always) get {}
  }
  var exponentBitPattern: Swift.UInt {
    get {}
  }
  var significandBitPattern: Swift.UInt64 {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponentBitPattern: Swift.UInt, significandBitPattern: Swift.UInt64)
  var isCanonical: Swift.Bool {
    get {}
  }
  static var infinity: Swift.Float80 {
    get {}
  }
  static var nan: Swift.Float80 {
    get {}
  }
  static var signalingNaN: Swift.Float80 {
    get {}
  }
  @available(*, unavailable, renamed: "nan") static var quietNaN: Swift.Float80 {
    get {}
  }
  static var greatestFiniteMagnitude: Swift.Float80 {
    get {}
  }
  static var pi: Swift.Float80 {
    get {}
  }
  var ulp: Swift.Float80 {
    get {}
  }
  static var leastNormalMagnitude: Swift.Float80 {
    get {}
  }
  static var leastNonzeroMagnitude: Swift.Float80 {
    get {}
  }
  var exponent: Swift.Int {
    get {}
  }
  var significand: Swift.Float80 {
    get {}
  }
  init(sign: Swift.FloatingPointSign, exponent: Swift.Int, significand: Swift.Float80)
  init(nan payload: Swift.Float80.RawSignificand, signaling: Swift.Bool)
  var nextUp: Swift.Float80 {
    get {}
  }
  mutating func round(_ rule: Swift.FloatingPointRoundingRule)
  mutating func negate()
  mutating func add(_ other: Swift.Float80)
  mutating func subtract(_ other: Swift.Float80)
  mutating func multiply(by other: Swift.Float80)
  mutating func divide(by other: Swift.Float80)
  mutating func formRemainder(dividingBy other: Swift.Float80)
  mutating func formTruncatingRemainder(dividingBy other: Swift.Float80)
  mutating func formSquareRoot()
  mutating func addProduct(_ lhs: Swift.Float80, _ rhs: Swift.Float80)
  func isEqual(to other: Swift.Float80) -> Swift.Bool
  func isLess(than other: Swift.Float80) -> Swift.Bool
  func isLessThanOrEqualTo(_ other: Swift.Float80) -> Swift.Bool
  var isNormal: Swift.Bool {
    get {}
  }
  var isFinite: Swift.Bool {
    get {}
  }
  var isZero: Swift.Bool {
    get {}
  }
  var isSubnormal: Swift.Bool {
    get {}
  }
  var isInfinite: Swift.Bool {
    get {}
  }
  var isNaN: Swift.Bool {
    get {}
  }
  var isSignalingNaN: Swift.Bool {
    get {}
  }
  var binade: Swift.Float80 {
    get {}
  }
  var significandWidth: Swift.Int {
    get {}
  }
  init(floatLiteral value: Swift.Float80)
  typealias RawExponent = Swift.UInt
  typealias FloatLiteralType = Swift.Float80
}
extension Float80 : _ExpressibleByBuiltinIntegerLiteral, ExpressibleByIntegerLiteral {
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int64)
  typealias IntegerLiteralType = Swift.Int64
}
extension Float80 : _ExpressibleByBuiltinFloatLiteral {
  init(_builtinFloatLiteral value: Builtin.FPIEEE80)
}
extension Float80 : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension Float80 : AbsoluteValuable {
  static func abs(_ x: Swift.Float80) -> Swift.Float80
}
extension Float80 {
  init(_ v: Swift.UInt8)
  init(_ v: Swift.Int8)
  init(_ v: Swift.UInt16)
  init(_ v: Swift.Int16)
  init(_ v: Swift.UInt32)
  init(_ v: Swift.Int32)
  init(_ v: Swift.UInt64)
  init(_ v: Swift.Int64)
  init(_ v: Swift.UInt)
  init(_ v: Swift.Int)
}
extension Float80 {
  init(_ other: Swift.Float)
  @inline(__always) init?(exactly other: Swift.Float)
  init(_ other: Swift.Double)
  @inline(__always) init?(exactly other: Swift.Double)
  init(_ other: Swift.Float80)
  @inline(__always) init?(exactly other: Swift.Float80)
}
extension Float80 : Strideable {
  func distance(to other: Swift.Float80) -> Swift.Float80
  func advanced(by amount: Swift.Float80) -> Swift.Float80
  typealias Stride = Swift.Float80
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
@objc protocol _NSDictionaryCore : _NSCopying, _NSFastEnumeration {
  @objc init(objects: Swift.UnsafePointer<AnyObject?>, forKeys: Swift.UnsafeRawPointer, count: Swift.Int)
  @objc var count: Swift.Int { get }
  @objc(objectForKey:) func objectFor(_ aKey: AnyObject) -> AnyObject?
  @objc func keyEnumerator() -> _NSEnumerator
  @objc(copyWithZone:) func copy(with zone: Swift._SwiftNSZone?) -> AnyObject
  @objc func getObjects(_ objects: Swift.UnsafeMutablePointer<AnyObject>?, andKeys keys: Swift.UnsafeMutablePointer<AnyObject>?)
  @objc(countByEnumeratingWithState:objects:count:) func countByEnumerating(with state: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState>, objects: Swift.UnsafeMutablePointer<AnyObject>?, count: Swift.Int) -> Swift.Int
}
@available(*, unavailable, message: "use isKnownUniquelyReferenced instead") class NonObjectiveCBase {
  @objc deinit
  init()
}
func _assumeNonNegative(_ x: Swift.Int8) -> Swift.Int8
func _assumeNonNegative(_ x: Swift.Int16) -> Swift.Int16
func _assumeNonNegative(_ x: Swift.Int32) -> Swift.Int32
func _assumeNonNegative(_ x: Swift.Int64) -> Swift.Int64
func _assumeNonNegative(_ x: Swift.Int) -> Swift.Int
func /=<T : FloatingPoint>(lhs: inout T, rhs: T)
func /=(lhs: inout Swift.Float, rhs: Swift.Float)
func /=(lhs: inout Swift.Double, rhs: Swift.Double)
func /=(lhs: inout Swift.Float80, rhs: Swift.Float80)
func /=<T : _IntegerArithmetic>(lhs: inout T, rhs: T)
func _convertConstStringToUTF8PointerArgument<ToPointer : _Pointer>(_ str: Swift.String) -> (AnyObject?, ToPointer)
struct _UnicodeExtendedGraphemeClusterSegmenter {
  let _noBoundaryRulesMatrix: Swift.UnsafePointer<Swift.UInt16>
  init()
  func isBoundaryAfter(_ gcb: Swift._GraphemeClusterBreakPropertyRawValue) -> Swift.Bool
  func isBoundary(_ gcb1: Swift._GraphemeClusterBreakPropertyRawValue, _ gcb2: Swift._GraphemeClusterBreakPropertyRawValue) -> Swift.Bool
}
struct _HashedContainerStorageHeader {
  init(capacity: Swift.Int)
  var capacity: Swift.Int
  var count: Swift.Int
  var maxLoadFactorInverse: Swift.Double
}
@_silgen_name("swift_StructMirror_count") func _getStructCount(_: Swift._MagicMirrorData) -> Swift.Int
@inline(never) @_semantics("stdlib_binary_only") func _cocoaStringToContiguous(source: Swift._CocoaString, range: Swift.Range<Swift.Int>, minimumCapacity: Swift.Int) -> Swift._StringBuffer
func _swift_stdlib_atomicFetchAndUInt64(object target: Swift.UnsafeMutablePointer<Swift.UInt64>, operand: Swift.UInt64) -> Swift.UInt64
protocol _CVarArgAligned : CVarArg {
  var _cVarArgAlignment: Swift.Int { get }
}
@_versioned var _objCTaggedPointerBits: Swift.UInt {
  @inline(__always) get {}
}
protocol _Strideable : Equatable {
  associatedtype Stride : SignedNumber
  func distance(to other: Self) -> Self.Stride
  func advanced(by n: Self.Stride) -> Self
  static func _step(after current: (index: Swift.Int?, value: Self), from start: Self, by distance: Self.Stride) -> (index: Swift.Int?, value: Self)
  associatedtype _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
@available(*, unavailable, renamed: "IteratorSequence") struct GeneratorSequence<Base : IteratorProtocol> {
  init()
}
struct EnumeratedSequence<Base : Sequence> : Sequence {
  var _base: Base
  init(_base: Base)
  func makeIterator() -> Swift.EnumeratedIterator<Base.Iterator>
  typealias Iterator = Swift.EnumeratedIterator<Base.Iterator>
  typealias SubSequence = Swift.AnySequence<(offset: Swift.Int, element: Base.Iterator.Element)>
}
extension EnumeratedSequence {
  @available(*, unavailable, message: "use the 'enumerated()' method on the sequence") init(_ base: Base)
}
struct _CocoaSetStorage : _HashStorage {
  var cocoaSet: _NSSet
  typealias Index = Swift._CocoaSetIndex
  typealias SequenceElement = AnyObject
  typealias SequenceElementWithoutLabels = AnyObject
  typealias Key = AnyObject
  typealias Value = AnyObject
  var startIndex: Swift._CocoaSetStorage.Index {
    get {}
  }
  var endIndex: Swift._CocoaSetStorage.Index {
    get {}
  }
  @_versioned func index(after i: Swift._CocoaSetStorage.Index) -> Swift._CocoaSetStorage.Index
  func formIndex(after i: inout Swift._CocoaSetStorage.Index)
  @_versioned func index(forKey key: Swift._CocoaSetStorage.Key) -> Swift._CocoaSetStorage.Index?
  func assertingGet(_ i: Swift._CocoaSetStorage.Index) -> Swift._CocoaSetStorage.SequenceElement
  func assertingGet(_ key: Swift._CocoaSetStorage.Key) -> Swift._CocoaSetStorage.Value
  @inline(__always) func maybeGet(_ key: Swift._CocoaSetStorage.Key) -> Swift._CocoaSetStorage.Value?
  @discardableResult mutating func updateValue(_ value: Swift._CocoaSetStorage.Value, forKey key: Swift._CocoaSetStorage.Key) -> Swift._CocoaSetStorage.Value?
  @discardableResult mutating func insert(_ value: Swift._CocoaSetStorage.Value, forKey key: Swift._CocoaSetStorage.Key) -> (inserted: Swift.Bool, memberAfterInsert: Swift._CocoaSetStorage.Value)
  @discardableResult mutating func remove(at index: Swift._CocoaSetStorage.Index) -> Swift._CocoaSetStorage.SequenceElement
  @discardableResult mutating func removeValue(forKey key: Swift._CocoaSetStorage.Key) -> Swift._CocoaSetStorage.Value?
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool)
  var count: Swift.Int {
    get {}
  }
  static func fromArray(_ elements: [Swift._CocoaSetStorage.SequenceElementWithoutLabels]) -> Swift._CocoaSetStorage
  init(cocoaSet: _NSSet)
}
protocol _AnyHashableBox {
  var _typeID: Swift.ObjectIdentifier { get }
  func _unbox<T : Hashable>() -> T?
  func _isEqual(to: _AnyHashableBox) -> Swift.Bool
  var _hashValue: Swift.Int { get }
  var _base: Any { get }
  func _downCastConditional<T>(into result: Swift.UnsafeMutablePointer<T>) -> Swift.Bool
}
func _withUninitializedString<R>(_ body: (Swift.UnsafeMutablePointer<Swift.String>) -> R) -> (R, Swift.String)
func _stdlib_initializeReturnAutoreleased()
func _log2(_ x: Swift.Float) -> Swift.Float
func _log2(_ x: Swift.Double) -> Swift.Double
@_silgen_name("_swift_setDownCastConditionalIndirect") func _setDownCastConditionalIndirect<SourceValue, TargetValue>(_ source: Swift.UnsafePointer<Swift.Set<SourceValue>>, _ target: Swift.UnsafeMutablePointer<Swift.Set<TargetValue>>) -> Swift.Bool
enum _StopIteration : Error {
  case stop
  infix static func ==(a: Swift._StopIteration, b: Swift._StopIteration) -> Swift.Bool
  var hashValue: Swift.Int {
    get {}
  }
  var _code: Swift.Int {
    get {}
  }
}
protocol SetAlgebra : Equatable, ExpressibleByArrayLiteral {
  associatedtype Element
  init()
  func contains(_ member: Self.Element) -> Swift.Bool
  func union(_ other: Self) -> Self
  func intersection(_ other: Self) -> Self
  func symmetricDifference(_ other: Self) -> Self
  @discardableResult mutating func insert(_ newMember: Self.Element) -> (inserted: Swift.Bool, memberAfterInsert: Self.Element)
  @discardableResult mutating func remove(_ member: Self.Element) -> Self.Element?
  @discardableResult mutating func update(with newMember: Self.Element) -> Self.Element?
  mutating func formUnion(_ other: Self)
  mutating func formIntersection(_ other: Self)
  mutating func formSymmetricDifference(_ other: Self)
  func subtracting(_ other: Self) -> Self
  func isSubset(of other: Self) -> Swift.Bool
  func isDisjoint(with other: Self) -> Swift.Bool
  func isSuperset(of other: Self) -> Swift.Bool
  var isEmpty: Swift.Bool { get }
  init<S : Sequence where S.Iterator.Element == Element>(_ sequence: S)
  mutating func subtract(_ other: Self)
}
extension SetAlgebra {
  convenience init<S : Sequence where S.Iterator.Element == Element>(_ sequence: S)
  convenience init(arrayLiteral: Self.Element...)
  mutating func subtract(_ other: Self)
  func isSubset(of other: Self) -> Swift.Bool
  func isSuperset(of other: Self) -> Swift.Bool
  func isDisjoint(with other: Self) -> Swift.Bool
  func subtracting(_ other: Self) -> Self
  var isEmpty: Swift.Bool {
    get {}
  }
  func isStrictSuperset(of other: Self) -> Swift.Bool
  func isStrictSubset(of other: Self) -> Swift.Bool
}
extension SetAlgebra {
  @available(*, unavailable, renamed: "intersection(_:)") func intersect(_ other: Self) -> Self
  @available(*, unavailable, renamed: "symmetricDifference(_:)") func exclusiveOr(_ other: Self) -> Self
  @available(*, unavailable, renamed: "formUnion(_:)") mutating func unionInPlace(_ other: Self)
  @available(*, unavailable, renamed: "formIntersection(_:)") mutating func intersectInPlace(_ other: Self)
  @available(*, unavailable, renamed: "formSymmetricDifference(_:)") mutating func exclusiveOrInPlace(_ other: Self)
  @available(*, unavailable, renamed: "isSubset(of:)") func isSubsetOf(_ other: Self) -> Swift.Bool
  @available(*, unavailable, renamed: "isDisjoint(with:)") func isDisjointWith(_ other: Self) -> Swift.Bool
  @available(*, unavailable, renamed: "isSuperset(of:)") func isSupersetOf(_ other: Self) -> Swift.Bool
  @available(*, unavailable, renamed: "subtract(_:)") mutating func subtractInPlace(_ other: Self)
  @available(*, unavailable, renamed: "isStrictSuperset(of:)") func isStrictSupersetOf(_ other: Self) -> Swift.Bool
  @available(*, unavailable, renamed: "isStrictSubset(of:)") func isStrictSubsetOf(_ other: Self) -> Swift.Bool
}
func _adHocPrint_unlocked<T, TargetStream : TextOutputStream>(_ value: T, _ mirror: Swift.Mirror, _ target: inout TargetStream, isDebugPrint: Swift.Bool)
struct Int8 : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int8
  init()
  init(_ _v: Builtin.Int8)
  init(_bits: Builtin.Int8)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int8)
  static var max: Swift.Int8 {
    get {}
  }
  static var min: Swift.Int8 {
    get {}
  }
  static var _sizeInBits: Swift.Int8 {
    get {}
  }
  static var _sizeInBytes: Swift.Int8 {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int8
  typealias Stride = Swift.Int
}
extension Int8 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int8 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int8 {
  static func addWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int8 : SignedNumber {
}
extension Int8 {
  init(_ value: Swift.UInt8)
  init?(exactly value: Swift.UInt8)
}
extension Int8 {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int8 will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int8 {
  init(_ value: Swift.UInt16)
  init?(exactly value: Swift.UInt16)
  init(truncatingBitPattern: Swift.UInt16)
}
extension Int8 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
  init(truncatingBitPattern: Swift.Int16)
}
extension Int8 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
  init(truncatingBitPattern: Swift.UInt32)
}
extension Int8 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
  init(truncatingBitPattern: Swift.Int32)
}
extension Int8 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension Int8 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension Int8 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension Int8 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension Int8 {
  init(bitPattern: Swift.UInt8)
}
extension Int8 : BitwiseOperations {
  static var allZeros: Swift.Int8 {
    get {}
  }
}
extension Int8 {
  typealias _DisabledRangeIndex = Swift.Int8
}
extension Int8 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int8 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int8 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int8 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Int8 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension Int8 {
  init(_ value: CoreGraphics.CGFloat)
}
func _typeName(_ type: Any.Type, qualified: Swift.Bool = default) -> Swift.String
protocol ExpressibleByFloatLiteral {
  associatedtype FloatLiteralType : _ExpressibleByBuiltinFloatLiteral
  init(floatLiteral value: Self.FloatLiteralType)
}
final class _RandomAccessCollectionBox<S : RandomAccessCollection where S.SubSequence : RandomAccessCollection, S.SubSequence.Iterator.Element == S.Iterator.Element, S.SubSequence.SubSequence == S.SubSequence, S.SubSequence.Index == S.Index, S.SubSequence.Indices : RandomAccessCollection, S.SubSequence.Indices.Iterator.Element == S.Index, S.SubSequence.Indices.Index == S.Index, S.SubSequence.Indices.SubSequence == S.SubSequence.Indices, S.Indices : RandomAccessCollection, S.Indices.Iterator.Element == S.Index, S.Indices.Index == S.Index, S.Indices.SubSequence == S.Indices> : Swift._AnyRandomAccessCollectionBox<S.Iterator.Element> {
  typealias Element = S.Iterator.Element
  override final func _makeIterator() -> Swift.AnyIterator<S.Iterator.Element>
  override final var _underestimatedCount: Swift.Int {
    override final get {}
  }
  override final func _map<T>(_ transform: (S.Iterator.Element) throws -> T) rethrows -> [T]
  override final func _filter(_ isIncluded: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [S.Iterator.Element]
  override final func _forEach(_ body: (S.Iterator.Element) throws -> Swift.Void) rethrows
  override final func __customContainsEquatableElement(_ element: S.Iterator.Element) -> Swift.Bool?
  override final func __preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  override final func __copyToContiguousArray() -> Swift.ContiguousArray<S.Iterator.Element>
  override final func __copyContents(initializing ptr: Swift.UnsafeMutablePointer<S.Iterator.Element>) -> Swift.UnsafeMutablePointer<S.Iterator.Element>
  override final func _dropFirst(_ n: Swift.Int) -> Swift._AnyRandomAccessCollectionBox<S.Iterator.Element>
  override final func _dropLast(_ n: Swift.Int) -> Swift._AnyRandomAccessCollectionBox<S.Iterator.Element>
  override final func _prefix(_ maxLength: Swift.Int) -> Swift._AnyRandomAccessCollectionBox<S.Iterator.Element>
  override final func _suffix(_ maxLength: Swift.Int) -> Swift._AnyRandomAccessCollectionBox<S.Iterator.Element>
  override final func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnySequence<S.Iterator.Element>]
  override final func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnyCollection<S.Iterator.Element>]
  override final func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnyBidirectionalCollection<S.Iterator.Element>]
  override final func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnyRandomAccessCollection<S.Iterator.Element>]
  init(_base: S)
  final func _unbox(_ position: _AnyIndexBox, file: Swift.StaticString = #file, line: Swift.UInt = #line) -> S.Index
  override final subscript(position: _AnyIndexBox) -> S.Iterator.Element {
    override final get {}
  }
  override final subscript(start start: _AnyIndexBox, end end: _AnyIndexBox) -> Swift._AnyRandomAccessCollectionBox<S.Iterator.Element> {
    override final get {}
  }
  override final func _index(after position: _AnyIndexBox) -> _AnyIndexBox
  override final func _formIndex(after position: _AnyIndexBox)
  override final func _index(_ i: _AnyIndexBox, offsetBy n: Swift.IntMax) -> _AnyIndexBox
  override final func _index(_ i: _AnyIndexBox, offsetBy n: Swift.IntMax, limitedBy limit: _AnyIndexBox) -> _AnyIndexBox?
  override final func _formIndex(_ i: inout _AnyIndexBox, offsetBy n: Swift.IntMax)
  override final func _formIndex(_ i: inout _AnyIndexBox, offsetBy n: Swift.IntMax, limitedBy limit: _AnyIndexBox) -> Swift.Bool
  override final func _distance(from start: _AnyIndexBox, to end: _AnyIndexBox) -> Swift.IntMax
  override final var _count: Swift.IntMax {
    override final get {}
  }
  override final var _first: S.Iterator.Element? {
    override final get {}
  }
  override final func _index(before position: _AnyIndexBox) -> _AnyIndexBox
  override final func _formIndex(before position: _AnyIndexBox)
  override final var _last: S.Iterator.Element? {
    override final get {}
  }
  final var _base: S
  @objc deinit
  init(_startIndex: _AnyIndexBox, endIndex: _AnyIndexBox)
}
struct _BridgeableMetatype : _ObjectiveCBridgeable {
  var value: AnyObject.Type
  typealias _ObjectiveCType = AnyObject
  func _bridgeToObjectiveC() -> AnyObject
  static func _forceBridgeFromObjectiveC(_ source: AnyObject, result: inout Swift._BridgeableMetatype?)
  static func _conditionallyBridgeFromObjectiveC(_ source: AnyObject, result: inout Swift._BridgeableMetatype?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: AnyObject?) -> Swift._BridgeableMetatype
  init(value: AnyObject.Type)
}
struct Set<Element : Hashable> : SetAlgebra, Hashable, Collection, ExpressibleByArrayLiteral {
  typealias _Self = Swift.Set<Element>
  typealias _VariantStorage = Swift._VariantSetStorage<Element>
  typealias _NativeStorage = Swift._NativeSetStorage<Element>
  typealias Index = Swift.SetIndex<Element>
  var _variantStorage: Swift._VariantSetStorage<Element>
  init(minimumCapacity: Swift.Int)
  init(_nativeStorage: Swift._NativeSetStorage<Element>)
  init(_nativeStorageOwner: Swift._NativeSetStorageOwner<Element>)
  init(_immutableCocoaSet: _NSSet)
  var startIndex: Swift.SetIndex<Element> {
    get {}
  }
  var endIndex: Swift.SetIndex<Element> {
    get {}
  }
  func index(after i: Swift.SetIndex<Element>) -> Swift.SetIndex<Element>
  func contains(_ member: Element) -> Swift.Bool
  func index(of member: Element) -> Swift.SetIndex<Element>?
  @discardableResult mutating func insert(_ newMember: Element) -> (inserted: Swift.Bool, memberAfterInsert: Element)
  @discardableResult mutating func update(with newMember: Element) -> Element?
  @discardableResult mutating func remove(_ member: Element) -> Element?
  @discardableResult mutating func remove(at position: Swift.SetIndex<Element>) -> Element
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
  @discardableResult mutating func removeFirst() -> Element
  var count: Swift.Int {
    get {}
  }
  subscript(position: Swift.SetIndex<Element>) -> Element {
    get {}
  }
  @inline(__always) func makeIterator() -> Swift.SetIterator<Element>
  init(arrayLiteral elements: Element...)
  init()
  init<Source : Sequence where Source.Iterator.Element == Element>(_ sequence: Source)
  func isSubset<S : Sequence where S.Iterator.Element == Element>(of possibleSuperset: S) -> Swift.Bool
  func isStrictSubset<S : Sequence where S.Iterator.Element == Element>(of possibleStrictSuperset: S) -> Swift.Bool
  func isSuperset<S : Sequence where S.Iterator.Element == Element>(of possibleSubset: S) -> Swift.Bool
  func isStrictSuperset<S : Sequence where S.Iterator.Element == Element>(of possibleStrictSubset: S) -> Swift.Bool
  func isDisjoint<S : Sequence where S.Iterator.Element == Element>(with other: S) -> Swift.Bool
  func union<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Swift.Set<Element>
  mutating func formUnion<S : Sequence where S.Iterator.Element == Element>(_ other: S)
  func subtracting<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Swift.Set<Element>
  func _subtracting<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Swift.Set<Element>
  mutating func subtract<S : Sequence where S.Iterator.Element == Element>(_ other: S)
  mutating func _subtract<S : Sequence where S.Iterator.Element == Element>(_ other: S)
  func intersection<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Swift.Set<Element>
  mutating func formIntersection<S : Sequence where S.Iterator.Element == Element>(_ other: S)
  func symmetricDifference<S : Sequence where S.Iterator.Element == Element>(_ other: S) -> Swift.Set<Element>
  mutating func formSymmetricDifference<S : Sequence where S.Iterator.Element == Element>(_ other: S)
  var hashValue: Swift.Int {
    get {}
  }
  func _customContainsEquatableElement(_ member: Element) -> Swift.Bool?
  func _customIndexOfEquatableElement(_ member: Element) -> Swift.SetIndex<Element>??
  var isEmpty: Swift.Bool {
    get {}
  }
  var first: Element? {
    get {}
  }
  typealias _Element = Element
  typealias SubSequence = Swift.Slice<Swift.Set<Element>>
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.SetIterator<Element>
  typealias Indices = Swift.DefaultIndices<Swift.Set<Element>>
  typealias Element = Element
}
extension Set {
  static func ==(lhs: Swift.Set<Element>, rhs: Swift.Set<Element>) -> Swift.Bool
}
extension Set : CustomStringConvertible, CustomDebugStringConvertible {
  func makeDescription(isDebug: Swift.Bool) -> Swift.String
  var description: Swift.String {
    get {}
  }
  var debugDescription: Swift.String {
    get {}
  }
}
extension Set : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Set {
  mutating func popFirst() -> Element?
}
extension Set {
  func _bridgeToObjectiveCImpl() -> _NSSetCore
  static func _bridgeFromObjectiveCAdoptingNativeStorageOf(_ s: AnyObject) -> Swift.Set<Element>?
}
extension Set {
  mutating func subtract(_ other: Swift.Set<Element>)
  func isSubset(of other: Swift.Set<Element>) -> Swift.Bool
  func isSuperset(of other: Swift.Set<Element>) -> Swift.Bool
  func isDisjoint(with other: Swift.Set<Element>) -> Swift.Bool
  func subtracting(_ other: Swift.Set<Element>) -> Swift.Set<Element>
  func isStrictSuperset(of other: Swift.Set<Element>) -> Swift.Bool
  func isStrictSubset(of other: Swift.Set<Element>) -> Swift.Bool
  func intersection(_ other: Swift.Set<Element>) -> Swift.Set<Element>
  mutating func formSymmetricDifference(_ other: Swift.Set<Element>)
}
extension Set {
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ index: Swift.SetIndex<Element>) -> Element
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.SetIterator<Element>
  @available(*, unavailable, renamed: "index(of:)") func indexOf(_ member: Element) -> Swift.SetIndex<Element>?
}
extension Set {
  @inline(__always) mutating func _concreteElement_insert(_ newMember: Element) -> (inserted: Swift.Bool, memberAfterInsert: Element)
  @inline(__always) mutating func _concreteElement_update(with newMember: Element) -> Element?
  @inline(__always) mutating func _concreteElement_remove(_ member: Element) -> Element?
}
extension Set where Element : _AnyHashableProtocol {
  mutating func insert<ConcreteElement : Hashable>(_ newMember: ConcreteElement) -> (inserted: Swift.Bool, memberAfterInsert: ConcreteElement)
  @discardableResult mutating func update<ConcreteElement : Hashable>(with newMember: ConcreteElement) -> ConcreteElement?
  @discardableResult mutating func remove<ConcreteElement : Hashable>(_ member: ConcreteElement) -> ConcreteElement?
}
extension Set {
  init(_cocoaSet: _NSSet)
}
extension Set : _ObjectiveCBridgeable {
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSSet
  static func _forceBridgeFromObjectiveC(_ s: Foundation.NSSet, result: inout Swift.Set<Element>?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSSet, result: inout Swift.Set<Element>?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ s: Foundation.NSSet?) -> Swift.Set<Element>
  typealias _ObjectiveCType = Foundation.NSSet
}
extension Set : CVarArg {
}
final class _BidirectionalCollectionBox<S : BidirectionalCollection where S.SubSequence : BidirectionalCollection, S.SubSequence.Iterator.Element == S.Iterator.Element, S.SubSequence.SubSequence == S.SubSequence, S.SubSequence.Index == S.Index, S.SubSequence.Indices : BidirectionalCollection, S.SubSequence.Indices.Iterator.Element == S.Index, S.SubSequence.Indices.Index == S.Index, S.SubSequence.Indices.SubSequence == S.SubSequence.Indices, S.Indices : BidirectionalCollection, S.Indices.Iterator.Element == S.Index, S.Indices.Index == S.Index, S.Indices.SubSequence == S.Indices> : Swift._AnyBidirectionalCollectionBox<S.Iterator.Element> {
  typealias Element = S.Iterator.Element
  override final func _makeIterator() -> Swift.AnyIterator<S.Iterator.Element>
  override final var _underestimatedCount: Swift.Int {
    override final get {}
  }
  override final func _map<T>(_ transform: (S.Iterator.Element) throws -> T) rethrows -> [T]
  override final func _filter(_ isIncluded: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [S.Iterator.Element]
  override final func _forEach(_ body: (S.Iterator.Element) throws -> Swift.Void) rethrows
  override final func __customContainsEquatableElement(_ element: S.Iterator.Element) -> Swift.Bool?
  override final func __preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  override final func __copyToContiguousArray() -> Swift.ContiguousArray<S.Iterator.Element>
  override final func __copyContents(initializing ptr: Swift.UnsafeMutablePointer<S.Iterator.Element>) -> Swift.UnsafeMutablePointer<S.Iterator.Element>
  override final func _dropFirst(_ n: Swift.Int) -> Swift._AnyBidirectionalCollectionBox<S.Iterator.Element>
  override final func _dropLast(_ n: Swift.Int) -> Swift._AnyBidirectionalCollectionBox<S.Iterator.Element>
  override final func _prefix(_ maxLength: Swift.Int) -> Swift._AnyBidirectionalCollectionBox<S.Iterator.Element>
  override final func _suffix(_ maxLength: Swift.Int) -> Swift._AnyBidirectionalCollectionBox<S.Iterator.Element>
  override final func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnySequence<S.Iterator.Element>]
  override final func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnyCollection<S.Iterator.Element>]
  override final func _split(maxSplits: Swift.Int, omittingEmptySubsequences: Swift.Bool, whereSeparator isSeparator: (S.Iterator.Element) throws -> Swift.Bool) rethrows -> [Swift.AnyBidirectionalCollection<S.Iterator.Element>]
  init(_base: S)
  final func _unbox(_ position: _AnyIndexBox, file: Swift.StaticString = #file, line: Swift.UInt = #line) -> S.Index
  override final subscript(position: _AnyIndexBox) -> S.Iterator.Element {
    override final get {}
  }
  override final subscript(start start: _AnyIndexBox, end end: _AnyIndexBox) -> Swift._AnyBidirectionalCollectionBox<S.Iterator.Element> {
    override final get {}
  }
  override final func _index(after position: _AnyIndexBox) -> _AnyIndexBox
  override final func _formIndex(after position: _AnyIndexBox)
  override final func _index(_ i: _AnyIndexBox, offsetBy n: Swift.IntMax) -> _AnyIndexBox
  override final func _index(_ i: _AnyIndexBox, offsetBy n: Swift.IntMax, limitedBy limit: _AnyIndexBox) -> _AnyIndexBox?
  override final func _formIndex(_ i: inout _AnyIndexBox, offsetBy n: Swift.IntMax)
  override final func _formIndex(_ i: inout _AnyIndexBox, offsetBy n: Swift.IntMax, limitedBy limit: _AnyIndexBox) -> Swift.Bool
  override final func _distance(from start: _AnyIndexBox, to end: _AnyIndexBox) -> Swift.IntMax
  override final var _count: Swift.IntMax {
    override final get {}
  }
  override final var _first: S.Iterator.Element? {
    override final get {}
  }
  override final func _index(before position: _AnyIndexBox) -> _AnyIndexBox
  override final func _formIndex(before position: _AnyIndexBox)
  override final var _last: S.Iterator.Element? {
    override final get {}
  }
  final var _base: S
  @objc deinit
  init(_startIndex: _AnyIndexBox, endIndex: _AnyIndexBox)
}
func _swift_stdlib_atomicLoadUInt32(object target: Swift.UnsafeMutablePointer<Swift.UInt32>) -> Swift.UInt32
struct Slice<Base : Indexable> : Collection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
  }
  typealias SubSequence = Swift.Slice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.Slice<Base> {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  let _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.Slice<Base>>
  typealias Indices = Swift.DefaultIndices<Swift.Slice<Base>>
}
@available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'MutableCollection' instead") protocol MutableIndexable : Indexable {
  associatedtype Index : Comparable
  var startIndex: Self.Index { get }
  var endIndex: Self.Index { get }
  associatedtype _Element
  subscript(position: Self.Index) -> Self._Element { get set }
  associatedtype SubSequence
  subscript(bounds: Swift.Range<Self.Index>) -> Self.SubSequence { get set }
  func _failEarlyRangeCheck(_ index: Self.Index, bounds: Swift.Range<Self.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Self.Index>, bounds: Swift.Range<Self.Index>)
  func index(after i: Self.Index) -> Self.Index
  func formIndex(after i: inout Self.Index)
}
extension MutableIndexable {
  subscript(bounds: Swift.ClosedRange<Self.Index>) -> Self.SubSequence {
    get {}
    set(newValue) {}
  }
}
extension MutableIndexable where Index : Strideable, Index.Stride : SignedInteger {
  subscript(bounds: Swift.CountableRange<Self.Index>) -> Self.SubSequence {
    get {}
    set(newValue) {}
  }
  subscript(bounds: Swift.CountableClosedRange<Self.Index>) -> Self.SubSequence {
    get {}
    set(newValue) {}
  }
}
@unsafe_no_objc_tagged_pointer @objc protocol _NSDictionary : _NSDictionaryCore {
  @objc func getObjects(_ objects: Swift.UnsafeMutablePointer<AnyObject>?, andKeys keys: Swift.UnsafeMutablePointer<AnyObject>?)
}
func _onFastPath()
protocol _HashStorage {
  associatedtype Key
  associatedtype Value
  associatedtype Index
  associatedtype SequenceElement
  associatedtype SequenceElementWithoutLabels
  var startIndex: Self.Index { get }
  var endIndex: Self.Index { get }
  func index(after i: Self.Index) -> Self.Index
  func formIndex(after i: inout Self.Index)
  func index(forKey key: Self.Key) -> Self.Index?
  func assertingGet(_ i: Self.Index) -> Self.SequenceElement
  func assertingGet(_ key: Self.Key) -> Self.Value
  func maybeGet(_ key: Self.Key) -> Self.Value?
  @discardableResult mutating func updateValue(_ value: Self.Value, forKey key: Self.Key) -> Self.Value?
  @discardableResult mutating func insert(_ value: Self.Value, forKey key: Self.Key) -> (inserted: Swift.Bool, memberAfterInsert: Self.Value)
  @discardableResult mutating func remove(at index: Self.Index) -> Self.SequenceElement
  @discardableResult mutating func removeValue(forKey key: Self.Key) -> Self.Value?
  @discardableResult mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool)
  var count: Swift.Int { get }
  static func fromArray(_ elements: [Self.SequenceElementWithoutLabels]) -> Self
}
protocol _ExpressibleByFileReferenceLiteral {
  init(fileReferenceLiteralResourceName path: Swift.String)
}
struct _ObjCMirror : _Mirror {
  let data: Swift._MagicMirrorData
  var value: Any {
    get {}
  }
  var valueType: Any.Type {
    get {}
  }
  var objectIdentifier: Swift.ObjectIdentifier? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  subscript(i: Swift.Int) -> (Swift.String, _Mirror) {
    get {}
  }
  var summary: Swift.String {
    get {}
  }
  var quickLookObject: Swift.PlaygroundQuickLook? {
    get {}
  }
  var disposition: Swift._MirrorDisposition {
    get {}
  }
  init(data: Swift._MagicMirrorData)
}
func sequence<T>(first: T, next: @escaping (T) -> T?) -> Swift.UnfoldSequence<T, (T?, Swift.Bool)>
func sequence<T, State>(state: State, next: @escaping (inout State) -> T?) -> Swift.UnfoldSequence<T, State>
func _isspace_clocale(_ u: Swift.UTF16.CodeUnit) -> Swift.Bool
@available(*, unavailable, renamed: "MemoryLayout.alignment(ofValue:)") func alignofValue<T>(_: T) -> Swift.Int
@inline(never) func _forceCreateUniqueMutableBuffer<_Buffer : _ArrayBufferProtocol>(_ source: inout _Buffer, newCount: Swift.Int, requiredCapacity: Swift.Int) -> Swift._ContiguousArrayBuffer<_Buffer.Element>
@inline(never) func _forceCreateUniqueMutableBuffer<_Buffer : _ArrayBufferProtocol>(_ source: inout _Buffer, countForNewBuffer: Swift.Int, minNewCapacity: Swift.Int) -> Swift._ContiguousArrayBuffer<_Buffer.Element>
protocol TextOutputStream {
  mutating func _lock()
  mutating func _unlock()
  mutating func write(_ string: Swift.String)
}
extension TextOutputStream {
  mutating func _lock()
  mutating func _unlock()
}
func _stdlib_NSSet_allObjects(_ nss: _NSSet) -> Swift._HeapBuffer<Swift.Int, AnyObject>
()
func _stdlib_didEnterMain(argc: Swift.Int32, argv: Swift.UnsafeMutablePointer<Swift.UnsafeMutablePointer<Swift.Int8>?>)
@_silgen_name("_swift_bridgeAnythingNonVerbatimToObjectiveC") func _bridgeAnythingNonVerbatimToObjectiveC<T>(_ x: T) -> AnyObject
protocol _AnyCollectionProtocol : Collection {
  var _boxID: Swift.ObjectIdentifier { get }
}
extension _AnyCollectionProtocol {
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.AnyIterator<Self.Iterator.Element>
}
var _emptyStringStorage: Swift.UInt32
func swap<T>(_ a: inout T, _ b: inout T)
struct UnsafeBufferPointer<Element> : Indexable, Collection, RandomAccessCollection {
  typealias Index = Swift.Int
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift.UnsafeBufferPointer<Element>>
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  func index(after i: Swift.Int) -> Swift.Int
  func formIndex(after i: inout Swift.Int)
  func index(before i: Swift.Int) -> Swift.Int
  func formIndex(before i: inout Swift.Int)
  func index(_ i: Swift.Int, offsetBy n: Swift.Int) -> Swift.Int
  func index(_ i: Swift.Int, offsetBy n: Swift.Int, limitedBy limit: Swift.Int) -> Swift.Int?
  func distance(from start: Swift.Int, to end: Swift.Int) -> Swift.Int
  func _failEarlyRangeCheck(_ index: Swift.Int, bounds: Swift.Range<Swift.Int>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Swift.Int>, bounds: Swift.Range<Swift.Int>)
  typealias Indices = Swift.CountableRange<Swift.Int>
  var indices: Swift.UnsafeBufferPointer.Indices {
    get {}
  }
  subscript(i: Swift.Int) -> Element {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift.RandomAccessSlice<Swift.UnsafeBufferPointer<Element>> {
    get {}
  }
  init(start: Swift.UnsafePointer<Element>?, count: Swift.Int)
  func makeIterator() -> Swift.UnsafeBufferPointerIterator<Element>
  var baseAddress: Swift.UnsafePointer<Element>? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  let _position: Swift.UnsafePointer<Element>?, _end: Swift.UnsafePointer<Element>?
  typealias _Element = Element
  typealias SubSequence = Swift.RandomAccessSlice<Swift.UnsafeBufferPointer<Element>>
}
extension UnsafeBufferPointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
@available(*, unavailable, message: "Bit enum has been removed. Please use Int instead.") enum Bit {
}
struct CollectionOfOne<Element> : MutableCollection, RandomAccessCollection {
  init(_ element: Element)
  typealias Index = Swift.Int
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  func index(after i: Swift.Int) -> Swift.Int
  func index(before i: Swift.Int) -> Swift.Int
  typealias Indices = Swift.CountableRange<Swift.Int>
  func makeIterator() -> Swift.IteratorOverOne<Element>
  subscript(position: Swift.Int) -> Element {
    get {}
    set(newValue) {}
  }
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift.MutableRandomAccessSlice<Swift.CollectionOfOne<Element>> {
    get {}
    set(newValue) {}
  }
  var count: Swift.Int {
    get {}
  }
  var _element: Element
  typealias IndexDistance = Swift.Int
  typealias _Element = Element
  typealias SubSequence = Swift.MutableRandomAccessSlice<Swift.CollectionOfOne<Element>>
  typealias Iterator = Swift.IteratorOverOne<Element>
}
extension CollectionOfOne : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension CollectionOfOne : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
@_silgen_name("_swift_class_getSuperclass") func _swift_class_getSuperclass(_ t: Swift.AnyClass) -> Swift.AnyClass?
struct UnsafeMutableBufferPointer<Element> : MutableIndexable, MutableCollection, RandomAccessCollection {
  typealias Index = Swift.Int
  typealias IndexDistance = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift.UnsafeMutableBufferPointer<Element>>
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  func index(after i: Swift.Int) -> Swift.Int
  func formIndex(after i: inout Swift.Int)
  func index(before i: Swift.Int) -> Swift.Int
  func formIndex(before i: inout Swift.Int)
  func index(_ i: Swift.Int, offsetBy n: Swift.Int) -> Swift.Int
  func index(_ i: Swift.Int, offsetBy n: Swift.Int, limitedBy limit: Swift.Int) -> Swift.Int?
  func distance(from start: Swift.Int, to end: Swift.Int) -> Swift.Int
  func _failEarlyRangeCheck(_ index: Swift.Int, bounds: Swift.Range<Swift.Int>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Swift.Int>, bounds: Swift.Range<Swift.Int>)
  typealias Indices = Swift.CountableRange<Swift.Int>
  var indices: Swift.UnsafeMutableBufferPointer.Indices {
    get {}
  }
  subscript(i: Swift.Int) -> Element {
    get {}
    set(newValue) {}
  }
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift.MutableRandomAccessSlice<Swift.UnsafeMutableBufferPointer<Element>> {
    get {}
    set(newValue) {}
  }
  init(start: Swift.UnsafeMutablePointer<Element>?, count: Swift.Int)
  func makeIterator() -> Swift.UnsafeBufferPointerIterator<Element>
  var baseAddress: Swift.UnsafeMutablePointer<Element>? {
    get {}
  }
  var count: Swift.Int {
    get {}
  }
  let _position: Swift.UnsafeMutablePointer<Element>?, _end: Swift.UnsafeMutablePointer<Element>?
  typealias _Element = Element
  typealias SubSequence = Swift.MutableRandomAccessSlice<Swift.UnsafeMutableBufferPointer<Element>>
}
extension UnsafeMutableBufferPointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
@_versioned struct _CocoaSetIndex : Comparable {
  let cocoaSet: _NSSet
  var allKeys: Swift._HeapBuffer<Swift.Int, AnyObject>
  var currentKeyIndex: Swift.Int
  init(_ cocoaSet: _NSSet, startIndex: ())
  init(_ cocoaSet: _NSSet, endIndex: ())
  init(_ cocoaSet: _NSSet, _ allKeys: Swift._HeapBuffer<Swift.Int, AnyObject>, _ currentKeyIndex: Swift.Int)
  func successor() -> Swift._CocoaSetIndex
}
extension _CocoaSetIndex {
  static func ==(lhs: Swift._CocoaSetIndex, rhs: Swift._CocoaSetIndex) -> Swift.Bool
  static func <(lhs: Swift._CocoaSetIndex, rhs: Swift._CocoaSetIndex) -> Swift.Bool
}
protocol CustomLeafReflectable : CustomReflectable {
}
@_silgen_name("_swift_stdlib_reportFatalError") func _reportFatalError(_ prefix: Swift.UnsafePointer<Swift.UInt8>, _ prefixLength: Swift.UInt, _ message: Swift.UnsafePointer<Swift.UInt8>, _ messageLength: Swift.UInt, flags: Swift.UInt32)
@_versioned func _isUniqueOrPinned<T>(_ object: inout T) -> Swift.Bool
enum DictionaryIteratorRepresentation<Key : Hashable, Value> {
  typealias _Iterator = Swift.DictionaryIterator<Key, Value>
  typealias _NativeStorageOwner = Swift._NativeDictionaryStorageOwner<Key, Value>
  typealias _NativeIndex = Swift._NativeDictionaryIndex<Key, Value>
  case _native(start: Swift._NativeDictionaryIndex<Key, Value>, end: Swift._NativeDictionaryIndex<Key, Value>, owner: Swift._NativeDictionaryStorageOwner<Key, Value>)
  case _cocoa(Swift._CocoaDictionaryIterator)
}
var _fastEnumerationStorageMutationsTarget: Swift.CUnsignedLong
struct _MagicMirrorData {
  let owner: Builtin.NativeObject
  let ptr: Builtin.RawPointer
  let metadata: Any.Type
  var value: Any {
    @_silgen_name("swift_MagicMirrorData_value") get {}
  }
  var valueType: Any.Type {
    @_silgen_name("swift_MagicMirrorData_valueType") get {}
  }
  var objcValue: Any {
    @_silgen_name("swift_MagicMirrorData_objcValue") get {}
  }
  var objcValueType: Any.Type {
    @_silgen_name("swift_MagicMirrorData_objcValueType") get {}
  }
  var summary: Swift.String {
    get {}
  }
  func _loadValue<T>(ofType _: T.Type) -> T
  init(owner: Builtin.NativeObject, ptr: Builtin.RawPointer, metadata: Any.Type)
}
@inline(never) @_semantics("stdlib_binary_only") func _cocoaStringToSwiftString_NonASCII(_ source: Swift._CocoaString) -> Swift.String
protocol _ExpressibleByBuiltinFloatLiteral {
  init(_builtinFloatLiteral value: Swift._MaxBuiltinFloatType)
}
struct MutableSlice<Base : MutableIndexable> : Collection, MutableCollection {
  typealias Index = Base.Index
  typealias IndexDistance = Base.IndexDistance
  var _startIndex: Base.Index
  var _endIndex: Base.Index
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  subscript(index: Base.Index) -> Base._Element {
    get {}
    set(newValue) {}
  }
  typealias SubSequence = Swift.MutableSlice<Base>
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.MutableSlice<Base> {
    get {}
    set(newValue) {}
  }
  func index(after i: Base.Index) -> Base.Index
  func formIndex(after i: inout Base.Index)
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func _failEarlyRangeCheck(_ index: Base.Index, bounds: Swift.Range<Base.Index>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Base.Index>, bounds: Swift.Range<Base.Index>)
  init(base: Base, bounds: Swift.Range<Base.Index>)
  var _base: Base
  var base: Base {
    get {}
  }
  typealias _Element = Base._Element
  typealias Iterator = Swift.IndexingIterator<Swift.MutableSlice<Base>>
  typealias Indices = Swift.DefaultIndices<Swift.MutableSlice<Base>>
}
struct Zip2Sequence<Sequence1 : Sequence, Sequence2 : Sequence> : Sequence {
  typealias Stream1 = Sequence1.Iterator
  typealias Stream2 = Sequence2.Iterator
  typealias Iterator = Swift.Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator>
  @available(*, unavailable, renamed: "Iterator") typealias Generator = Swift.Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator>
  init(_sequence1 sequence1: Sequence1, _sequence2 sequence2: Sequence2)
  func makeIterator() -> Swift.Zip2Iterator<Sequence1.Iterator, Sequence2.Iterator>
  let _sequence1: Sequence1
  let _sequence2: Sequence2
  typealias SubSequence = Swift.AnySequence<(Sequence1.Iterator.Element, Sequence2.Iterator.Element)>
}
extension Zip2Sequence {
  @available(*, unavailable, message: "use zip(_:_:) free function instead") init(_ sequence1: Sequence1, _ sequence2: Sequence2)
}
struct LazyFilterSequence<Base : Sequence> : LazySequenceProtocol {
  func makeIterator() -> Swift.LazyFilterIterator<Base.Iterator>
  init(_base base: Base, _ isIncluded: @escaping (Base.Iterator.Element) -> Swift.Bool)
  let base: Base
  let _include: (Base.Iterator.Element) -> Swift.Bool
  typealias Elements = Swift.LazyFilterSequence<Base>
  typealias Iterator = Swift.LazyFilterIterator<Base.Iterator>
  typealias SubSequence = Swift.AnySequence<Base.Iterator.Element>
}
extension LazyFilterSequence {
  @available(*, unavailable, message: "use '.lazy.filter' on the sequence") init(_ base: Base, whereElementsSatisfy predicate: (Base.Iterator.Element) -> Swift.Bool)
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.LazyFilterIterator<Base.Iterator>
}
@available(*, deprecated, message: "it will be removed in Swift 4.0.  Please use 'RandomAccessCollection' instead") protocol RandomAccessIndexable : BidirectionalIndexable {
}
extension RandomAccessIndexable {
  func index(_ i: Self.Index, offsetBy n: Self.IndexDistance, limitedBy limit: Self.Index) -> Self.Index?
}
protocol _ExpressibleByBuiltinExtendedGraphemeClusterLiteral : _ExpressibleByBuiltinUnicodeScalarLiteral {
  init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
func _introSortImpl<C where C : MutableCollection & RandomAccessCollection>(_ elements: inout C, subRange range: Swift.Range<C.Index>, by areInIncreasingOrder: inout @escaping (C.Iterator.Element, C.Iterator.Element) -> Swift.Bool, depthLimit: Swift.Int)
func _introSortImpl<C where C : MutableCollection & RandomAccessCollection, C.Iterator.Element : Comparable>(_ elements: inout C, subRange range: Swift.Range<C.Index>, depthLimit: Swift.Int)
protocol ExpressibleByArrayLiteral {
  associatedtype Element
  init(arrayLiteral elements: Self.Element...)
}
@_silgen_name("swift_getSummary") func _getSummary<T>(_ out: Swift.UnsafeMutablePointer<Swift.String>, x: T)
func _swift_stdlib_atomicLoadUInt64(object target: Swift.UnsafeMutablePointer<Swift.UInt64>) -> Swift.UInt64
func _sanityCheck(_ condition: @autoclosure () -> Swift.Bool, _ message: Swift.StaticString = default, file: Swift.StaticString = #file, line: Swift.UInt = #line)
protocol FloatingPoint : Comparable, ExpressibleByIntegerLiteral, SignedNumber, AbsoluteValuable, Strideable {
  associatedtype Exponent : SignedInteger
  init(sign: Swift.FloatingPointSign, exponent: Self.Exponent, significand: Self)
  init(signOf: Self, magnitudeOf: Self)
  init(_ value: Swift.UInt8)
  init(_ value: Swift.Int8)
  init(_ value: Swift.UInt16)
  init(_ value: Swift.Int16)
  init(_ value: Swift.UInt32)
  init(_ value: Swift.Int32)
  init(_ value: Swift.UInt64)
  init(_ value: Swift.Int64)
  init(_ value: Swift.UInt)
  init(_ value: Swift.Int)
  static var radix: Swift.Int { get }
  static var nan: Self { get }
  static var signalingNaN: Self { get }
  static var infinity: Self { get }
  static var greatestFiniteMagnitude: Self { get }
  static var pi: Self { get }
  var ulp: Self { get }
  static var ulpOfOne: Self { get }
  static var leastNormalMagnitude: Self { get }
  static var leastNonzeroMagnitude: Self { get }
  var sign: Swift.FloatingPointSign { get }
  var exponent: Self.Exponent { get }
  var significand: Self { get }
  func adding(_ other: Self) -> Self
  mutating func add(_ other: Self)
  func negated() -> Self
  mutating func negate()
  func subtracting(_ other: Self) -> Self
  mutating func subtract(_ other: Self)
  func multiplied(by other: Self) -> Self
  mutating func multiply(by other: Self)
  func divided(by other: Self) -> Self
  mutating func divide(by other: Self)
  func remainder(dividingBy other: Self) -> Self
  mutating func formRemainder(dividingBy other: Self)
  func truncatingRemainder(dividingBy other: Self) -> Self
  mutating func formTruncatingRemainder(dividingBy other: Self)
  func squareRoot() -> Self
  mutating func formSquareRoot()
  func addingProduct(_ lhs: Self, _ rhs: Self) -> Self
  mutating func addProduct(_ lhs: Self, _ rhs: Self)
  static func minimum(_ x: Self, _ y: Self) -> Self
  static func maximum(_ x: Self, _ y: Self) -> Self
  static func minimumMagnitude(_ x: Self, _ y: Self) -> Self
  static func maximumMagnitude(_ x: Self, _ y: Self) -> Self
  func rounded(_ rule: Swift.FloatingPointRoundingRule) -> Self
  mutating func round(_ rule: Swift.FloatingPointRoundingRule)
  var nextUp: Self { get }
  var nextDown: Self { get }
  func isEqual(to other: Self) -> Swift.Bool
  func isLess(than other: Self) -> Swift.Bool
  func isLessThanOrEqualTo(_ other: Self) -> Swift.Bool
  func isTotallyOrdered(belowOrEqualTo other: Self) -> Swift.Bool
  var isNormal: Swift.Bool { get }
  var isFinite: Swift.Bool { get }
  var isZero: Swift.Bool { get }
  var isSubnormal: Swift.Bool { get }
  var isInfinite: Swift.Bool { get }
  var isNaN: Swift.Bool { get }
  var isSignalingNaN: Swift.Bool { get }
  var floatingPointClass: Swift.FloatingPointClassification { get }
  var isCanonical: Swift.Bool { get }
}
extension FloatingPoint {
  static var ulpOfOne: Self {
    get {}
  }
  func rounded(_ rule: Swift.FloatingPointRoundingRule) -> Self
  func rounded() -> Self
  mutating func round()
  var nextDown: Self {
    get {}
  }
  func truncatingRemainder(dividingBy other: Self) -> Self
  func remainder(dividingBy rhs: Self) -> Self
  func squareRoot() -> Self
  func addingProduct(_ lhs: Self, _ rhs: Self) -> Self
  static func minimum(_ x: Self, _ y: Self) -> Self
  static func maximum(_ x: Self, _ y: Self) -> Self
  static func minimumMagnitude(_ x: Self, _ y: Self) -> Self
  static func maximumMagnitude(_ x: Self, _ y: Self) -> Self
  var floatingPointClass: Swift.FloatingPointClassification {
    get {}
  }
  func adding(_ other: Self) -> Self
  func subtracting(_ other: Self) -> Self
  func multiplied(by other: Self) -> Self
  func divided(by other: Self) -> Self
  func negated() -> Self
}
func _isPOD<T>(_ type: T.Type) -> Swift.Bool
protocol BinaryFloatingPoint : FloatingPoint, ExpressibleByFloatLiteral {
  associatedtype RawSignificand : UnsignedInteger
  associatedtype RawExponent : UnsignedInteger
  init(sign: Swift.FloatingPointSign, exponentBitPattern: Self.RawExponent, significandBitPattern: Self.RawSignificand)
  init(_ value: Swift.Float)
  init(_ value: Swift.Double)
  init(_ value: Swift.Float80)
  static var exponentBitCount: Swift.Int { get }
  static var significandBitCount: Swift.Int { get }
  var exponentBitPattern: Self.RawExponent { get }
  var significandBitPattern: Self.RawSignificand { get }
  var binade: Self { get }
  var significandWidth: Swift.Int { get }
}
extension BinaryFloatingPoint {
  static var radix: Swift.Int {
    get {}
  }
  convenience init(signOf: Self, magnitudeOf: Self)
  func isTotallyOrdered(belowOrEqualTo other: Self) -> Swift.Bool
  @available(*, unavailable, renamed: "isSignalingNaN") var isSignaling: Swift.Bool {
    get {}
  }
}
protocol _ExpressibleByBuiltinBooleanLiteral {
  init(_builtinBooleanLiteral value: Builtin.Int1)
}
class ManagedBuffer<Header, Element> {
  final class func create(minimumCapacity: Swift.Int, makingHeaderWith factory: (Swift.ManagedBuffer<Header, Element>) throws -> Header) rethrows -> Swift.ManagedBuffer<Header, Element>
  @objc deinit
  final var capacity: Swift.Int {
    final get {}
  }
  final func withUnsafeMutablePointerToHeader<R>(_ body: (Swift.UnsafeMutablePointer<Header>) throws -> R) rethrows -> R
  final func withUnsafeMutablePointerToElements<R>(_ body: (Swift.UnsafeMutablePointer<Element>) throws -> R) rethrows -> R
  final func withUnsafeMutablePointers<R>(_ body: (Swift.UnsafeMutablePointer<Header>, Swift.UnsafeMutablePointer<Element>) throws -> R) rethrows -> R
  final var header: Header
  final var header: Header {
    addressWithNativeOwner {}
    mutableAddressWithNativeOwner {}
  }
  init(_doNotCallMe: ())
}
extension ManagedBuffer {
  @available(*, unavailable, renamed: "create(minimumCapacity:makingHeaderWith:)") final class func create(_ minimumCapacity: Swift.Int, initialValue: (Swift.ManagedBuffer<Header, Element>) -> Header) -> Swift.ManagedBuffer<Header, Element>
}
class _HeapBufferStorage<Value, Element> {
  init()
  typealias Buffer = Swift._HeapBuffer<Value, Element>
  @objc deinit
  final func __getInstanceSizeAndAlignMask() -> (Swift.Int, Swift.Int)
}
struct UInt16 : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int16
  init()
  init(_ _v: Builtin.Int16)
  init(_bits: Builtin.Int16)
  init(bigEndian value: Swift.UInt16)
  init(littleEndian value: Swift.UInt16)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt16)
  var bigEndian: Swift.UInt16 {
    get {}
  }
  var littleEndian: Swift.UInt16 {
    get {}
  }
  var byteSwapped: Swift.UInt16 {
    get {}
  }
  static var max: Swift.UInt16 {
    get {}
  }
  static var min: Swift.UInt16 {
    get {}
  }
  static var _sizeInBits: Swift.UInt16 {
    get {}
  }
  static var _sizeInBytes: Swift.UInt16 {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt16
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt16 : BitwiseOperations {
  static var allZeros: Swift.UInt16 {
    get {}
  }
}
extension UInt16 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt16 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt16 {
  static func addWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt16 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt16 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt16 {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt16 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to UInt16 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension UInt16 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
}
extension UInt16 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
  init(truncatingBitPattern: Swift.UInt32)
}
extension UInt16 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
  init(truncatingBitPattern: Swift.Int32)
}
extension UInt16 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension UInt16 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension UInt16 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension UInt16 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension UInt16 {
  init(bitPattern: Swift.Int16)
}
extension UInt16 {
  typealias _DisabledRangeIndex = Swift.UInt16
}
extension UInt16 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt16 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt16 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt16 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Swift.UTF16.CodeUnit : _StringElement {
  static func _toUTF16CodeUnit(_ x: Swift.UTF16.CodeUnit) -> Swift.UTF16.CodeUnit
  static func _fromUTF16CodeUnit(_ utf16: Swift.UTF16.CodeUnit) -> Swift.UTF16.CodeUnit
}
extension UInt16 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension UInt16 {
  init(_ value: CoreGraphics.CGFloat)
}
struct JoinedSequence<Base : Sequence where Base.Iterator.Element : Sequence> : Sequence {
  init<Separator : Sequence where Separator.Iterator.Element == Base.Iterator.Element.Iterator.Element>(base: Base, separator: Separator)
  func makeIterator() -> Swift.JoinedIterator<Base.Iterator>
  func _copyToContiguousArray() -> Swift.ContiguousArray<Base.Iterator.Element.Iterator.Element>
  var _base: Base
  var _separator: Swift.ContiguousArray<Base.Iterator.Element.Iterator.Element>
  typealias Iterator = Swift.JoinedIterator<Base.Iterator>
  typealias SubSequence = Swift.AnySequence<Base.Iterator.Element.Iterator.Element>
}
extension JoinedSequence {
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.JoinedIterator<Base.Iterator>
}
struct String {
  init()
  init(_ _core: Swift._StringCore)
  var _core: Swift._StringCore
}
extension String {
  init(_ c: Swift.Character)
}
extension String {
  init(cString: Swift.UnsafePointer<Swift.CChar>)
  init(cString: Swift.UnsafePointer<Swift.UInt8>)
  init?(validatingUTF8 cString: Swift.UnsafePointer<Swift.CChar>)
  static func decodeCString<Encoding : UnicodeCodec>(_ cString: Swift.UnsafePointer<Encoding.CodeUnit>?, as encoding: Encoding.Type, repairingInvalidCodeUnits isRepairing: Swift.Bool = default) -> (result: Swift.String, repairsMade: Swift.Bool)?
}
extension String {
  @available(*, unavailable, message: "Please use String.init?(validatingUTF8:) instead. Note that it no longer accepts NULL as a valid input. Also consider using String(cString:), that will attempt to repair ill-formed code units.") static func fromCString(_ cs: Swift.UnsafePointer<Swift.CChar>) -> Swift.String?
  @available(*, unavailable, message: "Please use String.init(cString:) instead. Note that it no longer accepts NULL as a valid input. See also String.decodeCString if you need more control.") static func fromCStringRepairingIllFormedUTF8(_ cs: Swift.UnsafePointer<Swift.CChar>) -> (Swift.String?, hadError: Swift.Bool)
}
extension String {
  func withCString<Result>(_ body: (Swift.UnsafePointer<Swift.Int8>) throws -> Result) rethrows -> Result
}
extension String : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension String : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension String : TextOutputStream {
  mutating func write(_ other: Swift.String)
}
extension String : TextOutputStreamable {
  func write<Target : TextOutputStream>(to target: inout Target)
}
extension String {
  struct CharacterView {
    var _core: Swift._StringCore
    init(_ text: Swift.String)
    init(_ _core: Swift._StringCore)
  }
  var characters: Swift.String.CharacterView {
    get {}
    set(newValue) {}
  }
  mutating func withMutableCharacters<R>(_ body: (inout Swift.String.CharacterView) -> R) -> R
  init(_ characters: Swift.String.CharacterView)
}
extension String {
  static func _fromWellFormedCodeUnitSequence<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> Swift.String
  static func _fromCodeUnitSequence<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> Swift.String?
  static func _fromCodeUnitSequenceWithRepair<Encoding, Input where Encoding : UnicodeCodec, Input : Collection, Input.Iterator.Element == Encoding.CodeUnit>(_ encoding: Encoding.Type, input: Input) -> (Swift.String, hadError: Swift.Bool)
}
extension String : _ExpressibleByBuiltinUnicodeScalarLiteral {
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
}
extension String : ExpressibleByUnicodeScalarLiteral {
  init(unicodeScalarLiteral value: Swift.String)
  typealias UnicodeScalarLiteralType = Swift.String
}
extension String : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral {
  @_semantics("string.makeUTF8") init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
extension String : ExpressibleByExtendedGraphemeClusterLiteral {
  init(extendedGraphemeClusterLiteral value: Swift.String)
  typealias ExtendedGraphemeClusterLiteralType = Swift.String
}
extension String : _ExpressibleByBuiltinUTF16StringLiteral {
  @_semantics("string.makeUTF16") init(_builtinUTF16StringLiteral start: Builtin.RawPointer, utf16CodeUnitCount: Builtin.Word)
}
extension String : _ExpressibleByBuiltinStringLiteral {
  @_semantics("string.makeUTF8") init(_builtinStringLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
}
extension String : ExpressibleByStringLiteral {
  init(stringLiteral value: Swift.String)
  typealias StringLiteralType = Swift.String
}
extension String : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension String {
  func _encodedLength<Encoding : UnicodeCodec>(_ encoding: Encoding.Type) -> Swift.Int
  func _encode<Encoding : UnicodeCodec>(_ encoding: Encoding.Type, into processCodeUnit: (Encoding.CodeUnit) -> Swift.Void)
}
extension String : Equatable {
  static func ==(lhs: Swift.String, rhs: Swift.String) -> Swift.Bool
}
extension String : Comparable {
  static func <(lhs: Swift.String, rhs: Swift.String) -> Swift.Bool
}
extension String {
  func _compareASCII(_ rhs: Swift.String) -> Swift.Int
  @inline(never) @_semantics("stdlib_binary_only") func _compareDeterministicUnicodeCollation(_ rhs: Swift.String) -> Swift.Int
  func _compareString(_ rhs: Swift.String) -> Swift.Int
}
extension String {
  mutating func append(_ other: Swift.String)
  @available(*, unavailable, message: "Replaced by append(_: String)") mutating func append(_ x: Swift.UnicodeScalar)
  init(_storage: Swift._StringBuffer)
}
extension String : Hashable {
  var hashValue: Swift.Int {
    get {}
  }
}
extension String {
  @_semantics("string.concat") static func +(lhs: Swift.String, rhs: Swift.String) -> Swift.String
  static func +=(lhs: inout Swift.String, rhs: Swift.String)
  @_silgen_name("swift_stringFromUTF8InRawMemory") static func _fromUTF8InRawMemory(_ resultStorage: Swift.UnsafeMutablePointer<Swift.String>, start: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>, utf8CodeUnitCount: Swift.Int)
}
extension String {
  var _asciiLowerCaseTable: Swift.UInt64 {
    @inline(__always) get {}
  }
  var _asciiUpperCaseTable: Swift.UInt64 {
    @inline(__always) get {}
  }
  func lowercased() -> Swift.String
  func uppercased() -> Swift.String
  init<T : LosslessStringConvertible>(_ value: T)
}
extension String : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension String : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension String {
  @available(*, unavailable, renamed: "append(_:)") mutating func appendContentsOf(_ other: Swift.String)
  @available(*, unavailable, renamed: "append(contentsOf:)") mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Character>(_ newElements: S)
  @available(*, unavailable, renamed: "insert(contentsOf:at:)") mutating func insertContentsOf<S : Collection where S.Iterator.Element == Character>(_ newElements: S, at i: Swift.String.Index)
  @available(*, unavailable, renamed: "replaceSubrange") mutating func replaceRange<C : Collection where C.Iterator.Element == Character>(_ subRange: Swift.Range<Swift.String.Index>, with newElements: C)
  @available(*, unavailable, renamed: "replaceSubrange") mutating func replaceRange(_ subRange: Swift.Range<Swift.String.Index>, with newElements: Swift.String)
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ i: Swift.String.Index) -> Swift.Character
  @available(*, unavailable, renamed: "removeSubrange") mutating func removeRange(_ subRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "lowercased()") var lowercaseString: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "uppercased()") var uppercaseString: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "init(describing:)") init<T>(_: T)
}
extension String {
  @inline(never) @_semantics("stdlib_binary_only") init(_cocoaString: AnyObject)
}
extension String {
  func _stdlib_binary_bridgeToObjectiveCImpl() -> AnyObject
  @inline(never) @_semantics("stdlib_binary_only") func _bridgeToObjectiveCImpl() -> AnyObject
}
extension String : ExpressibleByStringInterpolation {
  init(stringInterpolation strings: Swift.String...)
  init<T>(stringInterpolationSegment expr: T)
  init(stringInterpolationSegment expr: Swift.String)
  init(stringInterpolationSegment expr: Swift.Character)
  init(stringInterpolationSegment expr: Swift.UnicodeScalar)
  init(stringInterpolationSegment expr: Swift.Bool)
  init(stringInterpolationSegment expr: Swift.Float32)
  init(stringInterpolationSegment expr: Swift.Float64)
  init(stringInterpolationSegment expr: Swift.UInt8)
  init(stringInterpolationSegment expr: Swift.Int8)
  init(stringInterpolationSegment expr: Swift.UInt16)
  init(stringInterpolationSegment expr: Swift.Int16)
  init(stringInterpolationSegment expr: Swift.UInt32)
  init(stringInterpolationSegment expr: Swift.Int32)
  init(stringInterpolationSegment expr: Swift.UInt64)
  init(stringInterpolationSegment expr: Swift.Int64)
  init(stringInterpolationSegment expr: Swift.UInt)
  init(stringInterpolationSegment expr: Swift.Int)
}
extension String {
  @available(*, unavailable, message: "Replaced by init(repeating: String, count: Int)") init(repeating repeatedValue: Swift.Character, count: Swift.Int)
  @available(*, unavailable, message: "Replaced by init(repeating: String, count: Int)") init(repeating repeatedValue: Swift.UnicodeScalar, count: Swift.Int)
  init(repeating repeatedValue: Swift.String, count: Swift.Int)
  var _lines: [Swift.String] {
    get {}
  }
  func _split(separator: Swift.UnicodeScalar) -> [Swift.String]
  var isEmpty: Swift.Bool {
    get {}
  }
}
extension String {
  init(_ _c: Swift.UnicodeScalar)
}
extension String {
  func hasPrefix(_ prefix: Swift.String) -> Swift.Bool
  func hasSuffix(_ suffix: Swift.String) -> Swift.Bool
}
extension String {
  init<T : _SignedInteger>(_ v: T)
  init<T : UnsignedInteger>(_ v: T)
  init<T : _SignedInteger>(_ value: T, radix: Swift.Int, uppercase: Swift.Bool = default)
  init<T : UnsignedInteger>(_ value: T, radix: Swift.Int, uppercase: Swift.Bool = default)
}
extension String {
  func _splitFirst(separator delim: Swift.UnicodeScalar) -> (before: Swift.String, after: Swift.String, wasFound: Swift.Bool)
  func _splitFirstIf(_ predicate: (Swift.UnicodeScalar) -> Swift.Bool) -> (before: Swift.String, found: Swift.UnicodeScalar, after: Swift.String, wasFound: Swift.Bool)
}
extension String {
  @available(*, unavailable, message: "Renamed to init(repeating:count:) and reordered parameters") init(count: Swift.Int, repeatedValue c: Swift.Character)
  @available(*, unavailable, message: "Renamed to init(repeating:count:) and reordered parameters") init(count: Swift.Int, repeatedValue c: Swift.UnicodeScalar)
}
extension String {
  typealias Index = Swift.String.CharacterView.Index
  typealias IndexDistance = Swift.String.CharacterView.IndexDistance
  var startIndex: Swift.String.Index {
    get {}
  }
  var endIndex: Swift.String.Index {
    get {}
  }
  func index(after i: Swift.String.Index) -> Swift.String.Index
  func index(before i: Swift.String.Index) -> Swift.String.Index
  func index(_ i: Swift.String.Index, offsetBy n: Swift.String.IndexDistance) -> Swift.String.Index
  func index(_ i: Swift.String.Index, offsetBy n: Swift.String.IndexDistance, limitedBy limit: Swift.String.Index) -> Swift.String.Index?
  func distance(from start: Swift.String.Index, to end: Swift.String.Index) -> Swift.String.IndexDistance
  subscript(i: Swift.String.Index) -> Swift.Character {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.String.Index>) -> Swift.String {
    get {}
  }
  subscript(bounds: Swift.ClosedRange<Swift.String.Index>) -> Swift.String {
    get {}
  }
}
extension String {
  init<S : Sequence where S.Iterator.Element == Character>(_ characters: S)
  mutating func reserveCapacity(_ n: Swift.Int)
  mutating func append(_ c: Swift.Character)
  mutating func append<S : Sequence where S.Iterator.Element == Character>(contentsOf newElements: S)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Swift.Range<Swift.String.Index>, with newElements: C)
  mutating func replaceSubrange(_ bounds: Swift.Range<Swift.String.Index>, with newElements: Swift.String)
  mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == Character>(_ bounds: Swift.ClosedRange<Swift.String.Index>, with newElements: C)
  mutating func replaceSubrange(_ bounds: Swift.ClosedRange<Swift.String.Index>, with newElements: Swift.String)
  mutating func insert(_ newElement: Swift.Character, at i: Swift.String.Index)
  mutating func insert<S : Collection where S.Iterator.Element == Character>(contentsOf newElements: S, at i: Swift.String.Index)
  @discardableResult mutating func remove(at i: Swift.String.Index) -> Swift.Character
  mutating func removeSubrange(_ bounds: Swift.Range<Swift.String.Index>)
  mutating func removeSubrange(_ bounds: Swift.ClosedRange<Swift.String.Index>)
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
}
extension String {
  struct UnicodeScalarView : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
    init(_ _core: Swift._StringCore)
    struct _ScratchIterator : IteratorProtocol {
      var core: Swift._StringCore
      var idx: Swift.Int
      @_versioned init(_ core: Swift._StringCore, _ pos: Swift.Int)
      @inline(__always) mutating func next() -> Swift.UTF16.CodeUnit?
      typealias Element = Swift.UTF16.CodeUnit
    }
    struct Index {
      init(_position: Swift.Int)
      @_versioned var _position: Swift.Int
    }
    var startIndex: Swift.String.UnicodeScalarView.Index {
      get {}
    }
    var endIndex: Swift.String.UnicodeScalarView.Index {
      get {}
    }
    func index(after i: Swift.String.UnicodeScalarView.Index) -> Swift.String.UnicodeScalarView.Index
    func index(before i: Swift.String.UnicodeScalarView.Index) -> Swift.String.UnicodeScalarView.Index
    subscript(position: Swift.String.UnicodeScalarView.Index) -> Swift.UnicodeScalar {
      get {}
    }
    subscript(r: Swift.Range<Swift.String.UnicodeScalarView.Index>) -> Swift.String.UnicodeScalarView {
      get {}
    }
    struct Iterator : IteratorProtocol {
      init(_ _base: Swift._StringCore)
      mutating func next() -> Swift.UnicodeScalar?
      var _decoder: Swift.UTF16
      let _baseSet: Swift.Bool
      let _ascii: Swift.Bool
      var _asciiBase: Swift.UnsafeBufferPointerIterator<Swift.UInt8>!
      var _base: Swift.UnsafeBufferPointerIterator<Swift.UInt16>!
      var _iterator: Swift.IndexingIterator<Swift._StringCore>!
      typealias Element = Swift.UnicodeScalar
    }
    func makeIterator() -> Swift.String.UnicodeScalarView.Iterator
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    var _core: Swift._StringCore
    typealias _Element = Swift.UnicodeScalar
    typealias SubSequence = Swift.String.UnicodeScalarView
    typealias IndexDistance = Swift.Int
    typealias Indices = Swift.DefaultBidirectionalIndices<Swift.String.UnicodeScalarView>
  }
  init(_ unicodeScalars: Swift.String.UnicodeScalarView)
  typealias UnicodeScalarIndex = Swift.String.UnicodeScalarView.Index
}
extension String {
  var unicodeScalars: Swift.String.UnicodeScalarView {
    get {}
    set(newValue) {}
  }
}
extension String {
  struct UTF16View : BidirectionalCollection, CustomStringConvertible, CustomDebugStringConvertible {
    struct Index {
      init(_offset: Swift.Int)
      let _offset: Swift.Int
    }
    typealias IndexDistance = Swift.Int
    var startIndex: Swift.String.UTF16View.Index {
      get {}
    }
    var endIndex: Swift.String.UTF16View.Index {
      get {}
    }
    struct Indices {
      var _elements: Swift.String.UTF16View
      var _startIndex: Swift.String.UTF16View.Indices.Index
      var _endIndex: Swift.String.UTF16View.Indices.Index
      init(_elements: Swift.String.UTF16View, _startIndex: Swift.String.UTF16View.Indices.Index, _endIndex: Swift.String.UTF16View.Indices.Index)
    }
    var indices: Swift.String.UTF16View.Indices {
      get {}
    }
    func index(after i: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index
    func index(before i: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index
    func index(_ i: Swift.String.UTF16View.Index, offsetBy n: Swift.String.UTF16View.IndexDistance) -> Swift.String.UTF16View.Index
    func index(_ i: Swift.String.UTF16View.Index, offsetBy n: Swift.String.UTF16View.IndexDistance, limitedBy limit: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.Index?
    func distance(from start: Swift.String.UTF16View.Index, to end: Swift.String.UTF16View.Index) -> Swift.String.UTF16View.IndexDistance
    func _internalIndex(at i: Swift.Int) -> Swift.Int
    subscript(i: Swift.String.UTF16View.Index) -> Swift.UTF16.CodeUnit {
      get {}
    }
    @available(*, unavailable, message: "Indexing a String's UTF16View requires a String.UTF16View.Index, which can be constructed from Int when Foundation is imported") subscript(i: Swift.Int) -> Swift.UTF16.CodeUnit {
      get {}
    }
    @available(*, unavailable, message: "Slicing a String's UTF16View requires a Range<String.UTF16View.Index>, String.UTF16View.Index can be constructed from Int when Foundation is imported") subscript(bounds: Swift.Range<Swift.Int>) -> Swift.String.UTF16View {
      get {}
    }
    subscript(bounds: Swift.Range<Swift.String.UTF16View.Index>) -> Swift.String.UTF16View {
      get {}
    }
    init(_ _core: Swift._StringCore)
    init(_ _core: Swift._StringCore, offset: Swift.Int, length: Swift.Int)
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    var _offset: Swift.Int
    var _length: Swift.Int
    let _core: Swift._StringCore
    typealias _Element = Swift.UTF16.CodeUnit
    typealias SubSequence = Swift.String.UTF16View
    typealias Iterator = Swift.IndexingIterator<Swift.String.UTF16View>
  }
  var utf16: Swift.String.UTF16View {
    get {}
    set(newValue) {}
  }
  init?(_ utf16: Swift.String.UTF16View)
  typealias UTF16Index = Swift.String.UTF16View.Index
}
extension String {
  struct UTF8View : Collection, CustomStringConvertible, CustomDebugStringConvertible {
    let _core: Swift._StringCore
    let _startIndex: Swift.String.UTF8View.Index
    let _endIndex: Swift.String.UTF8View.Index
    init(_ _core: Swift._StringCore)
    init(_ _core: Swift._StringCore, _ s: Swift.String.UTF8View.Index, _ e: Swift.String.UTF8View.Index)
    struct Index {
      typealias Buffer = Swift._StringCore._UTF8Chunk
      init(_coreIndex: Swift.Int, _ _buffer: Swift.String.UTF8View.Index.Buffer)
      func _isOnUnicodeScalarBoundary(in core: Swift._StringCore) -> Swift.Bool
      func _isEndIndex(of core: Swift._StringCore) -> Swift.Bool
      var _utf8ContinuationBytesUntilNextUnicodeScalar: Swift.Int {
        get {}
      }
      static var _emptyBuffer: Swift.String.UTF8View.Index.Buffer {
        get {}
      }
      static var _bufferHiByte: Swift.String.UTF8View.Index.Buffer {
        get {}
      }
      static func _nextBuffer(after thisBuffer: Swift.String.UTF8View.Index.Buffer) -> Swift.String.UTF8View.Index.Buffer
      let _coreIndex: Swift.Int
      let _buffer: Swift.String.UTF8View.Index.Buffer
    }
    typealias IndexDistance = Swift.Int
    var startIndex: Swift.String.UTF8View.Index {
      get {}
    }
    var endIndex: Swift.String.UTF8View.Index {
      get {}
    }
    func index(after i: Swift.String.UTF8View.Index) -> Swift.String.UTF8View.Index
    subscript(position: Swift.String.UTF8View.Index) -> Swift.UTF8.CodeUnit {
      get {}
    }
    subscript(bounds: Swift.Range<Swift.String.UTF8View.Index>) -> Swift.String.UTF8View {
      get {}
    }
    var description: Swift.String {
      get {}
    }
    var debugDescription: Swift.String {
      get {}
    }
    typealias _Element = Swift.UTF8.CodeUnit
    typealias SubSequence = Swift.String.UTF8View
    typealias Iterator = Swift.IndexingIterator<Swift.String.UTF8View>
    typealias Indices = Swift.DefaultIndices<Swift.String.UTF8View>
  }
  var utf8: Swift.String.UTF8View {
    get {}
    set(newValue) {}
  }
  var _contiguousUTF8: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>? {
    get {}
  }
  var utf8CString: Swift.ContiguousArray<Swift.CChar> {
    get {}
  }
  func _withUnsafeBufferPointerToUTF8<R>(_ body: (Swift.UnsafeBufferPointer<Swift.UTF8.CodeUnit>) throws -> R) rethrows -> R
  init?(_ utf8: Swift.String.UTF8View)
  typealias UTF8Index = Swift.String.UTF8View.Index
}
extension String {
  @available(*, unavailable, message: "Please use String.utf8CString instead.") var nulTerminatedUTF8: Swift.ContiguousArray<Swift.UTF8.CodeUnit> {
    get {}
  }
}
extension String {
  @available(*, unavailable, message: "cannot subscript String with an Int, see the documentation comment for discussion") subscript(i: Swift.Int) -> Swift.Character {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a Range<Int>, see the documentation comment for discussion") subscript(bounds: Swift.Range<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a ClosedRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.ClosedRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a CountableRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.CountableRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "cannot subscript String with a CountableClosedRange<Int>, see the documentation comment for discussion") subscript(bounds: Swift.CountableClosedRange<Swift.Int>) -> Swift.String {
    get {}
  }
  @available(*, unavailable, message: "there is no universally good answer, see the documentation comment for discussion") var count: Swift.Int {
    get {}
  }
}
extension String : MirrorPath {
}
extension String {
  init<Subject>(describing instance: Subject)
  init<Subject>(reflecting subject: Subject)
}
extension String {
  init(_sel: ObjectiveC.Selector)
}
extension String {
  init(_ cocoaString: Foundation.NSString)
}
extension String : _ObjectiveCBridgeable {
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSString
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSString, result: inout Swift.String?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSString, result: inout Swift.String?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSString?) -> Swift.String
  typealias _ObjectiveCType = Foundation.NSString
}
extension String : CVarArg {
}
extension String {
  var _ns: Foundation.NSString {
    get {}
  }
  func _index(_ utf16Index: Swift.Int) -> Swift.String.Index
  func _range(_ r: Foundation.NSRange) -> Swift.Range<Swift.String.Index>
  func _optionalRange(_ r: Foundation.NSRange) -> Swift.Range<Swift.String.Index>?
  func _withOptionalOutParameter<Result>(_ index: Swift.UnsafeMutablePointer<Swift.String.Index>?, _ body: (Swift.UnsafeMutablePointer<Swift.Int>?) -> Result) -> Result
  func _withOptionalOutParameter<Result>(_ range: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>?, _ body: (Swift.UnsafeMutablePointer<Foundation.NSRange>?) -> Result) -> Result
  static var availableStringEncodings: [Swift.String.Encoding] {
    get {}
  }
  static var defaultCStringEncoding: Swift.String.Encoding {
    get {}
  }
  static func localizedName(of encoding: Swift.String.Encoding) -> Swift.String
  static func localizedStringWithFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, message: "Use fileURL(withPathComponents:) on URL instead.") static func path(withComponents components: [Swift.String]) -> Swift.String
  init?(utf8String bytes: Swift.UnsafePointer<Swift.CChar>)
  func canBeConverted(to encoding: Swift.String.Encoding) -> Swift.Bool
  var capitalized: Swift.String {
    get {}
  }
  @available(OSX 10.11, iOS 9.0, *)
  var localizedCapitalized: Swift.String {
    get {}
  }
  func capitalized(with locale: Foundation.Locale?) -> Swift.String
  func caseInsensitiveCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func commonPrefix(with aString: Swift.String, options: Swift.String.CompareOptions = default) -> Swift.String
  func compare(_ aString: Swift.String, options mask: Swift.String.CompareOptions = default, range: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Foundation.ComparisonResult
  func completePath(into outputName: Swift.UnsafeMutablePointer<Swift.String>? = default, caseSensitive: Swift.Bool, matchesInto outputArray: Swift.UnsafeMutablePointer<[Swift.String]>? = default, filterTypes: [Swift.String]? = default) -> Swift.Int
  func components(separatedBy separator: Foundation.CharacterSet) -> [Swift.String]
  func components(separatedBy separator: Swift.String) -> [Swift.String]
  func cString(using encoding: Swift.String.Encoding) -> [Swift.CChar]?
  func data(using encoding: Swift.String.Encoding, allowLossyConversion: Swift.Bool = default) -> Foundation.Data?
  var decomposedStringWithCanonicalMapping: Swift.String {
    get {}
  }
  var decomposedStringWithCompatibilityMapping: Swift.String {
    get {}
  }
  func enumerateLines(invoking body: @escaping (Swift.String, inout Swift.Bool) -> ())
  func enumerateLinguisticTags(in range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, invoking body: (Swift.String, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  func enumerateSubstrings(in range: Swift.Range<Swift.String.Index>, options opts: Swift.String.EnumerationOptions = default, _ body: @escaping (Swift.String?, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  var fastestEncoding: Swift.String.Encoding {
    get {}
  }
  @available(*, unavailable, message: "Use getFileSystemRepresentation on URL instead.") var fileSystemRepresentation: [Swift.CChar] {
    get {}
  }
  func getBytes(_ buffer: inout [Swift.UInt8], maxLength maxBufferCount: Swift.Int, usedLength usedBufferCount: Swift.UnsafeMutablePointer<Swift.Int>, encoding: Swift.String.Encoding, options: Swift.String.EncodingConversionOptions = default, range: Swift.Range<Swift.String.Index>, remaining leftover: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>) -> Swift.Bool
  func getCString(_ buffer: inout [Swift.CChar], maxLength: Swift.Int, encoding: Swift.String.Encoding) -> Swift.Bool
  @available(*, unavailable, message: "Use getFileSystemRepresentation on URL instead.") func getFileSystemRepresentation(_ buffer: inout [Swift.CChar], maxLength: Swift.Int) -> Swift.Bool
  func getLineStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, for range: Swift.Range<Swift.String.Index>)
  func getParagraphStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, for range: Swift.Range<Swift.String.Index>)
  var hash: Swift.Int {
    get {}
  }
  init?<S : Sequence where S.Iterator.Element == UInt8>(bytes: S, encoding: Swift.String.Encoding)
  init?(bytesNoCopy bytes: Swift.UnsafeMutableRawPointer, length: Swift.Int, encoding: Swift.String.Encoding, freeWhenDone flag: Swift.Bool)
  init(utf16CodeUnits: Swift.UnsafePointer<Foundation.unichar>, count: Swift.Int)
  init(utf16CodeUnitsNoCopy: Swift.UnsafePointer<Foundation.unichar>, count: Swift.Int, freeWhenDone flag: Swift.Bool)
  init(contentsOfFile path: Swift.String, encoding enc: Swift.String.Encoding) throws
  init(contentsOfFile path: Swift.String, usedEncoding: inout Swift.String.Encoding) throws
  init(contentsOfFile path: Swift.String) throws
  init(contentsOf url: Foundation.URL, encoding enc: Swift.String.Encoding) throws
  init(contentsOf url: Foundation.URL, usedEncoding: inout Swift.String.Encoding) throws
  init(contentsOf url: Foundation.URL) throws
  init?(cString: Swift.UnsafePointer<Swift.CChar>, encoding enc: Swift.String.Encoding)
  init?(data: Foundation.Data, encoding: Swift.String.Encoding)
  init(format: Swift.String, _ arguments: CVarArg...)
  init(format: Swift.String, arguments: [CVarArg])
  init(format: Swift.String, locale: Foundation.Locale?, _ args: CVarArg...)
  init(format: Swift.String, locale: Foundation.Locale?, arguments: [CVarArg])
  @available(*, unavailable, message: "Use lastPathComponent on URL instead.") var lastPathComponent: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Take the count of a UTF-16 view instead, i.e. str.utf16.count") var utf16Count: Swift.Int {
    get {}
  }
  func lengthOfBytes(using encoding: Swift.String.Encoding) -> Swift.Int
  func lineRange(for aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  func linguisticTags(in range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, tokenRanges: Swift.UnsafeMutablePointer<[Swift.Range<Swift.String.Index>]>? = default) -> [Swift.String]
  func localizedCaseInsensitiveCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func localizedCompare(_ aString: Swift.String) -> Foundation.ComparisonResult
  func localizedStandardCompare(_ string: Swift.String) -> Foundation.ComparisonResult
  @available(OSX 10.11, iOS 9.0, *)
  var localizedLowercase: Swift.String {
    get {}
  }
  func lowercased(with locale: Foundation.Locale?) -> Swift.String
  func maximumLengthOfBytes(using encoding: Swift.String.Encoding) -> Swift.Int
  func paragraphRange(for aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, message: "Use pathComponents on URL instead.") var pathComponents: [Swift.String] {
    get {}
  }
  @available(*, unavailable, message: "Use pathExtension on URL instead.") var pathExtension: Swift.String {
    get {}
  }
  var precomposedStringWithCanonicalMapping: Swift.String {
    get {}
  }
  var precomposedStringWithCompatibilityMapping: Swift.String {
    get {}
  }
  func propertyList() -> Any
  func propertyListFromStringsFileFormat() -> [Swift.String : Swift.String]
  func rangeOfCharacter(from aSet: Foundation.CharacterSet, options mask: Swift.String.CompareOptions = default, range aRange: Swift.Range<Swift.String.Index>? = default) -> Swift.Range<Swift.String.Index>?
  func rangeOfComposedCharacterSequence(at anIndex: Swift.String.Index) -> Swift.Range<Swift.String.Index>
  func rangeOfComposedCharacterSequences(for range: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  func range(of aString: Swift.String, options mask: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Swift.Range<Swift.String.Index>?
  @available(OSX 10.11, iOS 9.0, *)
  func localizedStandardContains(_ string: Swift.String) -> Swift.Bool
  @available(OSX 10.11, iOS 9.0, *)
  func localizedStandardRange(of string: Swift.String) -> Swift.Range<Swift.String.Index>?
  var smallestEncoding: Swift.String.Encoding {
    get {}
  }
  @available(*, unavailable, message: "Use abbreviatingWithTildeInPath on NSString instead.") var abbreviatingWithTildeInPath: Swift.String {
    get {}
  }
  func addingPercentEncoding(withAllowedCharacters allowedCharacters: Foundation.CharacterSet) -> Swift.String?
  @available(*, deprecated, message: "Use addingPercentEncoding(withAllowedCharacters:) instead, which always uses the recommended UTF-8 encoding, and which encodes for a specific URL component or subcomponent since each URL component or subcomponent has different rules for what characters are valid.") func addingPercentEscapes(using encoding: Swift.String.Encoding) -> Swift.String?
  func appendingFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, message: "Use appendingPathComponent on URL instead.") func appendingPathComponent(_ aString: Swift.String) -> Swift.String
  @available(*, unavailable, message: "Use appendingPathExtension on URL instead.") func appendingPathExtension(_ ext: Swift.String) -> Swift.String?
  func appending(_ aString: Swift.String) -> Swift.String
  @available(*, unavailable, message: "Use deletingLastPathComponent on URL instead.") var deletingLastPathComponent: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use deletingPathExtension on URL instead.") var deletingPathExtension: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use expandingTildeInPath on NSString instead.") var expandingTildeInPath: Swift.String {
    get {}
  }
  @available(*, unavailable, renamed: "folding(options:locale:)") func folding(_ options: Swift.String.CompareOptions = default, locale: Foundation.Locale?) -> Swift.String
  func folding(options: Swift.String.CompareOptions = default, locale: Foundation.Locale?) -> Swift.String
  func padding(toLength newLength: Swift.Int, withPad padString: Swift.String, startingAt padIndex: Swift.Int) -> Swift.String
  var removingPercentEncoding: Swift.String? {
    get {}
  }
  func replacingCharacters(in range: Swift.Range<Swift.String.Index>, with replacement: Swift.String) -> Swift.String
  func replacingOccurrences(of target: Swift.String, with replacement: Swift.String, options: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default) -> Swift.String
  @available(*, deprecated, message: "Use removingPercentEncoding instead, which always uses the recommended UTF-8 encoding.") func replacingPercentEscapes(using encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, message: "Use resolvingSymlinksInPath on URL instead.") var resolvingSymlinksInPath: Swift.String {
    get {}
  }
  @available(*, unavailable, message: "Use standardizingPath on URL instead.") var standardizingPath: Swift.String {
    get {}
  }
  func trimmingCharacters(in set: Foundation.CharacterSet) -> Swift.String
  @available(*, unavailable, message: "Map over paths with appendingPathComponent instead.") func strings(byAppendingPaths paths: [Swift.String]) -> [Swift.String]
  func substring(from index: Swift.String.Index) -> Swift.String
  func substring(to index: Swift.String.Index) -> Swift.String
  func substring(with aRange: Swift.Range<Swift.String.Index>) -> Swift.String
  @available(OSX 10.11, iOS 9.0, *)
  var localizedUppercase: Swift.String {
    get {}
  }
  func uppercased(with locale: Foundation.Locale?) -> Swift.String
  func write(toFile path: Swift.String, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  func write(to url: Foundation.URL, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  @available(OSX 10.11, iOS 9.0, *)
  func applyingTransform(_ transform: Foundation.StringTransform, reverse: Swift.Bool) -> Swift.String?
  func contains(_ other: Swift.String) -> Swift.Bool
  func localizedCaseInsensitiveContains(_ other: Swift.String) -> Swift.Bool
}
extension String {
  @available(*, unavailable, renamed: "localizedName(of:)") static func localizedNameOfStringEncoding(_ encoding: Swift.String.Encoding) -> Swift.String
  @available(*, unavailable, message: "Use fileURL(withPathComponents:) on URL instead.") static func pathWithComponents(_ components: [Swift.String]) -> Swift.String
  @available(*, unavailable, renamed: "canBeConverted(to:)") func canBeConvertedToEncoding(_ encoding: Swift.String.Encoding) -> Swift.Bool
  @available(*, unavailable, renamed: "capitalizedString(with:)") func capitalizedStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "commonPrefix(with:options:)") func commonPrefixWith(_ aString: Swift.String, options: Swift.String.CompareOptions) -> Swift.String
  @available(*, unavailable, renamed: "completePath(into:outputName:caseSensitive:matchesInto:filterTypes:)") func completePathInto(_ outputName: Swift.UnsafeMutablePointer<Swift.String>? = default, caseSensitive: Swift.Bool, matchesInto matchesIntoArray: Swift.UnsafeMutablePointer<[Swift.String]>? = default, filterTypes: [Swift.String]? = default) -> Swift.Int
  @available(*, unavailable, renamed: "components(separatedBy:)") func componentsSeparatedByCharactersIn(_ separator: Foundation.CharacterSet) -> [Swift.String]
  @available(*, unavailable, renamed: "componentsSeparated(by:)") func componentsSeparatedBy(_ separator: Swift.String) -> [Swift.String]
  @available(*, unavailable, renamed: "cString(usingEncoding:)") func cStringUsingEncoding(_ encoding: Swift.String.Encoding) -> [Swift.CChar]?
  @available(*, unavailable, renamed: "data(usingEncoding:allowLossyConversion:)") func dataUsingEncoding(_ encoding: Swift.String.Encoding, allowLossyConversion: Swift.Bool = default) -> Foundation.Data?
  @available(*, unavailable, renamed: "enumerateLinguisticTags(in:scheme:options:orthography:_:)") func enumerateLinguisticTagsIn(_ range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options, orthography: Foundation.NSOrthography?, _ body: (Swift.String, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  @available(*, unavailable, renamed: "enumerateSubstrings(in:options:_:)") func enumerateSubstringsIn(_ range: Swift.Range<Swift.String.Index>, options opts: Swift.String.EnumerationOptions = default, _ body: (Swift.String?, Swift.Range<Swift.String.Index>, Swift.Range<Swift.String.Index>, inout Swift.Bool) -> ())
  @available(*, unavailable, renamed: "getBytes(_:maxLength:usedLength:encoding:options:range:remaining:)") func getBytes(_ buffer: inout [Swift.UInt8], maxLength maxBufferCount: Swift.Int, usedLength usedBufferCount: Swift.UnsafeMutablePointer<Swift.Int>, encoding: Swift.String.Encoding, options: Swift.String.EncodingConversionOptions = default, range: Swift.Range<Swift.String.Index>, remainingRange leftover: Swift.UnsafeMutablePointer<Swift.Range<Swift.String.Index>>) -> Swift.Bool
  @available(*, unavailable, renamed: "getLineStart(_:end:contentsEnd:for:)") func getLineStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, forRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "getParagraphStart(_:end:contentsEnd:for:)") func getParagraphStart(_ start: Swift.UnsafeMutablePointer<Swift.String.Index>, end: Swift.UnsafeMutablePointer<Swift.String.Index>, contentsEnd: Swift.UnsafeMutablePointer<Swift.String.Index>, forRange: Swift.Range<Swift.String.Index>)
  @available(*, unavailable, renamed: "lengthOfBytes(using:)") func lengthOfBytesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.Int
  @available(*, unavailable, renamed: "lineRange(for:)") func lineRangeFor(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "linguisticTags(in:scheme:options:orthography:tokenRanges:)") func linguisticTagsIn(_ range: Swift.Range<Swift.String.Index>, scheme tagScheme: Swift.String, options opts: Foundation.NSLinguisticTagger.Options = default, orthography: Foundation.NSOrthography? = default, tokenRanges: Swift.UnsafeMutablePointer<[Swift.Range<Swift.String.Index>]>? = default) -> [Swift.String]
  @available(*, unavailable, renamed: "lowercased(with:)") func lowercaseStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "maximumLengthOfBytes(using:)") func maximumLengthOfBytesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.Int
  @available(*, unavailable, renamed: "paragraphRange(for:)") func paragraphRangeFor(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "rangeOfCharacter(from:options:range:)") func rangeOfCharacterFrom(_ aSet: Foundation.CharacterSet, options mask: Swift.String.CompareOptions = default, range aRange: Swift.Range<Swift.String.Index>? = default) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "rangeOfComposedCharacterSequence(at:)") func rangeOfComposedCharacterSequenceAt(_ anIndex: Swift.String.Index) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "rangeOfComposedCharacterSequences(for:)") func rangeOfComposedCharacterSequencesFor(_ range: Swift.Range<Swift.String.Index>) -> Swift.Range<Swift.String.Index>
  @available(*, unavailable, renamed: "range(of:options:range:locale:)") func rangeOf(_ aString: Swift.String, options mask: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default, locale: Foundation.Locale? = default) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "localizedStandardRange(of:)") func localizedStandardRangeOf(_ string: Swift.String) -> Swift.Range<Swift.String.Index>?
  @available(*, unavailable, renamed: "addingPercentEncoding(withAllowedCharacters:)") func addingPercentEncodingWithAllowedCharacters(_ allowedCharacters: Foundation.CharacterSet) -> Swift.String?
  @available(*, unavailable, renamed: "addingPercentEscapes(using:)") func addingPercentEscapesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, renamed: "appendingFormat") func stringByAppendingFormat(_ format: Swift.String, _ arguments: CVarArg...) -> Swift.String
  @available(*, unavailable, renamed: "padding(toLength:with:startingAt:)") func byPaddingToLength(_ newLength: Swift.Int, withString padString: Swift.String, startingAt padIndex: Swift.Int) -> Swift.String
  @available(*, unavailable, renamed: "replacingCharacters(in:with:)") func replacingCharactersIn(_ range: Swift.Range<Swift.String.Index>, withString replacement: Swift.String) -> Swift.String
  @available(*, unavailable, renamed: "replacingOccurrences(of:with:options:range:)") func replacingOccurrencesOf(_ target: Swift.String, withString replacement: Swift.String, options: Swift.String.CompareOptions = default, range searchRange: Swift.Range<Swift.String.Index>? = default) -> Swift.String
  @available(*, unavailable, renamed: "replacingPercentEscapes(usingEncoding:)") func replacingPercentEscapesUsingEncoding(_ encoding: Swift.String.Encoding) -> Swift.String?
  @available(*, unavailable, renamed: "trimmingCharacters(in:)") func byTrimmingCharactersIn(_ set: Foundation.CharacterSet) -> Swift.String
  @available(*, unavailable, renamed: "strings(byAppendingPaths:)") func stringsByAppendingPaths(_ paths: [Swift.String]) -> [Swift.String]
  @available(*, unavailable, renamed: "substring(from:)") func substringFrom(_ index: Swift.String.Index) -> Swift.String
  @available(*, unavailable, renamed: "substring(to:)") func substringTo(_ index: Swift.String.Index) -> Swift.String
  @available(*, unavailable, renamed: "substring(with:)") func substringWith(_ aRange: Swift.Range<Swift.String.Index>) -> Swift.String
  @available(*, unavailable, renamed: "uppercased(with:)") func uppercaseStringWith(_ locale: Foundation.Locale?) -> Swift.String
  @available(*, unavailable, renamed: "write(toFile:atomically:encoding:)") func writeToFile(_ path: Swift.String, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
  @available(*, unavailable, renamed: "write(to:atomically:encoding:)") func writeToURL(_ url: Foundation.URL, atomically useAuxiliaryFile: Swift.Bool, encoding enc: Swift.String.Encoding) throws
}
extension String {
  struct Encoding : RawRepresentable {
    var rawValue: Swift.UInt
    init(rawValue: Swift.UInt)
    static var ascii: Swift.String.Encoding
    static var nextstep: Swift.String.Encoding
    static var japaneseEUC: Swift.String.Encoding
    static var utf8: Swift.String.Encoding
    static var isoLatin1: Swift.String.Encoding
    static var symbol: Swift.String.Encoding
    static var nonLossyASCII: Swift.String.Encoding
    static var shiftJIS: Swift.String.Encoding
    static var isoLatin2: Swift.String.Encoding
    static var unicode: Swift.String.Encoding
    static var windowsCP1251: Swift.String.Encoding
    static var windowsCP1252: Swift.String.Encoding
    static var windowsCP1253: Swift.String.Encoding
    static var windowsCP1254: Swift.String.Encoding
    static var windowsCP1250: Swift.String.Encoding
    static var iso2022JP: Swift.String.Encoding
    static var macOSRoman: Swift.String.Encoding
    static var utf16: Swift.String.Encoding
    static var utf16BigEndian: Swift.String.Encoding
    static var utf16LittleEndian: Swift.String.Encoding
    static var utf32: Swift.String.Encoding
    static var utf32BigEndian: Swift.String.Encoding
    static var utf32LittleEndian: Swift.String.Encoding
    typealias RawValue = Swift.UInt
  }
  typealias EncodingConversionOptions = Foundation.NSString.EncodingConversionOptions
  typealias EnumerationOptions = Foundation.NSString.EnumerationOptions
  typealias CompareOptions = Foundation.NSString.CompareOptions
}
extension String : Toastable {
  func mainMessage() -> Swift.String
  func detailMessage() -> Swift.String
}
struct _Buffer32 {
  var _x0: Swift.UInt8
  var _x1: Swift.UInt8
  var _x2: Swift.UInt8
  var _x3: Swift.UInt8
  var _x4: Swift.UInt8
  var _x5: Swift.UInt8
  var _x6: Swift.UInt8
  var _x7: Swift.UInt8
  var _x8: Swift.UInt8
  var _x9: Swift.UInt8
  var _x10: Swift.UInt8
  var _x11: Swift.UInt8
  var _x12: Swift.UInt8
  var _x13: Swift.UInt8
  var _x14: Swift.UInt8
  var _x15: Swift.UInt8
  var _x16: Swift.UInt8
  var _x17: Swift.UInt8
  var _x18: Swift.UInt8
  var _x19: Swift.UInt8
  var _x20: Swift.UInt8
  var _x21: Swift.UInt8
  var _x22: Swift.UInt8
  var _x23: Swift.UInt8
  var _x24: Swift.UInt8
  var _x25: Swift.UInt8
  var _x26: Swift.UInt8
  var _x27: Swift.UInt8
  var _x28: Swift.UInt8
  var _x29: Swift.UInt8
  var _x30: Swift.UInt8
  var _x31: Swift.UInt8
  mutating func withBytes<Result>(_ body: (Swift.UnsafeMutablePointer<Swift.UInt8>) throws -> Result) rethrows -> Result
  init(_x0: Swift.UInt8, _x1: Swift.UInt8, _x2: Swift.UInt8, _x3: Swift.UInt8, _x4: Swift.UInt8, _x5: Swift.UInt8, _x6: Swift.UInt8, _x7: Swift.UInt8, _x8: Swift.UInt8, _x9: Swift.UInt8, _x10: Swift.UInt8, _x11: Swift.UInt8, _x12: Swift.UInt8, _x13: Swift.UInt8, _x14: Swift.UInt8, _x15: Swift.UInt8, _x16: Swift.UInt8, _x17: Swift.UInt8, _x18: Swift.UInt8, _x19: Swift.UInt8, _x20: Swift.UInt8, _x21: Swift.UInt8, _x22: Swift.UInt8, _x23: Swift.UInt8, _x24: Swift.UInt8, _x25: Swift.UInt8, _x26: Swift.UInt8, _x27: Swift.UInt8, _x28: Swift.UInt8, _x29: Swift.UInt8, _x30: Swift.UInt8, _x31: Swift.UInt8)
  init()
}
@objc class _ContiguousArrayStorageBase : Swift._SwiftNativeNSArrayWithContiguousStorage {
  override func withUnsafeBufferOfObjects<R>(_ body: (Swift.UnsafeBufferPointer<AnyObject>) throws -> R) rethrows -> R
  func _withVerbatimBridgedUnsafeBuffer<R>(_ body: (Swift.UnsafeBufferPointer<AnyObject>) throws -> R) rethrows -> R?
  func _getNonVerbatimBridgedCount(_ dummy: Swift.Void) -> Swift.Int
  func _getNonVerbatimBridgedHeapBuffer(_ dummy: Swift.Void) -> Swift._HeapBuffer<Swift.Int, AnyObject>
  func canStoreElements(ofDynamicType _: Any.Type) -> Swift.Bool
  var staticElementType: Any.Type {
    get {}
  }
  @objc deinit
  @objc init()
}
func _swift_stdlib_atomicFetchOrInt(object target: Swift.UnsafeMutablePointer<Swift.Int>, operand: Swift.Int) -> Swift.Int
@_versioned var _objectPointerSpareBits: Swift.UInt {
  @inline(__always) get {}
}
@_silgen_name("swift_stdlib_CFSetGetValues") func _stdlib_CFSetGetValues(_ nss: _NSSet, _: Swift.UnsafeMutablePointer<AnyObject>)
func _isBridgedVerbatimToObjectiveC<T>(_: T.Type) -> Swift.Bool
func _sin(_ x: Swift.Float) -> Swift.Float
func _sin(_ x: Swift.Double) -> Swift.Double
func _growArrayCapacity(_ capacity: Swift.Int) -> Swift.Int
@_versioned struct _ArrayBody {
  var _storage: SwiftShims._SwiftArrayBodyStorage
  @_versioned init(count: Swift.Int, capacity: Swift.Int, elementTypeIsBridgedVerbatim: Swift.Bool = default)
  init()
  var count: Swift.Int {
    get {}
    set(newCount) {}
  }
  var capacity: Swift.Int {
    get {}
  }
  var elementTypeIsBridgedVerbatim: Swift.Bool {
    get {}
    set(newValue) {}
  }
  var _capacityAndFlags: Swift.UInt {
    get {}
    set(newValue) {}
  }
}
protocol LazyCollectionProtocol : Collection, LazySequenceProtocol {
  associatedtype Elements : Collection = Self
}
extension LazyCollectionProtocol where Self : Collection, Elements : Collection {
  func filter(_ isIncluded: @escaping (Self.Elements.Iterator.Element) -> Swift.Bool) -> Swift.LazyFilterCollection<Self.Elements>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection {
  func filter(_ isIncluded: @escaping (Self.Elements.Iterator.Element) -> Swift.Bool) -> Swift.LazyFilterBidirectionalCollection<Self.Elements>
}
extension LazyCollectionProtocol {
  func flatMap<SegmentOfResult : Collection>(_ transform: @escaping (Self.Elements.Iterator.Element) -> SegmentOfResult) -> Swift.LazyCollection<Swift.FlattenCollection<Swift.LazyMapCollection<Self.Elements, SegmentOfResult>>>
  func flatMap<ElementOfResult>(_ transform: @escaping (Self.Elements.Iterator.Element) -> ElementOfResult?) -> Swift.LazyMapCollection<Swift.LazyFilterCollection<Swift.LazyMapCollection<Self.Elements, ElementOfResult?>>, ElementOfResult>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection {
  func flatMap<SegmentOfResult : Collection where SegmentOfResult : BidirectionalCollection>(_ transform: @escaping (Self.Elements.Iterator.Element) -> SegmentOfResult) -> Swift.LazyCollection<Swift.FlattenBidirectionalCollection<Swift.LazyMapBidirectionalCollection<Self.Elements, SegmentOfResult>>>
  func flatMap<ElementOfResult>(_ transform: @escaping (Self.Elements.Iterator.Element) -> ElementOfResult?) -> Swift.LazyMapBidirectionalCollection<Swift.LazyFilterBidirectionalCollection<Swift.LazyMapBidirectionalCollection<Self.Elements, ElementOfResult?>>, ElementOfResult>
}
extension LazyCollectionProtocol where Self : Collection, Elements : Collection, Iterator.Element : Collection, Elements.Iterator.Element : Collection, Iterator.Element == Elements.Iterator.Element {
  func joined() -> Swift.LazyCollection<Swift.FlattenCollection<Self.Elements>>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.LazyCollection<Swift.FlattenCollection<Self.Elements>>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection, Iterator.Element : BidirectionalCollection, Elements.Iterator.Element : BidirectionalCollection, Iterator.Element == Elements.Iterator.Element {
  func joined() -> Swift.LazyCollection<Swift.FlattenBidirectionalCollection<Self.Elements>>
  @available(*, unavailable, renamed: "joined()") func flatten() -> Swift.LazyCollection<Swift.FlattenBidirectionalCollection<Self.Elements>>
}
extension LazyCollectionProtocol where Elements == Self {
  var elements: Self {
    get {}
  }
}
extension LazyCollectionProtocol where Self : Collection, Elements : Collection {
  func map<U>(_ transform: @escaping (Self.Elements.Iterator.Element) -> U) -> Swift.LazyMapCollection<Self.Elements, U>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection {
  func map<U>(_ transform: @escaping (Self.Elements.Iterator.Element) -> U) -> Swift.LazyMapBidirectionalCollection<Self.Elements, U>
}
extension LazyCollectionProtocol where Self : RandomAccessCollection, Elements : RandomAccessCollection {
  func map<U>(_ transform: @escaping (Self.Elements.Iterator.Element) -> U) -> Swift.LazyMapRandomAccessCollection<Self.Elements, U>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection {
  func reversed() -> Swift.LazyBidirectionalCollection<Swift.ReversedCollection<Self.Elements>>
}
extension LazyCollectionProtocol where Self : RandomAccessCollection, Elements : RandomAccessCollection {
  func reversed() -> Swift.LazyRandomAccessCollection<Swift.ReversedRandomAccessCollection<Self.Elements>>
}
extension LazyCollectionProtocol where Self : BidirectionalCollection, Elements : BidirectionalCollection {
  @available(*, unavailable, renamed: "reversed()") func reverse() -> Swift.LazyCollection<Swift.ReversedCollection<Self.Elements>>
}
extension LazyCollectionProtocol where Self : RandomAccessCollection, Elements : RandomAccessCollection {
  @available(*, unavailable, renamed: "reversed()") func reverse() -> Swift.LazyCollection<Swift.ReversedRandomAccessCollection<Self.Elements>>
}
protocol _DisallowMixedSignArithmetic : _Integer {
  associatedtype _DisallowMixedSignArithmetic : SignedInteger = Swift.Int
}
func _introSort<C where C : MutableCollection & RandomAccessCollection>(_ elements: inout C, subRange range: Swift.Range<C.Index>, by areInIncreasingOrder: @escaping (C.Iterator.Element, C.Iterator.Element) -> Swift.Bool)
func _introSort<C where C : MutableCollection & RandomAccessCollection, C.Iterator.Element : Comparable>(_ elements: inout C, subRange range: Swift.Range<C.Index>)
func <<=(lhs: inout Swift.UInt8, rhs: Swift.UInt8)
func <<=(lhs: inout Swift.Int8, rhs: Swift.Int8)
func <<=(lhs: inout Swift.UInt16, rhs: Swift.UInt16)
func <<=(lhs: inout Swift.Int16, rhs: Swift.Int16)
func <<=(lhs: inout Swift.UInt32, rhs: Swift.UInt32)
func <<=(lhs: inout Swift.Int32, rhs: Swift.Int32)
func <<=(lhs: inout Swift.UInt64, rhs: Swift.UInt64)
func <<=(lhs: inout Swift.Int64, rhs: Swift.Int64)
func <<=(lhs: inout Swift.UInt, rhs: Swift.UInt)
func <<=(lhs: inout Swift.Int, rhs: Swift.Int)
@_silgen_name("swift_getTypeByMangledName") func _getTypeByMangledName(_ name: Swift.UnsafePointer<Swift.UInt8>, _ nameLength: Swift.UInt) -> Any.Type?
struct Int8 : SignedInteger, Comparable, Equatable {
  var _value: Builtin.Int8
  init()
  init(_ _v: Builtin.Int8)
  init(_bits: Builtin.Int8)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.Int8)
  static var max: Swift.Int8 {
    get {}
  }
  static var min: Swift.Int8 {
    get {}
  }
  static var _sizeInBits: Swift.Int8 {
    get {}
  }
  static var _sizeInBytes: Swift.Int8 {
    get {}
  }
  typealias IntegerLiteralType = Swift.Int8
  typealias Stride = Swift.Int
}
extension Int8 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension Int8 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Int8 {
  static func addWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.Int8, _ rhs: Swift.Int8) -> (Swift.Int8, overflow: Swift.Bool)
  func toIntMax() -> Swift.IntMax
}
extension Int8 : SignedNumber {
}
extension Int8 {
  init(_ value: Swift.UInt8)
  init?(exactly value: Swift.UInt8)
}
extension Int8 {
  init(_ value: Swift.Int8)
  @available(*, message: "Converting Int8 to Int8 will always succeed.") init?(exactly value: Swift.Int8)
}
extension Int8 {
  init(_ value: Swift.UInt16)
  init?(exactly value: Swift.UInt16)
  init(truncatingBitPattern: Swift.UInt16)
}
extension Int8 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
  init(truncatingBitPattern: Swift.Int16)
}
extension Int8 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
  init(truncatingBitPattern: Swift.UInt32)
}
extension Int8 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
  init(truncatingBitPattern: Swift.Int32)
}
extension Int8 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension Int8 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension Int8 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension Int8 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension Int8 {
  init(bitPattern: Swift.UInt8)
}
extension Int8 : BitwiseOperations {
  static var allZeros: Swift.Int8 {
    get {}
  }
}
extension Int8 {
  typealias _DisabledRangeIndex = Swift.Int8
}
extension Int8 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension Int8 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension Int8 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Int8 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Int8 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension Int8 {
  init(_ value: CoreGraphics.CGFloat)
}
enum _DisabledRangeIndex_ {
}
func _exp2(_ x: Swift.Float) -> Swift.Float
func _exp2(_ x: Swift.Double) -> Swift.Double
@objc protocol AnyObject {
}
@_silgen_name("_swift_bridgeNonVerbatimBoxedValue") func _bridgeNonVerbatimBoxedValue<NativeType>(_ x: Swift.UnsafePointer<NativeType>, _ result: inout NativeType?)
struct AnyRandomAccessCollection<Element> : _AnyCollectionProtocol, RandomAccessCollection {
  init(_box: Swift._AnyRandomAccessCollectionBox<Element>)
  init<C : RandomAccessCollection where C.Iterator.Element == Element, C.SubSequence : RandomAccessCollection, C.SubSequence.Iterator.Element == Element, C.SubSequence.Index == C.Index, C.SubSequence.Indices : RandomAccessCollection, C.SubSequence.Indices.Iterator.Element == C.Index, C.SubSequence.Indices.Index == C.Index, C.SubSequence.Indices.SubSequence == C.SubSequence.Indices, C.SubSequence.SubSequence == C.SubSequence, C.Indices : RandomAccessCollection, C.Indices.Iterator.Element == C.Index, C.Indices.Index == C.Index, C.Indices.SubSequence == C.Indices>(_ base: C)
  init(_ other: Swift.AnyRandomAccessCollection<Element>)
  init?(_ other: Swift.AnyCollection<Element>)
  init?(_ other: Swift.AnyBidirectionalCollection<Element>)
  typealias Index = Swift.AnyIndex
  typealias IndexDistance = Swift.IntMax
  var startIndex: Swift.AnyIndex {
    get {}
  }
  var endIndex: Swift.AnyIndex {
    get {}
  }
  subscript(position: Swift.AnyIndex) -> Element {
    get {}
  }
  subscript(bounds: Swift.Range<Swift.AnyIndex>) -> Swift.AnyRandomAccessCollection<Element> {
    get {}
  }
  func _failEarlyRangeCheck(_ index: Swift.AnyIndex, bounds: Swift.Range<Swift.AnyIndex>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Swift.AnyRandomAccessCollection.Index>, bounds: Swift.Range<Swift.AnyRandomAccessCollection.Index>)
  func index(after i: Swift.AnyIndex) -> Swift.AnyIndex
  func formIndex(after i: inout Swift.AnyIndex)
  func index(_ i: Swift.AnyIndex, offsetBy n: Swift.IntMax) -> Swift.AnyIndex
  func index(_ i: Swift.AnyIndex, offsetBy n: Swift.IntMax, limitedBy limit: Swift.AnyIndex) -> Swift.AnyIndex?
  func formIndex(_ i: inout Swift.AnyIndex, offsetBy n: Swift.IntMax)
  func formIndex(_ i: inout Swift.AnyIndex, offsetBy n: Swift.IntMax, limitedBy limit: Swift.AnyIndex) -> Swift.Bool
  func distance(from start: Swift.AnyIndex, to end: Swift.AnyIndex) -> Swift.IntMax
  var count: Swift.IntMax {
    get {}
  }
  var first: Element? {
    get {}
  }
  func index(before i: Swift.AnyIndex) -> Swift.AnyIndex
  func formIndex(before i: inout Swift.AnyIndex)
  var last: Element? {
    get {}
  }
  var _boxID: Swift.ObjectIdentifier {
    get {}
  }
  let _box: Swift._AnyRandomAccessCollectionBox<Element>
  typealias _Element = Element
  typealias SubSequence = Swift.AnyRandomAccessCollection<Element>
  typealias Indices = Swift.DefaultRandomAccessIndices<Swift.AnyRandomAccessCollection<Element>>
  typealias Iterator = Swift.AnyIterator<Element>
}
extension AnyRandomAccessCollection {
  func makeIterator() -> Swift.AnyIterator<Element>
  var underestimatedCount: Swift.Int {
    get {}
  }
  func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]
  func filter(_ isIncluded: (Element) throws -> Swift.Bool) rethrows -> [Element]
  func forEach(_ body: (Element) throws -> Swift.Void) rethrows
  func dropFirst(_ n: Swift.Int) -> Swift.AnyRandomAccessCollection<Element>
  func dropLast(_ n: Swift.Int) -> Swift.AnyRandomAccessCollection<Element>
  func prefix(_ maxLength: Swift.Int) -> Swift.AnyRandomAccessCollection<Element>
  func suffix(_ maxLength: Swift.Int) -> Swift.AnyRandomAccessCollection<Element>
  func split(maxSplits: Swift.Int = default, omittingEmptySubsequences: Swift.Bool = default, whereSeparator isSeparator: (Element) throws -> Swift.Bool) rethrows -> [Swift.AnyRandomAccessCollection<Element>]
  func _preprocessingPass<R>(_ preprocess: () throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Element>
  func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Element>) -> Swift.UnsafeMutablePointer<Element>
}
extension AnyRandomAccessCollection {
  @available(*, unavailable, renamed: "getter:underestimatedCount()") func underestimateCount() -> Swift.Int
}
protocol OptionSet : SetAlgebra, RawRepresentable {
  associatedtype Element = Self
  init(rawValue: Self.RawValue)
}
extension OptionSet {
  func union(_ other: Self) -> Self
  func intersection(_ other: Self) -> Self
  func symmetricDifference(_ other: Self) -> Self
}
extension OptionSet where Element == Self {
  func contains(_ member: Self) -> Swift.Bool
  @discardableResult mutating func insert(_ newMember: Self) -> (inserted: Swift.Bool, memberAfterInsert: Self)
  @discardableResult mutating func remove(_ member: Self) -> Self?
  @discardableResult mutating func update(with newMember: Self) -> Self?
}
extension OptionSet where RawValue : BitwiseOperations {
  convenience init()
  mutating func formUnion(_ other: Self)
  mutating func formIntersection(_ other: Self)
  mutating func formSymmetricDifference(_ other: Self)
}
func _dictionaryBridgeFromObjectiveCConditional<ObjCKey, ObjCValue, SwiftKey, SwiftValue>(_ source: [ObjCKey : ObjCValue]) -> [SwiftKey : SwiftValue]?
struct UnsafeRawPointer : Strideable, Hashable, _Pointer {
  let _rawValue: Builtin.RawPointer
  init(_ other: Swift.UnsafeRawPointer)
  init?(_ other: Swift.UnsafeRawPointer?)
  init(_ _rawValue: Builtin.RawPointer)
  init(_ other: Swift.OpaquePointer)
  init?(_ other: Swift.OpaquePointer?)
  init?(bitPattern: Swift.Int)
  init?(bitPattern: Swift.UInt)
  init<T>(_ other: Swift.UnsafePointer<T>)
  init?<T>(_ other: Swift.UnsafePointer<T>?)
  init(_ other: Swift.UnsafeMutableRawPointer)
  init?(_ other: Swift.UnsafeMutableRawPointer?)
  init<T>(_ other: Swift.UnsafeMutablePointer<T>)
  init?<T>(_ other: Swift.UnsafeMutablePointer<T>?)
  func deallocate(bytes: Swift.Int, alignedTo: Swift.Int)
  @discardableResult func bindMemory<T>(to type: T.Type, capacity count: Swift.Int) -> Swift.UnsafePointer<T>
  func assumingMemoryBound<T>(to: T.Type) -> Swift.UnsafePointer<T>
  func load<T>(fromByteOffset offset: Swift.Int = default, as type: T.Type) -> T
  var hashValue: Swift.Int {
    get {}
  }
  func distance(to x: Swift.UnsafeRawPointer) -> Swift.Int
  func advanced(by n: Swift.Int) -> Swift.UnsafeRawPointer
  typealias Stride = Swift.Int
  typealias _DisabledRangeIndex = Swift._DisabledRangeIndex_
}
extension UnsafeRawPointer {
  init<T>(_ other: Swift.AutoreleasingUnsafeMutablePointer<T>)
  init?<T>(_ other: Swift.AutoreleasingUnsafeMutablePointer<T>?)
}
extension UnsafeRawPointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension UnsafeRawPointer : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UnsafeRawPointer : CustomPlaygroundQuickLookable {
  var summary: Swift.String {
    get {}
  }
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
final class _NativeSetStorageKeyNSEnumerator<Element : Hashable> : Swift._SwiftNativeNSEnumerator, _NSEnumerator {
  typealias NativeStorageOwner = Swift._NativeSetStorageOwner<Element>
  typealias Index = Swift._NativeSetIndex<Element>
  @objc required init()
  init(_ nativeStorageOwner: Swift._NativeSetStorageOwner<Element>)
  final var nativeStorageOwner: Swift._NativeSetStorageOwner<Element>
  final var nextIndex: Swift._NativeSetIndex<Element>
  final var endIndex: Swift._NativeSetIndex<Element>
  @objc final func nextObject() -> AnyObject?
  @objc(countByEnumeratingWithState:objects:count:) final func countByEnumerating(with state: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState>, objects: Swift.UnsafeMutablePointer<AnyObject>, count: Swift.Int) -> Swift.Int
  @objc deinit
}
struct StrideToIterator<Element : Strideable> : IteratorProtocol {
  let _start: Element
  let _end: Element
  let _stride: Element.Stride
  var _current: (index: Swift.Int?, value: Element)
  init(_start: Element, end: Element, stride: Element.Stride)
  mutating func next() -> Element?
  typealias Element = Element
}
@inline(__always) func _allocateUninitializedArray<Element>(_ builtinCount: Builtin.Word) -> ([Element], Builtin.RawPointer)
protocol FloatingPoint : Comparable, ExpressibleByIntegerLiteral, SignedNumber, AbsoluteValuable, Strideable {
  associatedtype Exponent : SignedInteger
  init(sign: Swift.FloatingPointSign, exponent: Self.Exponent, significand: Self)
  init(signOf: Self, magnitudeOf: Self)
  init(_ value: Swift.UInt8)
  init(_ value: Swift.Int8)
  init(_ value: Swift.UInt16)
  init(_ value: Swift.Int16)
  init(_ value: Swift.UInt32)
  init(_ value: Swift.Int32)
  init(_ value: Swift.UInt64)
  init(_ value: Swift.Int64)
  init(_ value: Swift.UInt)
  init(_ value: Swift.Int)
  static var radix: Swift.Int { get }
  static var nan: Self { get }
  static var signalingNaN: Self { get }
  static var infinity: Self { get }
  static var greatestFiniteMagnitude: Self { get }
  static var pi: Self { get }
  var ulp: Self { get }
  static var ulpOfOne: Self { get }
  static var leastNormalMagnitude: Self { get }
  static var leastNonzeroMagnitude: Self { get }
  var sign: Swift.FloatingPointSign { get }
  var exponent: Self.Exponent { get }
  var significand: Self { get }
  func adding(_ other: Self) -> Self
  mutating func add(_ other: Self)
  func negated() -> Self
  mutating func negate()
  func subtracting(_ other: Self) -> Self
  mutating func subtract(_ other: Self)
  func multiplied(by other: Self) -> Self
  mutating func multiply(by other: Self)
  func divided(by other: Self) -> Self
  mutating func divide(by other: Self)
  func remainder(dividingBy other: Self) -> Self
  mutating func formRemainder(dividingBy other: Self)
  func truncatingRemainder(dividingBy other: Self) -> Self
  mutating func formTruncatingRemainder(dividingBy other: Self)
  func squareRoot() -> Self
  mutating func formSquareRoot()
  func addingProduct(_ lhs: Self, _ rhs: Self) -> Self
  mutating func addProduct(_ lhs: Self, _ rhs: Self)
  static func minimum(_ x: Self, _ y: Self) -> Self
  static func maximum(_ x: Self, _ y: Self) -> Self
  static func minimumMagnitude(_ x: Self, _ y: Self) -> Self
  static func maximumMagnitude(_ x: Self, _ y: Self) -> Self
  func rounded(_ rule: Swift.FloatingPointRoundingRule) -> Self
  mutating func round(_ rule: Swift.FloatingPointRoundingRule)
  var nextUp: Self { get }
  var nextDown: Self { get }
  func isEqual(to other: Self) -> Swift.Bool
  func isLess(than other: Self) -> Swift.Bool
  func isLessThanOrEqualTo(_ other: Self) -> Swift.Bool
  func isTotallyOrdered(belowOrEqualTo other: Self) -> Swift.Bool
  var isNormal: Swift.Bool { get }
  var isFinite: Swift.Bool { get }
  var isZero: Swift.Bool { get }
  var isSubnormal: Swift.Bool { get }
  var isInfinite: Swift.Bool { get }
  var isNaN: Swift.Bool { get }
  var isSignalingNaN: Swift.Bool { get }
  var floatingPointClass: Swift.FloatingPointClassification { get }
  var isCanonical: Swift.Bool { get }
}
extension FloatingPoint {
  static var ulpOfOne: Self {
    get {}
  }
  func rounded(_ rule: Swift.FloatingPointRoundingRule) -> Self
  func rounded() -> Self
  mutating func round()
  var nextDown: Self {
    get {}
  }
  func truncatingRemainder(dividingBy other: Self) -> Self
  func remainder(dividingBy rhs: Self) -> Self
  func squareRoot() -> Self
  func addingProduct(_ lhs: Self, _ rhs: Self) -> Self
  static func minimum(_ x: Self, _ y: Self) -> Self
  static func maximum(_ x: Self, _ y: Self) -> Self
  static func minimumMagnitude(_ x: Self, _ y: Self) -> Self
  static func maximumMagnitude(_ x: Self, _ y: Self) -> Self
  var floatingPointClass: Swift.FloatingPointClassification {
    get {}
  }
  func adding(_ other: Self) -> Self
  func subtracting(_ other: Self) -> Self
  func multiplied(by other: Self) -> Self
  func divided(by other: Self) -> Self
  func negated() -> Self
}
@available(*, unavailable, message: "use MemoryLayout<T>.stride instead.") func strideof<T>(_: T.Type) -> Swift.Int
protocol ExpressibleByFloatLiteral {
  associatedtype FloatLiteralType : _ExpressibleByBuiltinFloatLiteral
  init(floatLiteral value: Self.FloatLiteralType)
}
protocol ExpressibleByUnicodeScalarLiteral {
  associatedtype UnicodeScalarLiteralType : _ExpressibleByBuiltinUnicodeScalarLiteral
  init(unicodeScalarLiteral value: Self.UnicodeScalarLiteralType)
}
@objc @_swift_native_objc_runtime_base(_SwiftNativeNSEnumeratorBase) class _SwiftNativeNSEnumerator {
  @objc init()
  @objc deinit
}
@available(*, deprecated, message: "it will be replaced or redesigned in Swift 4.0.  Instead of conforming to 'ExpressibleByStringInterpolation', consider adding an 'init(_:String)'") protocol ExpressibleByStringInterpolation {
  init(stringInterpolation strings: Self...)
  init<T>(stringInterpolationSegment expr: T)
}
@available(*, unavailable, message: "Removed in Swift 3. Use Unmanaged.passUnretained(x).toOpaque() instead.") func unsafeAddressOf(_ object: AnyObject) -> Swift.UnsafePointer<Swift.Void>
final class _NativeDictionaryStorageImpl<Key, Value> : Swift.ManagedBuffer<Swift._HashedContainerStorageHeader, Swift.UInt8> {
  typealias BufferPointer = Swift.ManagedBufferPointer<Swift._HashedContainerStorageHeader, Swift.UInt8>
  typealias StorageImpl = Swift._NativeDictionaryStorageImpl<Key, Value>
  static func bytesForBitMap(capacity: Swift.Int) -> Swift.Int
  static func bytesForKeys(capacity: Swift.Int) -> Swift.Int
  static func bytesForValues(capacity: Swift.Int) -> Swift.Int
  final var buffer: Swift._NativeDictionaryStorageImpl.BufferPointer {
    final get {}
  }
  final var _body: Swift._HashedContainerStorageHeader
  final var _body: Swift._HashedContainerStorageHeader {
    unsafeAddress {}
    unsafeMutableAddress {}
  }
  @_versioned final var _capacity: Swift.Int {
    final get {}
  }
  @_versioned final var _count: Swift.Int {
    final get {}
    final set(newValue) {}
  }
  final var _maxLoadFactorInverse: Swift.Double {
    final get {}
  }
  final var _initializedHashtableEntriesBitMapStorage: Swift.UnsafeMutablePointer<Swift.UInt> {
    final get {}
  }
  final var _keys: Swift.UnsafeMutablePointer<Key> {
    final get {}
  }
  final var _values: Swift.UnsafeMutablePointer<Value> {
    final get {}
  }
  final class func create(capacity: Swift.Int) -> Swift._NativeDictionaryStorageImpl<Key, Value>
  @objc deinit
  init(_doNotCallMe: ())
}
@inline(never) @_semantics("stdlib_binary_only") func _dictionaryBridgeToObjectiveC<SwiftKey, SwiftValue, ObjCKey, ObjCValue>(_ source: [SwiftKey : SwiftValue]) -> [ObjCKey : ObjCValue]
protocol _AnyCollectionProtocol : Collection {
  var _boxID: Swift.ObjectIdentifier { get }
}
extension _AnyCollectionProtocol {
  @available(*, unavailable, renamed: "makeIterator()") func generate() -> Swift.AnyIterator<Self.Iterator.Element>
}
@_versioned func _isReleaseAssertConfiguration() -> Swift.Bool
class _Box<Wrapped> {
  var _value: Wrapped
  init(_ value: Wrapped)
  @objc deinit
}
@_versioned @_silgen_name("_swift_isClassOrObjCExistentialType") func _swift_isClassOrObjCExistentialType<T>(_ x: T.Type) -> Swift.Bool
protocol _DefaultCustomPlaygroundQuickLookable {
  var _defaultCustomPlaygroundQuickLook: Swift.PlaygroundQuickLook { get }
}
protocol ExpressibleByBooleanLiteral {
  associatedtype BooleanLiteralType : _ExpressibleByBuiltinBooleanLiteral
  init(booleanLiteral value: Self.BooleanLiteralType)
}
@_silgen_name("_swift_bridgeNonVerbatimFromObjectiveCToAny") func _bridgeNonVerbatimFromObjectiveCToAny(_ x: AnyObject, _ result: inout Any?)
func _getBridgedObjectiveCType<T>(_: T.Type) -> Any.Type?
@_silgen_name("swift_stdlib_getErrorEmbeddedNSErrorIndirect") func _stdlib_getErrorEmbeddedNSErrorIndirect<T : Error>(_ x: Swift.UnsafePointer<T>) -> AnyObject?
protocol TextOutputStreamable {
  func write<Target : TextOutputStream>(to target: inout Target)
}
extension TextOutputStreamable {
  @available(*, unavailable, renamed: "write(to:)") func writeTo<Target : TextOutputStream>(_ target: inout Target)
}
@_versioned @inline(__always) func _nonPointerBits(_ x: Builtin.BridgeObject) -> Swift.UInt
@_silgen_name("swift_stdlib_getErrorEmbeddedNSError") func _stdlib_getErrorEmbeddedNSError<T : Error>(_ x: T) -> AnyObject?
@_silgen_name("_swift_setDownCastIndirect") func _setDownCastIndirect<SourceValue, TargetValue>(_ source: Swift.UnsafePointer<Swift.Set<SourceValue>>, _ target: Swift.UnsafeMutablePointer<Swift.Set<TargetValue>>)
struct DictionaryIterator<Key : Hashable, Value> : IteratorProtocol {
  typealias _NativeStorageOwner = Swift._NativeDictionaryStorageOwner<Key, Value>
  typealias _NativeIndex = Swift._NativeDictionaryIndex<Key, Value>
  @_versioned var _state: Swift.DictionaryIteratorRepresentation<Key, Value>
  @_versioned static func _native(start: Swift._NativeDictionaryIndex<Key, Value>, end: Swift._NativeDictionaryIndex<Key, Value>, owner: Swift._NativeDictionaryStorageOwner<Key, Value>) -> Swift.DictionaryIterator<Key, Value>
  @_versioned static func _cocoa(_ iterator: Swift._CocoaDictionaryIterator) -> Swift.DictionaryIterator<Key, Value>
  @_versioned var _guaranteedNative: Swift.Bool {
    get {}
  }
  @_versioned mutating func _nativeNext() -> (key: Key, value: Value)?
  @inline(__always) mutating func next() -> (key: Key, value: Value)?
  typealias Element = (key: Key, value: Value)
  init(_state: Swift.DictionaryIteratorRepresentation<Key, Value>)
}
extension DictionaryIterator : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
@_silgen_name("swift_class_getInstanceExtents") func swift_class_getInstanceExtents(_ theClass: Swift.AnyClass) -> (negative: Swift.UInt, positive: Swift.UInt)
struct _Buffer72 {
  var _x0: Swift.UInt8
  var _x1: Swift.UInt8
  var _x2: Swift.UInt8
  var _x3: Swift.UInt8
  var _x4: Swift.UInt8
  var _x5: Swift.UInt8
  var _x6: Swift.UInt8
  var _x7: Swift.UInt8
  var _x8: Swift.UInt8
  var _x9: Swift.UInt8
  var _x10: Swift.UInt8
  var _x11: Swift.UInt8
  var _x12: Swift.UInt8
  var _x13: Swift.UInt8
  var _x14: Swift.UInt8
  var _x15: Swift.UInt8
  var _x16: Swift.UInt8
  var _x17: Swift.UInt8
  var _x18: Swift.UInt8
  var _x19: Swift.UInt8
  var _x20: Swift.UInt8
  var _x21: Swift.UInt8
  var _x22: Swift.UInt8
  var _x23: Swift.UInt8
  var _x24: Swift.UInt8
  var _x25: Swift.UInt8
  var _x26: Swift.UInt8
  var _x27: Swift.UInt8
  var _x28: Swift.UInt8
  var _x29: Swift.UInt8
  var _x30: Swift.UInt8
  var _x31: Swift.UInt8
  var _x32: Swift.UInt8
  var _x33: Swift.UInt8
  var _x34: Swift.UInt8
  var _x35: Swift.UInt8
  var _x36: Swift.UInt8
  var _x37: Swift.UInt8
  var _x38: Swift.UInt8
  var _x39: Swift.UInt8
  var _x40: Swift.UInt8
  var _x41: Swift.UInt8
  var _x42: Swift.UInt8
  var _x43: Swift.UInt8
  var _x44: Swift.UInt8
  var _x45: Swift.UInt8
  var _x46: Swift.UInt8
  var _x47: Swift.UInt8
  var _x48: Swift.UInt8
  var _x49: Swift.UInt8
  var _x50: Swift.UInt8
  var _x51: Swift.UInt8
  var _x52: Swift.UInt8
  var _x53: Swift.UInt8
  var _x54: Swift.UInt8
  var _x55: Swift.UInt8
  var _x56: Swift.UInt8
  var _x57: Swift.UInt8
  var _x58: Swift.UInt8
  var _x59: Swift.UInt8
  var _x60: Swift.UInt8
  var _x61: Swift.UInt8
  var _x62: Swift.UInt8
  var _x63: Swift.UInt8
  var _x64: Swift.UInt8
  var _x65: Swift.UInt8
  var _x66: Swift.UInt8
  var _x67: Swift.UInt8
  var _x68: Swift.UInt8
  var _x69: Swift.UInt8
  var _x70: Swift.UInt8
  var _x71: Swift.UInt8
  mutating func withBytes<Result>(_ body: (Swift.UnsafeMutablePointer<Swift.UInt8>) throws -> Result) rethrows -> Result
  init(_x0: Swift.UInt8, _x1: Swift.UInt8, _x2: Swift.UInt8, _x3: Swift.UInt8, _x4: Swift.UInt8, _x5: Swift.UInt8, _x6: Swift.UInt8, _x7: Swift.UInt8, _x8: Swift.UInt8, _x9: Swift.UInt8, _x10: Swift.UInt8, _x11: Swift.UInt8, _x12: Swift.UInt8, _x13: Swift.UInt8, _x14: Swift.UInt8, _x15: Swift.UInt8, _x16: Swift.UInt8, _x17: Swift.UInt8, _x18: Swift.UInt8, _x19: Swift.UInt8, _x20: Swift.UInt8, _x21: Swift.UInt8, _x22: Swift.UInt8, _x23: Swift.UInt8, _x24: Swift.UInt8, _x25: Swift.UInt8, _x26: Swift.UInt8, _x27: Swift.UInt8, _x28: Swift.UInt8, _x29: Swift.UInt8, _x30: Swift.UInt8, _x31: Swift.UInt8, _x32: Swift.UInt8, _x33: Swift.UInt8, _x34: Swift.UInt8, _x35: Swift.UInt8, _x36: Swift.UInt8, _x37: Swift.UInt8, _x38: Swift.UInt8, _x39: Swift.UInt8, _x40: Swift.UInt8, _x41: Swift.UInt8, _x42: Swift.UInt8, _x43: Swift.UInt8, _x44: Swift.UInt8, _x45: Swift.UInt8, _x46: Swift.UInt8, _x47: Swift.UInt8, _x48: Swift.UInt8, _x49: Swift.UInt8, _x50: Swift.UInt8, _x51: Swift.UInt8, _x52: Swift.UInt8, _x53: Swift.UInt8, _x54: Swift.UInt8, _x55: Swift.UInt8, _x56: Swift.UInt8, _x57: Swift.UInt8, _x58: Swift.UInt8, _x59: Swift.UInt8, _x60: Swift.UInt8, _x61: Swift.UInt8, _x62: Swift.UInt8, _x63: Swift.UInt8, _x64: Swift.UInt8, _x65: Swift.UInt8, _x66: Swift.UInt8, _x67: Swift.UInt8, _x68: Swift.UInt8, _x69: Swift.UInt8, _x70: Swift.UInt8, _x71: Swift.UInt8)
  init()
}
func _leadingZeros(_ x: Builtin.Int8) -> Builtin.Int8
func _leadingZeros(_ x: Builtin.Int16) -> Builtin.Int16
func _leadingZeros(_ x: Builtin.Int32) -> Builtin.Int32
func _leadingZeros(_ x: Builtin.Int64) -> Builtin.Int64
func _leadingZeros(_ x: Builtin.Int128) -> Builtin.Int128
struct OpaquePointer : Hashable {
  var _rawValue: Builtin.RawPointer
  @_versioned init(_ v: Builtin.RawPointer)
  init?(bitPattern: Swift.Int)
  init?(bitPattern: Swift.UInt)
  init<T>(_ from: Swift.UnsafePointer<T>)
  init?<T>(_ from: Swift.UnsafePointer<T>?)
  init<T>(_ from: Swift.UnsafeMutablePointer<T>)
  init?<T>(_ from: Swift.UnsafeMutablePointer<T>?)
  var hashValue: Swift.Int {
    get {}
  }
}
extension OpaquePointer : Equatable {
  static func ==(lhs: Swift.OpaquePointer, rhs: Swift.OpaquePointer) -> Swift.Bool
}
extension OpaquePointer : CustomDebugStringConvertible {
  var debugDescription: Swift.String {
    get {}
  }
}
extension OpaquePointer {
  @available(*, unavailable, message: "use 'Unmanaged.toOpaque()' instead") init<T>(bitPattern bits: Swift.Unmanaged<T>)
}
extension OpaquePointer {
  init(_ from: Swift.UnsafeMutableRawPointer)
  init?(_ from: Swift.UnsafeMutableRawPointer?)
}
extension OpaquePointer {
  init(_ from: Swift.UnsafeRawPointer)
  init?(_ from: Swift.UnsafeRawPointer?)
}
extension OpaquePointer : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
@objc protocol _NSSetCore : _NSCopying, _NSFastEnumeration {
  @objc init(objects: Swift.UnsafePointer<AnyObject?>, count: Swift.Int)
  @objc var count: Swift.Int { get }
  @objc func member(_ object: AnyObject) -> AnyObject?
  @objc func objectEnumerator() -> _NSEnumerator
  @objc(copyWithZone:) func copy(with zone: Swift._SwiftNSZone?) -> AnyObject
  @objc(countByEnumeratingWithState:objects:count:) func countByEnumerating(with state: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState>, objects: Swift.UnsafeMutablePointer<AnyObject>?, count: Swift.Int) -> Swift.Int
}
func _swift_stdlib_atomicFetchAndInt32(object target: Swift.UnsafeMutablePointer<Swift.Int32>, operand: Swift.Int32) -> Swift.Int32
func _mixInt(_ value: Swift.Int) -> Swift.Int
@_silgen_name("swift_OpaqueSummary") func _opaqueSummary(_ metadata: Any.Type) -> Swift.UnsafePointer<Swift.CChar>?
struct LazyRandomAccessCollection<Base : RandomAccessCollection> : LazyCollectionProtocol {
  typealias Elements = Base
  var elements: Base {
    get {}
  }
  typealias Index = Base.Index
  init(_base: Base)
  var _base: Base
  typealias _Element = Base.Iterator.Element
  typealias SubSequence = Swift.LazyRandomAccessCollection<Swift.RandomAccessSlice<Base>>
  typealias IndexDistance = Base.IndexDistance
  typealias Indices = Base.Indices
}
extension LazyRandomAccessCollection : Sequence {
  func makeIterator() -> Base.Iterator
  var underestimatedCount: Swift.Int {
    get {}
  }
  func _copyToContiguousArray() -> Swift.ContiguousArray<Base.Iterator.Element>
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Base.Iterator.Element>) -> Swift.UnsafeMutablePointer<Base.Iterator.Element>
  func _customContainsEquatableElement(_ element: Base.Iterator.Element) -> Swift.Bool?
  typealias Iterator = Base.Iterator
}
extension LazyRandomAccessCollection : RandomAccessCollection {
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  var indices: Base.Indices {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  subscript(position: Base.Index) -> Base.Iterator.Element {
    get {}
  }
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.LazyRandomAccessCollection<Swift.RandomAccessSlice<Base>> {
    get {}
  }
  var isEmpty: Swift.Bool {
    get {}
  }
  var count: Base.IndexDistance {
    get {}
  }
  func _customIndexOfEquatableElement(_ element: Base.Iterator.Element) -> Base.Index??
  var first: Base.Iterator.Element? {
    get {}
  }
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  func index(before i: Base.Index) -> Base.Index
  var last: Base.Iterator.Element? {
    get {}
  }
}
func _isOptional<T>(_ type: T.Type) -> Swift.Bool
func _encodeBitsAsWords<T>(_ x: T) -> [Swift.Int]
protocol AbsoluteValuable : SignedNumber {
  static func abs(_ x: Self) -> Self
}
struct LazyCollection<Base : Collection> : LazyCollectionProtocol {
  typealias Elements = Base
  var elements: Base {
    get {}
  }
  typealias Index = Base.Index
  init(_base: Base)
  var _base: Base
}
extension LazyCollection : Sequence {
  func makeIterator() -> Base.Iterator
  var underestimatedCount: Swift.Int {
    get {}
  }
  func _copyToContiguousArray() -> Swift.ContiguousArray<Base.Iterator.Element>
  @discardableResult func _copyContents(initializing ptr: Swift.UnsafeMutablePointer<Base.Iterator.Element>) -> Swift.UnsafeMutablePointer<Base.Iterator.Element>
  func _customContainsEquatableElement(_ element: Base.Iterator.Element) -> Swift.Bool?
}
extension LazyCollection : Collection {
  var startIndex: Base.Index {
    get {}
  }
  var endIndex: Base.Index {
    get {}
  }
  var indices: Base.Indices {
    get {}
  }
  func index(after i: Base.Index) -> Base.Index
  subscript(position: Base.Index) -> Base.Iterator.Element {
    get {}
  }
  subscript(bounds: Swift.Range<Base.Index>) -> Swift.LazyCollection<Swift.Slice<Base>> {
    get {}
  }
  var isEmpty: Swift.Bool {
    get {}
  }
  var count: Base.IndexDistance {
    get {}
  }
  func _customIndexOfEquatableElement(_ element: Base.Iterator.Element) -> Base.Index??
  var first: Base.Iterator.Element? {
    get {}
  }
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance) -> Base.Index
  func index(_ i: Base.Index, offsetBy n: Base.IndexDistance, limitedBy limit: Base.Index) -> Base.Index?
  func distance(from start: Base.Index, to end: Base.Index) -> Base.IndexDistance
  typealias _Element = Base.Iterator.Element
  typealias SubSequence = Swift.LazyCollection<Swift.Slice<Base>>
  typealias IndexDistance = Base.IndexDistance
  typealias Iterator = Base.Iterator
  typealias Indices = Base.Indices
}
struct StrideTo<Element : Strideable> : Sequence, CustomReflectable {
  func makeIterator() -> Swift.StrideToIterator<Element>
  init(_start: Element, end: Element, stride: Element.Stride)
  let _start: Element
  let _end: Element
  let _stride: Element.Stride
  var customMirror: Swift.Mirror {
    get {}
  }
  typealias Iterator = Swift.StrideToIterator<Element>
  typealias SubSequence = Swift.AnySequence<Element>
}
struct ArraySlice<Element> : RandomAccessCollection, MutableCollection, _DestructorSafeContainer {
  typealias Index = Swift.Int
  typealias Iterator = Swift.IndexingIterator<Swift.ArraySlice<Element>>
  var startIndex: Swift.Int {
    get {}
  }
  var endIndex: Swift.Int {
    get {}
  }
  func index(after i: Swift.Int) -> Swift.Int
  func formIndex(after i: inout Swift.Int)
  func index(before i: Swift.Int) -> Swift.Int
  func formIndex(before i: inout Swift.Int)
  func index(_ i: Swift.Int, offsetBy n: Swift.Int) -> Swift.Int
  func index(_ i: Swift.Int, offsetBy n: Swift.Int, limitedBy limit: Swift.Int) -> Swift.Int?
  func distance(from start: Swift.Int, to end: Swift.Int) -> Swift.Int
  func _failEarlyRangeCheck(_ index: Swift.Int, bounds: Swift.Range<Swift.Int>)
  func _failEarlyRangeCheck(_ range: Swift.Range<Swift.Int>, bounds: Swift.Range<Swift.Int>)
  typealias Indices = Swift.CountableRange<Swift.Int>
  subscript(index: Swift.Int) -> Element {
    get {}
    mutableAddressWithPinnedNativeOwner {}
  }
  subscript(bounds: Swift.Range<Swift.Int>) -> Swift.ArraySlice<Element> {
    get {}
    set(rhs) {}
  }
  @_semantics("array.props.isNativeTypeChecked") func _hoistableIsNativeTypeChecked() -> Swift.Bool
  @_semantics("array.get_count") func _getCount() -> Swift.Int
  @_semantics("array.get_capacity") func _getCapacity() -> Swift.Int
  @_semantics("array.owner") func _getOwnerWithSemanticLabel_native() -> Builtin.NativeObject
  @inline(__always) func _getOwner_native() -> Builtin.NativeObject
  static func _copyBuffer(_ buffer: inout Swift._SliceBuffer<Element>)
  @_semantics("array.make_mutable") mutating func _makeMutableAndUnique()
  @_semantics("array.make_mutable") mutating func _makeMutableAndUniqueOrPinned()
  @inline(__always) func _checkSubscript_native(_ index: Swift.Int)
  @_semantics("array.check_subscript") func _checkSubscript(_ index: Swift.Int, wasNativeTypeChecked: Swift.Bool) -> Swift._DependenceToken
  @_semantics("array.check_index") func _checkIndex(_ index: Swift.Int)
  @_semantics("array.get_element") @inline(__always) func _getElement(_ index: Swift.Int, wasNativeTypeChecked: Swift.Bool, matchingSubscriptCheck: Swift._DependenceToken) -> Element
  @_semantics("array.get_element_address") func _getElementAddress(_ index: Swift.Int) -> Swift.UnsafeMutablePointer<Element>
  typealias _Buffer = Swift._SliceBuffer<Element>
  init(_buffer: Swift._SliceBuffer<Element>)
  init(_buffer: Swift._ContiguousArrayBuffer<Element>)
  var _buffer: Swift._SliceBuffer<Element>
  typealias _Element = Element
  typealias SubSequence = Swift.ArraySlice<Element>
  typealias IndexDistance = Swift.Int
}
extension ArraySlice : ExpressibleByArrayLiteral {
  init(arrayLiteral elements: Element...)
  typealias Element = Element
}
extension ArraySlice : RangeReplaceableCollection, _ArrayProtocol {
  @_semantics("array.init") init()
  init<S : Sequence where S.Iterator.Element == Element>(_ s: S)
  @_semantics("array.init") init(repeating repeatedValue: Element, count: Swift.Int)
  @inline(never) static func _allocateBufferUninitialized(minimumCapacity: Swift.Int) -> Swift._SliceBuffer<Element>
  init(_uninitializedCount count: Swift.Int)
  @_versioned @_semantics("array.uninitialized") static func _allocateUninitialized(_ count: Swift.Int) -> (Swift.ArraySlice<Element>, Swift.UnsafeMutablePointer<Element>)
  var count: Swift.Int {
    get {}
  }
  var capacity: Swift.Int {
    get {}
  }
  var _owner: AnyObject? {
    get {}
  }
  var _baseAddressIfContiguous: Swift.UnsafeMutablePointer<Element>? {
    get {}
  }
  var _baseAddress: Swift.UnsafeMutablePointer<Element> {
    get {}
  }
  @_semantics("array.mutate_unknown") mutating func reserveCapacity(_ minimumCapacity: Swift.Int)
  @inline(never) mutating func _copyToNewBuffer(oldCount: Swift.Int)
  @_semantics("array.make_mutable") mutating func _makeUniqueAndReserveCapacityIfNotUnique()
  @_semantics("array.mutate_unknown") mutating func _reserveCapacityAssumingUniqueBuffer(oldCount: Swift.Int)
  @_semantics("array.mutate_unknown") mutating func _appendElementAssumeUniqueAndCapacity(_ oldCount: Swift.Int, newElement: Element)
  mutating func append(_ newElement: Element)
  mutating func append<S : Sequence where S.Iterator.Element == Element>(contentsOf newElements: S)
  mutating func append<C : Collection where C.Iterator.Element == Element>(contentsOf newElements: C)
  mutating func _customRemoveLast() -> Element?
  mutating func insert(_ newElement: Element, at i: Swift.Int)
  @discardableResult mutating func remove(at index: Swift.Int) -> Element
  mutating func removeAll(keepingCapacity keepCapacity: Swift.Bool = default)
  mutating func _withUnsafeMutableBufferPointerIfSupported<R>(_ body: (Swift.UnsafeMutablePointer<Element>, Swift.Int) throws -> R) rethrows -> R?
  func _copyToContiguousArray() -> Swift.ContiguousArray<Element>
}
extension ArraySlice : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension ArraySlice : CustomStringConvertible, CustomDebugStringConvertible {
  func _makeDescription(isDebug: Swift.Bool) -> Swift.String
  var description: Swift.String {
    get {}
  }
  var debugDescription: Swift.String {
    get {}
  }
}
extension ArraySlice {
  @_versioned func _cPointerArgs() -> (AnyObject?, Swift.UnsafeRawPointer?)
}
extension ArraySlice {
  func withUnsafeBufferPointer<R>(_ body: (Swift.UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
  @_semantics("array.withUnsafeMutableBufferPointer") @inline(__always) mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout Swift.UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension ArraySlice {
  @_semantics("array.mutate_unknown") mutating func replaceSubrange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subrange: Swift.Range<Swift.Int>, with newElements: C)
}
extension ArraySlice {
  init(_startIndex: Swift.Int)
}
extension ArraySlice {
  @available(*, unavailable, message: "Please use init(repeating:count:) instead") init(count: Swift.Int, repeatedValue: Element)
  @available(*, unavailable, renamed: "remove(at:)") mutating func removeAtIndex(_ index: Swift.Int) -> Element
  @available(*, unavailable, renamed: "replaceSubrange(_:with:)") mutating func replaceRange<C where C : Collection, C.Iterator.Element == _Buffer.Element>(_ subRange: Swift.Range<Swift.Int>, with newElements: C)
  @available(*, unavailable, renamed: "append(contentsOf:)") mutating func appendContentsOf<S : Sequence where S.Iterator.Element == Element>(_ newElements: S)
}
func _ascii16(_ c: Swift.UnicodeScalar) -> Swift.UTF16.CodeUnit
@available(*, unavailable, message: "use MemoryLayout<T>.size instead.") func sizeof<T>(_: T.Type) -> Swift.Int
func _float32ToString(_ value: Swift.Float32, debug: Swift.Bool) -> Swift.String
protocol _Mirror {
  var value: Any { get }
  var valueType: Any.Type { get }
  var objectIdentifier: Swift.ObjectIdentifier? { get }
  var count: Swift.Int { get }
  subscript(i: Swift.Int) -> (Swift.String, _Mirror) { get }
  var summary: Swift.String { get }
  var quickLookObject: Swift.PlaygroundQuickLook? { get }
  var disposition: Swift._MirrorDisposition { get }
}
extension _Mirror {
  func _superMirror() -> _Mirror?
}
@available(*, unavailable, message: "PermutationGenerator has been removed in Swift 3") struct PermutationGenerator<C : Collection, Indices : Sequence> {
  init()
}
struct StaticString : _ExpressibleByBuiltinUnicodeScalarLiteral, _ExpressibleByBuiltinExtendedGraphemeClusterLiteral, _ExpressibleByBuiltinStringLiteral, ExpressibleByUnicodeScalarLiteral, ExpressibleByExtendedGraphemeClusterLiteral, ExpressibleByStringLiteral, CustomStringConvertible, CustomDebugStringConvertible, CustomReflectable {
  var _startPtrOrData: Builtin.Word
  var _utf8CodeUnitCount: Builtin.Word
  var _flags: Builtin.Int8
  var utf8Start: Swift.UnsafePointer<Swift.UInt8> {
    get {}
  }
  var unicodeScalar: Swift.UnicodeScalar {
    get {}
  }
  var utf8CodeUnitCount: Swift.Int {
    get {}
  }
  var hasPointerRepresentation: Swift.Bool {
    get {}
  }
  var isASCII: Swift.Bool {
    get {}
  }
  func withUTF8Buffer<R>(_ body: (Swift.UnsafeBufferPointer<Swift.UInt8>) -> R) -> R
  init()
  @_versioned init(_start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
  @_versioned init(unicodeScalar: Builtin.Int32)
  init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
  init(unicodeScalarLiteral value: Swift.StaticString)
  init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
  init(extendedGraphemeClusterLiteral value: Swift.StaticString)
  init(_builtinStringLiteral start: Builtin.RawPointer, utf8CodeUnitCount: Builtin.Word, isASCII: Builtin.Int1)
  init(stringLiteral value: Swift.StaticString)
  var description: Swift.String {
    get {}
  }
  var debugDescription: Swift.String {
    get {}
  }
  typealias StringLiteralType = Swift.StaticString
  typealias ExtendedGraphemeClusterLiteralType = Swift.StaticString
  typealias UnicodeScalarLiteralType = Swift.StaticString
}
extension StaticString {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension StaticString {
  @available(*, unavailable, renamed: "utf8CodeUnitCount") var byteSize: Swift.Int {
    get {}
  }
  @available(*, unavailable, message: "use the 'String(_:)' initializer") var stringValue: Swift.String {
    get {}
  }
}
struct _Stdout : TextOutputStream {
  mutating func _lock()
  mutating func _unlock()
  mutating func write(_ string: Swift.String)
  init()
}
func _persistCString(_ p: Swift.UnsafePointer<Swift.CChar>?) -> [Swift.CChar]?
func unsafeDowncast<T : AnyObject>(_ x: AnyObject, to: T.Type) -> T
protocol ExpressibleByExtendedGraphemeClusterLiteral : ExpressibleByUnicodeScalarLiteral {
  associatedtype ExtendedGraphemeClusterLiteralType : _ExpressibleByBuiltinExtendedGraphemeClusterLiteral
  init(extendedGraphemeClusterLiteral value: Self.ExtendedGraphemeClusterLiteralType)
}
struct UInt16 : UnsignedInteger, Comparable, Equatable {
  var _value: Builtin.Int16
  init()
  init(_ _v: Builtin.Int16)
  init(_bits: Builtin.Int16)
  init(bigEndian value: Swift.UInt16)
  init(littleEndian value: Swift.UInt16)
  init(_builtinIntegerLiteral value: Builtin.Int2048)
  init(integerLiteral value: Swift.UInt16)
  var bigEndian: Swift.UInt16 {
    get {}
  }
  var littleEndian: Swift.UInt16 {
    get {}
  }
  var byteSwapped: Swift.UInt16 {
    get {}
  }
  static var max: Swift.UInt16 {
    get {}
  }
  static var min: Swift.UInt16 {
    get {}
  }
  static var _sizeInBits: Swift.UInt16 {
    get {}
  }
  static var _sizeInBytes: Swift.UInt16 {
    get {}
  }
  typealias IntegerLiteralType = Swift.UInt16
  typealias Stride = Swift.Int
  typealias _DisallowMixedSignArithmetic = Swift.Int
}
extension UInt16 : BitwiseOperations {
  static var allZeros: Swift.UInt16 {
    get {}
  }
}
extension UInt16 : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension UInt16 : Hashable {
  var hashValue: Swift.Int {
    @inline(__always) get {}
  }
}
extension UInt16 {
  static func addWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func subtractWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func multiplyWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func divideWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  static func remainderWithOverflow(_ lhs: Swift.UInt16, _ rhs: Swift.UInt16) -> (Swift.UInt16, overflow: Swift.Bool)
  func toUIntMax() -> Swift.UIntMax
  func toIntMax() -> Swift.IntMax
}
extension UInt16 {
  init(_ value: Swift.UInt8)
  @available(*, message: "Converting UInt8 to UInt16 will always succeed.") init?(exactly value: Swift.UInt8)
}
extension UInt16 {
  init(_ value: Swift.Int8)
  init?(exactly value: Swift.Int8)
}
extension UInt16 {
  init(_ value: Swift.UInt16)
  @available(*, message: "Converting UInt16 to UInt16 will always succeed.") init?(exactly value: Swift.UInt16)
}
extension UInt16 {
  init(_ value: Swift.Int16)
  init?(exactly value: Swift.Int16)
}
extension UInt16 {
  init(_ value: Swift.UInt32)
  init?(exactly value: Swift.UInt32)
  init(truncatingBitPattern: Swift.UInt32)
}
extension UInt16 {
  init(_ value: Swift.Int32)
  init?(exactly value: Swift.Int32)
  init(truncatingBitPattern: Swift.Int32)
}
extension UInt16 {
  init(_ value: Swift.UInt64)
  init?(exactly value: Swift.UInt64)
  init(truncatingBitPattern: Swift.UInt64)
}
extension UInt16 {
  init(_ value: Swift.Int64)
  init?(exactly value: Swift.Int64)
  init(truncatingBitPattern: Swift.Int64)
}
extension UInt16 {
  init(_ value: Swift.UInt)
  init?(exactly value: Swift.UInt)
  init(truncatingBitPattern: Swift.UInt)
}
extension UInt16 {
  init(_ value: Swift.Int)
  init?(exactly value: Swift.Int)
  init(truncatingBitPattern: Swift.Int)
}
extension UInt16 {
  init(bitPattern: Swift.Int16)
}
extension UInt16 {
  typealias _DisabledRangeIndex = Swift.UInt16
}
extension UInt16 {
  init(_ other: Swift.Float)
  init(_ other: Swift.Double)
  init(_ other: Swift.Float80)
}
extension UInt16 {
  init?(_ text: Swift.String, radix: Swift.Int = default)
}
extension UInt16 : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension UInt16 : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Swift.UTF16.CodeUnit : _StringElement {
  static func _toUTF16CodeUnit(_ x: Swift.UTF16.CodeUnit) -> Swift.UTF16.CodeUnit
  static func _fromUTF16CodeUnit(_ utf16: Swift.UTF16.CodeUnit) -> Swift.UTF16.CodeUnit
}
extension UInt16 : CVarArg {
  var _cVarArgEncoding: [Swift.Int] {
    get {}
  }
}
extension UInt16 {
  init(_ value: CoreGraphics.CGFloat)
}
@_silgen_name("swift_float64ToString") func _float64ToStringImpl(_ buffer: Swift.UnsafeMutablePointer<Swift.UTF8.CodeUnit>, _ bufferLength: Swift.UInt, _ value: Swift.Float64, _ debug: Swift.Bool) -> Swift.UInt
func _dictionaryDownCastConditional<BaseKey, BaseValue, DerivedKey, DerivedValue>(_ source: [BaseKey : BaseValue]) -> [DerivedKey : DerivedValue]?
struct Bool {
  var _value: Builtin.Int1
  init()
  @_versioned init(_ v: Builtin.Int1)
  init(_ value: Swift.Bool)
}
extension Bool : Equatable, Hashable {
  var hashValue: Swift.Int {
    get {}
  }
  static func ==(lhs: Swift.Bool, rhs: Swift.Bool) -> Swift.Bool
}
extension Bool : _ExpressibleByBuiltinBooleanLiteral, ExpressibleByBooleanLiteral {
  init(_builtinBooleanLiteral value: Builtin.Int1)
  init(booleanLiteral value: Swift.Bool)
  typealias BooleanLiteralType = Swift.Bool
}
extension Bool {
  func _getBuiltinLogicValue() -> Builtin.Int1
}
extension Bool : CustomStringConvertible {
  var description: Swift.String {
    get {}
  }
}
extension Bool : LosslessStringConvertible {
  init?(_ description: Swift.String)
}
extension Bool {
  prefix static func !(a: Swift.Bool) -> Swift.Bool
}
extension Bool {
  @inline(__always) static func &&(lhs: Swift.Bool, rhs: @autoclosure () throws -> Swift.Bool) rethrows -> Swift.Bool
  @inline(__always) static func ||(lhs: Swift.Bool, rhs: @autoclosure () throws -> Swift.Bool) rethrows -> Swift.Bool
}
extension Bool : CustomReflectable {
  var customMirror: Swift.Mirror {
    get {}
  }
}
extension Bool : CustomPlaygroundQuickLookable {
  var customPlaygroundQuickLook: Swift.PlaygroundQuickLook {
    get {}
  }
}
extension Bool : _ObjectiveCBridgeable {
  init(_ number: Foundation.NSNumber)
  @_semantics("convertToObjectiveC") func _bridgeToObjectiveC() -> Foundation.NSNumber
  static func _forceBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Bool?)
  static func _conditionallyBridgeFromObjectiveC(_ x: Foundation.NSNumber, result: inout Swift.Bool?) -> Swift.Bool
  static func _unconditionallyBridgeFromObjectiveC(_ source: Foundation.NSNumber?) -> Swift.Bool
  typealias _ObjectiveCType = Foundation.NSNumber
}
func _siftDown<C where C : MutableCollection & RandomAccessCollection>(_ elements: inout C, index: C.Index, subRange range: Swift.Range<C.Index>, by areInIncreasingOrder: inout @escaping (C.Iterator.Element, C.Iterator.Element) -> Swift.Bool)
func _siftDown<C where C : MutableCollection & RandomAccessCollection, C.Iterator.Element : Comparable>(_ elements: inout C, index: C.Index, subRange range: Swift.Range<C.Index>)
final class _NativeSetStorageOwner<Element : Hashable> : Swift._SwiftNativeNSSet, _NSSetCore {
  typealias NativeStorage = Swift._NativeSetStorage<Element>
  typealias BridgedNativeStorage = Swift._BridgedNativeSetStorage
  typealias Key = Element
  typealias Value = Element
  @objc init(minimumCapacity: Swift.Int = default)
  init(nativeStorage: Swift._NativeSetStorage<Element>)
  @objc final var _heapBufferBridged_DoNotUse: AnyObject?
  final var nativeStorage: Swift._NativeSetStorage<Element>
  @objc required init(objects: Swift.UnsafePointer<AnyObject?>, count: Swift.Int)
  @objc final func member(_ object: AnyObject) -> AnyObject?
  @objc final func objectEnumerator() -> _NSEnumerator
  @objc(copyWithZone:) final func copy(with zone: Swift._SwiftNSZone?) -> AnyObject
  @objc final var _heapBufferBridgedPtr: Swift.UnsafeMutablePointer<AnyObject?> {
    @objc final get {}
  }
  final var _bridgedBuffer: Swift._BridgedNativeSetStorage.StorageImpl? {
    final get {}
  }
  @objc final func _initializeHeapBufferBridged(_ newBuffer: AnyObject)
  @objc final func deinitializeHeapBufferBridged()
  final var bridgedNativeStorage: Swift._NativeSetStorageOwner.BridgedNativeStorage {
    final get {}
  }
  final func _createBridgedNativeStorage(_ capacity: Swift.Int) -> Swift._NativeSetStorageOwner.BridgedNativeStorage
  @objc final func bridgeEverything()
  final func _getBridgedKey(_ i: Swift._NativeSetIndex<Element>) -> AnyObject
  final func _getBridgedValue(_ i: Swift._NativeSetIndex<Element>) -> AnyObject
  @objc final var count: Swift.Int {
    @objc final get {}
  }
  @objc final func bridgingObjectForKey(_ aKey: AnyObject) -> AnyObject?
  @objc final func bridgingKeyEnumerator() -> _NSEnumerator
  @objc(countByEnumeratingWithState:objects:count:) final func countByEnumerating(with state: Swift.UnsafeMutablePointer<SwiftShims._SwiftNSFastEnumerationState>, objects: Swift.UnsafeMutablePointer<AnyObject>?, count: Swift.Int) -> Swift.Int
  @objc init()
  @objc deinit
}
func _fixLifetime<T>(_ x: T)
protocol RawRepresentable {
  associatedtype RawValue
  init?(rawValue: Self.RawValue)
  var rawValue: Self.RawValue { get }
}
struct FlattenIterator<Base : IteratorProtocol where Base.Element : Sequence> : IteratorProtocol, Sequence {
  init(_base: Base)
  mutating func next() -> Base.Element.Iterator.Element?
  var _base: Base
  var _inner: Base.Element.Iterator?
  typealias Element = Base.Element.Iterator.Element
  typealias Iterator = Swift.FlattenIterator<Base>
  typealias SubSequence = Swift.AnySequence<Base.Element.Iterator.Element>
}
func <<(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.UInt8
func <<(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Int8
func <<(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.UInt16
func <<(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Int16
func <<(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.UInt32
func <<(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Int32
func <<(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.UInt64
func <<(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Int64
func <<(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.UInt
func <<(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Int
func >>=(lhs: inout Swift.UInt8, rhs: Swift.UInt8)
func >>=(lhs: inout Swift.Int8, rhs: Swift.Int8)
func >>=(lhs: inout Swift.UInt16, rhs: Swift.UInt16)
func >>=(lhs: inout Swift.Int16, rhs: Swift.Int16)
func >>=(lhs: inout Swift.UInt32, rhs: Swift.UInt32)
func >>=(lhs: inout Swift.Int32, rhs: Swift.Int32)
func >>=(lhs: inout Swift.UInt64, rhs: Swift.UInt64)
func >>=(lhs: inout Swift.Int64, rhs: Swift.Int64)
func >>=(lhs: inout Swift.UInt, rhs: Swift.UInt)
func >>=(lhs: inout Swift.Int, rhs: Swift.Int)
func <=<T : Comparable>(lhs: T, rhs: T) -> Swift.Bool
func <=(lhs: Swift.UInt8, rhs: Swift.UInt8) -> Swift.Bool
func <=(lhs: Swift.Int8, rhs: Swift.Int8) -> Swift.Bool
func <=(lhs: Swift.UInt16, rhs: Swift.UInt16) -> Swift.Bool
func <=(lhs: Swift.Int16, rhs: Swift.Int16) -> Swift.Bool
func <=(lhs: Swift.UInt32, rhs: Swift.UInt32) -> Swift.Bool
func <=(lhs: Swift.Int32, rhs: Swift.Int32) -> Swift.Bool
func <=(lhs: Swift.UInt64, rhs: Swift.UInt64) -> Swift.Bool
func <=(lhs: Swift.Int64, rhs: Swift.Int64) -> Swift.Bool
func <=(lhs: Swift.UInt, rhs: Swift.UInt) -> Swift.Bool
func <=(lhs: Swift.Int, rhs: Swift.Int) -> Swift.Bool
func <=<T : FloatingPoint>(lhs: T, rhs: T) -> Swift.Bool
func <=<T : _SwiftNewtypeWrapper where T.RawValue : Comparable>(lhs: T, rhs: T) -> Swift.Bool
func <=<A : Comparable, B : Comparable>(lhs: (A, B), rhs: (A, B)) -> Swift.Bool
func <=<A : Comparable, B : Comparable, C : Comparable>(lhs: (A, B, C), rhs: (A, B, C)) -> Swift.Bool
func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable>(lhs: (A, B, C, D), rhs: (A, B, C, D)) -> Swift.Bool
func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable>(lhs: (A, B, C, D, E), rhs: (A, B, C, D, E)) -> Swift.Bool
func <=<A : Comparable, B : Comparable, C : Comparable, D : Comparable, E : Comparable, F : Comparable>(lhs: (A, B, C, D, E, F), rhs: (A, B, C, D, E, F)) -> Swift.Bool
func _swift_stdlib_atomicLoadInt32(object target: Swift.UnsafeMutablePointer<Swift.Int32>) -> Swift.Int32
@_silgen_name("swift_stdlib_NSStringHashValue") func _stdlib_NSStringHashValue(_ str: AnyObject, _ isASCII: Swift.Bool) -> Swift.Int
func _expectEnd<C : Collection>(_ i: C.Index, _ s: C)