protocol AbsoluteValuable : SignedNumberType {
    static func abs(_ x: Self) -> Self
}

protocol AbsoluteValuable : SignedNumberType {
    @warn_unused_result
    static func abs(_ x: Self) -> Self
}

static func abs(_ x: Self) -> Self

@warn_unused_result
    static func abs(_ x: Self) -> Self

struct Array<T> : MutableCollectionType, Sliceable, _DestructorSafeContainer {
    typealias Element = T
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (index: Int) -> T
    func generate() -> IndexingGenerator<[T]>
    typealias SubSlice = ArraySlice<T>
    subscript (subRange: Range<Int>) -> ArraySlice<T>
    init(_ buffer: _ArrayBuffer<T>)
}
extension Array : _ObjectiveCBridgeable {
    init(_fromNSArray source: NSArray, noCopy noCopy: Bool = default)
}
extension Array : __ArrayType {
}
extension Array : ArrayLiteralConvertible {
    init(arrayLiteral elements: T...)
}
extension Array : _ArrayType {
    init()
    init<S : SequenceType where T == T>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: T)
    init(_uninitializedCount count: Int)
    var count: Int { get }
    var capacity: Int { get }
    var isEmpty: Bool { get }
    var first: T? { get }
    var last: T? { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: T)
    mutating func extend<S : SequenceType where T == T>(_ newElements: S)
    mutating func removeLast() -> T
    mutating func insert(_ newElement: T, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> T
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func join<S : SequenceType where [T] == [T]>(_ elements: S) -> [T]
    func reduce<U>(_ initial: U, combine combine: @noescape (U, T) -> U) -> U
    mutating func sort(_ isOrderedBefore: (T, T) -> Bool)
    func sorted(_ isOrderedBefore: (T, T) -> Bool) -> [T]
    func map<U>(_ transform: (T) -> U) -> [U]
    func flatMap<U>(_ transform: @noescape (T) -> [U]) -> [U]
    func reverse() -> [T]
    func filter(_ includeElement: (T) -> Bool) -> [T]
}
extension Array : Reflectable {
    func getMirror() -> MirrorType
}
extension Array : Printable, DebugPrintable {
    var description: String { get }
    var debugDescription: String { get }
}
extension Array {
    func withUnsafeBufferPointer<R>(_ body: @noescape (UnsafeBufferPointer<T>) -> R) -> R
    mutating func withUnsafeMutableBufferPointer<R>(_ body: @noescape (inout UnsafeMutableBufferPointer<T>) -> R) -> R
}
extension Array {
    mutating func replaceRange<C : CollectionType where T == T>(_ subRange: Range<Int>, with newElements: C)
    mutating func splice<S : CollectionType where T == T>(_ newElements: S, atIndex i: Int)
    mutating func removeRange(_ subRange: Range<Int>)
}
extension Array {
    init(_fromCocoaArray source: _NSArrayCoreType, noCopy noCopy: Bool = default)
}

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?
}

mutating func append(_ newElement: T)

mutating func append(_ newElement: Element)

init<S : SequenceType where T == T>(_ s: S)

init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)

S : SequenceType, S.Generator.Element == _Buffer.Element

init(arrayLiteral elements: T...)

init(arrayLiteral elements: Element...)

init(count count: Int, repeatedValue repeatedValue: T)

init(count count: Int, repeatedValue repeatedValue: Element)

mutating func insert(_ newElement: T, atIndex i: Int)

mutating func insert(_ newElement: Element, atIndex i: Int)

mutating func removeAtIndex(_ index: Int) -> T

mutating func removeAtIndex(_ index: Int) -> Element

mutating func removeLast() -> T

mutating func removeLast() -> Element

subscript (index: Int) -> T

subscript (_ index: Int) -> Element

subscript (subRange: Range<Int>) -> ArraySlice<T>

subscript (_ subRange: Range<Int>) -> ArraySlice<Element>

protocol ArrayLiteralConvertible {
    typealias Element
    init(arrayLiteral elements: Element...)
}

protocol ArrayLiteralConvertible {
    typealias Element
    init(arrayLiteral elements: Self.Element...)
}

init(arrayLiteral elements: Element...)

init(arrayLiteral elements: Self.Element...)

struct ArraySlice<T> : MutableCollectionType, Sliceable, _DestructorSafeContainer {
    typealias Element = T
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (index: Int) -> T
    func generate() -> IndexingGenerator<ArraySlice<T>>
    typealias SubSlice = ArraySlice<T>
    subscript (subRange: Range<Int>) -> ArraySlice<T>
    init(_ buffer: _SliceBuffer<T>)
}
extension ArraySlice : __ArrayType {
}
extension ArraySlice : ArrayLiteralConvertible {
    init(arrayLiteral elements: T...)
}
extension ArraySlice : _ArrayType {
    init()
    init<S : SequenceType where T == T>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: T)
    init(_uninitializedCount count: Int)
    var count: Int { get }
    var capacity: Int { get }
    var isEmpty: Bool { get }
    var first: T? { get }
    var last: T? { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: T)
    mutating func extend<S : SequenceType where T == T>(_ newElements: S)
    mutating func removeLast() -> T
    mutating func insert(_ newElement: T, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> T
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func join<S : SequenceType where ArraySlice<T> == ArraySlice<T>>(_ elements: S) -> ArraySlice<T>
    func reduce<U>(_ initial: U, combine combine: @noescape (U, T) -> U) -> U
    mutating func sort(_ isOrderedBefore: (T, T) -> Bool)
    func sorted(_ isOrderedBefore: (T, T) -> Bool) -> ArraySlice<T>
    func map<U>(_ transform: (T) -> U) -> ArraySlice<U>
    func flatMap<U>(_ transform: @noescape (T) -> ArraySlice<U>) -> ArraySlice<U>
    func reverse() -> ArraySlice<T>
    func filter(_ includeElement: (T) -> Bool) -> ArraySlice<T>
}
extension ArraySlice : Reflectable {
    func getMirror() -> MirrorType
}
extension ArraySlice : Printable, DebugPrintable {
    var description: String { get }
    var debugDescription: String { get }
}
extension ArraySlice {
    func withUnsafeBufferPointer<R>(_ body: @noescape (UnsafeBufferPointer<T>) -> R) -> R
    mutating func withUnsafeMutableBufferPointer<R>(_ body: @noescape (inout UnsafeMutableBufferPointer<T>) -> R) -> R
}
extension ArraySlice {
    mutating func replaceRange<C : CollectionType where T == T>(_ subRange: Range<Int>, with newElements: C)
    mutating func splice<S : CollectionType where T == T>(_ newElements: S, atIndex i: Int)
    mutating func removeRange(_ subRange: Range<Int>)
}

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)
}

mutating func append(_ newElement: T)

mutating func append(_ newElement: Element)

init<S : SequenceType where T == T>(_ s: S)

init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)

S : SequenceType, S.Generator.Element == _Buffer.Element

init(arrayLiteral elements: T...)

init(arrayLiteral elements: Element...)

init(count count: Int, repeatedValue repeatedValue: T)

init(count count: Int, repeatedValue repeatedValue: Element)

mutating func insert(_ newElement: T, atIndex i: Int)

mutating func insert(_ newElement: Element, atIndex i: Int)

mutating func removeAtIndex(_ index: Int) -> T

mutating func removeAtIndex(_ index: Int) -> Element

mutating func removeLast() -> T

mutating func removeLast() -> Element

subscript (index: Int) -> T

subscript (_ index: Int) -> Element

subscript (subRange: Range<Int>) -> ArraySlice<T>

subscript (_ subRange: Range<Int>) -> ArraySlice<Element>

