struct AnyBidirectionalCollection<Element> : AnyCollectionType, CollectionType, Indexable, SequenceType {
    typealias T = Element
    init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyBidirectionalCollection<Element>)
    init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyRandomAccessCollection<Element>)
    init?(_ other: AnyForwardCollection<Element>)
    func generate() -> AnyGenerator<Element>
    var startIndex: AnyBidirectionalIndex { get }
    var endIndex: AnyBidirectionalIndex { get }
    subscript (_ position: AnyBidirectionalIndex) -> Element { get }
    var count: IntMax { get }
}
extension AnyBidirectionalCollection {
    func underestimateCount() -> Int
}

struct AnyBidirectionalCollection<Element> : AnyCollectionType {
    typealias T = Element
    init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyBidirectionalCollection<Element>)
    init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyRandomAccessCollection<Element>)
    init?(_ other: AnyForwardCollection<Element>)
    func generate() -> AnyGenerator<Element>
    var startIndex: AnyBidirectionalIndex { get }
    var endIndex: AnyBidirectionalIndex { get }
    subscript (_ position: AnyBidirectionalIndex) -> Element { get }
    var count: IntMax { get }
}
extension AnyBidirectionalCollection {
    func underestimateCount() -> Int
}

struct AnyBidirectionalIndex : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType {
    typealias Distance = IntMax
    init<BaseIndex : BidirectionalIndexType>(_ base: BaseIndex)
    func successor() -> AnyBidirectionalIndex
    func predecessor() -> AnyBidirectionalIndex
}

struct AnyBidirectionalIndex : BidirectionalIndexType {
    typealias Distance = IntMax
    init<BaseIndex : BidirectionalIndexType>(_ base: BaseIndex)
    func successor() -> AnyBidirectionalIndex
    func predecessor() -> AnyBidirectionalIndex
}

struct AnyForwardCollection<Element> : AnyCollectionType, CollectionType, Indexable, SequenceType {
    typealias T = Element
    init<C : CollectionType where C.Index : ForwardIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyForwardCollection<Element>)
    init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyBidirectionalCollection<Element>)
    init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyRandomAccessCollection<Element>)
    func generate() -> AnyGenerator<Element>
    var startIndex: AnyForwardIndex { get }
    var endIndex: AnyForwardIndex { get }
    subscript (_ position: AnyForwardIndex) -> Element { get }
    var count: IntMax { get }
}
extension AnyForwardCollection {
    func underestimateCount() -> Int
}

struct AnyForwardCollection<Element> : AnyCollectionType {
    typealias T = Element
    init<C : CollectionType where C.Index : ForwardIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyForwardCollection<Element>)
    init<C : CollectionType where C.Index : BidirectionalIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyBidirectionalCollection<Element>)
    init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyRandomAccessCollection<Element>)
    func generate() -> AnyGenerator<Element>
    var startIndex: AnyForwardIndex { get }
    var endIndex: AnyForwardIndex { get }
    subscript (_ position: AnyForwardIndex) -> Element { get }
    var count: IntMax { get }
}
extension AnyForwardCollection {
    func underestimateCount() -> Int
}

struct AnyForwardIndex : ForwardIndexType, _Incrementable, Equatable {
    typealias Distance = IntMax
    init<BaseIndex : ForwardIndexType>(_ base: BaseIndex)
    func successor() -> AnyForwardIndex
}

struct AnyForwardIndex : ForwardIndexType {
    typealias Distance = IntMax
    init<BaseIndex : ForwardIndexType>(_ base: BaseIndex)
    func successor() -> AnyForwardIndex
}

struct AnyRandomAccessCollection<Element> : AnyCollectionType, CollectionType, Indexable, SequenceType {
    typealias T = Element
    init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyRandomAccessCollection<Element>)
    init?(_ other: AnyForwardCollection<Element>)
    init?(_ other: AnyBidirectionalCollection<Element>)
    func generate() -> AnyGenerator<Element>
    var startIndex: AnyRandomAccessIndex { get }
    var endIndex: AnyRandomAccessIndex { get }
    subscript (_ position: AnyRandomAccessIndex) -> Element { get }
    var count: IntMax { get }
}
extension AnyRandomAccessCollection {
    func underestimateCount() -> Int
}

struct AnyRandomAccessCollection<Element> : AnyCollectionType {
    typealias T = Element
    init<C : CollectionType where C.Index : RandomAccessIndexType, C.Generator.Element == Element>(_ base: C)
    init(_ other: AnyRandomAccessCollection<Element>)
    init?(_ other: AnyForwardCollection<Element>)
    init?(_ other: AnyBidirectionalCollection<Element>)
    func generate() -> AnyGenerator<Element>
    var startIndex: AnyRandomAccessIndex { get }
    var endIndex: AnyRandomAccessIndex { get }
    subscript (_ position: AnyRandomAccessIndex) -> Element { get }
    var count: IntMax { get }
}
extension AnyRandomAccessCollection {
    func underestimateCount() -> Int
}

struct AnyRandomAccessIndex : ForwardIndexType, _Incrementable, Equatable, RandomAccessIndexType, BidirectionalIndexType, Strideable, Comparable, _Strideable, _RandomAccessAmbiguity {
    typealias Distance = IntMax
    init<BaseIndex : RandomAccessIndexType>(_ base: BaseIndex)
    func successor() -> AnyRandomAccessIndex
    func predecessor() -> AnyRandomAccessIndex
    func distanceTo(_ other: AnyRandomAccessIndex) -> Distance
    func advancedBy(_ amount: Distance) -> AnyRandomAccessIndex
    func advancedBy(_ amount: Distance, limit limit: AnyRandomAccessIndex) -> AnyRandomAccessIndex
}

struct AnyRandomAccessIndex : RandomAccessIndexType {
    typealias Distance = IntMax
    init<BaseIndex : RandomAccessIndexType>(_ base: BaseIndex)
    func successor() -> AnyRandomAccessIndex
    func predecessor() -> AnyRandomAccessIndex
    func distanceTo(_ other: AnyRandomAccessIndex) -> Distance
    func advancedBy(_ amount: Distance) -> AnyRandomAccessIndex
    func advancedBy(_ amount: Distance, limit limit: AnyRandomAccessIndex) -> AnyRandomAccessIndex
}

struct Array<Element> : CollectionType, Indexable, SequenceType, MutableCollectionType, MutableIndexable, _DestructorSafeContainer {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ index: Int) -> Element
    subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
}
extension Array : _ObjectiveCBridgeable {
}
extension Array : ArrayLiteralConvertible {
    init(arrayLiteral elements: Element...)
}
extension Array : _ArrayType, MutableSliceable, RangeReplaceableCollectionType {
    init()
    init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: Element)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S)
    mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C)
    mutating func removeLast() -> Element
    mutating func insert(_ newElement: Element, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
}
extension Array : _Reflectable {
}
extension Array : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Array {
    @rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    @rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension Array {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
}
extension Array {
    mutating func popLast() -> Element?
}

struct Array<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ index: Int) -> Element
    subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
}
extension Array : _ObjectiveCBridgeable {
}
extension Array : ArrayLiteralConvertible {
    init(arrayLiteral elements: Element...)
}
extension Array : _ArrayType {
    init()
    init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: Element)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S)
    mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C)
    mutating func removeLast() -> Element
    mutating func insert(_ newElement: Element, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> [Element]
}
extension Array : _Reflectable {
}
extension Array : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Array {
    func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension Array {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
}
extension Array {
    mutating func popLast() -> Element?
}

@rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

@rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

struct ArraySlice<Element> : Indexable, SequenceType, CollectionType, MutableCollectionType, MutableIndexable, _DestructorSafeContainer {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ index: Int) -> Element
    subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
}
extension ArraySlice : ArrayLiteralConvertible {
    init(arrayLiteral elements: Element...)
}
extension ArraySlice : _ArrayType, MutableSliceable, RangeReplaceableCollectionType {
    init()
    init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: Element)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S)
    mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C)
    mutating func removeLast() -> Element
    mutating func insert(_ newElement: Element, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> ArraySlice<Element>
}
extension ArraySlice : _Reflectable {
}
extension ArraySlice : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension ArraySlice {
    @rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    @rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension ArraySlice {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
}

struct ArraySlice<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ index: Int) -> Element
    subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
}
extension ArraySlice : ArrayLiteralConvertible {
    init(arrayLiteral elements: Element...)
}
extension ArraySlice : _ArrayType {
    init()
    init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: Element)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S)
    mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C)
    mutating func removeLast() -> Element
    mutating func insert(_ newElement: Element, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> ArraySlice<Element>
}
extension ArraySlice : _Reflectable {
}
extension ArraySlice : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension ArraySlice {
    func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension ArraySlice {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
}

@rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

@rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

enum Bit : Int, _Incrementable, Comparable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity, _Reflectable {
    typealias Distance = Int
    case Zero
    case One
    func successor() -> Bit
    func predecessor() -> Bit
    func distanceTo(_ other: Bit) -> Int
    func advancedBy(_ n: Distance) -> Bit
}
extension Bit : IntegerArithmeticType, _IntegerArithmeticType {
    static func addWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool)
    static func divideWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool)
    func toIntMax() -> IntMax
}

enum Bit : Int, Comparable, RandomAccessIndexType, _Reflectable {
    typealias Distance = Int
    case Zero
    case One
    func successor() -> Bit
    func predecessor() -> Bit
    func distanceTo(_ other: Bit) -> Int
    func advancedBy(_ n: Distance) -> Bit
}
extension Bit : IntegerArithmeticType {
    static func addWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool)
    static func divideWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Bit, _ rhs: Bit) -> (Bit, overflow: Bool)
    func toIntMax() -> IntMax
}

struct Character : Hashable, Equatable, ExtendedGraphemeClusterLiteralConvertible, UnicodeScalarLiteralConvertible, Comparable {
    init(_ scalar: UnicodeScalar)
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
    init(unicodeScalarLiteral value: Character)
    init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    init(extendedGraphemeClusterLiteral value: Character)
    init(_ s: String)
    var hashValue: Int { get }
}
extension Character : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Character : _Reflectable {
}
extension Character : Streamable {
    func writeTo<Target : OutputStreamType>(inout _ target: Target)
}

struct Character : ExtendedGraphemeClusterLiteralConvertible, Equatable, Hashable, Comparable {
    init(_ scalar: UnicodeScalar)
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
    init(unicodeScalarLiteral value: Character)
    init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    init(extendedGraphemeClusterLiteral value: Character)
    init(_ s: String)
    var hashValue: Int { get }
}
extension Character : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension Character : _Reflectable {
}
extension Character : Streamable {
    func writeTo<Target : OutputStreamType>(inout _ target: Target)
}

struct CollectionOfOne<Element> : CollectionType, Indexable, SequenceType {
    typealias T = Element
    typealias Index = Bit
    init(_ element: Element)
    var startIndex: Index { get }
    var endIndex: Index { get }
    func generate() -> GeneratorOfOne<Element>
    subscript (_ position: Index) -> Element { get }
    var count: Int { get }
}
extension CollectionOfOne : _Reflectable {
}

struct CollectionOfOne<Element> : CollectionType {
    typealias T = Element
    typealias Index = Bit
    init(_ element: Element)
    var startIndex: Index { get }
    var endIndex: Index { get }
    func generate() -> GeneratorOfOne<Element>
    subscript (_ position: Index) -> Element { get }
    var count: Int { get }
}
extension CollectionOfOne : _Reflectable {
}

@warn_unused_result
    @rethrows func indexOf(@noescape _ predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Self.Index?

@warn_unused_result
    func indexOf(@noescape _ predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Self.Index?

@warn_unused_result
    @rethrows func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T]

@warn_unused_result
    func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T]

@warn_unused_result
    @rethrows func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]

@warn_unused_result
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]

struct ContiguousArray<Element> : CollectionType, Indexable, SequenceType, MutableCollectionType, MutableIndexable, _DestructorSafeContainer {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ index: Int) -> Element
    subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
}
extension ContiguousArray : ArrayLiteralConvertible {
    init(arrayLiteral elements: Element...)
}
extension ContiguousArray : _ArrayType, MutableSliceable, RangeReplaceableCollectionType {
    init()
    init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: Element)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S)
    mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C)
    mutating func removeLast() -> Element
    mutating func insert(_ newElement: Element, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> ContiguousArray<Element>
}
extension ContiguousArray : _Reflectable {
}
extension ContiguousArray : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension ContiguousArray {
    @rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    @rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension ContiguousArray {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
}
extension ContiguousArray {
    mutating func popLast() -> Element?
}

struct ContiguousArray<Element> : CollectionType, MutableCollectionType, _DestructorSafeContainer {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ index: Int) -> Element
    subscript (_ subRange: Range<Int>) -> ArraySlice<Element>
}
extension ContiguousArray : ArrayLiteralConvertible {
    init(arrayLiteral elements: Element...)
}
extension ContiguousArray : _ArrayType {
    init()
    init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: Element)
    var count: Int { get }
    var capacity: Int { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Element>(_ newElements: S)
    mutating func appendContentsOf<C : CollectionType where C.Generator.Element == Element>(_ newElements: C)
    mutating func removeLast() -> Element
    mutating func insert(_ newElement: Element, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func sorted(_ isOrderedBefore: (Element, Element) -> Bool) -> ContiguousArray<Element>
}
extension ContiguousArray : _Reflectable {
}
extension ContiguousArray : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension ContiguousArray {
    func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R
    mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R
}
extension ContiguousArray {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == _Buffer.Element>(_ subRange: Range<Int>, with newElements: C)
}
extension ContiguousArray {
    mutating func popLast() -> Element?
}

@rethrows func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

func withUnsafeBufferPointer<R>(@noescape _ body: (UnsafeBufferPointer<Element>) throws -> R) rethrows -> R

@rethrows mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

mutating func withUnsafeMutableBufferPointer<R>(@noescape _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R

struct Dictionary<Key : Hashable, Value> : CollectionType, Indexable, SequenceType, DictionaryLiteralConvertible {
    typealias Element = (Key, Value)
    typealias Index = DictionaryIndex<Key, Value>
    init()
    init(minimumCapacity minimumCapacity: Int)
    var startIndex: DictionaryIndex<Key, Value> { get }
    var endIndex: DictionaryIndex<Key, Value> { get }
    @warn_unused_result
    func indexForKey(_ key: Key) -> DictionaryIndex<Key, Value>?
    subscript (_ position: DictionaryIndex<Key, Value>) -> (Key, Value) { get }
    subscript (_ key: Key) -> Value?
    mutating func updateValue(_ value: Value, forKey key: Key) -> Value?
    mutating func removeAtIndex(_ index: DictionaryIndex<Key, Value>) -> (Key, Value)
    mutating func removeValueForKey(_ key: Key) -> Value?
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    var count: Int { get }
    func generate() -> DictionaryGenerator<Key, Value>
    init(dictionaryLiteral elements: (Key, Value)...)
    var keys: LazyMapCollection<[Key : Value], Key> { get }
    var values: LazyMapCollection<[Key : Value], Value> { get }
    var isEmpty: Bool { get }
}
extension Dictionary : _ObjectiveCBridgeable {
}
extension Dictionary : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Dictionary : _Reflectable {
}
extension Dictionary {
    mutating func popFirst() -> (Key, Value)?
}

struct Dictionary<Key : Hashable, Value> : CollectionType, DictionaryLiteralConvertible {
    typealias Element = (Key, Value)
    typealias Index = DictionaryIndex<Key, Value>
    init()
    init(minimumCapacity minimumCapacity: Int)
    var startIndex: DictionaryIndex<Key, Value> { get }
    var endIndex: DictionaryIndex<Key, Value> { get }
    @warn_unused_result
    func indexForKey(_ key: Key) -> DictionaryIndex<Key, Value>?
    subscript (_ position: DictionaryIndex<Key, Value>) -> (Key, Value) { get }
    subscript (_ key: Key) -> Value?
    mutating func updateValue(_ value: Value, forKey key: Key) -> Value?
    mutating func removeAtIndex(_ index: DictionaryIndex<Key, Value>) -> (Key, Value)
    mutating func removeValueForKey(_ key: Key) -> Value?
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    var count: Int { get }
    func generate() -> DictionaryGenerator<Key, Value>
    init(dictionaryLiteral elements: (Key, Value)...)
    var keys: LazyMapCollection<[Key : Value], Key> { get }
    var values: LazyMapCollection<[Key : Value], Value> { get }
    var isEmpty: Bool { get }
}
extension Dictionary : _ObjectiveCBridgeable {
}
extension Dictionary : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Dictionary : _Reflectable {
}
extension Dictionary {
    mutating func popFirst() -> (Key, Value)?
}

struct DictionaryIndex<Key : Hashable, Value> : ForwardIndexType, _Incrementable, Equatable, Comparable {
    func successor() -> DictionaryIndex<Key, Value>
}

struct DictionaryIndex<Key : Hashable, Value> : ForwardIndexType, Comparable {
    func successor() -> DictionaryIndex<Key, Value>
}

struct DictionaryLiteral<Key, Value> : DictionaryLiteralConvertible {
    init(dictionaryLiteral elements: (Key, Value)...)
}
extension DictionaryLiteral : CollectionType, Indexable, SequenceType {
    var startIndex: Int { get }
    var endIndex: Int { get }
    typealias Element = (Key, Value)
    subscript (_ position: Int) -> (Key, Value) { get }
}

struct DictionaryLiteral<Key, Value> : DictionaryLiteralConvertible {
    init(dictionaryLiteral elements: (Key, Value)...)
}
extension DictionaryLiteral : CollectionType {
    var startIndex: Int { get }
    var endIndex: Int { get }
    typealias Element = (Key, Value)
    subscript (_ position: Int) -> (Key, Value) { get }
}

struct Double {
    var value: Builtin.FPIEEE64
    init()
    init(_bits v: Builtin.FPIEEE64)
    init(_ value: Double)
}
extension Double {
    init(_ value: CGFloat)
}
extension Double : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Double : CustomStringConvertible {
    var description: String { get }
}
extension Double : FloatingPointType {
    static var infinity: Double { get }
    static var NaN: Double { get }
    static var quietNaN: Double { get }
    var isSignMinus: Bool { get }
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignaling: Bool { get }
}
extension Double {
    var floatingPointClass: FloatingPointClassification { get }
}
extension Double : IntegerLiteralConvertible {
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
}
extension Double {
    init(_builtinFloatLiteral value: Builtin.FPIEEE64)
}
extension Double : FloatLiteralConvertible {
    init(floatLiteral value: Double)
}
extension Double : Comparable, Equatable {
}
extension Double : Hashable {
    var hashValue: Int { get }
}
extension Double : SignedNumberType, AbsoluteValuable {
    @warn_unused_result
    static func abs(_ x: Double) -> Double
}
extension Double {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
}
extension Double {
    init(_ other: Float)
}
extension Double : Strideable, _Strideable {
    func distanceTo(_ other: Double) -> Double
    func advancedBy(_ amount: Double) -> Double
}
extension Double {
    init?(_ text: String)
}
extension Double : _Reflectable {
}
extension Double : _CVarArgPassedAsDouble, CVarArgType, _CVarArgAlignedType {
}

struct Double {
    var value: Builtin.FPIEEE64
    init()
    init(_bits v: Builtin.FPIEEE64)
    init(_ value: Double)
}
extension Double {
    init(_ value: CGFloat)
}
extension Double : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Double : CustomStringConvertible {
    var description: String { get }
}
extension Double : FloatingPointType {
    static var infinity: Double { get }
    static var NaN: Double { get }
    static var quietNaN: Double { get }
    var isSignMinus: Bool { get }
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignaling: Bool { get }
}
extension Double {
    var floatingPointClass: FloatingPointClassification { get }
}
extension Double : IntegerLiteralConvertible {
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
}
extension Double {
    init(_builtinFloatLiteral value: Builtin.FPIEEE64)
}
extension Double : FloatLiteralConvertible {
    init(floatLiteral value: Double)
}
extension Double : Comparable, Equatable {
}
extension Double : Hashable {
    var hashValue: Int { get }
}
extension Double : AbsoluteValuable {
    @warn_unused_result
    static func abs(_ x: Double) -> Double
}
extension Double {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
}
extension Double {
    init(_ other: Float)
}
extension Double : Strideable {
    func distanceTo(_ other: Double) -> Double
    func advancedBy(_ amount: Double) -> Double
}
extension Double {
    init?(_ text: String)
}
extension Double : _Reflectable {
}
extension Double : _CVarArgPassedAsDouble, _CVarArgAlignedType {
}

struct EmptyCollection<Element> : CollectionType, Indexable, SequenceType {
    typealias T = Element
    typealias Index = Int
    init()
    var startIndex: Index { get }
    var endIndex: Index { get }
    func generate() -> EmptyGenerator<Element>
    subscript (_ position: Index) -> Element { get }
    var count: Int { get }
}
extension EmptyCollection : _Reflectable {
}

struct EmptyCollection<Element> : CollectionType {
    typealias T = Element
    typealias Index = Int
    init()
    var startIndex: Index { get }
    var endIndex: Index { get }
    func generate() -> EmptyGenerator<Element>
    subscript (_ position: Index) -> Element { get }
    var count: Int { get }
}
extension EmptyCollection : _Reflectable {
}

struct FlattenBidirectionalCollection<Base : CollectionType where Base.Generator.Element : CollectionType, Base.Index : BidirectionalIndexType, Base.Generator.Element.Index : BidirectionalIndexType> : CollectionType, Indexable, SequenceType {
    typealias Index = FlattenBidirectionalCollectionIndex<Base>
    init(_ base: Base)
    func generate() -> FlattenGenerator<Base.Generator>
    var startIndex: FlattenBidirectionalCollectionIndex<Base> { get }
    var endIndex: FlattenBidirectionalCollectionIndex<Base> { get }
    subscript (_ position: FlattenBidirectionalCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element { get }
    func underestimateCount() -> Int
}

struct FlattenBidirectionalCollection<Base : CollectionType where Base.Generator.Element : CollectionType, Base.Index : BidirectionalIndexType, Base.Generator.Element.Index : BidirectionalIndexType> : CollectionType {
    typealias Index = FlattenBidirectionalCollectionIndex<Base>
    init(_ base: Base)
    func generate() -> FlattenGenerator<Base.Generator>
    var startIndex: FlattenBidirectionalCollectionIndex<Base> { get }
    var endIndex: FlattenBidirectionalCollectionIndex<Base> { get }
    subscript (_ position: FlattenBidirectionalCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element { get }
    func underestimateCount() -> Int
}

struct FlattenBidirectionalCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType, BaseElements.Index : BidirectionalIndexType, BaseElements.Generator.Element.Index : BidirectionalIndexType> : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType {
    func successor() -> FlattenBidirectionalCollectionIndex<BaseElements>
    func predecessor() -> FlattenBidirectionalCollectionIndex<BaseElements>
}

struct FlattenBidirectionalCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType, BaseElements.Index : BidirectionalIndexType, BaseElements.Generator.Element.Index : BidirectionalIndexType> : BidirectionalIndexType {
    func successor() -> FlattenBidirectionalCollectionIndex<BaseElements>
    func predecessor() -> FlattenBidirectionalCollectionIndex<BaseElements>
}

struct FlattenCollection<Base : CollectionType where Base.Generator.Element : CollectionType> : CollectionType, Indexable, SequenceType {
    typealias Index = FlattenCollectionIndex<Base>
    init(_ base: Base)
    func generate() -> FlattenGenerator<Base.Generator>
    var startIndex: FlattenCollectionIndex<Base> { get }
    var endIndex: FlattenCollectionIndex<Base> { get }
    subscript (_ position: FlattenCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element { get }
    func underestimateCount() -> Int
}

struct FlattenCollection<Base : CollectionType where Base.Generator.Element : CollectionType> : CollectionType {
    typealias Index = FlattenCollectionIndex<Base>
    init(_ base: Base)
    func generate() -> FlattenGenerator<Base.Generator>
    var startIndex: FlattenCollectionIndex<Base> { get }
    var endIndex: FlattenCollectionIndex<Base> { get }
    subscript (_ position: FlattenCollectionIndex<Base>) -> Base.Generator.Element.Generator.Element { get }
    func underestimateCount() -> Int
}

struct FlattenCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType> : ForwardIndexType, _Incrementable, Equatable {
    func successor() -> FlattenCollectionIndex<BaseElements>
}

struct FlattenCollectionIndex<BaseElements : CollectionType where BaseElements.Generator.Element : CollectionType> : ForwardIndexType {
    func successor() -> FlattenCollectionIndex<BaseElements>
}

struct Float {
    var value: Builtin.FPIEEE32
    init()
    init(_bits v: Builtin.FPIEEE32)
    init(_ value: Float)
}
extension Float {
    init(_ value: CGFloat)
}
extension Float : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Float : CustomStringConvertible {
    var description: String { get }
}
extension Float : FloatingPointType {
    static var infinity: Float { get }
    static var NaN: Float { get }
    static var quietNaN: Float { get }
    var isSignMinus: Bool { get }
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignaling: Bool { get }
}
extension Float {
    var floatingPointClass: FloatingPointClassification { get }
}
extension Float : IntegerLiteralConvertible {
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
}
extension Float {
    init(_builtinFloatLiteral value: Builtin.FPIEEE64)
}
extension Float : FloatLiteralConvertible {
    init(floatLiteral value: Float)
}
extension Float : Comparable, Equatable {
}
extension Float : Hashable {
    var hashValue: Int { get }
}
extension Float : SignedNumberType, AbsoluteValuable {
    @warn_unused_result
    static func abs(_ x: Float) -> Float
}
extension Float {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
}
extension Float {
    init(_ other: Double)
}
extension Float : Strideable, _Strideable {
    func distanceTo(_ other: Float) -> Float
    func advancedBy(_ amount: Float) -> Float
}
extension Float {
    init?(_ text: String)
}
extension Float : _Reflectable {
}
extension Float : _CVarArgPassedAsDouble, CVarArgType, _CVarArgAlignedType {
}

struct Float {
    var value: Builtin.FPIEEE32
    init()
    init(_bits v: Builtin.FPIEEE32)
    init(_ value: Float)
}
extension Float {
    init(_ value: CGFloat)
}
extension Float : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Float : CustomStringConvertible {
    var description: String { get }
}
extension Float : FloatingPointType {
    static var infinity: Float { get }
    static var NaN: Float { get }
    static var quietNaN: Float { get }
    var isSignMinus: Bool { get }
    var isNormal: Bool { get }
    var isFinite: Bool { get }
    var isZero: Bool { get }
    var isSubnormal: Bool { get }
    var isInfinite: Bool { get }
    var isNaN: Bool { get }
    var isSignaling: Bool { get }
}
extension Float {
    var floatingPointClass: FloatingPointClassification { get }
}
extension Float : IntegerLiteralConvertible {
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
}
extension Float {
    init(_builtinFloatLiteral value: Builtin.FPIEEE64)
}
extension Float : FloatLiteralConvertible {
    init(floatLiteral value: Float)
}
extension Float : Comparable, Equatable {
}
extension Float : Hashable {
    var hashValue: Int { get }
}
extension Float : AbsoluteValuable {
    @warn_unused_result
    static func abs(_ x: Float) -> Float
}
extension Float {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
}
extension Float {
    init(_ other: Double)
}
extension Float : Strideable {
    func distanceTo(_ other: Float) -> Float
    func advancedBy(_ amount: Float) -> Float
}
extension Float {
    init?(_ text: String)
}
extension Float : _Reflectable {
}
extension Float : _CVarArgPassedAsDouble, _CVarArgAlignedType {
}

enum ImplicitlyUnwrappedOptional<Wrapped> : _Reflectable, NilLiteralConvertible {
    case None
    case Some(Wrapped)
    typealias T = Wrapped
    init()
    init(_ some: Wrapped)
    init(_ v: Wrapped?)
    init(nilLiteral nilLiteral: ())
    @warn_unused_result
    @rethrows func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U!
    @warn_unused_result
    @rethrows func flatMap<U>(@noescape _ f: (Wrapped) throws -> U!) rethrows -> U!
}
extension ImplicitlyUnwrappedOptional : CustomStringConvertible {
    var description: String { get }
}
extension ImplicitlyUnwrappedOptional : _ObjectiveCBridgeable {
}

enum ImplicitlyUnwrappedOptional<Wrapped> : _Reflectable, NilLiteralConvertible {
    case None
    case Some(Wrapped)
    typealias T = Wrapped
    init()
    init(_ some: Wrapped)
    init(_ v: Wrapped?)
    init(nilLiteral nilLiteral: ())
    @warn_unused_result
    func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U!
    @warn_unused_result
    func flatMap<U>(@noescape _ f: (Wrapped) throws -> U!) rethrows -> U!
}
extension ImplicitlyUnwrappedOptional : CustomStringConvertible {
    var description: String { get }
}
extension ImplicitlyUnwrappedOptional : _ObjectiveCBridgeable {
}

@warn_unused_result
    @rethrows func flatMap<U>(@noescape _ f: (Wrapped) throws -> U!) rethrows -> U!

@warn_unused_result
    func flatMap<U>(@noescape _ f: (Wrapped) throws -> U!) rethrows -> U!

@warn_unused_result
    @rethrows func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U!

@warn_unused_result
    func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U!

struct Int : Equatable, _SignedIntegerType, Comparable, _IntegerType, IntegerArithmeticType, _IntegerArithmeticType, IntegerType, SignedIntegerType {
    var value: Builtin.Int32
    typealias Distance = Int
    init()
    init(_ v: Builtin.Word)
    init(_ value: Int)
    init(bigEndian value: Int)
    init(littleEndian value: Int)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int)
    var bigEndian: Int { get }
    var littleEndian: Int { get }
    var byteSwapped: Int { get }
    static var max: Int { get }
    static var min: Int { get }
}
extension Int {
    init(_ value: CGFloat)
}
extension Int : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Int : ForwardIndexType, _Incrementable, RandomAccessIndexType, BidirectionalIndexType, Strideable, _Strideable, _RandomAccessAmbiguity {
    func successor() -> Int
    func predecessor() -> Int
    func distanceTo(_ other: Int) -> Distance
    func advancedBy(_ n: Distance) -> Int
}
extension Int : Hashable {
    var hashValue: Int { get }
}
extension Int : CustomStringConvertible {
    var description: String { get }
}
extension Int {
    static func addWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int : SignedNumberType, IntegerLiteralConvertible {
}
extension Int {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(bitPattern bitPattern: UInt)
}
extension Int : BitwiseOperationsType {
    static var allZeros: Int { get }
}
extension Int {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int {
    init?(_ text: String, radix radix: Int = default)
}
extension Int : _Reflectable {
}
extension Int : MirrorPathType {
}
extension Int : CVarArgType {
}

struct Int : SignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int32
    typealias Distance = Int
    init()
    init(_ v: Builtin.Word)
    init(_ value: Int)
    init(bigEndian value: Int)
    init(littleEndian value: Int)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int)
    var bigEndian: Int { get }
    var littleEndian: Int { get }
    var byteSwapped: Int { get }
    static var max: Int { get }
    static var min: Int { get }
}
extension Int {
    init(_ value: CGFloat)
}
extension Int : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Int : RandomAccessIndexType {
    func successor() -> Int
    func predecessor() -> Int
    func distanceTo(_ other: Int) -> Distance
    func advancedBy(_ n: Distance) -> Int
}
extension Int : Hashable {
    var hashValue: Int { get }
}
extension Int : CustomStringConvertible {
    var description: String { get }
}
extension Int {
    static func addWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int, _ rhs: Int) -> (Int, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int : SignedNumberType {
}
extension Int {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(bitPattern bitPattern: UInt)
}
extension Int : BitwiseOperationsType {
    static var allZeros: Int { get }
}
extension Int {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int {
    init?(_ text: String, radix radix: Int = default)
}
extension Int : _Reflectable {
}
extension Int : MirrorPathType {
}
extension Int : CVarArgType {
}

struct Int16 : _IntegerArithmeticType, Comparable, Equatable, _SignedIntegerType, _IntegerType, IntegerArithmeticType, IntegerType, SignedIntegerType {
    var value: Builtin.Int16
    typealias Distance = Int
    init()
    init(_ value: Int16)
    init(bigEndian value: Int16)
    init(littleEndian value: Int16)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int16)
    var bigEndian: Int16 { get }
    var littleEndian: Int16 { get }
    var byteSwapped: Int16 { get }
    static var max: Int16 { get }
    static var min: Int16 { get }
}
extension Int16 {
    init(_ value: CGFloat)
}
extension Int16 : Hashable {
    var hashValue: Int { get }
}
extension Int16 : CustomStringConvertible {
    var description: String { get }
}
extension Int16 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity {
    func successor() -> Int16
    func predecessor() -> Int16
    func distanceTo(_ other: Int16) -> Distance
    func advancedBy(_ n: Distance) -> Int16
}
extension Int16 {
    static func addWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int16 : SignedNumberType, IntegerLiteralConvertible {
}
extension Int16 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt16)
}
extension Int16 : BitwiseOperationsType {
    static var allZeros: Int16 { get }
}
extension Int16 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int16 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int16 : _Reflectable {
}
extension Int16 : CVarArgType {
}

struct Int16 : SignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int16
    typealias Distance = Int
    init()
    init(_ value: Int16)
    init(bigEndian value: Int16)
    init(littleEndian value: Int16)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int16)
    var bigEndian: Int16 { get }
    var littleEndian: Int16 { get }
    var byteSwapped: Int16 { get }
    static var max: Int16 { get }
    static var min: Int16 { get }
}
extension Int16 {
    init(_ value: CGFloat)
}
extension Int16 : Hashable {
    var hashValue: Int { get }
}
extension Int16 : CustomStringConvertible {
    var description: String { get }
}
extension Int16 : RandomAccessIndexType {
    func successor() -> Int16
    func predecessor() -> Int16
    func distanceTo(_ other: Int16) -> Distance
    func advancedBy(_ n: Distance) -> Int16
}
extension Int16 {
    static func addWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int16, _ rhs: Int16) -> (Int16, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int16 : SignedNumberType {
}
extension Int16 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt16)
}
extension Int16 : BitwiseOperationsType {
    static var allZeros: Int16 { get }
}
extension Int16 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int16 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int16 : _Reflectable {
}
extension Int16 : CVarArgType {
}

struct Int32 : _IntegerArithmeticType, Comparable, Equatable, _SignedIntegerType, _IntegerType, IntegerArithmeticType, IntegerType, SignedIntegerType {
    var value: Builtin.Int32
    typealias Distance = Int
    init()
    init(_ value: Int32)
    init(bigEndian value: Int32)
    init(littleEndian value: Int32)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int32)
    var bigEndian: Int32 { get }
    var littleEndian: Int32 { get }
    var byteSwapped: Int32 { get }
    static var max: Int32 { get }
    static var min: Int32 { get }
}
extension Int32 {
    init(_ value: CGFloat)
}
extension Int32 : Hashable {
    var hashValue: Int { get }
}
extension Int32 : CustomStringConvertible {
    var description: String { get }
}
extension Int32 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity {
    func successor() -> Int32
    func predecessor() -> Int32
    func distanceTo(_ other: Int32) -> Distance
    func advancedBy(_ n: Distance) -> Int32
}
extension Int32 {
    static func addWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int32 : SignedNumberType, IntegerLiteralConvertible {
}
extension Int32 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt32)
}
extension Int32 : BitwiseOperationsType {
    static var allZeros: Int32 { get }
}
extension Int32 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int32 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int32 : _Reflectable {
}
extension Int32 : CVarArgType {
}