struct AutoreleasingUnsafeMutablePointer<T> : Equatable, NilLiteralConvertible, _PointerType {
    var memory: T { get nonmutating set }
    subscript (i: Int) -> T { get }
    init(nilLiteral nilLiteral: ())
    static func null() -> AutoreleasingUnsafeMutablePointer<T>
    init()
    init<U>(_ ptr: UnsafeMutablePointer<U>)
    init<U>(_ ptr: UnsafePointer<U>)
}
extension AutoreleasingUnsafeMutablePointer : DebugPrintable {
    var debugDescription: String { get }
}
extension AutoreleasingUnsafeMutablePointer : CVarArgType {
    func encode() -> [Word]
}

struct AutoreleasingUnsafeMutablePointer<Memory> : Equatable, NilLiteralConvertible, _PointerType {
    typealias T = Memory
    var memory: Memory { get nonmutating set }
    subscript (_ i: Int) -> Memory { get }
    init(nilLiteral nilLiteral: ())
    init()
    init<U>(_ ptr: UnsafeMutablePointer<U>)
}
extension AutoreleasingUnsafeMutablePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension AutoreleasingUnsafeMutablePointer : CVarArgType {
}

var memory: T { get nonmutating set }

var memory: Memory { get nonmutating set }

subscript (i: Int) -> T { get }

subscript (_ i: Int) -> Memory { get }

protocol BidirectionalIndexType : ForwardIndexType, _BidirectionalIndexType {
}

protocol BidirectionalIndexType : ForwardIndexType {
    @warn_unused_result
    func predecessor() -> Self
}

enum Bit : Int, RandomAccessIndexType, Reflectable {
    case Zero
    case One
    func successor() -> Bit
    func predecessor() -> Bit
    func distanceTo(_ other: Bit) -> Int
    func advancedBy(_ distance: Int) -> Bit
    func getMirror() -> MirrorType
}
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
}

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
}

func advancedBy(_ distance: Int) -> Bit

func advancedBy(_ n: Distance) -> Bit

protocol BitwiseOperationsType {
    func &(_ lhs: Self, _ rhs: Self) -> Self
    func |(_ lhs: Self, _ rhs: Self) -> Self
    func ^(_ lhs: Self, _ rhs: Self) -> Self
    prefix func ~(_ x: Self) -> Self
    static var allZeros: Self { get }
}

protocol BitwiseOperationsType {
    @warn_unused_result
    func &(_ lhs: Self, _ rhs: Self) -> Self
    @warn_unused_result
    func |(_ lhs: Self, _ rhs: Self) -> Self
    @warn_unused_result
    func ^(_ lhs: Self, _ rhs: Self) -> Self
    @warn_unused_result
    prefix func ~(_ x: Self) -> Self
    static var allZeros: Self { get }
}

struct Bool {
    var value: Builtin.Int1
    init()
    init(_ v: Builtin.Int1)
}
extension Bool : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Bool : BooleanLiteralConvertible {
    init(_builtinBooleanLiteral value: Builtin.Int1)
    init(booleanLiteral value: Bool)
}
extension Bool : BooleanType {
    var boolValue: Bool { get }
    init<T : BooleanType>(_ value: T)
}
extension Bool : Printable {
    var description: String { get }
}
extension Bool : Equatable, Hashable {
    var hashValue: Int { get }
}
extension Bool : Reflectable {
    func getMirror() -> MirrorType
}

struct Bool {
    init()
}
extension Bool : _ObjectiveCBridgeable {
    init(_ number: NSNumber)
}
extension Bool : BooleanLiteralConvertible {
    init(_builtinBooleanLiteral value: Builtin.Int1)
    init(booleanLiteral value: Bool)
}
extension Bool : BooleanType {
    var boolValue: Bool { get }
    init<T : BooleanType>(_ value: T)
}
extension Bool : CustomStringConvertible {
    var description: String { get }
}
extension Bool : Equatable, Hashable {
    var hashValue: Int { get }
}
extension Bool : _Reflectable {
}

T : BooleanType

protocol BooleanLiteralConvertible {
    typealias BooleanLiteralType
    init(booleanLiteral value: BooleanLiteralType)
}

protocol BooleanLiteralConvertible {
    typealias BooleanLiteralType
    init(booleanLiteral value: Self.BooleanLiteralType)
}

init(booleanLiteral value: BooleanLiteralType)

init(booleanLiteral value: Self.BooleanLiteralType)

struct Character : ExtendedGraphemeClusterLiteralConvertible, Equatable, Hashable, Comparable {
    enum Representation {
        case Large
        case Small
    }
    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 }
    typealias UTF16View = String.UTF16View
    var utf16: UTF16View { get }
}
extension Character : DebugPrintable {
    var debugDescription: String { get }
}
extension Character : Reflectable {
    func getMirror() -> MirrorType
}
extension Character : Streamable {
    func writeTo<Target : OutputStreamType>(inout _ target: Target)
}

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)
}

Target : OutputStreamType

struct ClosedInterval<T : Comparable> : IntervalType, Equatable, Printable, DebugPrintable, Reflectable {
    typealias Bound = T
    init(_ x: ClosedInterval<T>)
    init(_ start: T, _ end: T)
    var start: T { get }
    var end: T { get }
    var description: String { get }
    var debugDescription: String { get }
    func contains(_ x: T) -> Bool
    func clamp(_ intervalToClamp: ClosedInterval<T>) -> ClosedInterval<T>
    func getMirror() -> MirrorType
}
extension ClosedInterval {
    var isEmpty: Bool { get }
}

struct ClosedInterval<Bound : Comparable> : IntervalType, Equatable, CustomStringConvertible, CustomDebugStringConvertible, _Reflectable {
    typealias T = Bound
    init(_ x: ClosedInterval<Bound>)
    init(_ start: Bound, _ end: Bound)
    var start: Bound { get }
    var end: Bound { get }
    var description: String { get }
    var debugDescription: String { get }
    @warn_unused_result
    func contains(_ x: Bound) -> Bool
    @warn_unused_result
    func clamp(_ intervalToClamp: ClosedInterval<Bound>) -> ClosedInterval<Bound>
}
extension ClosedInterval {
    var isEmpty: Bool { get }
}

Bound : Comparable

func clamp(_ intervalToClamp: ClosedInterval<T>) -> ClosedInterval<T>

@warn_unused_result
    func clamp(_ intervalToClamp: ClosedInterval<Bound>) -> ClosedInterval<Bound>

func contains(_ x: T) -> Bool

@warn_unused_result
    func contains(_ x: Bound) -> Bool

var end: T { get }

var end: Bound { get }

init(_ x: ClosedInterval<T>)

init(_ x: ClosedInterval<Bound>)

init(_ start: T, _ end: T)

init(_ start: Bound, _ end: Bound)

var start: T { get }

var start: Bound { get }

struct CollectionOfOne<T> : CollectionType {
    typealias Index = Bit
    init(_ element: T)
    var startIndex: Index { get }
    var endIndex: Index { get }
    func generate() -> GeneratorOfOne<T>
    subscript (position: Index) -> T { get }
    let element: T
}
extension CollectionOfOne : Reflectable {
    func getMirror() -> MirrorType
}

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 {
}

func generate() -> GeneratorOfOne<T>

func generate() -> GeneratorOfOne<Element>

init(_ element: T)

init(_ element: Element)

subscript (position: Index) -> T { get }

subscript (_ position: Index) -> Element { get }

protocol CollectionType : _CollectionType, SequenceType {
    subscript (position: Self.Index) -> Self.Generator.Element { get }
}