struct Int32 : SignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int32
    typealias Distance = Int
    init()
    init(_ value: Int32)
    init(bigEndian value: Int32)
    init(littleEndian value: Int32)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int32)
    var bigEndian: Int32 { get }
    var littleEndian: Int32 { get }
    var byteSwapped: Int32 { get }
    static var max: Int32 { get }
    static var min: Int32 { get }
}
extension Int32 {
    init(_ value: CGFloat)
}
extension Int32 : Hashable {
    var hashValue: Int { get }
}
extension Int32 : CustomStringConvertible {
    var description: String { get }
}
extension Int32 : RandomAccessIndexType {
    func successor() -> Int32
    func predecessor() -> Int32
    func distanceTo(_ other: Int32) -> Distance
    func advancedBy(_ n: Distance) -> Int32
}
extension Int32 {
    static func addWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int32, _ rhs: Int32) -> (Int32, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int32 : SignedNumberType {
}
extension Int32 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt32)
}
extension Int32 : BitwiseOperationsType {
    static var allZeros: Int32 { get }
}
extension Int32 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int32 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int32 : _Reflectable {
}
extension Int32 : CVarArgType {
}

struct Int64 : _SignedIntegerType, Comparable, Equatable, _IntegerType, IntegerArithmeticType, _IntegerArithmeticType, IntegerType, SignedIntegerType {
    var value: Builtin.Int64
    typealias Distance = Int
    init()
    init(_ value: Int64)
    init(bigEndian value: Int64)
    init(littleEndian value: Int64)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
    var bigEndian: Int64 { get }
    var littleEndian: Int64 { get }
    var byteSwapped: Int64 { get }
    static var max: Int64 { get }
    static var min: Int64 { get }
}
extension Int64 {
    init(_ value: CGFloat)
}
extension Int64 : Hashable {
    var hashValue: Int { get }
}
extension Int64 : CustomStringConvertible {
    var description: String { get }
}
extension Int64 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity {
    func successor() -> Int64
    func predecessor() -> Int64
    func distanceTo(_ other: Int64) -> Distance
    func advancedBy(_ n: Distance) -> Int64
}
extension Int64 {
    static func addWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int64 : SignedNumberType, IntegerLiteralConvertible {
}
extension Int64 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: UInt)
    init(_ v: Int)
    init(bitPattern bitPattern: UInt64)
}
extension Int64 : BitwiseOperationsType {
    static var allZeros: Int64 { get }
}
extension Int64 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int64 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int64 : _Reflectable {
}
extension Int64 : CVarArgType, _CVarArgAlignedType {
}

struct Int64 : SignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int64
    typealias Distance = Int
    init()
    init(_ value: Int64)
    init(bigEndian value: Int64)
    init(littleEndian value: Int64)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
    var bigEndian: Int64 { get }
    var littleEndian: Int64 { get }
    var byteSwapped: Int64 { get }
    static var max: Int64 { get }
    static var min: Int64 { get }
}
extension Int64 {
    init(_ value: CGFloat)
}
extension Int64 : Hashable {
    var hashValue: Int { get }
}
extension Int64 : CustomStringConvertible {
    var description: String { get }
}
extension Int64 : RandomAccessIndexType {
    func successor() -> Int64
    func predecessor() -> Int64
    func distanceTo(_ other: Int64) -> Distance
    func advancedBy(_ n: Distance) -> Int64
}
extension Int64 {
    static func addWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int64, _ rhs: Int64) -> (Int64, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int64 : SignedNumberType {
}
extension Int64 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(_ v: UInt)
    init(_ v: Int)
    init(bitPattern bitPattern: UInt64)
}
extension Int64 : BitwiseOperationsType {
    static var allZeros: Int64 { get }
}
extension Int64 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int64 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int64 : _Reflectable {
}
extension Int64 : CVarArgType, _CVarArgAlignedType {
}

struct Int8 : _IntegerArithmeticType, Comparable, Equatable, _SignedIntegerType, _IntegerType, IntegerArithmeticType, IntegerType, SignedIntegerType {
    var value: Builtin.Int8
    typealias Distance = Int
    init()
    init(_ value: Int8)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int8)
    static var max: Int8 { get }
    static var min: Int8 { get }
}
extension Int8 {
    init(_ value: CGFloat)
}
extension Int8 : Hashable {
    var hashValue: Int { get }
}
extension Int8 : CustomStringConvertible {
    var description: String { get }
}
extension Int8 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity {
    func successor() -> Int8
    func predecessor() -> Int8
    func distanceTo(_ other: Int8) -> Distance
    func advancedBy(_ n: Distance) -> Int8
}
extension Int8 {
    static func addWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int8 : SignedNumberType, IntegerLiteralConvertible {
}
extension Int8 {
    init(_ v: UInt8)
    init(_ v: UInt16)
    init(truncatingBitPattern truncatingBitPattern: UInt16)
    init(_ v: Int16)
    init(truncatingBitPattern truncatingBitPattern: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt8)
}
extension Int8 : BitwiseOperationsType {
    static var allZeros: Int8 { get }
}
extension Int8 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int8 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int8 : _Reflectable {
}
extension Int8 : CVarArgType {
}

struct Int8 : SignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int8
    typealias Distance = Int
    init()
    init(_ value: Int8)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int8)
    static var max: Int8 { get }
    static var min: Int8 { get }
}
extension Int8 {
    init(_ value: CGFloat)
}
extension Int8 : Hashable {
    var hashValue: Int { get }
}
extension Int8 : CustomStringConvertible {
    var description: String { get }
}
extension Int8 : RandomAccessIndexType {
    func successor() -> Int8
    func predecessor() -> Int8
    func distanceTo(_ other: Int8) -> Distance
    func advancedBy(_ n: Distance) -> Int8
}
extension Int8 {
    static func addWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func subtractWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func divideWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    static func remainderWithOverflow(_ lhs: Int8, _ rhs: Int8) -> (Int8, overflow: Bool)
    func toIntMax() -> IntMax
}
extension Int8 : SignedNumberType {
}
extension Int8 {
    init(_ v: UInt8)
    init(_ v: UInt16)
    init(truncatingBitPattern truncatingBitPattern: UInt16)
    init(_ v: Int16)
    init(truncatingBitPattern truncatingBitPattern: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: UInt8)
}
extension Int8 : BitwiseOperationsType {
    static var allZeros: Int8 { get }
}
extension Int8 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Int8 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int8 : _Reflectable {
}
extension Int8 : CVarArgType {
}

struct LazyCollection<Base : CollectionType> : LazyCollectionType, LazySequenceType {
    typealias Elements = Base
    var elements: Base { get }
    typealias Index = Base.Index
    init(_ base: Base)
}
extension LazyCollection : SequenceType {
    func generate() -> Base.Generator
    func underestimateCount() -> Int
}
extension LazyCollection : CollectionType, Indexable {
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (_ position: Base.Index) -> Base.Generator.Element { get }
    subscript (_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get }
    var isEmpty: Bool { get }
    var count: Base.Index.Distance { get }
    var first: Base.Generator.Element? { get }
    typealias S = Void
}

struct LazyCollection<Base : CollectionType> : LazyCollectionType {
    typealias Elements = Base
    var elements: Base { get }
    typealias Index = Base.Index
    init(_ base: Base)
}
extension LazyCollection : SequenceType {
    func generate() -> Base.Generator
    func underestimateCount() -> Int
}
extension LazyCollection : CollectionType {
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (_ position: Base.Index) -> Base.Generator.Element { get }
    subscript (_ bounds: Range<Base.Index>) -> LazyCollection<Slice<Base>> { get }
    var isEmpty: Bool { get }
    var count: Base.Index.Distance { get }
    var first: Base.Generator.Element? { get }
    typealias S = Void
}

protocol LazyCollectionType : CollectionType, LazySequenceType {
    typealias Elements : CollectionType, SequenceType = Self
}

protocol LazyCollectionType : CollectionType, LazySequenceType {
    typealias Elements : CollectionType = Self
}

struct LazyFilterCollection<Base : CollectionType> : LazyCollectionType, CollectionType, Indexable, SequenceType, LazySequenceType {
    typealias Index = LazyFilterIndex<Base>
    init(_ base: Base, whereElementsSatisfy predicate: (Base.Generator.Element) -> Bool)
    var startIndex: LazyFilterIndex<Base> { get }
    var endIndex: LazyFilterIndex<Base> { get }
    subscript (_ position: LazyFilterIndex<Base>) -> Base.Generator.Element { get }
    func generate() -> LazyFilterGenerator<Base.Generator>
}

struct LazyFilterCollection<Base : CollectionType> : LazyCollectionType {
    typealias Index = LazyFilterIndex<Base>
    init(_ base: Base, whereElementsSatisfy predicate: (Base.Generator.Element) -> Bool)
    var startIndex: LazyFilterIndex<Base> { get }
    var endIndex: LazyFilterIndex<Base> { get }
    subscript (_ position: LazyFilterIndex<Base>) -> Base.Generator.Element { get }
    func generate() -> LazyFilterGenerator<Base.Generator>
}

struct LazyFilterIndex<BaseElements : CollectionType> : ForwardIndexType, _Incrementable, Equatable {
    func successor() -> LazyFilterIndex<BaseElements>
    let base: BaseElements.Index
    typealias Base = BaseElements
}

struct LazyFilterIndex<BaseElements : CollectionType> : ForwardIndexType {
    func successor() -> LazyFilterIndex<BaseElements>
    let base: BaseElements.Index
    typealias Base = BaseElements
}

struct LazyFilterSequence<Base : SequenceType> : LazySequenceType, SequenceType {
    func generate() -> LazyFilterGenerator<Base.Generator>
    init(_ base: Base, whereElementsSatisfy predicate: (Base.Generator.Element) -> Bool)
    let base: Base
}

struct LazyFilterSequence<Base : SequenceType> : LazySequenceType {
    func generate() -> LazyFilterGenerator<Base.Generator>
    init(_ base: Base, whereElementsSatisfy predicate: (Base.Generator.Element) -> Bool)
    let base: Base
}

struct LazyMapCollection<Base : CollectionType, Element> : LazyCollectionType, CollectionType, Indexable, SequenceType, LazySequenceType {
    typealias Index = Base.Index
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (_ position: Base.Index) -> Element { get }
    var isEmpty: Bool { get }
    var first: Element? { get }
    func generate() -> LazyMapGenerator<Base.Generator, Element>
    func underestimateCount() -> Int
    var count: Base.Index.Distance { get }
    init(_ base: Base, transform transform: (Base.Generator.Element) -> Element)
    typealias T = Element
}

struct LazyMapCollection<Base : CollectionType, Element> : LazyCollectionType {
    typealias Index = Base.Index
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (_ position: Base.Index) -> Element { get }
    var isEmpty: Bool { get }
    var first: Element? { get }
    func generate() -> LazyMapGenerator<Base.Generator, Element>
    func underestimateCount() -> Int
    var count: Base.Index.Distance { get }
    init(_ base: Base, transform transform: (Base.Generator.Element) -> Element)
    typealias T = Element
}

struct LazyMapSequence<Base : SequenceType, Element> : LazySequenceType, SequenceType {
    typealias Elements = LazyMapSequence<Base, Element>
    func generate() -> LazyMapGenerator<Base.Generator, Element>
    func underestimateCount() -> Int
    init(_ base: Base, transform transform: (Base.Generator.Element) -> Element)
    typealias T = Element
}

struct LazyMapSequence<Base : SequenceType, Element> : LazySequenceType {
    typealias Elements = LazyMapSequence<Base, Element>
    func generate() -> LazyMapGenerator<Base.Generator, Element>
    func underestimateCount() -> Int
    init(_ base: Base, transform transform: (Base.Generator.Element) -> Element)
    typealias T = Element
}

struct LazySequence<Base : SequenceType> : LazySequenceType, SequenceType, _SequenceWrapperType {
    init(_ base: Base)
    var elements: Base { get }
    typealias S = Void
}

struct LazySequence<Base : SequenceType> : LazySequenceType, _SequenceWrapperType {
    init(_ base: Base)
    var elements: Base { get }
    typealias S = Void
}

protocol MutableCollectionType : MutableIndexable, CollectionType {
    typealias SubSequence : Indexable, SequenceType = MutableSlice<Self>
    subscript (_ position: Self.Index) -> Self.Generator.Element { get set }
    subscript (_ bounds: Range<Self.Index>) -> Self.SubSequence { get set }
}

protocol MutableCollectionType : MutableIndexable, CollectionType {
    typealias SubSequence = MutableSlice<Self>
    subscript (_ position: Self.Index) -> Self.Generator.Element { get set }
    subscript (_ bounds: Range<Self.Index>) -> Self.SubSequence { get set }
}

struct MutableSlice<Base : MutableIndexable> : MutableCollectionType, CollectionType, Indexable, SequenceType, MutableIndexable {
    typealias Index = Base.Index
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (_ index: Base.Index) -> Base._Element
    subscript (_ bounds: Range<Base.Index>) -> MutableSlice<Base>
    init(base base: Base, bounds bounds: Range<Base.Index>)
}

struct MutableSlice<Base : MutableIndexable> : MutableCollectionType {
    typealias Index = Base.Index
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (_ index: Base.Index) -> Base._Element
    subscript (_ bounds: Range<Base.Index>) -> MutableSlice<Base>
    init(base base: Base, bounds bounds: Range<Base.Index>)
}

struct ObjectIdentifier : Hashable, Equatable, Comparable {
    var uintValue: UInt { get }
    var hashValue: Int { get }
    init(_ x: AnyObject)
    init(_ x: Any.Type)
}

struct ObjectIdentifier : Hashable, Comparable {
    var uintValue: UInt { get }
    var hashValue: Int { get }
    init(_ x: AnyObject)
    init(_ x: Any.Type)
}

enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible {
    case None
    case Some(Wrapped)
    typealias T = Wrapped
    init()
    init(_ some: Wrapped)
    @warn_unused_result
    @rethrows func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U?
    @warn_unused_result
    @rethrows func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U?
    init(nilLiteral nilLiteral: ())
}
extension Optional : CustomDebugStringConvertible {
    var debugDescription: String { get }
}

enum Optional<Wrapped> : _Reflectable, NilLiteralConvertible {
    case None
    case Some(Wrapped)
    typealias T = Wrapped
    init()
    init(_ some: Wrapped)
    @warn_unused_result
    func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U?
    @warn_unused_result
    func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U?
    init(nilLiteral nilLiteral: ())
}
extension Optional : CustomDebugStringConvertible {
    var debugDescription: String { get }
}

@warn_unused_result
    @rethrows func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U?

@warn_unused_result
    func flatMap<U>(@noescape _ f: (Wrapped) throws -> U?) rethrows -> U?

@warn_unused_result
    @rethrows func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U?

@warn_unused_result
    func map<U>(@noescape _ f: (Wrapped) throws -> U) rethrows -> U?

struct Range<Element : ForwardIndexType> : Equatable, CollectionType, Indexable, SequenceType, CustomStringConvertible, CustomDebugStringConvertible {
    typealias T = Element
    init(_ x: Range<Element>)
    init(start start: Element, end end: Element)
    subscript (_ position: Element) -> Element { get }
    subscript (_ _: Element._DisabledRangeIndex) -> Element { get }
    func generate() -> RangeGenerator<Element>
    var startIndex: Element
    var endIndex: Element
    var description: String { get }
    var debugDescription: String { get }
}
extension Range : _Reflectable {
}

struct Range<Element : ForwardIndexType> : Equatable, CollectionType, CustomStringConvertible, CustomDebugStringConvertible {
    typealias T = Element
    init(_ x: Range<Element>)
    init(start start: Element, end end: Element)
    subscript (_ position: Element) -> Element { get }
    subscript (_ _: Element._DisabledRangeIndex) -> Element { get }
    func generate() -> RangeGenerator<Element>
    var startIndex: Element
    var endIndex: Element
    var description: String { get }
    var debugDescription: String { get }
}
extension Range : _Reflectable {
}

struct Repeat<Element> : CollectionType, Indexable, SequenceType {
    typealias T = Element
    typealias Index = Int
    init(count count: Int, repeatedValue repeatedValue: Element)
    var startIndex: Index { get }
    var endIndex: Index { get }
    subscript (_ position: Int) -> Element { get }
    var count: Int
    let repeatedValue: Element
}