protocol CollectionType : Indexable, SequenceType {
    typealias Generator : GeneratorType = IndexingGenerator<Self>
    func generate() -> Self.Generator
    typealias SubSequence : Indexable, SequenceType = Slice<Self>
    subscript (_ position: Self.Index) -> Self.Generator.Element { get }
    subscript (_ bounds: Range<Self.Index>) -> Self.SubSequence { get }
    @warn_unused_result
    func prefixUpTo(_ end: Self.Index) -> Self.SubSequence
    @warn_unused_result
    func suffixFrom(_ start: Self.Index) -> Self.SubSequence
    @warn_unused_result
    func prefixThrough(_ position: Self.Index) -> Self.SubSequence
    var isEmpty: Bool { get }
    var count: Self.Index.Distance { get }
    var first: Self.Generator.Element? { get }
}

protocol Comparable : _Comparable, Equatable {
    func <=(_ lhs: Self, _ rhs: Self) -> Bool
    func >=(_ lhs: Self, _ rhs: Self) -> Bool
    func >(_ lhs: Self, _ rhs: Self) -> Bool
}

protocol Comparable : Equatable {
    @warn_unused_result
    func <(_ lhs: Self, _ rhs: Self) -> Bool
    @warn_unused_result
    func <=(_ lhs: Self, _ rhs: Self) -> Bool
    @warn_unused_result
    func >=(_ lhs: Self, _ rhs: Self) -> Bool
    @warn_unused_result
    func >(_ lhs: Self, _ rhs: Self) -> Bool
}

struct ContiguousArray<T> : MutableCollectionType, Sliceable, _DestructorSafeContainer {
    typealias Element = T
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (index: Int) -> T
    func generate() -> IndexingGenerator<ContiguousArray<T>>
    typealias SubSlice = ArraySlice<T>
    subscript (subRange: Range<Int>) -> ArraySlice<T>
    init(_ buffer: _ContiguousArrayBuffer<T>)
}
extension ContiguousArray : __ArrayType {
}
extension ContiguousArray : ArrayLiteralConvertible {
    init(arrayLiteral elements: T...)
}
extension ContiguousArray : _ArrayType {
    init()
    init<S : SequenceType where T == T>(_ s: S)
    init(count count: Int, repeatedValue repeatedValue: T)
    init(_uninitializedCount count: Int)
    var count: Int { get }
    var capacity: Int { get }
    var isEmpty: Bool { get }
    var first: T? { get }
    var last: T? { get }
    mutating func reserveCapacity(_ minimumCapacity: Int)
    mutating func append(_ newElement: T)
    mutating func extend<S : SequenceType where T == T>(_ newElements: S)
    mutating func removeLast() -> T
    mutating func insert(_ newElement: T, atIndex i: Int)
    mutating func removeAtIndex(_ index: Int) -> T
    mutating func removeAll(keepCapacity keepCapacity: Bool = default)
    func join<S : SequenceType where ContiguousArray<T> == ContiguousArray<T>>(_ elements: S) -> ContiguousArray<T>
    func reduce<U>(_ initial: U, combine combine: @noescape (U, T) -> U) -> U
    mutating func sort(_ isOrderedBefore: (T, T) -> Bool)
    func sorted(_ isOrderedBefore: (T, T) -> Bool) -> ContiguousArray<T>
    func map<U>(_ transform: (T) -> U) -> ContiguousArray<U>
    func flatMap<U>(_ transform: @noescape (T) -> ContiguousArray<U>) -> ContiguousArray<U>
    func reverse() -> ContiguousArray<T>
    func filter(_ includeElement: (T) -> Bool) -> ContiguousArray<T>
}
extension ContiguousArray : Reflectable {
    func getMirror() -> MirrorType
}
extension ContiguousArray : Printable, DebugPrintable {
    var description: String { get }
    var debugDescription: String { get }
}
extension ContiguousArray {
    func withUnsafeBufferPointer<R>(_ body: @noescape (UnsafeBufferPointer<T>) -> R) -> R
    mutating func withUnsafeMutableBufferPointer<R>(_ body: @noescape (inout UnsafeMutableBufferPointer<T>) -> R) -> R
}
extension ContiguousArray {
    mutating func replaceRange<C : CollectionType where T == T>(_ subRange: Range<Int>, with newElements: C)
    mutating func splice<S : CollectionType where T == T>(_ newElements: S, atIndex i: Int)
    mutating func removeRange(_ subRange: Range<Int>)
}

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?
}

mutating func append(_ newElement: T)

mutating func append(_ newElement: Element)

init<S : SequenceType where T == T>(_ s: S)

init<S : SequenceType where S.Generator.Element == _Buffer.Element>(_ s: S)

S : SequenceType, S.Generator.Element == _Buffer.Element

init(arrayLiteral elements: T...)

init(arrayLiteral elements: Element...)

init(count count: Int, repeatedValue repeatedValue: T)

init(count count: Int, repeatedValue repeatedValue: Element)

mutating func insert(_ newElement: T, atIndex i: Int)

mutating func insert(_ newElement: Element, atIndex i: Int)

mutating func removeAtIndex(_ index: Int) -> T

mutating func removeAtIndex(_ index: Int) -> Element

mutating func removeLast() -> T

mutating func removeLast() -> Element

subscript (index: Int) -> T

subscript (_ index: Int) -> Element

subscript (subRange: Range<Int>) -> ArraySlice<T>

subscript (_ subRange: Range<Int>) -> ArraySlice<Element>

struct COpaquePointer : Equatable, Hashable, NilLiteralConvertible {
    init()
    init(_ v: Builtin.RawPointer)
    init(bitPattern bitPattern: Word)
    init(bitPattern bitPattern: UWord)
    init<T>(_ source: UnsafePointer<T>)
    init<T>(_ source: UnsafeMutablePointer<T>)
    static func null() -> COpaquePointer
    var hashValue: Int { get }
    init(nilLiteral nilLiteral: ())
}
extension COpaquePointer : DebugPrintable {
    var debugDescription: String { get }
}
extension COpaquePointer {
    init<T>(_ value: CFunctionPointer<T>)
}
extension COpaquePointer : CVarArgType {
    func encode() -> [Word]
}

struct COpaquePointer : Equatable, Hashable, NilLiteralConvertible {
    init()
    init(bitPattern bitPattern: Int)
    init(bitPattern bitPattern: UInt)
    init<T>(_ source: UnsafePointer<T>)
    init<T>(_ source: UnsafeMutablePointer<T>)
    var hashValue: Int { get }
    init(nilLiteral nilLiteral: ())
}
extension COpaquePointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}
extension COpaquePointer : CVarArgType {
}

init(bitPattern bitPattern: Word)

init(bitPattern bitPattern: Int)

init(bitPattern bitPattern: UWord)

init(bitPattern bitPattern: UInt)

struct CVaListPointer {
    var value: UnsafeMutablePointer<Void>
    init(_fromUnsafeMutablePointer from: UnsafeMutablePointer<Void>)
}
extension CVaListPointer : DebugPrintable {
    var debugDescription: String { get }
}

struct CVaListPointer {
    init(_fromUnsafeMutablePointer from: UnsafeMutablePointer<Void>)
}
extension CVaListPointer : CustomDebugStringConvertible {
    var debugDescription: String { get }
}

protocol CVarArgType {
    func encode() -> [Word]
}

protocol CVarArgType {
}

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 }
    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>)
    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 isEmpty: Bool { get }
    var keys: LazyForwardCollection<MapCollectionView<[Key : Value], Key>> { get }
    var values: LazyForwardCollection<MapCollectionView<[Key : Value], Value>> { get }
}
extension Dictionary : _ObjectiveCBridgeable {
}
extension Dictionary : Printable, DebugPrintable {
    var description: String { get }
    var debugDescription: String { get }
}
extension Dictionary : Reflectable {
    func getMirror() -> MirrorType
}

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)?
}

Key : Hashable

func indexForKey(_ key: Key) -> DictionaryIndex<Key, Value>?

@warn_unused_result
    func indexForKey(_ key: Key) -> DictionaryIndex<Key, Value>?

subscript (position: DictionaryIndex<Key, Value>) -> (Key, Value) { get }

subscript (_ position: DictionaryIndex<Key, Value>) -> (Key, Value) { get }

subscript (key: Key) -> Value?

subscript (_ key: Key) -> Value?

Key : Hashable

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

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

Key : Hashable

protocol DictionaryLiteralConvertible {
    typealias Key
    typealias Value
    init(dictionaryLiteral elements: (Key, Value)...)
}

protocol DictionaryLiteralConvertible {
    typealias Key
    typealias Value
    init(dictionaryLiteral elements: (Self.Key, Self.Value)...)
}

init(dictionaryLiteral elements: (Key, Value)...)

init(dictionaryLiteral elements: (Self.Key, Self.Value)...)

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 : Printable {
    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.FPIEEE80)
}
extension Double : FloatLiteralConvertible {
    init(floatLiteral value: Double)
}
extension Double : Comparable {
}
extension Double : Hashable {
    var hashValue: Int { get }
}
extension Double : AbsoluteValuable {
    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)
    init(_ other: Float80)
}
extension Double : Strideable {
    func distanceTo(_ other: Double) -> Double
    func advancedBy(_ amount: Double) -> Double
}
extension Double : Reflectable {
    func getMirror() -> MirrorType
}
extension Double : _CVarArgPassedAsDouble {
    func encode() -> [Word]
}

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.FPIEEE80)
}
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)
    init(_ other: Float80)
}
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 {
}

static func abs(_ x: Double) -> Double

@warn_unused_result
    static func abs(_ x: Double) -> Double

struct EmptyCollection<T> : CollectionType {
    typealias Index = Int
    init()
    var startIndex: Index { get }
    var endIndex: Index { get }
    func generate() -> EmptyGenerator<T>
    subscript (position: Index) -> T { get }
}
extension EmptyCollection : Reflectable {
    func getMirror() -> MirrorType
}

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 {
}

func generate() -> EmptyGenerator<T>

func generate() -> EmptyGenerator<Element>

subscript (position: Index) -> T { get }

subscript (_ position: Index) -> Element { get }

struct EmptyGenerator<T> : GeneratorType, SequenceType {
    init()
    func generate() -> EmptyGenerator<T>
    mutating func next() -> T?
}

struct EmptyGenerator<Element> : GeneratorType, SequenceType {
    typealias T = Element
    init()
    mutating func next() -> Element?
}

mutating func next() -> T?

mutating func next() -> Element?

struct EnumerateGenerator<Base : GeneratorType> : GeneratorType, SequenceType {
    typealias Element = (index: Int, element: Base.Element)
    var base: Base
    var count: Int
    init(_ base: Base)
    mutating func next() -> Element?
    typealias Generator = EnumerateGenerator<Base>
    func generate() -> EnumerateGenerator<Base>
}

struct EnumerateGenerator<Base : GeneratorType> : GeneratorType, SequenceType {
    typealias Element = (index: Int, element: Base.Element)
    init(_ base: Base)
    mutating func next() -> (index: Int, element: Base.Element)?
}

Base : GeneratorType

mutating func next() -> Element?

mutating func next() -> (index: Int, element: Base.Element)?

struct EnumerateSequence<Base : SequenceType> : SequenceType {
    var base: Base
    init(_ base: Base)
    func generate() -> EnumerateGenerator<Base.Generator>
}

struct EnumerateSequence<Base : SequenceType> : SequenceType {
    init(_ base: Base)
    func generate() -> EnumerateGenerator<Base.Generator>
}

Base : SequenceType

protocol Equatable {
    func ==(_ lhs: Self, _ rhs: Self) -> Bool
}

protocol Equatable {
    @warn_unused_result
    func ==(_ lhs: Self, _ rhs: Self) -> Bool
}

protocol ExtendedGraphemeClusterLiteralConvertible : UnicodeScalarLiteralConvertible {
    typealias ExtendedGraphemeClusterLiteralType
    init(extendedGraphemeClusterLiteral value: ExtendedGraphemeClusterLiteralType)
}

protocol ExtendedGraphemeClusterLiteralConvertible : UnicodeScalarLiteralConvertible {
    typealias ExtendedGraphemeClusterLiteralType
    init(extendedGraphemeClusterLiteral value: Self.ExtendedGraphemeClusterLiteralType)
}

init(extendedGraphemeClusterLiteral value: ExtendedGraphemeClusterLiteralType)

init(extendedGraphemeClusterLiteral value: Self.ExtendedGraphemeClusterLiteralType)

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 : Printable {
    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.FPIEEE80)
}
extension Float : FloatLiteralConvertible {
    init(floatLiteral value: Float)
}
extension Float : Comparable {
}
extension Float : Hashable {
    var hashValue: Int { get }
}
extension Float : AbsoluteValuable {
    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)
    init(_ other: Float80)
}
extension Float : Strideable {
    func distanceTo(_ other: Float) -> Float
    func advancedBy(_ amount: Float) -> Float
}
extension Float : Reflectable {
    func getMirror() -> MirrorType
}
extension Float : _CVarArgPassedAsDouble {
    func encode() -> [Word]
}

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.FPIEEE80)
}
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)
    init(_ other: Float80)
}
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 {
}

static func abs(_ x: Float) -> Float

@warn_unused_result
    static func abs(_ x: Float) -> Float