struct Repeat<Element> : CollectionType {
    typealias T = Element
    typealias Index = Int
    init(count count: Int, repeatedValue repeatedValue: Element)
    var startIndex: Index { get }
    var endIndex: Index { get }
    subscript (_ position: Int) -> Element { get }
    var count: Int
    let repeatedValue: Element
}

struct ReverseCollection<Base : CollectionType where Base.Index : BidirectionalIndexType> : CollectionType, Indexable, _ReverseCollectionType, SequenceType {
    init(_ base: Base)
    typealias Index = ReverseIndex<Base.Index>
    typealias Generator = IndexingGenerator<ReverseCollection<Base>>
    typealias T = Base
}

struct ReverseCollection<Base : CollectionType where Base.Index : BidirectionalIndexType> : CollectionType, _ReverseCollectionType {
    init(_ base: Base)
    typealias Index = ReverseIndex<Base.Index>
    typealias Generator = IndexingGenerator<ReverseCollection<Base>>
    typealias T = Base
}

struct ReverseIndex<Base : BidirectionalIndexType> : ReverseIndexType, BidirectionalIndexType, ForwardIndexType, _Incrementable, Equatable {
    typealias Distance = Base.Distance
    init(_ base: Base)
    let base: Base
    typealias I = Base
}

struct ReverseIndex<Base : BidirectionalIndexType> : BidirectionalIndexType, ReverseIndexType {
    typealias Distance = Base.Distance
    init(_ base: Base)
    let base: Base
    typealias I = Base
}

struct ReverseRandomAccessCollection<Base : CollectionType where Base.Index : RandomAccessIndexType> : _ReverseCollectionType, CollectionType, Indexable, SequenceType {
    init(_ base: Base)
    typealias Index = ReverseRandomAccessIndex<Base.Index>
    typealias Generator = IndexingGenerator<ReverseRandomAccessCollection<Base>>
    typealias T = Base
}

struct ReverseRandomAccessCollection<Base : CollectionType where Base.Index : RandomAccessIndexType> : _ReverseCollectionType {
    init(_ base: Base)
    typealias Index = ReverseRandomAccessIndex<Base.Index>
    typealias Generator = IndexingGenerator<ReverseRandomAccessCollection<Base>>
    typealias T = Base
}

struct ReverseRandomAccessIndex<Base : RandomAccessIndexType> : ForwardIndexType, _Incrementable, Equatable, _Strideable, ReverseIndexType, BidirectionalIndexType, RandomAccessIndexType, Strideable, Comparable, _RandomAccessAmbiguity {
    typealias Distance = Base.Distance
    init(_ base: Base)
    let base: Base
    func distanceTo(_ other: ReverseRandomAccessIndex<Base>) -> Base.Distance
    func advancedBy(_ n: Base.Distance) -> ReverseRandomAccessIndex<Base>
    typealias I = Base
}

struct ReverseRandomAccessIndex<Base : RandomAccessIndexType> : RandomAccessIndexType, ReverseIndexType {
    typealias Distance = Base.Distance
    init(_ base: Base)
    let base: Base
    func distanceTo(_ other: ReverseRandomAccessIndex<Base>) -> Base.Distance
    func advancedBy(_ n: Base.Distance) -> ReverseRandomAccessIndex<Base>
    typealias I = Base
}

protocol SequenceType {
    typealias Generator : GeneratorType
    typealias SubSequence
    @warn_unused_result
    func generate() -> Self.Generator
    @warn_unused_result
    func underestimateCount() -> Int
    @warn_unused_result
    @rethrows func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T]
    @warn_unused_result
    @rethrows func filter(@noescape _ includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
    @rethrows func forEach(@noescape _ body: (Self.Generator.Element) throws -> ()) rethrows
    @warn_unused_result
    func dropFirst(_ n: Int) -> Self.SubSequence
    @warn_unused_result
    func dropLast(_ n: Int) -> Self.SubSequence
    @warn_unused_result
    func prefix(_ maxLength: Int) -> Self.SubSequence
    @warn_unused_result
    func suffix(_ maxLength: Int) -> Self.SubSequence
    @warn_unused_result
    @rethrows func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
}

protocol SequenceType {
    typealias Generator : GeneratorType
    typealias SubSequence
    @warn_unused_result
    func generate() -> Self.Generator
    @warn_unused_result
    func underestimateCount() -> Int
    @warn_unused_result
    func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T]
    @warn_unused_result
    func filter(@noescape _ includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]
    func forEach(@noescape _ body: (Self.Generator.Element) throws -> ()) rethrows
    @warn_unused_result
    func dropFirst(_ n: Int) -> Self.SubSequence
    @warn_unused_result
    func dropLast(_ n: Int) -> Self.SubSequence
    @warn_unused_result
    func prefix(_ maxLength: Int) -> Self.SubSequence
    @warn_unused_result
    func suffix(_ maxLength: Int) -> Self.SubSequence
    @warn_unused_result
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]
}

@warn_unused_result
    @rethrows func contains(@noescape _ predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Bool

@warn_unused_result
    func contains(@noescape _ predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Bool

@warn_unused_result
    @rethrows func elementsEqual<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isEquivalent isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool

@warn_unused_result
    func elementsEqual<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isEquivalent isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool

@warn_unused_result
    @rethrows func filter(@noescape _ includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]

@warn_unused_result
    func filter(@noescape _ includeElement: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.Generator.Element]

@warn_unused_result
    @rethrows func flatMap<T>(@noescape _ transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]

@warn_unused_result
    func flatMap<T>(@noescape _ transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]

@warn_unused_result
    @rethrows func flatMap<S : SequenceType>(_ transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]

@warn_unused_result
    func flatMap<S : SequenceType>(_ transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]

@rethrows func forEach(@noescape _ body: (Self.Generator.Element) throws -> ()) rethrows

func forEach(@noescape _ body: (Self.Generator.Element) throws -> ()) rethrows

@warn_unused_result
    @rethrows func lexicographicalCompare<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isOrderedBefore isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool

@warn_unused_result
    func lexicographicalCompare<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isOrderedBefore isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool

@warn_unused_result
    @rethrows func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T]

@warn_unused_result
    func map<T>(@noescape _ transform: (Self.Generator.Element) throws -> T) rethrows -> [T]

@warn_unused_result
    @rethrows func maxElement(@noescape _ isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element?

@warn_unused_result
    func maxElement(@noescape _ isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element?

@warn_unused_result
    @rethrows func minElement(@noescape _ isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element?

@warn_unused_result
    func minElement(@noescape _ isOrderedBefore: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element?

@warn_unused_result
    @rethrows func reduce<T>(_ initial: T, @noescape combine combine: (T, Self.Generator.Element) throws -> T) rethrows -> T

@warn_unused_result
    func reduce<T>(_ initial: T, @noescape combine combine: (T, Self.Generator.Element) throws -> T) rethrows -> T

@warn_unused_result
    @rethrows func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]

@warn_unused_result
    func split(_ maxSplit: Int, allowEmptySlices allowEmptySlices: Bool, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [Self.SubSequence]

@warn_unused_result
    @rethrows func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [AnySequence<Self.Generator.Element>]

@warn_unused_result
    func split(_ maxSplit: Int = default, allowEmptySlices allowEmptySlices: Bool = default, @noescape isSeparator isSeparator: (Self.Generator.Element) throws -> Bool) rethrows -> [AnySequence<Self.Generator.Element>]

@warn_unused_result
    @rethrows func startsWith<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isEquivalent isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool

@warn_unused_result
    func startsWith<OtherSequence : SequenceType where OtherSequence.Generator.Element == Generator.Element>(_ other: OtherSequence, @noescape isEquivalent isEquivalent: (Self.Generator.Element, Self.Generator.Element) throws -> Bool) rethrows -> Bool

struct Set<Element : Hashable> : Hashable, Equatable, CollectionType, Indexable, SequenceType, ArrayLiteralConvertible {
    typealias T = Element
    typealias Index = SetIndex<Element>
    init(minimumCapacity minimumCapacity: Int)
    var startIndex: SetIndex<Element> { get }
    var endIndex: SetIndex<Element> { get }
    @warn_unused_result
    func contains(_ member: Element) -> Bool
    @warn_unused_result
    func indexOf(_ member: Element) -> SetIndex<Element>?
    mutating func insert(_ member: Element)
    mutating func remove(_ member: Element) -> Element?
    mutating func removeAtIndex(_ index: SetIndex<Element>) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    mutating func removeFirst() -> Element
    var count: Int { get }
    subscript (_ position: SetIndex<Element>) -> Element { get }
    func generate() -> SetGenerator<Element>
    init(arrayLiteral elements: Element...)
    init()
    init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func isSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isStrictSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isStrictSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isDisjointWith<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func union<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func unionInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func subtract<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func subtractInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func intersect<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func intersectInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func exclusiveOr<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func exclusiveOrInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    var hashValue: Int { get }
    var isEmpty: Bool { get }
    var first: Element? { get }
}
extension Set : _ObjectiveCBridgeable {
}
extension Set : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Set : _Reflectable {
}
extension Set {
    mutating func popFirst() -> Element?
}

struct Set<Element : Hashable> : Hashable, CollectionType, ArrayLiteralConvertible {
    typealias T = Element
    typealias Index = SetIndex<Element>
    init(minimumCapacity minimumCapacity: Int)
    var startIndex: SetIndex<Element> { get }
    var endIndex: SetIndex<Element> { get }
    @warn_unused_result
    func contains(_ member: Element) -> Bool
    @warn_unused_result
    func indexOf(_ member: Element) -> SetIndex<Element>?
    mutating func insert(_ member: Element)
    mutating func remove(_ member: Element) -> Element?
    mutating func removeAtIndex(_ index: SetIndex<Element>) -> Element
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    mutating func removeFirst() -> Element
    var count: Int { get }
    subscript (_ position: SetIndex<Element>) -> Element { get }
    func generate() -> SetGenerator<Element>
    init(arrayLiteral elements: Element...)
    init()
    init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func isSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isStrictSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isStrictSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func isDisjointWith<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool
    @warn_unused_result
    func union<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func unionInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func subtract<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func subtractInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func intersect<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func intersectInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    @warn_unused_result
    func exclusiveOr<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>
    mutating func exclusiveOrInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)
    var hashValue: Int { get }
    var isEmpty: Bool { get }
    var first: Element? { get }
}
extension Set : _ObjectiveCBridgeable {
}
extension Set : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension Set : _Reflectable {
}
extension Set {
    mutating func popFirst() -> Element?
}

struct SetIndex<Element : Hashable> : ForwardIndexType, _Incrementable, Equatable, Comparable {
    typealias T = Element
    func successor() -> SetIndex<Element>
}

struct SetIndex<Element : Hashable> : ForwardIndexType, Comparable {
    typealias T = Element
    func successor() -> SetIndex<Element>
}

struct Slice<Base : Indexable> : Indexable, SequenceType, CollectionType {
    typealias Index = Base.Index
    let startIndex: Base.Index
    let endIndex: Base.Index
    subscript (_ index: Base.Index) -> Base._Element { get }
    subscript (_ bounds: Range<Base.Index>) -> Slice<Base> { get }
    init(base base: Base, bounds bounds: Range<Base.Index>)
}

struct Slice<Base : Indexable> : CollectionType {
    typealias Index = Base.Index
    let startIndex: Base.Index
    let endIndex: Base.Index
    subscript (_ index: Base.Index) -> Base._Element { get }
    subscript (_ bounds: Range<Base.Index>) -> Slice<Base> { get }
    init(base base: Base, bounds bounds: Range<Base.Index>)
}

struct StaticString : _Reflectable, UnicodeScalarLiteralConvertible, ExtendedGraphemeClusterLiteralConvertible, StringLiteralConvertible, CustomStringConvertible, CustomDebugStringConvertible {
    var utf8Start: UnsafePointer<UInt8> { get }
    var unicodeScalar: UnicodeScalar { get }
    var byteSize: Int { get }
    var hasPointerRepresentation: Bool { get }
    var isASCII: Bool { get }
    func withUTF8Buffer<R>(@noescape _ body: (UnsafeBufferPointer<UInt8>) -> R) -> R
    var stringValue: String { get }
    init()
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
    init(unicodeScalarLiteral value: StaticString)
    init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    init(extendedGraphemeClusterLiteral value: StaticString)
    init(_builtinStringLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    init(stringLiteral value: StaticString)
    var description: String { get }
    var debugDescription: String { get }
}

struct StaticString : UnicodeScalarLiteralConvertible, ExtendedGraphemeClusterLiteralConvertible, StringLiteralConvertible, CustomStringConvertible, CustomDebugStringConvertible, _Reflectable {
    var utf8Start: UnsafePointer<UInt8> { get }
    var unicodeScalar: UnicodeScalar { get }
    var byteSize: Int { get }
    var hasPointerRepresentation: Bool { get }
    var isASCII: Bool { get }
    func withUTF8Buffer<R>(@noescape _ body: (UnsafeBufferPointer<UInt8>) -> R) -> R
    var stringValue: String { get }
    init()
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
    init(unicodeScalarLiteral value: StaticString)
    init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    init(extendedGraphemeClusterLiteral value: StaticString)
    init(_builtinStringLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    init(stringLiteral value: StaticString)
    var description: String { get }
    var debugDescription: String { get }
}

struct String {
    init()
}
extension String {
    @warn_unused_result
    static func availableStringEncodings() -> [NSStringEncoding]
    @warn_unused_result
    static func defaultCStringEncoding() -> NSStringEncoding
    @warn_unused_result
    static func localizedNameOfStringEncoding(_ encoding: NSStringEncoding) -> String
    @warn_unused_result
    static func localizedStringWithFormat(_ format: String, _ arguments: CVarArgType...) -> String
    static func pathWithComponents(_ components: [String]) -> String
    init?(UTF8String bytes: UnsafePointer<CChar>)
    @warn_unused_result
    func canBeConvertedToEncoding(_ encoding: NSStringEncoding) -> Bool
    var capitalizedString: String { get }
    var localizedCapitalizedString: String { get }
    @warn_unused_result
    func capitalizedStringWithLocale(_ locale: NSLocale?) -> String
    @warn_unused_result
    func caseInsensitiveCompare(_ aString: String) -> NSComparisonResult
    @warn_unused_result
    func commonPrefixWithString(_ aString: String, options options: NSStringCompareOptions) -> String
    @warn_unused_result
    func compare(_ aString: String, options mask: NSStringCompareOptions = default, range range: Range<Index>? = default, locale locale: NSLocale? = default) -> NSComparisonResult
    @warn_unused_result
    func completePathIntoString(_ outputName: UnsafeMutablePointer<String> = default, caseSensitive caseSensitive: Bool, matchesIntoArray matchesIntoArray: UnsafeMutablePointer<[String]> = default, filterTypes filterTypes: [String]? = default) -> Int
    @warn_unused_result
    func componentsSeparatedByCharactersInSet(_ separator: NSCharacterSet) -> [String]
    func componentsSeparatedByString(_ separator: String) -> [String]
    @warn_unused_result
    func cStringUsingEncoding(_ encoding: NSStringEncoding) -> [CChar]?
    @warn_unused_result
    func dataUsingEncoding(_ encoding: NSStringEncoding, allowLossyConversion allowLossyConversion: Bool = default) -> NSData?
    var decomposedStringWithCanonicalMapping: String { get }
    var decomposedStringWithCompatibilityMapping: String { get }
    func enumerateLines(_ body: (line: String, inout stop: Bool) -> ())
    func enumerateLinguisticTagsInRange(_ range: Range<Index>, scheme tagScheme: String, options opts: NSLinguisticTaggerOptions, orthography orthography: NSOrthography?, _ body: (String, Range<Index>, Range<Index>, inout Bool) -> ())
    func enumerateSubstringsInRange(_ range: Range<Index>, options opts: NSStringEnumerationOptions, _ body: (substring: String?, substringRange: Range<Index>, enclosingRange: Range<Index>, inout Bool) -> ())
    var fastestEncoding: NSStringEncoding { get }
    func fileSystemRepresentation() -> [CChar]
    func getBytes(inout _ buffer: [UInt8], maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding encoding: NSStringEncoding, options options: NSStringEncodingConversionOptions, range range: Range<Index>, remainingRange leftover: UnsafeMutablePointer<Range<Index>>) -> Bool
    func getCString(inout _ buffer: [CChar], maxLength maxLength: Int, encoding encoding: NSStringEncoding) -> Bool
    func getFileSystemRepresentation(inout _ buffer: [CChar], maxLength maxLength: Int) -> Bool
    func getLineStart(_ start: UnsafeMutablePointer<Index>, end end: UnsafeMutablePointer<Index>, contentsEnd contentsEnd: UnsafeMutablePointer<Index>, forRange forRange: Range<Index>)
    func getParagraphStart(_ start: UnsafeMutablePointer<Index>, end end: UnsafeMutablePointer<Index>, contentsEnd contentsEnd: UnsafeMutablePointer<Index>, forRange forRange: Range<Index>)
    var hash: Int { get }
    init?<S : SequenceType where S.Generator.Element == UInt8>(bytes bytes: S, encoding encoding: NSStringEncoding)
    init?(bytesNoCopy bytes: UnsafeMutablePointer<Void>, length length: Int, encoding encoding: NSStringEncoding, freeWhenDone flag: Bool)
    init(utf16CodeUnits utf16CodeUnits: UnsafePointer<unichar>, count count: Int)
    init(utf16CodeUnitsNoCopy utf16CodeUnitsNoCopy: UnsafePointer<unichar>, count count: Int, freeWhenDone flag: Bool)
    init(contentsOfFile path: String, encoding enc: NSStringEncoding) throws
    init(contentsOfFile path: String, usedEncoding usedEncoding: UnsafeMutablePointer<NSStringEncoding> = default) throws
    init(contentsOfURL url: NSURL, encoding enc: NSStringEncoding) throws
    init(contentsOfURL url: NSURL, usedEncoding enc: UnsafeMutablePointer<NSStringEncoding> = default) throws
    init?(CString CString: UnsafePointer<CChar>, encoding enc: NSStringEncoding)
    init?(data data: NSData, encoding encoding: NSStringEncoding)
    init(format format: String, _ arguments: CVarArgType...)
    init(format format: String, arguments arguments: [CVarArgType])
    init(format format: String, locale locale: NSLocale?, _ args: CVarArgType...)
    init(format format: String, locale locale: NSLocale?, arguments arguments: [CVarArgType])
    var lastPathComponent: String { get }
    var utf16Count: Int { get }
    @warn_unused_result
    func lengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int
    @warn_unused_result
    func lineRangeForRange(_ aRange: Range<Index>) -> Range<Index>
    @warn_unused_result
    func linguisticTagsInRange(_ range: Range<Index>, scheme tagScheme: String, options opts: NSLinguisticTaggerOptions = default, orthography orthography: NSOrthography? = default, tokenRanges tokenRanges: UnsafeMutablePointer<[Range<Index>]> = default) -> [String]
    @warn_unused_result
    func localizedCaseInsensitiveCompare(_ aString: String) -> NSComparisonResult
    @warn_unused_result
    func localizedCompare(_ aString: String) -> NSComparisonResult
    @warn_unused_result
    func localizedStandardCompare(_ string: String) -> NSComparisonResult
    var localizedLowercaseString: String { get }
    @warn_unused_result
    func lowercaseStringWithLocale(_ locale: NSLocale?) -> String
    @warn_unused_result
    func maximumLengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int
    @warn_unused_result
    func paragraphRangeForRange(_ aRange: Range<Index>) -> Range<Index>
    var pathComponents: [String] { get }
    var pathExtension: String { get }
    var precomposedStringWithCanonicalMapping: String { get }
    var precomposedStringWithCompatibilityMapping: String { get }
    @warn_unused_result
    func propertyList() -> AnyObject
    @warn_unused_result
    func propertyListFromStringsFileFormat() -> [String : String]
    @warn_unused_result
    func rangeOfCharacterFromSet(_ aSet: NSCharacterSet, options mask: NSStringCompareOptions = default, range aRange: Range<Index>? = default) -> Range<Index>?
    @warn_unused_result
    func rangeOfComposedCharacterSequenceAtIndex(_ anIndex: Index) -> Range<Index>
    @warn_unused_result
    func rangeOfComposedCharacterSequencesForRange(_ range: Range<Index>) -> Range<Index>
    @warn_unused_result
    func rangeOfString(_ aString: String, options mask: NSStringCompareOptions = default, range searchRange: Range<Index>? = default, locale locale: NSLocale? = default) -> Range<Index>?
    @warn_unused_result
    func localizedStandardContainsString(_ string: String) -> Bool
    @warn_unused_result
    func localizedStandardRangeOfString(_ string: String) -> Range<Index>?
    var smallestEncoding: NSStringEncoding { get }
    var stringByAbbreviatingWithTildeInPath: String { get }
    @warn_unused_result
    func stringByAddingPercentEncodingWithAllowedCharacters(_ allowedCharacters: NSCharacterSet) -> String?
    func stringByAddingPercentEscapesUsingEncoding(_ encoding: NSStringEncoding) -> String?
    @warn_unused_result
    func stringByAppendingFormat(_ format: String, _ arguments: CVarArgType...) -> String
    func stringByAppendingPathComponent(_ aString: String) -> String
    func stringByAppendingPathExtension(_ ext: String) -> String?
    @warn_unused_result
    func stringByAppendingString(_ aString: String) -> String
    var stringByDeletingLastPathComponent: String { get }
    var stringByDeletingPathExtension: String { get }
    var stringByExpandingTildeInPath: String { get }
    @warn_unused_result
    func stringByFoldingWithOptions(_ options: NSStringCompareOptions, locale locale: NSLocale?) -> String
    @warn_unused_result
    func stringByPaddingToLength(_ newLength: Int, withString padString: String, startingAtIndex padIndex: Int) -> String
    var stringByRemovingPercentEncoding: String? { get }
    @warn_unused_result
    func stringByReplacingCharactersInRange(_ range: Range<Index>, withString replacement: String) -> String
    @warn_unused_result
    func stringByReplacingOccurrencesOfString(_ target: String, withString replacement: String, options options: NSStringCompareOptions = default, range searchRange: Range<Index>? = default) -> String
    func stringByReplacingPercentEscapesUsingEncoding(_ encoding: NSStringEncoding) -> String?
    var stringByResolvingSymlinksInPath: String { get }
    var stringByStandardizingPath: String { get }
    @warn_unused_result
    func stringByTrimmingCharactersInSet(_ set: NSCharacterSet) -> String
    func stringsByAppendingPaths(_ paths: [String]) -> [String]
    @warn_unused_result
    func substringFromIndex(_ index: Index) -> String
    @warn_unused_result
    func substringToIndex(_ index: Index) -> String
    @warn_unused_result
    func substringWithRange(_ aRange: Range<Index>) -> String
    var localizedUppercaseString: String { get }
    @warn_unused_result
    func uppercaseStringWithLocale(_ locale: NSLocale?) -> String
    func writeToFile(_ path: String, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding) throws
    func writeToURL(_ url: NSURL, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding) throws
    @warn_unused_result
    func stringByApplyingTransform(_ transform: String, reverse reverse: Bool) -> String?
    @warn_unused_result
    func containsString(_ other: String) -> Bool
    @warn_unused_result
    func localizedCaseInsensitiveContainsString(_ other: String) -> Bool
}
extension String : _ObjectiveCBridgeable {
}
extension String {
    init(_ cocoaString: NSString)
}
extension String {
    typealias Index = String.CharacterView.Index
    var startIndex: Index { get }
    var endIndex: Index { get }
    subscript (_ i: Index) -> Character { get }
}
extension String {
    struct CharacterView {
        init(_ text: String)
    }
    var characters: String.CharacterView { get }
    mutating func withMutableCharacters<R>(_ body: (inout String.CharacterView) -> R) -> R
    init(_ characters: String.CharacterView)
}
extension String {
    struct UnicodeScalarView : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType, Comparable {
            @warn_unused_result
            func successor() -> String.UnicodeScalarView.Index
            @warn_unused_result
            func predecessor() -> String.UnicodeScalarView.Index
        }
        var startIndex: String.UnicodeScalarView.Index { get }
        var endIndex: String.UnicodeScalarView.Index { get }
        subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
        subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
        struct Generator : GeneratorType {
            mutating func next() -> UnicodeScalar?
        }
        @warn_unused_result
        func generate() -> String.UnicodeScalarView.Generator
        var description: String { get }
        var debugDescription: String { get }
    }
    init(_ unicodeScalars: String.UnicodeScalarView)
    typealias UnicodeScalarIndex = String.UnicodeScalarView.Index
}
extension String {
    struct UTF16View : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        var startIndex: String.UTF16View.Index { get }
        var endIndex: String.UTF16View.Index { get }
        subscript (_ i: String.UTF16View.Index) -> CodeUnit { get }
        subscript (_ i: Int) -> CodeUnit { get }
        subscript (_ subRange: Range<Int>) -> String.UTF16View { get }
        subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
    var utf16: String.UTF16View { get }
    init?(_ utf16: String.UTF16View)
    typealias UTF16Index = String.UTF16View.Index
}
extension String {
    struct UTF8View : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : ForwardIndexType, _Incrementable, Equatable {
            @warn_unused_result
            func successor() -> String.UTF8View.Index
        }
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        subscript (_ position: String.UTF8View.Index) -> CodeUnit { get }
        subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
    var utf8: String.UTF8View { get }
    var nulTerminatedUTF8: ContiguousArray<CodeUnit> { get }
    init?(_ utf8: String.UTF8View)
    typealias UTF8Index = String.UTF8View.Index
}
extension String {
    @warn_unused_result
    static func fromCString(_ cs: UnsafePointer<CChar>) -> String?
    @warn_unused_result
    static func fromCStringRepairingIllFormedUTF8(_ cs: UnsafePointer<CChar>) -> (String?, hadError: Bool)
}
extension String {
    init(_ c: Character)
}
extension String {
    @rethrows func withCString<Result>(@noescape _ f: UnsafePointer<Int8> throws -> Result) rethrows -> Result
}
extension String : _Reflectable {
}
extension String : OutputStreamType {
    mutating func write(_ other: String)
}
extension String : Streamable {
    func writeTo<Target : OutputStreamType>(inout _ target: Target)
}
extension String {
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
}
extension String : UnicodeScalarLiteralConvertible {
    init(unicodeScalarLiteral value: String)
}
extension String {
    init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
}
extension String : ExtendedGraphemeClusterLiteralConvertible {
    init(extendedGraphemeClusterLiteral value: String)
}
extension String {
    init(_builtinUTF16StringLiteral start: Builtin.RawPointer, numberOfCodeUnits numberOfCodeUnits: Builtin.Word)
}
extension String {
    init(_builtinStringLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
}
extension String : StringLiteralConvertible {
    init(stringLiteral value: String)
}
extension String : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension String : Equatable {
}
extension String : Comparable {
}
extension String {
    mutating func appendContentsOf(_ other: String)
    mutating func append(_ x: UnicodeScalar)
}
extension String : Hashable {
    var hashValue: Int { get }
}
extension String {
    subscript (_ subRange: Range<Index>) -> String { get }
}
extension String {
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ c: Character)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_ newElements: S)
    init<S : SequenceType where S.Generator.Element == Character>(_ characters: S)
}
extension String {
    func join<S : SequenceType where S.Generator.Element == String>(_ elements: S) -> String
}
extension String {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == Character>(_ subRange: Range<Index>, with newElements: C)
    mutating func replaceRange(_ subRange: Range<Index>, with newElements: String)
    mutating func insert(_ newElement: Character, atIndex i: Index)
    mutating func insertContentsOf<S : CollectionType where S.Generator.Element == Character>(_ newElements: S, at i: Index)
    mutating func removeAtIndex(_ i: Index) -> Character
    mutating func removeRange(_ subRange: Range<Index>)
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
}
extension String {
    var lowercaseString: String { get }
    var uppercaseString: String { get }
}
extension String : StringInterpolationConvertible {
    init(stringInterpolation strings: String...)
    init<T>(stringInterpolationSegment expr: T)
    init(stringInterpolationSegment expr: String)
    init(stringInterpolationSegment expr: Character)
    init(stringInterpolationSegment expr: UnicodeScalar)
    init(stringInterpolationSegment expr: Bool)
    init(stringInterpolationSegment expr: Float32)
    init(stringInterpolationSegment expr: Float64)
    init(stringInterpolationSegment expr: UInt8)
    init(stringInterpolationSegment expr: Int8)
    init(stringInterpolationSegment expr: UInt16)
    init(stringInterpolationSegment expr: Int16)
    init(stringInterpolationSegment expr: UInt32)
    init(stringInterpolationSegment expr: Int32)
    init(stringInterpolationSegment expr: UInt64)
    init(stringInterpolationSegment expr: Int64)
    init(stringInterpolationSegment expr: UInt)
    init(stringInterpolationSegment expr: Int)
}
extension String {
    init(count count: Int, repeatedValue c: Character)
    init(count count: Int, repeatedValue c: UnicodeScalar)
    var isEmpty: Bool { get }
}
extension String {
    func hasPrefix(_ prefix: String) -> Bool
    func hasSuffix(_ suffix: String) -> Bool
}
extension String {
    init<T : _SignedIntegerType>(_ v: T)
    init<T : UnsignedIntegerType>(_ v: T)
    init<T : _SignedIntegerType>(_ v: T, radix radix: Int, uppercase uppercase: Bool = default)
    init<T : UnsignedIntegerType>(_ v: T, radix radix: Int, uppercase uppercase: Bool = default)
}
extension String {
    func toInt() -> Int?
}
extension String {
    var unicodeScalars: String.UnicodeScalarView
}
extension String {
    subscript (_ i: Int) -> Character { get }
    subscript (_ subRange: Range<Int>) -> String { get }
    var count: Int { get }
}
extension String : MirrorPathType {
}
extension String {
    init<T>(_ instance: T)
    init<T>(reflecting subject: T)
}

struct String {
    init()
}
extension String {
    @warn_unused_result
    static func availableStringEncodings() -> [NSStringEncoding]
    @warn_unused_result
    static func defaultCStringEncoding() -> NSStringEncoding
    @warn_unused_result
    static func localizedNameOfStringEncoding(_ encoding: NSStringEncoding) -> String
    @warn_unused_result
    static func localizedStringWithFormat(_ format: String, _ arguments: CVarArgType...) -> String
    static func pathWithComponents(_ components: [String]) -> String
    init?(UTF8String bytes: UnsafePointer<CChar>)
    @warn_unused_result
    func canBeConvertedToEncoding(_ encoding: NSStringEncoding) -> Bool
    var capitalizedString: String { get }
    var localizedCapitalizedString: String { get }
    @warn_unused_result
    func capitalizedStringWithLocale(_ locale: NSLocale?) -> String
    @warn_unused_result
    func caseInsensitiveCompare(_ aString: String) -> NSComparisonResult
    @warn_unused_result
    func commonPrefixWithString(_ aString: String, options options: NSStringCompareOptions) -> String
    @warn_unused_result
    func compare(_ aString: String, options mask: NSStringCompareOptions = default, range range: Range<Index>? = default, locale locale: NSLocale? = default) -> NSComparisonResult
    @warn_unused_result
    func completePathIntoString(_ outputName: UnsafeMutablePointer<String> = default, caseSensitive caseSensitive: Bool, matchesIntoArray matchesIntoArray: UnsafeMutablePointer<[String]> = default, filterTypes filterTypes: [String]? = default) -> Int
    @warn_unused_result
    func componentsSeparatedByCharactersInSet(_ separator: NSCharacterSet) -> [String]
    func componentsSeparatedByString(_ separator: String) -> [String]
    @warn_unused_result
    func cStringUsingEncoding(_ encoding: NSStringEncoding) -> [CChar]?
    @warn_unused_result
    func dataUsingEncoding(_ encoding: NSStringEncoding, allowLossyConversion allowLossyConversion: Bool = default) -> NSData?
    var decomposedStringWithCanonicalMapping: String { get }
    var decomposedStringWithCompatibilityMapping: String { get }
    func enumerateLines(_ body: (line: String, inout stop: Bool) -> ())
    func enumerateLinguisticTagsInRange(_ range: Range<Index>, scheme tagScheme: String, options opts: NSLinguisticTaggerOptions, orthography orthography: NSOrthography?, _ body: (String, Range<Index>, Range<Index>, inout Bool) -> ())
    func enumerateSubstringsInRange(_ range: Range<Index>, options opts: NSStringEnumerationOptions, _ body: (substring: String?, substringRange: Range<Index>, enclosingRange: Range<Index>, inout Bool) -> ())
    var fastestEncoding: NSStringEncoding { get }
    func fileSystemRepresentation() -> [CChar]
    func getBytes(inout _ buffer: [UInt8], maxLength maxBufferCount: Int, usedLength usedBufferCount: UnsafeMutablePointer<Int>, encoding encoding: NSStringEncoding, options options: NSStringEncodingConversionOptions, range range: Range<Index>, remainingRange leftover: UnsafeMutablePointer<Range<Index>>) -> Bool
    func getCString(inout _ buffer: [CChar], maxLength maxLength: Int, encoding encoding: NSStringEncoding) -> Bool
    func getFileSystemRepresentation(inout _ buffer: [CChar], maxLength maxLength: Int) -> Bool
    func getLineStart(_ start: UnsafeMutablePointer<Index>, end end: UnsafeMutablePointer<Index>, contentsEnd contentsEnd: UnsafeMutablePointer<Index>, forRange forRange: Range<Index>)
    func getParagraphStart(_ start: UnsafeMutablePointer<Index>, end end: UnsafeMutablePointer<Index>, contentsEnd contentsEnd: UnsafeMutablePointer<Index>, forRange forRange: Range<Index>)
    var hash: Int { get }
    init?<S : SequenceType where S.Generator.Element == UInt8>(bytes bytes: S, encoding encoding: NSStringEncoding)
    init?(bytesNoCopy bytes: UnsafeMutablePointer<Void>, length length: Int, encoding encoding: NSStringEncoding, freeWhenDone flag: Bool)
    init(utf16CodeUnits utf16CodeUnits: UnsafePointer<unichar>, count count: Int)
    init(utf16CodeUnitsNoCopy utf16CodeUnitsNoCopy: UnsafePointer<unichar>, count count: Int, freeWhenDone flag: Bool)
    init(contentsOfFile path: String, encoding enc: NSStringEncoding) throws
    init(contentsOfFile path: String, usedEncoding usedEncoding: UnsafeMutablePointer<NSStringEncoding> = default) throws
    init(contentsOfURL url: NSURL, encoding enc: NSStringEncoding) throws
    init(contentsOfURL url: NSURL, usedEncoding enc: UnsafeMutablePointer<NSStringEncoding> = default) throws
    init?(CString CString: UnsafePointer<CChar>, encoding enc: NSStringEncoding)
    init?(data data: NSData, encoding encoding: NSStringEncoding)
    init(format format: String, _ arguments: CVarArgType...)
    init(format format: String, arguments arguments: [CVarArgType])
    init(format format: String, locale locale: NSLocale?, _ args: CVarArgType...)
    init(format format: String, locale locale: NSLocale?, arguments arguments: [CVarArgType])
    var lastPathComponent: String { get }
    var utf16Count: Int { get }
    @warn_unused_result
    func lengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int
    @warn_unused_result
    func lineRangeForRange(_ aRange: Range<Index>) -> Range<Index>
    @warn_unused_result
    func linguisticTagsInRange(_ range: Range<Index>, scheme tagScheme: String, options opts: NSLinguisticTaggerOptions = default, orthography orthography: NSOrthography? = default, tokenRanges tokenRanges: UnsafeMutablePointer<[Range<Index>]> = default) -> [String]
    @warn_unused_result
    func localizedCaseInsensitiveCompare(_ aString: String) -> NSComparisonResult
    @warn_unused_result
    func localizedCompare(_ aString: String) -> NSComparisonResult
    @warn_unused_result
    func localizedStandardCompare(_ string: String) -> NSComparisonResult
    var localizedLowercaseString: String { get }
    @warn_unused_result
    func lowercaseStringWithLocale(_ locale: NSLocale?) -> String
    @warn_unused_result
    func maximumLengthOfBytesUsingEncoding(_ encoding: NSStringEncoding) -> Int
    @warn_unused_result
    func paragraphRangeForRange(_ aRange: Range<Index>) -> Range<Index>
    var pathComponents: [String] { get }
    var pathExtension: String { get }
    var precomposedStringWithCanonicalMapping: String { get }
    var precomposedStringWithCompatibilityMapping: String { get }
    @warn_unused_result
    func propertyList() -> AnyObject
    @warn_unused_result
    func propertyListFromStringsFileFormat() -> [String : String]
    @warn_unused_result
    func rangeOfCharacterFromSet(_ aSet: NSCharacterSet, options mask: NSStringCompareOptions = default, range aRange: Range<Index>? = default) -> Range<Index>?
    @warn_unused_result
    func rangeOfComposedCharacterSequenceAtIndex(_ anIndex: Index) -> Range<Index>
    @warn_unused_result
    func rangeOfComposedCharacterSequencesForRange(_ range: Range<Index>) -> Range<Index>
    @warn_unused_result
    func rangeOfString(_ aString: String, options mask: NSStringCompareOptions = default, range searchRange: Range<Index>? = default, locale locale: NSLocale? = default) -> Range<Index>?
    @warn_unused_result
    func localizedStandardContainsString(_ string: String) -> Bool
    @warn_unused_result
    func localizedStandardRangeOfString(_ string: String) -> Range<Index>?
    var smallestEncoding: NSStringEncoding { get }
    var stringByAbbreviatingWithTildeInPath: String { get }
    @warn_unused_result
    func stringByAddingPercentEncodingWithAllowedCharacters(_ allowedCharacters: NSCharacterSet) -> String?
    func stringByAddingPercentEscapesUsingEncoding(_ encoding: NSStringEncoding) -> String?
    @warn_unused_result
    func stringByAppendingFormat(_ format: String, _ arguments: CVarArgType...) -> String
    func stringByAppendingPathComponent(_ aString: String) -> String
    func stringByAppendingPathExtension(_ ext: String) -> String?
    @warn_unused_result
    func stringByAppendingString(_ aString: String) -> String
    var stringByDeletingLastPathComponent: String { get }
    var stringByDeletingPathExtension: String { get }
    var stringByExpandingTildeInPath: String { get }
    @warn_unused_result
    func stringByFoldingWithOptions(_ options: NSStringCompareOptions, locale locale: NSLocale?) -> String
    @warn_unused_result
    func stringByPaddingToLength(_ newLength: Int, withString padString: String, startingAtIndex padIndex: Int) -> String
    var stringByRemovingPercentEncoding: String? { get }
    @warn_unused_result
    func stringByReplacingCharactersInRange(_ range: Range<Index>, withString replacement: String) -> String
    @warn_unused_result
    func stringByReplacingOccurrencesOfString(_ target: String, withString replacement: String, options options: NSStringCompareOptions = default, range searchRange: Range<Index>? = default) -> String
    func stringByReplacingPercentEscapesUsingEncoding(_ encoding: NSStringEncoding) -> String?
    var stringByResolvingSymlinksInPath: String { get }
    var stringByStandardizingPath: String { get }
    @warn_unused_result
    func stringByTrimmingCharactersInSet(_ set: NSCharacterSet) -> String
    func stringsByAppendingPaths(_ paths: [String]) -> [String]
    @warn_unused_result
    func substringFromIndex(_ index: Index) -> String
    @warn_unused_result
    func substringToIndex(_ index: Index) -> String
    @warn_unused_result
    func substringWithRange(_ aRange: Range<Index>) -> String
    var localizedUppercaseString: String { get }
    @warn_unused_result
    func uppercaseStringWithLocale(_ locale: NSLocale?) -> String
    func writeToFile(_ path: String, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding) throws
    func writeToURL(_ url: NSURL, atomically useAuxiliaryFile: Bool, encoding enc: NSStringEncoding) throws
    @warn_unused_result
    func stringByApplyingTransform(_ transform: String, reverse reverse: Bool) -> String?
    @warn_unused_result
    func containsString(_ other: String) -> Bool
    @warn_unused_result
    func localizedCaseInsensitiveContainsString(_ other: String) -> Bool
}
extension String : _ObjectiveCBridgeable {
}
extension String {
    init(_ cocoaString: NSString)
}
extension String {
    typealias Index = String.CharacterView.Index
    var startIndex: Index { get }
    var endIndex: Index { get }
    subscript (_ i: Index) -> Character { get }
}
extension String {
    struct CharacterView {
        init(_ text: String)
    }
    var characters: String.CharacterView { get }
    mutating func withMutableCharacters<R>(_ body: (inout String.CharacterView) -> R) -> R
    init(_ characters: String.CharacterView)
}
extension String {
    struct UnicodeScalarView : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : BidirectionalIndexType, Comparable {
            @warn_unused_result
            func successor() -> String.UnicodeScalarView.Index
            @warn_unused_result
            func predecessor() -> String.UnicodeScalarView.Index
        }
        var startIndex: String.UnicodeScalarView.Index { get }
        var endIndex: String.UnicodeScalarView.Index { get }
        subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
        subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
        struct Generator : GeneratorType {
            mutating func next() -> UnicodeScalar?
        }
        @warn_unused_result
        func generate() -> String.UnicodeScalarView.Generator
        var description: String { get }
        var debugDescription: String { get }
    }
    init(_ unicodeScalars: String.UnicodeScalarView)
    typealias UnicodeScalarIndex = String.UnicodeScalarView.Index
}
extension String {
    struct UTF16View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        var startIndex: String.UTF16View.Index { get }
        var endIndex: String.UTF16View.Index { get }
        subscript (_ i: String.UTF16View.Index) -> CodeUnit { get }
        subscript (_ i: Int) -> CodeUnit { get }
        subscript (_ subRange: Range<Int>) -> String.UTF16View { get }
        subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
    var utf16: String.UTF16View { get }
    init?(_ utf16: String.UTF16View)
    typealias UTF16Index = String.UTF16View.Index
}
extension String {
    struct UTF8View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : ForwardIndexType {
            @warn_unused_result
            func successor() -> String.UTF8View.Index
        }
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        subscript (_ position: String.UTF8View.Index) -> CodeUnit { get }
        subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get }
        var description: String { get }
        var debugDescription: String { get }
    }
    var utf8: String.UTF8View { get }
    var nulTerminatedUTF8: ContiguousArray<CodeUnit> { get }
    init?(_ utf8: String.UTF8View)
    typealias UTF8Index = String.UTF8View.Index
}
extension String {
    @warn_unused_result
    static func fromCString(_ cs: UnsafePointer<CChar>) -> String?
    @warn_unused_result
    static func fromCStringRepairingIllFormedUTF8(_ cs: UnsafePointer<CChar>) -> (String?, hadError: Bool)
}
extension String {
    init(_ c: Character)
}
extension String {
    func withCString<Result>(@noescape _ f: UnsafePointer<Int8> throws -> Result) rethrows -> Result
}
extension String : _Reflectable {
}
extension String : OutputStreamType {
    mutating func write(_ other: String)
}
extension String : Streamable {
    func writeTo<Target : OutputStreamType>(inout _ target: Target)
}
extension String {
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
}
extension String : UnicodeScalarLiteralConvertible {
    init(unicodeScalarLiteral value: String)
}
extension String {
    init(_builtinExtendedGraphemeClusterLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
}
extension String : ExtendedGraphemeClusterLiteralConvertible {
    init(extendedGraphemeClusterLiteral value: String)
}
extension String {
    init(_builtinUTF16StringLiteral start: Builtin.RawPointer, numberOfCodeUnits numberOfCodeUnits: Builtin.Word)
}
extension String {
    init(_builtinStringLiteral start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
}
extension String : StringLiteralConvertible {
    init(stringLiteral value: String)
}
extension String : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension String : Equatable {
}
extension String : Comparable {
}
extension String {
    mutating func appendContentsOf(_ other: String)
    mutating func append(_ x: UnicodeScalar)
}
extension String : Hashable {
    var hashValue: Int { get }
}
extension String {
    subscript (_ subRange: Range<Index>) -> String { get }
}
extension String {
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ c: Character)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_ newElements: S)
    init<S : SequenceType where S.Generator.Element == Character>(_ characters: S)
}
extension String {
    func join<S : SequenceType where S.Generator.Element == String>(_ elements: S) -> String
}
extension String {
    mutating func replaceRange<C : CollectionType where C.Generator.Element == Character>(_ subRange: Range<Index>, with newElements: C)
    mutating func replaceRange(_ subRange: Range<Index>, with newElements: String)
    mutating func insert(_ newElement: Character, atIndex i: Index)
    mutating func insertContentsOf<S : CollectionType where S.Generator.Element == Character>(_ newElements: S, at i: Index)
    mutating func removeAtIndex(_ i: Index) -> Character
    mutating func removeRange(_ subRange: Range<Index>)
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
}
extension String {
    var lowercaseString: String { get }
    var uppercaseString: String { get }
}
extension String : StringInterpolationConvertible {
    init(stringInterpolation strings: String...)
    init<T>(stringInterpolationSegment expr: T)
    init(stringInterpolationSegment expr: String)
    init(stringInterpolationSegment expr: Character)
    init(stringInterpolationSegment expr: UnicodeScalar)
    init(stringInterpolationSegment expr: Bool)
    init(stringInterpolationSegment expr: Float32)
    init(stringInterpolationSegment expr: Float64)
    init(stringInterpolationSegment expr: UInt8)
    init(stringInterpolationSegment expr: Int8)
    init(stringInterpolationSegment expr: UInt16)
    init(stringInterpolationSegment expr: Int16)
    init(stringInterpolationSegment expr: UInt32)
    init(stringInterpolationSegment expr: Int32)
    init(stringInterpolationSegment expr: UInt64)
    init(stringInterpolationSegment expr: Int64)
    init(stringInterpolationSegment expr: UInt)
    init(stringInterpolationSegment expr: Int)
}
extension String {
    init(count count: Int, repeatedValue c: Character)
    init(count count: Int, repeatedValue c: UnicodeScalar)
    var isEmpty: Bool { get }
}
extension String {
    func hasPrefix(_ prefix: String) -> Bool
    func hasSuffix(_ suffix: String) -> Bool
}
extension String {
    init<T : _SignedIntegerType>(_ v: T)
    init<T : UnsignedIntegerType>(_ v: T)
    init<T : _SignedIntegerType>(_ v: T, radix radix: Int, uppercase uppercase: Bool = default)
    init<T : UnsignedIntegerType>(_ v: T, radix radix: Int, uppercase uppercase: Bool = default)
}
extension String {
    func toInt() -> Int?
}
extension String {
    var unicodeScalars: String.UnicodeScalarView
}
extension String {
    subscript (_ i: Int) -> Character { get }
    subscript (_ subRange: Range<Int>) -> String { get }
    var count: Int { get }
}
extension String : MirrorPathType {
}
extension String {
    init<T>(_ instance: T)
    init<T>(reflecting subject: T)
}

@rethrows func withCString<Result>(@noescape _ f: UnsafePointer<Int8> throws -> Result) rethrows -> Result

func withCString<Result>(@noescape _ f: UnsafePointer<Int8> throws -> Result) rethrows -> Result

struct CharacterView {
        init(_ text: String)
    }
extension String.CharacterView : CollectionType, Indexable, SequenceType {
    struct Index : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType, Comparable, _Reflectable {
        func successor() -> String.CharacterView.Index
        func predecessor() -> String.CharacterView.Index
    }
    var startIndex: String.CharacterView.Index { get }
    var endIndex: String.CharacterView.Index { get }
    subscript (_ i: String.CharacterView.Index) -> Character { get }
}
extension String.CharacterView : RangeReplaceableCollectionType {
    init()
    mutating func replaceRange<C : CollectionType where C.Generator.Element == Character>(_ subRange: Range<String.CharacterView.Index>, with newElements: C)
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ c: Character)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_ newElements: S)
    init<S : SequenceType where S.Generator.Element == Character>(_ characters: S)
}
extension String.CharacterView {
    subscript (_ subRange: Range<String.CharacterView.Index>) -> String.CharacterView { get }
}