struct Float80 {
    var value: Builtin.FPIEEE80
    init()
    init(_bits v: Builtin.FPIEEE80)
    init(_ value: Float80)
}
extension Float80 : Printable {
    var description: String { get }
}
extension Float80 : IntegerLiteralConvertible {
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
}
extension Float80 {
    init(_builtinFloatLiteral value: Builtin.FPIEEE80)
}
extension Float80 : FloatLiteralConvertible {
    init(floatLiteral value: Float80)
}
extension Float80 : Comparable {
}
extension Float80 : Hashable {
    var hashValue: Int { get }
}
extension Float80 : AbsoluteValuable {
    static func abs(_ x: Float80) -> Float80
}
extension Float80 {
    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 Float80 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Float80 : Strideable {
    func distanceTo(_ other: Float80) -> Float80
    func advancedBy(_ amount: Float80) -> Float80
}

struct Float80 {
    var value: Builtin.FPIEEE80
    init()
    init(_bits v: Builtin.FPIEEE80)
    init(_ value: Float80)
}
extension Float80 : CustomStringConvertible {
    var description: String { get }
}
extension Float80 : IntegerLiteralConvertible {
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: Int64)
}
extension Float80 {
    init(_builtinFloatLiteral value: Builtin.FPIEEE80)
}
extension Float80 : FloatLiteralConvertible {
    init(floatLiteral value: Float80)
}
extension Float80 : Comparable, Equatable {
}
extension Float80 : Hashable {
    var hashValue: Int { get }
}
extension Float80 : AbsoluteValuable, SignedNumberType {
    @warn_unused_result
    static func abs(_ x: Float80) -> Float80
}
extension Float80 {
    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 Float80 {
    init(_ other: Float)
    init(_ other: Double)
}
extension Float80 : Strideable, _Strideable {
    func distanceTo(_ other: Float80) -> Float80
    func advancedBy(_ amount: Float80) -> Float80
}
extension Float80 {
    init?(_ text: String)
}

static func abs(_ x: Float80) -> Float80

@warn_unused_result
    static func abs(_ x: Float80) -> Float80

protocol FloatingPointType : Strideable {
    typealias _BitsType
    static func _fromBitPattern(_ bits: _BitsType) -> Self
    func _toBitPattern() -> _BitsType
    init(_ value: UInt8)
    init(_ value: Int8)
    init(_ value: UInt16)
    init(_ value: Int16)
    init(_ value: UInt32)
    init(_ value: Int32)
    init(_ value: UInt64)
    init(_ value: Int64)
    init(_ value: UInt)
    init(_ value: Int)
    static var infinity: Self { get }
    static var NaN: Self { get }
    static var quietNaN: Self { get }
    var floatingPointClass: FloatingPointClassification { 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 }
}

protocol FloatingPointType : Strideable {
    init(_ value: UInt8)
    init(_ value: Int8)
    init(_ value: UInt16)
    init(_ value: Int16)
    init(_ value: UInt32)
    init(_ value: Int32)
    init(_ value: UInt64)
    init(_ value: Int64)
    init(_ value: UInt)
    init(_ value: Int)
    static var infinity: Self { get }
    static var NaN: Self { get }
    static var quietNaN: Self { get }
    var floatingPointClass: FloatingPointClassification { 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 }
}

protocol FloatLiteralConvertible {
    typealias FloatLiteralType
    init(floatLiteral value: FloatLiteralType)
}

protocol FloatLiteralConvertible {
    typealias FloatLiteralType
    init(floatLiteral value: Self.FloatLiteralType)
}

init(floatLiteral value: FloatLiteralType)

init(floatLiteral value: Self.FloatLiteralType)

protocol ForwardIndexType : _ForwardIndexType {
}

protocol ForwardIndexType : _Incrementable {
    typealias Distance : _SignedIntegerType = Int
    @warn_unused_result
    func advancedBy(_ n: Self.Distance) -> Self
    @warn_unused_result
    func advancedBy(_ n: Self.Distance, limit limit: Self) -> Self
    @warn_unused_result
    func distanceTo(_ end: Self) -> Self.Distance
}

struct GeneratorOfOne<T> : GeneratorType, SequenceType {
    init(_ element: T?)
    func generate() -> GeneratorOfOne<T>
    mutating func next() -> T?
    var elements: T?
}

struct GeneratorOfOne<Element> : GeneratorType, SequenceType {
    typealias T = Element
    init(_ element: Element?)
    mutating func next() -> Element?
}

init(_ element: T?)

init(_ element: Element?)

mutating func next() -> T?

mutating func next() -> Element?

struct GeneratorSequence<G : GeneratorType> : GeneratorType, SequenceType {
    init(_ base: G)
    mutating func next() -> G.Element?
    func generate() -> GeneratorSequence<G>
}

struct GeneratorSequence<Base : GeneratorType> : GeneratorType, SequenceType {
    typealias G = Base
    init(_ base: Base)
    mutating func next() -> Base.Element?
}

Base : GeneratorType

init(_ base: G)

init(_ base: Base)

mutating func next() -> G.Element?

mutating func next() -> Base.Element?

protocol GeneratorType {
    typealias Element
    mutating func next() -> Element?
}

protocol GeneratorType {
    typealias Element
    @warn_unused_result
    mutating func next() -> Self.Element?
}

mutating func next() -> Element?

@warn_unused_result
    mutating func next() -> Self.Element?

struct HalfOpenInterval<T : Comparable> : IntervalType, Equatable, Printable, DebugPrintable, Reflectable {
    typealias Bound = T
    init(_ x: HalfOpenInterval<T>)
    init(_ start: T, _ end: T)
    var start: T { get }
    var end: T { get }
    var description: String { get }
    var debugDescription: String { get }
    func contains(_ x: T) -> Bool
    func clamp(_ intervalToClamp: HalfOpenInterval<T>) -> HalfOpenInterval<T>
    func getMirror() -> MirrorType
}
extension HalfOpenInterval {
    var isEmpty: Bool { get }
}

struct HalfOpenInterval<Bound : Comparable> : IntervalType, Equatable, CustomStringConvertible, CustomDebugStringConvertible, _Reflectable {
    typealias T = Bound
    init(_ x: HalfOpenInterval<Bound>)
    init(_ start: Bound, _ end: Bound)
    var start: Bound { get }
    var end: Bound { get }
    var description: String { get }
    var debugDescription: String { get }
    @warn_unused_result
    func contains(_ x: Bound) -> Bool
    @warn_unused_result
    func clamp(_ intervalToClamp: HalfOpenInterval<Bound>) -> HalfOpenInterval<Bound>
}
extension HalfOpenInterval {
    var isEmpty: Bool { get }
}

Bound : Comparable

func clamp(_ intervalToClamp: HalfOpenInterval<T>) -> HalfOpenInterval<T>

@warn_unused_result
    func clamp(_ intervalToClamp: HalfOpenInterval<Bound>) -> HalfOpenInterval<Bound>

func contains(_ x: T) -> Bool

@warn_unused_result
    func contains(_ x: Bound) -> Bool

var end: T { get }

var end: Bound { get }

init(_ x: HalfOpenInterval<T>)

init(_ x: HalfOpenInterval<Bound>)

init(_ start: T, _ end: T)

init(_ start: Bound, _ end: Bound)

var start: T { get }

var start: Bound { get }

enum ImplicitlyUnwrappedOptional<T> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)
    init()
    init(_ some: T)
    init(_ v: T?)
    init(nilLiteral nilLiteral: ())
    func map<U>(_ f: @noescape (T) -> U) -> U!
    func flatMap<U>(_ f: @noescape (T) -> U!) -> U!
    func getMirror() -> MirrorType
}
extension ImplicitlyUnwrappedOptional : Printable {
    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
    @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 {
}

init(_ v: T?)

init(_ v: Wrapped?)

init(_ some: T)

init(_ some: Wrapped)

case Some(T)

case Some(Wrapped)

func samePositionIn(_ utf8: String.UTF8View) -> String.UTF8View.Index

@warn_unused_result
    func samePositionIn(_ utf8: String.UTF8View) -> String.UTF8View.Index

func samePositionIn(_ utf16: String.UTF16View) -> String.UTF16View.Index

@warn_unused_result
    func samePositionIn(_ utf16: String.UTF16View) -> String.UTF16View.Index

func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> String.UnicodeScalarView.Index

@warn_unused_result
    func samePositionIn(_ unicodeScalars: String.UnicodeScalarView) -> String.UnicodeScalarView.Index

struct IndexingGenerator<C : _CollectionType> : GeneratorType, SequenceType {
    init(_ seq: C)
    func generate() -> IndexingGenerator<C>
    mutating func next() -> C._Element?
}

struct IndexingGenerator<Elements : Indexable> : GeneratorType, SequenceType {
    init(_ elements: Elements)
    mutating func next() -> Elements._Element?
}

Elements : Indexable

struct Int : SignedIntegerType {
    var value: Builtin.Int64
    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 : Hashable {
    var hashValue: Int { get }
}
extension Int : Printable {
    var description: String { get }
}
extension Int : RandomAccessIndexType {
    func successor() -> Int
    func predecessor() -> Int
    func distanceTo(_ other: Int) -> Distance
    func advancedBy(_ amount: Distance) -> Int
}
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)
    init(_ other: Float80)
}
extension Int : Reflectable {
    func getMirror() -> MirrorType
}
extension Int : CVarArgType {
    func encode() -> [Word]
}

struct Int : Equatable, _SignedIntegerType, Comparable, _IntegerType, IntegerArithmeticType, _IntegerArithmeticType, IntegerType, SignedIntegerType {
    var value: Builtin.Int64
    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)
    init(_ other: Float80)
}
extension Int {
    init?(_ text: String, radix radix: Int = default)
}
extension Int : _Reflectable {
}
extension Int : MirrorPathType {
}
extension Int : CVarArgType {
}

struct Int16 : 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 : Printable {
    var description: String { get }
}
extension Int16 : RandomAccessIndexType {
    func successor() -> Int16
    func predecessor() -> Int16
    func distanceTo(_ other: Int16) -> Distance
    func advancedBy(_ amount: 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)
    init(_ other: Float80)
}
extension Int16 : Reflectable {
    func getMirror() -> MirrorType
}
extension Int16 : CVarArgType {
    func encode() -> [Word]
}

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)
    init(_ other: Float80)
}
extension Int16 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int16 : _Reflectable {
}
extension Int16 : CVarArgType {
}