struct CharacterView {
        init(_ text: String)
    }
extension String.CharacterView : CollectionType {
    struct Index : BidirectionalIndexType, Comparable, _Reflectable {
        func successor() -> String.CharacterView.Index
        func predecessor() -> String.CharacterView.Index
    }
    var startIndex: String.CharacterView.Index { get }
    var endIndex: String.CharacterView.Index { get }
    subscript (_ i: String.CharacterView.Index) -> Character { get }
}
extension String.CharacterView : RangeReplaceableCollectionType {
    init()
    mutating func replaceRange<C : CollectionType where C.Generator.Element == Character>(_ subRange: Range<String.CharacterView.Index>, with newElements: C)
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ c: Character)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Character>(_ newElements: S)
    init<S : SequenceType where S.Generator.Element == Character>(_ characters: S)
}
extension String.CharacterView {
    subscript (_ subRange: Range<String.CharacterView.Index>) -> String.CharacterView { get }
}

struct Index : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType, Comparable, _Reflectable {
        func successor() -> String.CharacterView.Index
        func predecessor() -> String.CharacterView.Index
    }

struct Index : BidirectionalIndexType, Comparable, _Reflectable {
        func successor() -> String.CharacterView.Index
        func predecessor() -> String.CharacterView.Index
    }

struct UnicodeScalarView : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType, Comparable {
            @warn_unused_result
            func successor() -> String.UnicodeScalarView.Index
            @warn_unused_result
            func predecessor() -> String.UnicodeScalarView.Index
        }
        var startIndex: String.UnicodeScalarView.Index { get }
        var endIndex: String.UnicodeScalarView.Index { get }
        subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
        subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
        struct Generator : GeneratorType {
            mutating func next() -> UnicodeScalar?
        }
        @warn_unused_result
        func generate() -> String.UnicodeScalarView.Generator
        var description: String { get }
        var debugDescription: String { get }
    }
extension String.UnicodeScalarView : RangeReplaceableCollectionType {
    init()
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ x: UnicodeScalar)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == UnicodeScalar>(_ newElements: S)
    mutating func replaceRange<C : CollectionType where C.Generator.Element == UnicodeScalar>(_ subRange: Range<String.UnicodeScalarView.Index>, with newElements: C)
}

struct UnicodeScalarView : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : BidirectionalIndexType, Comparable {
            @warn_unused_result
            func successor() -> String.UnicodeScalarView.Index
            @warn_unused_result
            func predecessor() -> String.UnicodeScalarView.Index
        }
        var startIndex: String.UnicodeScalarView.Index { get }
        var endIndex: String.UnicodeScalarView.Index { get }
        subscript (_ position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
        subscript (_ r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
        struct Generator : GeneratorType {
            mutating func next() -> UnicodeScalar?
        }
        @warn_unused_result
        func generate() -> String.UnicodeScalarView.Generator
        var description: String { get }
        var debugDescription: String { get }
    }
extension String.UnicodeScalarView : RangeReplaceableCollectionType {
    init()
    mutating func reserveCapacity(_ n: Int)
    mutating func append(_ x: UnicodeScalar)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == UnicodeScalar>(_ newElements: S)
    mutating func replaceRange<C : CollectionType where C.Generator.Element == UnicodeScalar>(_ subRange: Range<String.UnicodeScalarView.Index>, with newElements: C)
}

struct Index : ForwardIndexType, _Incrementable, Equatable, BidirectionalIndexType, Comparable {
            @warn_unused_result
            func successor() -> String.UnicodeScalarView.Index
            @warn_unused_result
            func predecessor() -> String.UnicodeScalarView.Index
        }

struct Index : BidirectionalIndexType, Comparable {
            @warn_unused_result
            func successor() -> String.UnicodeScalarView.Index
            @warn_unused_result
            func predecessor() -> String.UnicodeScalarView.Index
        }

struct UTF16View : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        var startIndex: String.UTF16View.Index { get }
        var endIndex: String.UTF16View.Index { get }
        subscript (_ i: String.UTF16View.Index) -> CodeUnit { get }
        subscript (_ i: Int) -> CodeUnit { get }
        subscript (_ subRange: Range<Int>) -> String.UTF16View { get }
        subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get }
        var description: String { get }
        var debugDescription: String { get }
    }