struct Int32 : 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 : Printable {
    var description: String { get }
}
extension Int32 : RandomAccessIndexType {
    func successor() -> Int32
    func predecessor() -> Int32
    func distanceTo(_ other: Int32) -> Distance
    func advancedBy(_ amount: 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)
    init(_ other: Float80)
}
extension Int32 : Reflectable {
    func getMirror() -> MirrorType
}
extension Int32 : CVarArgType {
    func encode() -> [Word]
}

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)
    init(_ other: Float80)
}
extension Int32 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int32 : _Reflectable {
}
extension Int32 : CVarArgType {
}

struct Int64 : 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 : Printable {
    var description: String { get }
}
extension Int64 : RandomAccessIndexType {
    func successor() -> Int64
    func predecessor() -> Int64
    func distanceTo(_ other: Int64) -> Distance
    func advancedBy(_ amount: 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)
    init(_ other: Float80)
}
extension Int64 : Reflectable {
    func getMirror() -> MirrorType
}
extension Int64 : CVarArgType {
    func encode() -> [Word]
}

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)
    init(_ other: Float80)
}
extension Int64 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int64 : _Reflectable {
}
extension Int64 : CVarArgType, _CVarArgAlignedType {
}

struct Int8 : 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 : Printable {
    var description: String { get }
}
extension Int8 : RandomAccessIndexType {
    func successor() -> Int8
    func predecessor() -> Int8
    func distanceTo(_ other: Int8) -> Distance
    func advancedBy(_ amount: 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)
    init(_ other: Float80)
}
extension Int8 : Reflectable {
    func getMirror() -> MirrorType
}
extension Int8 : CVarArgType {
    func encode() -> [Word]
}

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)
    init(_ other: Float80)
}
extension Int8 {
    init?(_ text: String, radix radix: Int = default)
}
extension Int8 : _Reflectable {
}
extension Int8 : CVarArgType {
}

protocol IntegerArithmeticType : _IntegerArithmeticType, Comparable {
    func +(_ lhs: Self, _ rhs: Self) -> Self
    func -(_ lhs: Self, _ rhs: Self) -> Self
    func *(_ lhs: Self, _ rhs: Self) -> Self
    func /(_ lhs: Self, _ rhs: Self) -> Self
    func %(_ lhs: Self, _ rhs: Self) -> Self
    func toIntMax() -> IntMax
}

protocol IntegerArithmeticType : _IntegerArithmeticType, Comparable {
    @warn_unused_result
    func +(_ lhs: Self, _ rhs: Self) -> Self
    @warn_unused_result
    func -(_ lhs: Self, _ rhs: Self) -> Self
    @warn_unused_result
    func *(_ lhs: Self, _ rhs: Self) -> Self
    @warn_unused_result
    func /(_ lhs: Self, _ rhs: Self) -> Self
    @warn_unused_result
    func %(_ lhs: Self, _ rhs: Self) -> Self
    @warn_unused_result
    func toIntMax() -> IntMax
}

func toIntMax() -> IntMax

@warn_unused_result
    func toIntMax() -> IntMax

protocol IntegerLiteralConvertible {
    typealias IntegerLiteralType
    init(integerLiteral value: IntegerLiteralType)
}

protocol IntegerLiteralConvertible {
    typealias IntegerLiteralType
    init(integerLiteral value: Self.IntegerLiteralType)
}

init(integerLiteral value: IntegerLiteralType)

init(integerLiteral value: Self.IntegerLiteralType)

protocol IntervalType {
    typealias Bound : Comparable
    func contains(_ value: Bound) -> Bool
    func clamp(_ intervalToClamp: Self) -> Self
    var isEmpty: Bool { get }
    var start: Bound { get }
    var end: Bound { get }
}

protocol IntervalType {
    typealias Bound : Comparable
    @warn_unused_result
    func contains(_ value: Self.Bound) -> Bool
    @warn_unused_result
    func clamp(_ intervalToClamp: Self) -> Self
    var isEmpty: Bool { get }
    var start: Self.Bound { get }
    var end: Self.Bound { get }
}

func clamp(_ intervalToClamp: Self) -> Self

@warn_unused_result
    func clamp(_ intervalToClamp: Self) -> Self

func contains(_ value: Bound) -> Bool

@warn_unused_result
    func contains(_ value: Self.Bound) -> Bool

var end: Bound { get }

var end: Self.Bound { get }

var start: Bound { get }

var start: Self.Bound { get }

struct LazySequence<S : SequenceType> : SequenceType {
    init(_ base: S)
    func generate() -> S.Generator
    var array: [S.Generator.Element] { get }
}
extension LazySequence {
    func filter(_ includeElement: (S.Generator.Element) -> Bool) -> LazySequence<FilterSequenceView<S>>
}
extension LazySequence {
    func map<U>(_ transform: (S.Generator.Element) -> U) -> LazySequence<MapSequenceView<S, U>>
}

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

Base : SequenceType

init(_ base: S)

init(_ base: Base)

class ManagedBuffer<Value, Element> : ManagedProtoBuffer<Value, Element> {
    final class func create(_ minimumCapacity: Int, initialValue initialValue: (ManagedProtoBuffer<Value, Element>) -> Value) -> ManagedBuffer<Value, Element>
    deinit 
    final var value: Value
}

class ManagedBuffer<Value, Element> : ManagedProtoBuffer<Value, Element> {
    final class func create(_ minimumCapacity: Int, initialValue initialValue: (ManagedProtoBuffer<Value, Element>) -> Value) -> ManagedBuffer<Value, Element>
    final var value: Value
}

struct ManagedBufferPointer<Value, Element> : Equatable {
    init(bufferClass bufferClass: AnyClass, minimumCapacity minimumCapacity: Int, initialValue initialValue: (buffer: AnyObject, allocatedCount: (AnyObject) -> Int) -> Value)
    init(unsafeBufferObject buffer: AnyObject)
    init(_uncheckedUnsafeBufferObject buffer: AnyObject)
    var value: Value
    var buffer: AnyObject { get }
    var allocatedElementCount: Int { get }
    func withUnsafeMutablePointerToValue<R>(_ body: (UnsafeMutablePointer<Value>) -> R) -> R
    func withUnsafeMutablePointerToElements<R>(_ body: (UnsafeMutablePointer<Element>) -> R) -> R
    func withUnsafeMutablePointers<R>(_ body: (UnsafeMutablePointer<Value>, UnsafeMutablePointer<Element>) -> R) -> R
    mutating func holdsUniqueReference() -> Bool
    mutating func holdsUniqueOrPinnedReference() -> Bool
    init(bufferClass bufferClass: AnyClass, minimumCapacity minimumCapacity: Int)
    init(_ buffer: ManagedProtoBuffer<Value, Element>)
}

struct ManagedBufferPointer<Value, Element> : Equatable {
    init(bufferClass bufferClass: AnyClass, minimumCapacity minimumCapacity: Int, initialValue initialValue: (buffer: AnyObject, allocatedCount: (AnyObject) -> Int) -> Value)
    init(unsafeBufferObject buffer: AnyObject)
    var value: Value
    var buffer: AnyObject { get }
    var allocatedElementCount: Int { get }
    func withUnsafeMutablePointerToValue<R>(_ body: (UnsafeMutablePointer<Value>) -> R) -> R
    func withUnsafeMutablePointerToElements<R>(_ body: (UnsafeMutablePointer<Element>) -> R) -> R
    func withUnsafeMutablePointers<R>(_ body: (UnsafeMutablePointer<Value>, UnsafeMutablePointer<Element>) -> R) -> R
    mutating func holdsUniqueReference() -> Bool
    mutating func holdsUniqueOrPinnedReference() -> Bool
}

protocol MutableCollectionType : CollectionType {
    subscript (position: Self.Index) -> Self.Generator.Element { get set }
}

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 MutableSliceable : Sliceable, MutableCollectionType {
    subscript (_: Range<Self.Index>) -> Self.SubSlice { get set }
}

protocol MutableSliceable : CollectionType, MutableCollectionType {
    subscript (_ _: Range<Self.Index>) -> Self.SubSequence { get set }
}

class NonObjectiveCBase {
}

class NonObjectiveCBase {
    init()
}

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

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

enum Optional<T> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)
    init()
    init(_ some: T)
    func map<U>(_ f: @noescape (T) -> U) -> U?
    func flatMap<U>(_ f: @noescape (T) -> U?) -> U?
    func getMirror() -> MirrorType
    init(nilLiteral nilLiteral: ())
}
extension Optional : DebugPrintable {
    var debugDescription: String { get }
}

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 }
}

init(_ some: T)

init(_ some: Wrapped)

case Some(T)

case Some(Wrapped)

struct PermutationGenerator<C : CollectionType, Indices : SequenceType where C.Index == C.Index> : GeneratorType, SequenceType {
    var seq: C
    var indices: Indices.Generator
    typealias Element = C.Generator.Element
    mutating func next() -> Element?
    typealias Generator = PermutationGenerator<C, Indices>
    func generate() -> PermutationGenerator<C, Indices>
    init(elements elements: C, indices indices: Indices)
}

struct PermutationGenerator<C : CollectionType, Indices : SequenceType where C.Index == Indices.Generator.Element> : GeneratorType, SequenceType {
    typealias Element = C.Generator.Element
    mutating func next() -> C.Generator.Element?
    init(elements elements: C, indices indices: Indices)
}

C : CollectionType, Indices : SequenceType, C.Index == Indices.Generator.Element

protocol RandomAccessIndexType : BidirectionalIndexType, _RandomAccessIndexType {
}

protocol RandomAccessIndexType : BidirectionalIndexType, Strideable, _RandomAccessAmbiguity {
    @warn_unused_result
    func distanceTo(_ other: Self) -> Self.Distance
    @warn_unused_result
    func advancedBy(_ n: Self.Distance) -> Self
    @warn_unused_result
    func advancedBy(_ n: Self.Distance, limit limit: Self) -> Self
}

struct Range<T : ForwardIndexType> : Equatable, CollectionType, Printable, DebugPrintable {
    init(_ x: Range<T>)
    init(start start: T, end end: T)
    var isEmpty: Bool { get }
    typealias Index = T
    typealias ArraySlice = Range<T>
    subscript (position: T) -> T { get }
    subscript (_: T._DisabledRangeIndex) -> T { get }
    typealias Generator = RangeGenerator<T>
    func generate() -> RangeGenerator<T>
    var startIndex: T
    var endIndex: T
    var description: String { get }
    var debugDescription: String { get }
}
extension Range {
    func map<U>(_ transform: (T) -> U) -> [U]
}
extension Range : Reflectable {
    func getMirror() -> MirrorType
}

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 {
}

Element : ForwardIndexType

var endIndex: T

var endIndex: Element

func generate() -> RangeGenerator<T>

func generate() -> RangeGenerator<Element>

init(_ x: Range<T>)

init(_ x: Range<Element>)

init(start start: T, end end: T)

init(start start: Element, end end: Element)

var startIndex: T

var startIndex: Element

subscript (position: T) -> T { get }

subscript (_ position: Element) -> Element { get }

subscript (_: T._DisabledRangeIndex) -> T { get }

subscript (_ _: Element._DisabledRangeIndex) -> Element { get }

struct RangeGenerator<T : ForwardIndexType> : GeneratorType, SequenceType {
    typealias Element = T
    init(_ bounds: Range<T>)
    mutating func next() -> T?
    typealias Generator = RangeGenerator<T>
    func generate() -> RangeGenerator<T>
    var startIndex: T
    var endIndex: T
}

struct RangeGenerator<Element : ForwardIndexType> : GeneratorType, SequenceType {
    typealias T = Element
    init(_ bounds: Range<Element>)
    mutating func next() -> Element?
    var startIndex: Element
    var endIndex: Element
}

Element : ForwardIndexType

var endIndex: T

var endIndex: Element

init(_ bounds: Range<T>)

init(_ bounds: Range<Element>)

mutating func next() -> T?

mutating func next() -> Element?

var startIndex: T

var startIndex: Element

protocol RangeReplaceableCollectionType : ExtensibleCollectionType {
    mutating func replaceRange<C : CollectionType where Self.Generator.Element == Self.Generator.Element>(_ subRange: Range<Self.Index>, with newElements: C)
    mutating func insert(_ newElement: Self.Generator.Element, atIndex i: Self.Index)
    mutating func splice<S : CollectionType where Self.Generator.Element == Self.Generator.Element>(_ newElements: S, atIndex i: Self.Index)
    mutating func removeAtIndex(_ i: Self.Index) -> Self.Generator.Element
    mutating func removeRange(_ subRange: Range<Self.Index>)
    mutating func removeAll(keepCapacity keepCapacity: Bool)
}

protocol RangeReplaceableCollectionType : CollectionType {
    init()
    mutating func replaceRange<C : CollectionType where C.Generator.Element == Generator.Element>(_ subRange: Range<Self.Index>, with newElements: C)
    mutating func reserveCapacity(_ n: Self.Index.Distance)
    mutating func append(_ x: Self.Generator.Element)
    mutating func appendContentsOf<S : SequenceType where S.Generator.Element == Generator.Element>(_ newElements: S)
    mutating func insert(_ newElement: Self.Generator.Element, atIndex i: Self.Index)
    mutating func insertContentsOf<S : CollectionType where S.Generator.Element == Generator.Element>(_ newElements: S, at i: Self.Index)
    mutating func removeAtIndex(_ i: Self.Index) -> Self.Generator.Element
    mutating func removeFirst() -> Self.Generator.Element
    mutating func removeFirst(_ n: Int)
    mutating func removeRange(_ subRange: Range<Self.Index>)
    mutating func removeAll(keepCapacity keepCapacity: Bool)
}

protocol RawRepresentable {
    typealias RawValue
    init?(rawValue rawValue: RawValue)
    var rawValue: RawValue { get }
}

protocol RawRepresentable {
    typealias RawValue
    init?(rawValue rawValue: Self.RawValue)
    var rawValue: Self.RawValue { get }
}

init?(rawValue rawValue: RawValue)

init?(rawValue rawValue: Self.RawValue)

var rawValue: RawValue { get }

var rawValue: Self.RawValue { get }

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

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
}

init(count count: Int, repeatedValue repeatedValue: T)

init(count count: Int, repeatedValue repeatedValue: Element)

let repeatedValue: T

let repeatedValue: Element

subscript (position: Int) -> T { get }

subscript (_ position: Int) -> Element { get }

struct ReverseRandomAccessIndex<I : RandomAccessIndexType> : RandomAccessIndexType {
    func successor() -> ReverseRandomAccessIndex<I>
    func predecessor() -> ReverseRandomAccessIndex<I>
    typealias Distance = I.Distance
    func distanceTo(_ other: ReverseRandomAccessIndex<I>) -> I.Distance
    func advancedBy(_ amount: I.Distance) -> ReverseRandomAccessIndex<I>
}

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
}

Base : RandomAccessIndexType

func advancedBy(_ amount: I.Distance) -> ReverseRandomAccessIndex<I>

func advancedBy(_ n: Base.Distance) -> ReverseRandomAccessIndex<Base>

func distanceTo(_ other: ReverseRandomAccessIndex<I>) -> I.Distance

func distanceTo(_ other: ReverseRandomAccessIndex<Base>) -> Base.Distance