struct UTF16View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index {
        }
        var startIndex: String.UTF16View.Index { get }
        var endIndex: String.UTF16View.Index { get }
        subscript (_ i: String.UTF16View.Index) -> CodeUnit { get }
        subscript (_ i: Int) -> CodeUnit { get }
        subscript (_ subRange: Range<Int>) -> String.UTF16View { get }
        subscript (_ subRange: Range<String.UTF16View.Index>) -> String.UTF16View { get }
        var description: String { get }
        var debugDescription: String { get }
    }

struct Index {
        }
extension String.UTF16View.Index : ForwardIndexType, _Incrementable, BidirectionalIndexType {
    typealias Distance = Int
    @warn_unused_result
    func successor() -> String.UTF16View.Index
    @warn_unused_result
    func predecessor() -> String.UTF16View.Index
}
extension String.UTF16View.Index : Equatable, Comparable {
}
extension String.UTF16View.Index {
    @warn_unused_result
    func distanceTo(_ end: String.UTF16View.Index) -> Distance
    @warn_unused_result
    func advancedBy(_ n: Distance) -> String.UTF16View.Index
    @warn_unused_result
    func advancedBy(_ n: Distance, limit limit: String.UTF16View.Index) -> String.UTF16View.Index
}
extension String.UTF16View.Index {
    init?(_ utf8Index: UTF8Index, within utf16: String.UTF16View)
    init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf16: String.UTF16View)
    init(_ characterIndex: Index, within utf16: String.UTF16View)
    @warn_unused_result
    func samePositionIn(_ utf8: String.UTF8View) -> String.UTF8View.Index?
    @warn_unused_result
    func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> UnicodeScalarIndex?
    @warn_unused_result
    func samePositionIn(_ characters: String) -> Index?
}

struct Index {
        }
extension String.UTF16View.Index : BidirectionalIndexType {
    typealias Distance = Int
    @warn_unused_result
    func successor() -> String.UTF16View.Index
    @warn_unused_result
    func predecessor() -> String.UTF16View.Index
}
extension String.UTF16View.Index : Comparable, Equatable {
}
extension String.UTF16View.Index {
    @warn_unused_result
    func distanceTo(_ end: String.UTF16View.Index) -> Distance
    @warn_unused_result
    func advancedBy(_ n: Distance) -> String.UTF16View.Index
    @warn_unused_result
    func advancedBy(_ n: Distance, limit limit: String.UTF16View.Index) -> String.UTF16View.Index
}
extension String.UTF16View.Index {
    init?(_ utf8Index: UTF8Index, within utf16: String.UTF16View)
    init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf16: String.UTF16View)
    init(_ characterIndex: Index, within utf16: String.UTF16View)
    @warn_unused_result
    func samePositionIn(_ utf8: String.UTF8View) -> String.UTF8View.Index?
    @warn_unused_result
    func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> UnicodeScalarIndex?
    @warn_unused_result
    func samePositionIn(_ characters: String) -> Index?
}

struct UTF8View : CollectionType, Indexable, SequenceType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : ForwardIndexType, _Incrementable, Equatable {
            @warn_unused_result
            func successor() -> String.UTF8View.Index
        }
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        subscript (_ position: String.UTF8View.Index) -> CodeUnit { get }
        subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get }
        var description: String { get }
        var debugDescription: String { get }
    }

struct UTF8View : CollectionType, _Reflectable, CustomStringConvertible, CustomDebugStringConvertible {
        struct Index : ForwardIndexType {
            @warn_unused_result
            func successor() -> String.UTF8View.Index
        }
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        subscript (_ position: String.UTF8View.Index) -> CodeUnit { get }
        subscript (_ subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get }
        var description: String { get }
        var debugDescription: String { get }
    }

struct Index : ForwardIndexType, _Incrementable, Equatable {
            @warn_unused_result
            func successor() -> String.UTF8View.Index
        }
extension String.UTF8View.Index {
    init?(_ utf16Index: UTF16Index, within utf8: String.UTF8View)
    init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf8: String.UTF8View)
    init(_ characterIndex: Index, within utf8: String.UTF8View)
    @warn_unused_result
    func samePositionIn(_ utf16: String.UTF16View) -> String.UTF16View.Index?
    @warn_unused_result
    func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> UnicodeScalarIndex?
    @warn_unused_result
    func samePositionIn(_ characters: String) -> Index?
}

struct Index : ForwardIndexType {
            @warn_unused_result
            func successor() -> String.UTF8View.Index
        }
extension String.UTF8View.Index {
    init?(_ utf16Index: UTF16Index, within utf8: String.UTF8View)
    init(_ unicodeScalarIndex: UnicodeScalarIndex, within utf8: String.UTF8View)
    init(_ characterIndex: Index, within utf8: String.UTF8View)
    @warn_unused_result
    func samePositionIn(_ utf16: String.UTF16View) -> String.UTF16View.Index?
    @warn_unused_result
    func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> UnicodeScalarIndex?
    @warn_unused_result
    func samePositionIn(_ characters: String) -> Index?
}

struct UInt : _IntegerArithmeticType, Comparable, Equatable, _DisallowMixedSignArithmetic, _IntegerType, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, UnsignedIntegerType {
    var value: Builtin.Int32
    typealias Distance = Int
    init()
    init(_ v: Builtin.Word)
    init(_ value: UInt)
    init(bigEndian value: UInt)
    init(littleEndian value: UInt)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt)
    var bigEndian: UInt { get }
    var littleEndian: UInt { get }
    var byteSwapped: UInt { get }
    static var max: UInt { get }
    static var min: UInt { get }
}
extension UInt {
    init(_ value: CGFloat)
}
extension UInt : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension UInt : Hashable {
    var hashValue: Int { get }
}
extension UInt : CustomStringConvertible {
    var description: String { get }
}
extension UInt : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity {
    func successor() -> UInt
    func predecessor() -> UInt
    func distanceTo(_ other: UInt) -> Distance
    func advancedBy(_ n: Distance) -> UInt
}
extension UInt {
    static func addWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: Int)
    init(bitPattern bitPattern: Int)
}
extension UInt : BitwiseOperationsType {
    static var allZeros: UInt { get }
}
extension UInt {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt : _Reflectable {
}
extension UInt : CVarArgType {
}

struct UInt : UnsignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int32
    typealias Distance = Int
    init()
    init(_ v: Builtin.Word)
    init(_ value: UInt)
    init(bigEndian value: UInt)
    init(littleEndian value: UInt)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt)
    var bigEndian: UInt { get }
    var littleEndian: UInt { get }
    var byteSwapped: UInt { get }
    static var max: UInt { get }
    static var min: UInt { get }
}
extension UInt {
    init(_ value: CGFloat)
}
extension UInt : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension UInt : Hashable {
    var hashValue: Int { get }
}
extension UInt : CustomStringConvertible {
    var description: String { get }
}
extension UInt : RandomAccessIndexType {
    func successor() -> UInt
    func predecessor() -> UInt
    func distanceTo(_ other: UInt) -> Distance
    func advancedBy(_ n: Distance) -> UInt
}
extension UInt {
    static func addWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt, _ rhs: UInt) -> (UInt, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: Int)
    init(bitPattern bitPattern: Int)
}
extension UInt : BitwiseOperationsType {
    static var allZeros: UInt { get }
}
extension UInt {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt : _Reflectable {
}
extension UInt : CVarArgType {
}

struct UInt16 : _IntegerArithmeticType, Comparable, Equatable, _DisallowMixedSignArithmetic, _IntegerType, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, UnsignedIntegerType {
    var value: Builtin.Int16
    typealias Distance = Int
    init()
    init(_ value: UInt16)
    init(bigEndian value: UInt16)
    init(littleEndian value: UInt16)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt16)
    var bigEndian: UInt16 { get }
    var littleEndian: UInt16 { get }
    var byteSwapped: UInt16 { get }
    static var max: UInt16 { get }
    static var min: UInt16 { get }
}
extension UInt16 {
    init(_ value: CGFloat)
}
extension UInt16 : Hashable {
    var hashValue: Int { get }
}
extension UInt16 : CustomStringConvertible {
    var description: String { get }
}
extension UInt16 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity {
    func successor() -> UInt16
    func predecessor() -> UInt16
    func distanceTo(_ other: UInt16) -> Distance
    func advancedBy(_ n: Distance) -> UInt16
}
extension UInt16 {
    static func addWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt16 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int16)
}
extension UInt16 : BitwiseOperationsType {
    static var allZeros: UInt16 { get }
}
extension UInt16 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt16 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt16 : _Reflectable {
}
extension UInt16 : CVarArgType {
}

struct UInt16 : UnsignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int16
    typealias Distance = Int
    init()
    init(_ value: UInt16)
    init(bigEndian value: UInt16)
    init(littleEndian value: UInt16)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt16)
    var bigEndian: UInt16 { get }
    var littleEndian: UInt16 { get }
    var byteSwapped: UInt16 { get }
    static var max: UInt16 { get }
    static var min: UInt16 { get }
}
extension UInt16 {
    init(_ value: CGFloat)
}
extension UInt16 : Hashable {
    var hashValue: Int { get }
}
extension UInt16 : CustomStringConvertible {
    var description: String { get }
}
extension UInt16 : RandomAccessIndexType {
    func successor() -> UInt16
    func predecessor() -> UInt16
    func distanceTo(_ other: UInt16) -> Distance
    func advancedBy(_ n: Distance) -> UInt16
}
extension UInt16 {
    static func addWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt16, _ rhs: UInt16) -> (UInt16, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt16 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int16)
}
extension UInt16 : BitwiseOperationsType {
    static var allZeros: UInt16 { get }
}
extension UInt16 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt16 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt16 : _Reflectable {
}
extension UInt16 : CVarArgType {
}

struct UInt32 : _IntegerArithmeticType, Comparable, Equatable, _DisallowMixedSignArithmetic, _IntegerType, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, UnsignedIntegerType {
    var value: Builtin.Int32
    typealias Distance = Int
    init()
    init(_ value: UInt32)
    init(bigEndian value: UInt32)
    init(littleEndian value: UInt32)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt32)
    var bigEndian: UInt32 { get }
    var littleEndian: UInt32 { get }
    var byteSwapped: UInt32 { get }
    static var max: UInt32 { get }
    static var min: UInt32 { get }
}
extension UInt32 {
    init(_ value: CGFloat)
}
extension UInt32 : Hashable {
    var hashValue: Int { get }
}
extension UInt32 : CustomStringConvertible {
    var description: String { get }
}
extension UInt32 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity {
    func successor() -> UInt32
    func predecessor() -> UInt32
    func distanceTo(_ other: UInt32) -> Distance
    func advancedBy(_ n: Distance) -> UInt32
}
extension UInt32 {
    static func addWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt32 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int32)
}
extension UInt32 : BitwiseOperationsType {
    static var allZeros: UInt32 { get }
}
extension UInt32 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt32 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt32 : _Reflectable {
}
extension UInt32 {
    init(_ v: UnicodeScalar)
}
extension UInt32 : CVarArgType {
}

struct UInt32 : UnsignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int32
    typealias Distance = Int
    init()
    init(_ value: UInt32)
    init(bigEndian value: UInt32)
    init(littleEndian value: UInt32)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt32)
    var bigEndian: UInt32 { get }
    var littleEndian: UInt32 { get }
    var byteSwapped: UInt32 { get }
    static var max: UInt32 { get }
    static var min: UInt32 { get }
}
extension UInt32 {
    init(_ value: CGFloat)
}
extension UInt32 : Hashable {
    var hashValue: Int { get }
}
extension UInt32 : CustomStringConvertible {
    var description: String { get }
}
extension UInt32 : RandomAccessIndexType {
    func successor() -> UInt32
    func predecessor() -> UInt32
    func distanceTo(_ other: UInt32) -> Distance
    func advancedBy(_ n: Distance) -> UInt32
}
extension UInt32 {
    static func addWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt32, _ rhs: UInt32) -> (UInt32, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt32 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int32)
}
extension UInt32 : BitwiseOperationsType {
    static var allZeros: UInt32 { get }
}
extension UInt32 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt32 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt32 : _Reflectable {
}
extension UInt32 {
    init(_ v: UnicodeScalar)
}
extension UInt32 : CVarArgType {
}

struct UInt64 : _IntegerArithmeticType, Comparable, Equatable, _DisallowMixedSignArithmetic, _IntegerType, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, UnsignedIntegerType {
    var value: Builtin.Int64
    typealias Distance = Int
    init()
    init(_ value: UInt64)
    init(bigEndian value: UInt64)
    init(littleEndian value: UInt64)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt64)
    var bigEndian: UInt64 { get }
    var littleEndian: UInt64 { get }
    var byteSwapped: UInt64 { get }
    static var max: UInt64 { get }
    static var min: UInt64 { get }
}
extension UInt64 {
    init(_ value: CGFloat)
}
extension UInt64 : Hashable {
    var hashValue: Int { get }
}
extension UInt64 : CustomStringConvertible {
    var description: String { get }
}
extension UInt64 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity {
    func successor() -> UInt64
    func predecessor() -> UInt64
    func distanceTo(_ other: UInt64) -> Distance
    func advancedBy(_ n: Distance) -> UInt64
}
extension UInt64 {
    static func addWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt64 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
    init(bitPattern bitPattern: Int64)
}
extension UInt64 : BitwiseOperationsType {
    static var allZeros: UInt64 { get }
}
extension UInt64 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt64 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt64 : _Reflectable {
}
extension UInt64 {
    init(_ v: UnicodeScalar)
}
extension UInt64 : CVarArgType, _CVarArgAlignedType {
}

struct UInt64 : UnsignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int64
    typealias Distance = Int
    init()
    init(_ value: UInt64)
    init(bigEndian value: UInt64)
    init(littleEndian value: UInt64)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt64)
    var bigEndian: UInt64 { get }
    var littleEndian: UInt64 { get }
    var byteSwapped: UInt64 { get }
    static var max: UInt64 { get }
    static var min: UInt64 { get }
}
extension UInt64 {
    init(_ value: CGFloat)
}
extension UInt64 : Hashable {
    var hashValue: Int { get }
}
extension UInt64 : CustomStringConvertible {
    var description: String { get }
}
extension UInt64 : RandomAccessIndexType {
    func successor() -> UInt64
    func predecessor() -> UInt64
    func distanceTo(_ other: UInt64) -> Distance
    func advancedBy(_ n: Distance) -> UInt64
}
extension UInt64 {
    static func addWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt64, _ rhs: UInt64) -> (UInt64, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt64 {
    init(_ v: UInt8)
    init(_ v: Int8)
    init(_ v: UInt16)
    init(_ v: Int16)
    init(_ v: UInt32)
    init(_ v: Int32)
    init(_ v: Int64)
    init(_ v: UInt)
    init(_ v: Int)
    init(bitPattern bitPattern: Int64)
}
extension UInt64 : BitwiseOperationsType {
    static var allZeros: UInt64 { get }
}
extension UInt64 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt64 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt64 : _Reflectable {
}
extension UInt64 {
    init(_ v: UnicodeScalar)
}
extension UInt64 : CVarArgType, _CVarArgAlignedType {
}

struct UInt8 : _IntegerArithmeticType, Comparable, Equatable, _DisallowMixedSignArithmetic, _IntegerType, IntegerArithmeticType, IntegerLiteralConvertible, IntegerType, UnsignedIntegerType {
    var value: Builtin.Int8
    typealias Distance = Int
    init()
    init(_ value: UInt8)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt8)
    static var max: UInt8 { get }
    static var min: UInt8 { get }
}
extension UInt8 {
    init(_ value: CGFloat)
}
extension UInt8 : Hashable {
    var hashValue: Int { get }
}
extension UInt8 : CustomStringConvertible {
    var description: String { get }
}
extension UInt8 : _Incrementable, RandomAccessIndexType, BidirectionalIndexType, ForwardIndexType, Strideable, _Strideable, _RandomAccessAmbiguity {
    func successor() -> UInt8
    func predecessor() -> UInt8
    func distanceTo(_ other: UInt8) -> Distance
    func advancedBy(_ n: Distance) -> UInt8
}
extension UInt8 {
    static func addWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt8 {
    init(_ v: Int8)
    init(_ v: UInt16)
    init(truncatingBitPattern truncatingBitPattern: UInt16)
    init(_ v: Int16)
    init(truncatingBitPattern truncatingBitPattern: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int8)
}
extension UInt8 : BitwiseOperationsType {
    static var allZeros: UInt8 { get }
}
extension UInt8 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt8 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt8 : _Reflectable {
}
extension UInt8 {
    init(ascii v: UnicodeScalar)
}
extension UInt8 : CVarArgType {
}

struct UInt8 : UnsignedIntegerType, Comparable, Equatable {
    var value: Builtin.Int8
    typealias Distance = Int
    init()
    init(_ value: UInt8)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt8)
    static var max: UInt8 { get }
    static var min: UInt8 { get }
}
extension UInt8 {
    init(_ value: CGFloat)
}
extension UInt8 : Hashable {
    var hashValue: Int { get }
}
extension UInt8 : CustomStringConvertible {
    var description: String { get }
}
extension UInt8 : RandomAccessIndexType {
    func successor() -> UInt8
    func predecessor() -> UInt8
    func distanceTo(_ other: UInt8) -> Distance
    func advancedBy(_ n: Distance) -> UInt8
}
extension UInt8 {
    static func addWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func subtractWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func multiplyWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func divideWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    static func remainderWithOverflow(_ lhs: UInt8, _ rhs: UInt8) -> (UInt8, overflow: Bool)
    func toUIntMax() -> UIntMax
    func toIntMax() -> IntMax
}
extension UInt8 {
    init(_ v: Int8)
    init(_ v: UInt16)
    init(truncatingBitPattern truncatingBitPattern: UInt16)
    init(_ v: Int16)
    init(truncatingBitPattern truncatingBitPattern: Int16)
    init(_ v: UInt32)
    init(truncatingBitPattern truncatingBitPattern: UInt32)
    init(_ v: Int32)
    init(truncatingBitPattern truncatingBitPattern: Int32)
    init(_ v: UInt64)
    init(truncatingBitPattern truncatingBitPattern: UInt64)
    init(_ v: Int64)
    init(truncatingBitPattern truncatingBitPattern: Int64)
    init(_ v: UInt)
    init(truncatingBitPattern truncatingBitPattern: UInt)
    init(_ v: Int)
    init(truncatingBitPattern truncatingBitPattern: Int)
    init(bitPattern bitPattern: Int8)
}
extension UInt8 : BitwiseOperationsType {
    static var allZeros: UInt8 { get }
}
extension UInt8 {
    init(_ other: Float)
    init(_ other: Double)
}
extension UInt8 {
    init?(_ text: String, radix radix: Int = default)
}
extension UInt8 : _Reflectable {
}
extension UInt8 {
    init(ascii v: UnicodeScalar)
}
extension UInt8 : CVarArgType {
}