protocol SequenceType : _Sequence_Type {
    typealias Generator : GeneratorType
    func generate() -> Generator
}

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]
}

func generate() -> Generator

@warn_unused_result
    func generate() -> Self.Generator

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

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?
}

Element : Hashable

func contains(_ member: T) -> Bool

@warn_unused_result
    func contains(_ member: Element) -> Bool

var endIndex: SetIndex<T> { get }

var endIndex: SetIndex<Element> { get }

func exclusiveOr<S : SequenceType where T == T>(_ sequence: S) -> Set<T>

@warn_unused_result
    func exclusiveOr<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>

S : SequenceType, S.Generator.Element == Element

mutating func exclusiveOrInPlace<S : SequenceType where T == T>(_ sequence: S)

mutating func exclusiveOrInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)

S : SequenceType, S.Generator.Element == Element

var first: T? { get }

var first: Element? { get }

func generate() -> SetGenerator<T>

func generate() -> SetGenerator<Element>

func indexOf(_ member: T) -> SetIndex<T>?

@warn_unused_result
    func indexOf(_ member: Element) -> SetIndex<Element>?

init<S : SequenceType where T == T>(_ sequence: S)

init<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)

S : SequenceType, S.Generator.Element == Element

init(arrayLiteral elements: T...)

init(arrayLiteral elements: Element...)

mutating func insert(_ member: T)

mutating func insert(_ member: Element)

func intersect<S : SequenceType where T == T>(_ sequence: S) -> Set<T>

@warn_unused_result
    func intersect<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>

S : SequenceType, S.Generator.Element == Element

mutating func intersectInPlace<S : SequenceType where T == T>(_ sequence: S)

mutating func intersectInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)

S : SequenceType, S.Generator.Element == Element

func isDisjointWith<S : SequenceType where T == T>(_ sequence: S) -> Bool

@warn_unused_result
    func isDisjointWith<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool

S : SequenceType, S.Generator.Element == Element

func isStrictSubsetOf<S : SequenceType where T == T>(_ sequence: S) -> Bool

@warn_unused_result
    func isStrictSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool

S : SequenceType, S.Generator.Element == Element

func isStrictSupersetOf<S : SequenceType where T == T>(_ sequence: S) -> Bool

@warn_unused_result
    func isStrictSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool

S : SequenceType, S.Generator.Element == Element

func isSubsetOf<S : SequenceType where T == T>(_ sequence: S) -> Bool

@warn_unused_result
    func isSubsetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool

S : SequenceType, S.Generator.Element == Element

func isSupersetOf<S : SequenceType where T == T>(_ sequence: S) -> Bool

@warn_unused_result
    func isSupersetOf<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Bool

S : SequenceType, S.Generator.Element == Element

mutating func remove(_ member: T) -> T?

mutating func remove(_ member: Element) -> Element?

mutating func removeFirst() -> T

mutating func removeFirst() -> Element

var startIndex: SetIndex<T> { get }

var startIndex: SetIndex<Element> { get }

subscript (position: SetIndex<T>) -> T { get }

subscript (_ position: SetIndex<Element>) -> Element { get }

func subtract<S : SequenceType where T == T>(_ sequence: S) -> Set<T>

@warn_unused_result
    func subtract<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>

S : SequenceType, S.Generator.Element == Element

mutating func subtractInPlace<S : SequenceType where T == T>(_ sequence: S)

mutating func subtractInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)

S : SequenceType, S.Generator.Element == Element

func union<S : SequenceType where T == T>(_ sequence: S) -> Set<T>

@warn_unused_result
    func union<S : SequenceType where S.Generator.Element == Element>(_ sequence: S) -> Set<Element>

S : SequenceType, S.Generator.Element == Element

mutating func unionInPlace<S : SequenceType where T == T>(_ sequence: S)

mutating func unionInPlace<S : SequenceType where S.Generator.Element == Element>(_ sequence: S)

S : SequenceType, S.Generator.Element == Element

struct SetGenerator<T : Hashable> : GeneratorType {
    mutating func next() -> T?
}

struct SetGenerator<Element : Hashable> : GeneratorType {
    typealias T = Element
    mutating func next() -> Element?
}

Element : Hashable

mutating func next() -> T?

mutating func next() -> Element?

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

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

Element : Hashable

func successor() -> SetIndex<T>

func successor() -> SetIndex<Element>

protocol SignedIntegerType : _SignedIntegerType, IntegerType {
}

protocol SignedIntegerType : _SignedIntegerType, IntegerType {
    func toIntMax() -> IntMax
    init(_ _: IntMax)
}

protocol SignedNumberType : _SignedNumberType {
    prefix func -(_ x: Self) -> Self
}

protocol SignedNumberType : Comparable, IntegerLiteralConvertible {
    @warn_unused_result
    prefix func -(_ x: Self) -> Self
    @warn_unused_result
    func -(_ lhs: Self, _ rhs: Self) -> Self
}

struct StaticString : UnicodeScalarLiteralConvertible, ExtendedGraphemeClusterLiteralConvertible, StringLiteralConvertible, Printable, DebugPrintable {
    var utf8Start: UnsafePointer<UInt8> { get }
    var unicodeScalar: UnicodeScalar { get }
    var byteSize: Word { get }
    var hasPointerRepresentation: Bool { get }
    var isASCII: Bool { get }
    func withUTF8Buffer<R>(_ body: @noescape (UnsafeBufferPointer<UInt8>) -> R) -> R
    var stringValue: String { get }
    init()
    init(start start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    init(unicodeScalar unicodeScalar: Builtin.Int32)
    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 : _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 }
}

var byteSize: Word { get }

var byteSize: Int { get }

func withUTF8Buffer<R>(_ body: @noescape (UnsafeBufferPointer<UInt8>) -> R) -> R

func withUTF8Buffer<R>(@noescape _ body: (UnsafeBufferPointer<UInt8>) -> R) -> R

Target : OutputStreamType

protocol Strideable : Comparable, _Strideable {
}

protocol Strideable : Comparable, _Strideable {
    typealias Stride : SignedNumberType
    @warn_unused_result
    func distanceTo(_ other: Self) -> Self.Stride
    @warn_unused_result
    func advancedBy(_ n: Self.Stride) -> Self
}

struct StrideThrough<T : Strideable> : SequenceType {
    func generate() -> StrideThroughGenerator<T>
    init(start start: T, end end: T, stride stride: T.Stride)
    let start: T
    let end: T
    let stride: T.Stride
}
extension StrideThrough : Reflectable {
    func getMirror() -> MirrorType
}

struct StrideThrough<Element : Strideable> : SequenceType {
    typealias T = Element
    func generate() -> StrideThroughGenerator<Element>
}
extension StrideThrough : _Reflectable {
}

Element : Strideable

func generate() -> StrideThroughGenerator<T>

func generate() -> StrideThroughGenerator<Element>

struct StrideThroughGenerator<T : Strideable> : GeneratorType {
    var current: T
    let end: T
    let stride: T.Stride
    var done: Bool
    mutating func next() -> T?
}

struct StrideThroughGenerator<Element : Strideable> : GeneratorType {
    typealias T = Element
    mutating func next() -> Element?
}

Element : Strideable

mutating func next() -> T?

mutating func next() -> Element?

struct StrideTo<T : Strideable> : SequenceType {
    func generate() -> StrideToGenerator<T>
    init(start start: T, end end: T, stride stride: T.Stride)
    let start: T
    let end: T
    let stride: T.Stride
}
extension StrideTo : Reflectable {
    func getMirror() -> MirrorType
}

struct StrideTo<Element : Strideable> : SequenceType {
    typealias T = Element
    func generate() -> StrideToGenerator<Element>
}
extension StrideTo : _Reflectable {
}

Element : Strideable