struct UnicodeScalar : UnicodeScalarLiteralConvertible {
    var value: UInt32 { get }
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
    init(unicodeScalarLiteral value: UnicodeScalar)
    init()
    init(_ v: UInt32)
    init(_ v: UInt16)
    init(_ v: UInt8)
    init(_ v: UnicodeScalar)
    @warn_unused_result
    func escape(asASCII forceASCII: Bool) -> String
    @warn_unused_result
    func isASCII() -> Bool
}
extension UnicodeScalar : _Reflectable {
}
extension UnicodeScalar : Streamable {
    func writeTo<Target : OutputStreamType>(inout _ target: Target)
}
extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension UnicodeScalar : Hashable {
    var hashValue: Int { get }
}
extension UnicodeScalar {
    init(_ v: Int)
}
extension UnicodeScalar : Equatable, Comparable {
}

struct UnicodeScalar : UnicodeScalarLiteralConvertible {
    var value: UInt32 { get }
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
    init(unicodeScalarLiteral value: UnicodeScalar)
    init()
    init(_ v: UInt32)
    init(_ v: UInt16)
    init(_ v: UInt8)
    init(_ v: UnicodeScalar)
    @warn_unused_result
    func escape(asASCII forceASCII: Bool) -> String
    @warn_unused_result
    func isASCII() -> Bool
}
extension UnicodeScalar : _Reflectable {
}
extension UnicodeScalar : Streamable {
    func writeTo<Target : OutputStreamType>(inout _ target: Target)
}
extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible {
    var description: String { get }
    var debugDescription: String { get }
}
extension UnicodeScalar : Hashable {
    var hashValue: Int { get }
}
extension UnicodeScalar {
    init(_ v: Int)
}
extension UnicodeScalar : Comparable, Equatable {
}

struct Unmanaged<Instance> {
    typealias T = Instance
    @warn_unused_result
    static func fromOpaque(_ value: COpaquePointer) -> Unmanaged<Instance>
    @warn_unused_result
    func toOpaque() -> COpaquePointer
    @warn_unused_result
    static func passRetained(_ value: Instance) -> Unmanaged<Instance>
    @warn_unused_result
    static func passUnretained(_ value: Instance) -> Unmanaged<Instance>
    @warn_unused_result
    func takeUnretainedValue() -> Instance
    @warn_unused_result
    func takeRetainedValue() -> Instance
    func retain() -> Unmanaged<Instance>
    func release()
    func autorelease() -> Unmanaged<Instance>
}

struct Unmanaged<Instance : AnyObject> {
    typealias T = Instance
    @warn_unused_result
    static func fromOpaque(_ value: COpaquePointer) -> Unmanaged<Instance>
    @warn_unused_result
    func toOpaque() -> COpaquePointer
    @warn_unused_result
    static func passRetained(_ value: Instance) -> Unmanaged<Instance>
    @warn_unused_result
    static func passUnretained(_ value: Instance) -> Unmanaged<Instance>
    @warn_unused_result
    func takeUnretainedValue() -> Instance
    @warn_unused_result
    func takeRetainedValue() -> Instance
    func retain() -> Unmanaged<Instance>
    func release()
    func autorelease() -> Unmanaged<Instance>
}

struct UnsafeBufferPointer<Element> : CollectionType, Indexable, SequenceType {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ i: Int) -> Element { get }
    init(start start: UnsafePointer<Element>, count count: Int)
    func generate() -> UnsafeBufferPointerGenerator<Element>
    var baseAddress: UnsafePointer<Element> { get }
    var count: Int { get }
}
extension UnsafeBufferPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}

struct UnsafeBufferPointer<Element> : CollectionType {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ i: Int) -> Element { get }
    init(start start: UnsafePointer<Element>, count count: Int)
    func generate() -> UnsafeBufferPointerGenerator<Element>
    var baseAddress: UnsafePointer<Element> { get }
    var count: Int { get }
}
extension UnsafeBufferPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}

struct UnsafeMutableBufferPointer<Element> : MutableCollectionType, CollectionType, Indexable, SequenceType, MutableIndexable {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ i: Int) -> Element { get nonmutating set }
    init(start start: UnsafeMutablePointer<Element>, count count: Int)
    func generate() -> UnsafeBufferPointerGenerator<Element>
    var baseAddress: UnsafeMutablePointer<Element> { get }
    var count: Int { get }
}
extension UnsafeMutableBufferPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}

struct UnsafeMutableBufferPointer<Element> : MutableCollectionType {
    typealias T = Element
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (_ i: Int) -> Element { get nonmutating set }
    init(start start: UnsafeMutablePointer<Element>, count count: Int)
    func generate() -> UnsafeBufferPointerGenerator<Element>
    var baseAddress: UnsafeMutablePointer<Element> { get }
    var count: Int { get }
}
extension UnsafeMutableBufferPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}

struct UnsafeMutablePointer<Memory> : Equatable, Hashable, NilLiteralConvertible, _PointerType, BidirectionalIndexType, ForwardIndexType, _Incrementable, RandomAccessIndexType, Strideable, Comparable, _Strideable, _RandomAccessAmbiguity {
    typealias T = Memory
    typealias Distance = Int
    init()
    init(_ other: COpaquePointer)
    init(bitPattern bitPattern: Int)
    init(bitPattern bitPattern: UInt)
    init<U>(_ from: UnsafeMutablePointer<U>)
    init<U>(_ from: UnsafePointer<U>)
    init(nilLiteral nilLiteral: ())
    @warn_unused_result
    static func alloc(_ num: Int) -> UnsafeMutablePointer<Memory>
    func dealloc(_ num: Int)
    var memory: Memory { get nonmutating set }
    func initialize(_ newvalue: Memory)
    @warn_unused_result
    func move() -> Memory
    func assignFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func assignBackwardFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func moveInitializeFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func moveInitializeBackwardFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func initializeFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func initializeFrom<C : CollectionType where C.Generator.Element == Memory>(_ source: C)
    func moveAssignFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func destroy()
    func destroy(_ count: Int)
    subscript (_ i: Int) -> Memory { get nonmutating set }
    var hashValue: Int { get }
    func successor() -> UnsafeMutablePointer<Memory>
    func predecessor() -> UnsafeMutablePointer<Memory>
    func distanceTo(_ x: UnsafeMutablePointer<Memory>) -> Int
    func advancedBy(_ n: Int) -> UnsafeMutablePointer<Memory>
}
extension UnsafeMutablePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension UnsafeMutablePointer : _Reflectable {
}
extension UnsafeMutablePointer : CVarArgType {
}

struct UnsafeMutablePointer<Memory> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType {
    typealias T = Memory
    typealias Distance = Int
    init()
    init(_ other: COpaquePointer)
    init(bitPattern bitPattern: Int)
    init(bitPattern bitPattern: UInt)
    init<U>(_ from: UnsafeMutablePointer<U>)
    init<U>(_ from: UnsafePointer<U>)
    init(nilLiteral nilLiteral: ())
    @warn_unused_result
    static func alloc(_ num: Int) -> UnsafeMutablePointer<Memory>
    func dealloc(_ num: Int)
    var memory: Memory { get nonmutating set }
    func initialize(_ newvalue: Memory)
    @warn_unused_result
    func move() -> Memory
    func assignFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func assignBackwardFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func moveInitializeFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func moveInitializeBackwardFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func initializeFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func initializeFrom<C : CollectionType where C.Generator.Element == Memory>(_ source: C)
    func moveAssignFrom(_ source: UnsafeMutablePointer<Memory>, count count: Int)
    func destroy()
    func destroy(_ count: Int)
    subscript (_ i: Int) -> Memory { get nonmutating set }
    var hashValue: Int { get }
    func successor() -> UnsafeMutablePointer<Memory>
    func predecessor() -> UnsafeMutablePointer<Memory>
    func distanceTo(_ x: UnsafeMutablePointer<Memory>) -> Int
    func advancedBy(_ n: Int) -> UnsafeMutablePointer<Memory>
}
extension UnsafeMutablePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension UnsafeMutablePointer : _Reflectable {
}
extension UnsafeMutablePointer : CVarArgType {
}

struct UnsafePointer<Memory> : Equatable, Hashable, NilLiteralConvertible, _PointerType, BidirectionalIndexType, ForwardIndexType, _Incrementable, RandomAccessIndexType, Strideable, Comparable, _Strideable, _RandomAccessAmbiguity {
    typealias T = Memory
    typealias Distance = Int
    init()
    init(_ other: COpaquePointer)
    init(bitPattern bitPattern: Int)
    init(bitPattern bitPattern: UInt)
    init<U>(_ from: UnsafeMutablePointer<U>)
    init<U>(_ from: UnsafePointer<U>)
    init(nilLiteral nilLiteral: ())
    var memory: Memory { get }
    subscript (_ i: Int) -> Memory { get }
    var hashValue: Int { get }
    func successor() -> UnsafePointer<Memory>
    func predecessor() -> UnsafePointer<Memory>
    func distanceTo(_ x: UnsafePointer<Memory>) -> Int
    func advancedBy(_ n: Int) -> UnsafePointer<Memory>
}
extension UnsafePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension UnsafePointer : _Reflectable {
}
extension UnsafePointer : CVarArgType {
}

struct UnsafePointer<Memory> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType {
    typealias T = Memory
    typealias Distance = Int
    init()
    init(_ other: COpaquePointer)
    init(bitPattern bitPattern: Int)
    init(bitPattern bitPattern: UInt)
    init<U>(_ from: UnsafeMutablePointer<U>)
    init<U>(_ from: UnsafePointer<U>)
    init(nilLiteral nilLiteral: ())
    var memory: Memory { get }
    subscript (_ i: Int) -> Memory { get }
    var hashValue: Int { get }
    func successor() -> UnsafePointer<Memory>
    func predecessor() -> UnsafePointer<Memory>
    func distanceTo(_ x: UnsafePointer<Memory>) -> Int
    func advancedBy(_ n: Int) -> UnsafePointer<Memory>
}
extension UnsafePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension UnsafePointer : _Reflectable {
}
extension UnsafePointer : CVarArgType {
}

@warn_unused_result
@rethrows func &&<T : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> Bool) rethrows -> Bool

@warn_unused_result
func &&<T : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> Bool) rethrows -> Bool

@warn_unused_result
@rethrows func &&<T : BooleanType, U : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> U) rethrows -> Bool

@warn_unused_result
func &&<T : BooleanType, U : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> U) rethrows -> Bool

@warn_unused_result
@rethrows func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T?) rethrows -> T?

@warn_unused_result
func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T?) rethrows -> T?

@warn_unused_result
@rethrows func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T) rethrows -> T

@warn_unused_result
func ??<T>(_ optional: T?, @autoclosure _ defaultValue: () throws -> T) rethrows -> T

func isUniquelyReferencedNonObjC<T>(inout _ object: T?) -> Bool

func isUniquelyReferencedNonObjC<T : AnyObject>(inout _ object: T?) -> Bool

func isUniquelyReferencedNonObjC<T>(inout _ object: T) -> Bool

func isUniquelyReferencedNonObjC<T : AnyObject>(inout _ object: T) -> Bool

typealias Elements : CollectionType, SequenceType = Self

typealias Elements : CollectionType = Self

typealias SubSequence : Indexable, SequenceType = MutableSlice<Self>

typealias SubSequence = MutableSlice<Self>

@warn_unused_result
func unsafeDowncast<T>(_ x: AnyObject) -> T

@warn_unused_result
func unsafeDowncast<T : AnyObject>(_ x: AnyObject) -> T

@rethrows func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: T throws -> Result) rethrows -> Result

func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: T throws -> Result) rethrows -> Result

@rethrows func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: () throws -> Result) rethrows -> Result

func withExtendedLifetime<T, Result>(_ x: T, @noescape _ f: () throws -> Result) rethrows -> Result

@rethrows func withUnsafeMutablePointer<T, Result>(inout _ arg: T, @noescape _ body: UnsafeMutablePointer<T> throws -> Result) rethrows -> Result

func withUnsafeMutablePointer<T, Result>(inout _ arg: T, @noescape _ body: UnsafeMutablePointer<T> throws -> Result) rethrows -> Result

@rethrows func withUnsafeMutablePointers<A0, A1, Result>(inout _ arg0: A0, inout _ arg1: A1, @noescape _ body: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>) throws -> Result) rethrows -> Result

func withUnsafeMutablePointers<A0, A1, Result>(inout _ arg0: A0, inout _ arg1: A1, @noescape _ body: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>) throws -> Result) rethrows -> Result

@rethrows func withUnsafeMutablePointers<A0, A1, A2, Result>(inout _ arg0: A0, inout _ arg1: A1, inout _ arg2: A2, @noescape _ body: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>, UnsafeMutablePointer<A2>) throws -> Result) rethrows -> Result

func withUnsafeMutablePointers<A0, A1, A2, Result>(inout _ arg0: A0, inout _ arg1: A1, inout _ arg2: A2, @noescape _ body: (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>, UnsafeMutablePointer<A2>) throws -> Result) rethrows -> Result

@rethrows func withUnsafePointer<T, Result>(inout _ arg: T, @noescape _ body: UnsafePointer<T> throws -> Result) rethrows -> Result

func withUnsafePointer<T, Result>(inout _ arg: T, @noescape _ body: UnsafePointer<T> throws -> Result) rethrows -> Result

@rethrows func withUnsafePointers<A0, A1, Result>(inout _ arg0: A0, inout _ arg1: A1, @noescape _ body: (UnsafePointer<A0>, UnsafePointer<A1>) throws -> Result) rethrows -> Result

func withUnsafePointers<A0, A1, Result>(inout _ arg0: A0, inout _ arg1: A1, @noescape _ body: (UnsafePointer<A0>, UnsafePointer<A1>) throws -> Result) rethrows -> Result

@rethrows func withUnsafePointers<A0, A1, A2, Result>(inout _ arg0: A0, inout _ arg1: A1, inout _ arg2: A2, @noescape _ body: (UnsafePointer<A0>, UnsafePointer<A1>, UnsafePointer<A2>) throws -> Result) rethrows -> Result

func withUnsafePointers<A0, A1, A2, Result>(inout _ arg0: A0, inout _ arg1: A1, inout _ arg2: A2, @noescape _ body: (UnsafePointer<A0>, UnsafePointer<A1>, UnsafePointer<A2>) throws -> Result) rethrows -> Result

@warn_unused_result
@rethrows func ||<T : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> Bool) rethrows -> Bool

@warn_unused_result
func ||<T : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> Bool) rethrows -> Bool

@warn_unused_result
@rethrows func ||<T : BooleanType, U : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> U) rethrows -> Bool

@warn_unused_result
func ||<T : BooleanType, U : BooleanType>(_ lhs: T, @autoclosure _ rhs: () throws -> U) rethrows -> Bool