class func abs(_ _: Self) -> Self

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

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

mutating func extend<S : SequenceType where T == T>(_ newElements: S)

mutating func replaceRange<C : CollectionType where T == T>(_ subRange: Range<Int>, with newValues: C)

mutating func replaceRange<C : CollectionType where T == T>(_ subRange: Range<Int>, with newElements: C)

mutating func splice<S : CollectionType where T == T>(_ s: S, atIndex i: Int)

mutating func splice<S : CollectionType where T == T>(_ newElements: S, atIndex i: Int)

mutating func insert(_ newElement: Self.Generator.Element, atIndex atIndex: Int)

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

struct AutoreleasingUnsafeMutablePointer<T> : Equatable, NilLiteralConvertible, _PointerType {
    let value: Builtin.RawPointer
    init(_ value: Builtin.RawPointer)
    var memory: T { get nonmutating set }
    subscript (i: Int) -> T { get }
    static func convertFromNilLiteral() -> AutoreleasingUnsafeMutablePointer<T>
    static func null() -> AutoreleasingUnsafeMutablePointer<T>
    init()
    init<U>(_ ptr: UnsafeMutablePointer<U>)
    init<U>(_ ptr: UnsafePointer<U>)
}

struct AutoreleasingUnsafeMutablePointer<T> : Equatable, NilLiteralConvertible, _PointerType {
    let value: Builtin.RawPointer
    init(_ value: Builtin.RawPointer)
    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>)
}

struct BidirectionalReverseView<T : CollectionType where T.Index : BidirectionalIndexType> : CollectionType {
    typealias Index = ReverseBidirectionalIndex<T.Index>
    typealias Generator = IndexingGenerator<BidirectionalReverseView<T>>
    func generate() -> IndexingGenerator<BidirectionalReverseView<T>>
    var startIndex: Index { get }
    var endIndex: Index { get }
    subscript (i: Index) -> T.Generator.Element { get }
}

struct BidirectionalReverseView<T : CollectionType where T.Index : BidirectionalIndexType> : CollectionType {
    typealias Index = ReverseBidirectionalIndex<T.Index>
    typealias Generator = IndexingGenerator<BidirectionalReverseView<T>>
    func generate() -> IndexingGenerator<BidirectionalReverseView<T>>
    var startIndex: Index { get }
    var endIndex: Index { get }
    subscript (position: Index) -> T.Generator.Element { get }
}

func &(_ _: Self, _ _: Self) -> Self

func &(_ lhs: Self, _ rhs: Self) -> Self

func ^(_ _: Self, _ _: Self) -> Self

func ^(_ lhs: Self, _ rhs: Self) -> Self

func |(_ _: Self, _ _: Self) -> Self

func |(_ lhs: Self, _ rhs: Self) -> Self

prefix func ~(_ _: Self) -> Self

prefix func ~(_ x: Self) -> Self

init<T : BooleanType>(_ v: T)

init<T : BooleanType>(_ value: T)

struct CFunctionPointer<T> : Equatable, Hashable, NilLiteralConvertible {
    var value: COpaquePointer
    init()
    init(_ value: COpaquePointer)
    static func null() -> CFunctionPointer<T>
    var hashValue: Int { get }
    static func convertFromNilLiteral() -> CFunctionPointer<T>
}

struct CFunctionPointer<T> : Equatable, Hashable, NilLiteralConvertible {
    var value: COpaquePointer
    init()
    init(_ value: COpaquePointer)
    static func null() -> CFunctionPointer<T>
    var hashValue: Int { get }
    init(nilLiteral nilLiteral: ())
}

struct COpaquePointer : Equatable, Hashable, NilLiteralConvertible {
    var value: Builtin.RawPointer
    init()
    init(_ v: Builtin.RawPointer)
    init(bitPattern bitPattern: Word)
    init(bitPattern bitPattern: UWord)
    init<T>(_ value: UnsafePointer<T>)
    init<T>(_ value: UnsafeMutablePointer<T>)
    static func null() -> COpaquePointer
    var hashValue: Int { get }
    static func convertFromNilLiteral() -> COpaquePointer
}

struct COpaquePointer : Equatable, Hashable, NilLiteralConvertible {
    var value: Builtin.RawPointer
    init()
    init(_ v: Builtin.RawPointer)
    init(bitPattern bitPattern: Word)
    init(bitPattern bitPattern: UWord)
    init<T>(_ value: UnsafePointer<T>)
    init<T>(_ value: UnsafeMutablePointer<T>)
    static func null() -> COpaquePointer
    var hashValue: Int { get }
    init(nilLiteral nilLiteral: ())
}

init<T>(_ from: CFunctionPointer<T>)

init<T>(_ value: CFunctionPointer<T>)

enum Character : ExtendedGraphemeClusterLiteralConvertible, Equatable, Hashable, Comparable {
    case LargeRepresentation(OnHeap<String>)
    case SmallRepresentation
    init(_ scalar: UnicodeScalar)
    static func convertFromExtendedGraphemeClusterLiteral(_ value: Character) -> Character
    init(_ s: String)
    struct SmallUTF16 : CollectionType {
        init(_ u8: UInt64)
        var startIndex: Int { get }
        var endIndex: Int { get }
        subscript (i: Int) -> CodeUnit { get }
        func generate() -> IndexingGenerator<Character.SmallUTF16>
        var count: UInt16
        var data: UInt64
    }
    var hashValue: Int { get }
    typealias UTF16View = String.UTF16View
    var utf16: UTF16View { get }
}

enum Character : ExtendedGraphemeClusterLiteralConvertible, Equatable, Hashable, Comparable {
    case LargeRepresentation(OnHeap<String>)
    case SmallRepresentation
    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 }
}

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

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
}

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

mutating func extend<S : SequenceType where T == T>(_ newElements: S)

mutating func replaceRange<C : CollectionType where T == T>(_ subRange: Range<Int>, with newValues: C)

mutating func replaceRange<C : CollectionType where T == T>(_ subRange: Range<Int>, with newElements: C)

mutating func splice<S : CollectionType where T == T>(_ s: S, atIndex i: Int)

mutating func splice<S : CollectionType where T == T>(_ newElements: S, atIndex i: Int)

struct Dictionary<Key : Hashable, Value> : CollectionType, DictionaryLiteralConvertible {
    typealias Element = (Key, Value)
    typealias Index = DictionaryIndex<Key, Value>
    init(minimumCapacity minimumCapacity: Int = default)
    var startIndex: DictionaryIndex<Key, Value> { get }
    var endIndex: DictionaryIndex<Key, Value> { get }
    func indexForKey(_ key: Key) -> DictionaryIndex<Key, Value>?
    subscript (i: 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>
    static func convertFromDictionaryLiteral(_ elements: (Key, Value)...) -> [Key : Value]
    var isEmpty: Bool { get }
    var keys: LazyBidirectionalCollection<MapCollectionView<[Key : Value], Key>> { get }
    var values: LazyBidirectionalCollection<MapCollectionView<[Key : Value], Value>> { get }
}

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: LazyBidirectionalCollection<MapCollectionView<[Key : Value], Key>> { get }
    var values: LazyBidirectionalCollection<MapCollectionView<[Key : Value], Value>> { get }
}

init(minimumCapacity minimumCapacity: Int = default)

init(minimumCapacity minimumCapacity: Int)

init(_ v: Float)

init(_ other: Float)

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

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

struct FilterCollectionView<Base : CollectionType> : CollectionType {
    typealias Index = FilterCollectionViewIndex<Base>
    init(_ base: Base, includeElement includeElement: (Base.Generator.Element) -> Bool)
    var startIndex: FilterCollectionViewIndex<Base> { get }
    var endIndex: FilterCollectionViewIndex<Base> { get }
    subscript (index: FilterCollectionViewIndex<Base>) -> Base.Generator.Element { get }
    func generate() -> FilterGenerator<Base.Generator>
}

struct FilterCollectionView<Base : CollectionType> : CollectionType {
    typealias Index = FilterCollectionViewIndex<Base>
    init(_ base: Base, includeElement predicate: (Base.Generator.Element) -> Bool)
    var startIndex: FilterCollectionViewIndex<Base> { get }
    var endIndex: FilterCollectionViewIndex<Base> { get }
    subscript (position: FilterCollectionViewIndex<Base>) -> Base.Generator.Element { get }
    func generate() -> FilterGenerator<Base.Generator>
}

init(_ base: Base, includeElement includeElement: (Base.Generator.Element) -> Bool)

init(_ base: Base, includeElement predicate: (Base.Generator.Element) -> Bool)

init(_ v: Double)

init(_ other: Double)

struct GeneratorOf<T> : GeneratorType, SequenceType {
    init(_ next: () -> T?)
    init<G : GeneratorType where T == T>(_ self_: G)
    mutating func next() -> T?
    func generate() -> GeneratorOf<T>
}

struct GeneratorOf<T> : GeneratorType, SequenceType {
    init(_ nextElement: () -> T?)
    init<G : GeneratorType where T == T>(_ base: G)
    mutating func next() -> T?
    func generate() -> GeneratorOf<T>
}

init(_ next: () -> T?)

init(_ nextElement: () -> T?)

init<G : GeneratorType where T == T>(_ self_: G)

init<G : GeneratorType where T == T>(_ base: G)

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

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

init(_ elements: T?)

init(_ element: T?)

struct HeapBuffer<Value, Element> : Equatable {
    typealias Storage = HeapBufferStorage<Value, Element>
    let storage: HeapBufferStorage<Value, Element>?
    var baseAddress: UnsafeMutablePointer<Element> { get }
    init()
    init(_ storage: HeapBufferStorage<Value, Element>)
    init(_ storageClass: HeapBufferStorageBase.Type, _ initializer: Value, _ capacity: Int)
    var value: Value { get nonmutating set }
    var hasStorage: Bool { get }
    subscript (i: Int) -> Element { get nonmutating set }
    static func fromNativeObject(_ x: Builtin.NativeObject) -> HeapBuffer<Value, Element>
    mutating func isUniquelyReferenced() -> Bool
}

struct HeapBuffer<Value, Element> : Equatable {
    typealias Storage = HeapBufferStorage<Value, Element>
    let storage: HeapBufferStorage<Value, Element>?
    var baseAddress: UnsafeMutablePointer<Element> { get }
    init()
    init(_ storage: HeapBufferStorage<Value, Element>)
    init(_ storageClass: AnyClass, _ initializer: Value, _ capacity: Int)
    var value: Value { get nonmutating set }
    var hasStorage: Bool { get }
    subscript (i: Int) -> Element { get nonmutating set }
    static func fromNativeObject(_ x: Builtin.NativeObject) -> HeapBuffer<Value, Element>
    mutating func isUniquelyReferenced() -> Bool
}

enum ImplicitlyUnwrappedOptional<T> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)
    init()
    init(_ some: T)
    init(_ v: T?)
    static func convertFromNilLiteral() -> T!
    func map<U>(_ f: (T) -> U) -> U!
    func getMirror() -> MirrorType
}

enum ImplicitlyUnwrappedOptional<T> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)
    init()
    init(_ some: T)
    init(_ v: T?)
    init(nilLiteral nilLiteral: ())
    func map<U>(_ f: (T) -> U) -> U!
    func getMirror() -> MirrorType
}

struct Int : SignedIntegerType {
    var value: Builtin.Word
    init()
    init(_ v: Builtin.Word)
    init(_ value: Int)
    init(bigEndian value: Int)
    init(littleEndian value: Int)
    static func convertFromIntegerLiteral(_ value: Int) -> Int
    typealias ArrayBound = Int
    var arrayBoundValue: Int { get }
    var bigEndian: Int { get }
    var littleEndian: Int { get }
    var byteSwapped: Int { get }
    static var max: Int { get }
    static var min: Int { get }
}

struct Int : SignedIntegerType {
    var value: Builtin.Word
    typealias Distance = Int
    init()
    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 }
}

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

func advancedBy(_ amount: Int) -> Int

func advancedBy(_ amount: Distance) -> Int

func distanceTo(_ other: Int) -> Int

func distanceTo(_ other: Int) -> Distance

struct Int16 : SignedIntegerType {
    var value: Builtin.Int16
    init()
    init(_ v: Builtin.Int16)
    init(_ value: Int16)
    init(bigEndian value: Int16)
    init(littleEndian value: Int16)
    static func convertFromIntegerLiteral(_ value: Int16) -> Int16
    typealias ArrayBound = Int16
    var arrayBoundValue: Int16 { get }
    var bigEndian: Int16 { get }
    var littleEndian: Int16 { get }
    var byteSwapped: Int16 { get }
    static var max: Int16 { get }
    static var min: Int16 { get }
}

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

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

func advancedBy(_ amount: Int) -> Int16

func advancedBy(_ amount: Distance) -> Int16

func distanceTo(_ other: Int16) -> Int

func distanceTo(_ other: Int16) -> Distance

struct Int32 : SignedIntegerType {
    var value: Builtin.Int32
    init()
    init(_ v: Builtin.Int32)
    init(_ value: Int32)
    init(bigEndian value: Int32)
    init(littleEndian value: Int32)
    static func convertFromIntegerLiteral(_ value: Int32) -> Int32
    typealias ArrayBound = Int32
    var arrayBoundValue: Int32 { get }
    var bigEndian: Int32 { get }
    var littleEndian: Int32 { get }
    var byteSwapped: Int32 { get }
    static var max: Int32 { get }
    static var min: Int32 { get }
}

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

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

func advancedBy(_ amount: Int) -> Int32

func advancedBy(_ amount: Distance) -> Int32

func distanceTo(_ other: Int32) -> Int

func distanceTo(_ other: Int32) -> Distance

struct Int64 : SignedIntegerType {
    var value: Builtin.Int64
    init()
    init(_ v: Builtin.Int64)
    init(_ value: Int64)
    init(bigEndian value: Int64)
    init(littleEndian value: Int64)
    static func convertFromIntegerLiteral(_ value: Int64) -> Int64
    typealias ArrayBound = Int64
    var arrayBoundValue: Int64 { get }
    var bigEndian: Int64 { get }
    var littleEndian: Int64 { get }
    var byteSwapped: Int64 { get }
    static var max: Int64 { get }
    static var min: Int64 { get }
}

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

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

func advancedBy(_ amount: Int) -> Int64

func advancedBy(_ amount: Distance) -> Int64

func distanceTo(_ other: Int64) -> Int

func distanceTo(_ other: Int64) -> Distance

struct Int8 : SignedIntegerType {
    var value: Builtin.Int8
    init()
    init(_ v: Builtin.Int8)
    init(_ value: Int8)
    static func convertFromIntegerLiteral(_ value: Int8) -> Int8
    typealias ArrayBound = Int8
    var arrayBoundValue: Int8 { get }
    static var max: Int8 { get }
    static var min: Int8 { get }
}

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

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

func advancedBy(_ amount: Int) -> Int8

func advancedBy(_ amount: Distance) -> Int8

func distanceTo(_ other: Int8) -> Int

func distanceTo(_ other: Int8) -> Distance

struct LazyBidirectionalCollection<S : CollectionType where S.Index : BidirectionalIndexType> : CollectionType {
    init(_ base: S)
    func generate() -> S.Generator
    var startIndex: S.Index { get }
    var endIndex: S.Index { get }
    var isEmpty: Bool { get }
    var first: S.Generator.Element? { get }
    var last: S.Generator.Element? { get }
    subscript (i: S.Index) -> S.Generator.Element { get }
    var array: [S.Generator.Element] { get }
}

struct LazyBidirectionalCollection<S : CollectionType where S.Index : BidirectionalIndexType> : CollectionType {
    init(_ base: S)
    func generate() -> S.Generator
    var startIndex: S.Index { get }
    var endIndex: S.Index { get }
    var isEmpty: Bool { get }
    var first: S.Generator.Element? { get }
    var last: S.Generator.Element? { get }
    subscript (position: S.Index) -> S.Generator.Element { get }
    var array: [S.Generator.Element] { get }
}

struct LazyForwardCollection<S : CollectionType where S.Index : ForwardIndexType> : CollectionType {
    init(_ base: S)
    func generate() -> S.Generator
    var startIndex: S.Index { get }
    var endIndex: S.Index { get }
    var isEmpty: Bool { get }
    var first: S.Generator.Element? { get }
    subscript (i: S.Index) -> S.Generator.Element { get }
    var array: [S.Generator.Element] { get }
}

struct LazyForwardCollection<S : CollectionType where S.Index : ForwardIndexType> : CollectionType {
    init(_ base: S)
    func generate() -> S.Generator
    var startIndex: S.Index { get }
    var endIndex: S.Index { get }
    var isEmpty: Bool { get }
    var first: S.Generator.Element? { get }
    subscript (position: S.Index) -> S.Generator.Element { get }
    var array: [S.Generator.Element] { get }
}

struct LazyRandomAccessCollection<S : CollectionType where S.Index : RandomAccessIndexType> : CollectionType {
    init(_ base: S)
    func generate() -> S.Generator
    var startIndex: S.Index { get }
    var endIndex: S.Index { get }
    var isEmpty: Bool { get }
    var first: S.Generator.Element? { get }
    var last: S.Generator.Element? { get }
    subscript (i: S.Index) -> S.Generator.Element { get }
    var array: [S.Generator.Element] { get }
}

struct LazyRandomAccessCollection<S : CollectionType where S.Index : RandomAccessIndexType> : CollectionType {
    init(_ base: S)
    func generate() -> S.Generator
    var startIndex: S.Index { get }
    var endIndex: S.Index { get }
    var isEmpty: Bool { get }
    var first: S.Generator.Element? { get }
    var last: S.Generator.Element? { get }
    subscript (position: S.Index) -> S.Generator.Element { get }
    var array: [S.Generator.Element] { get }
}

struct MapCollectionView<Base : CollectionType, T> : CollectionType {
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (index: Base.Index) -> T { get }
    func generate() -> MapSequenceGenerator<Base.Generator, T>
}

struct MapCollectionView<Base : CollectionType, T> : CollectionType {
    var startIndex: Base.Index { get }
    var endIndex: Base.Index { get }
    subscript (position: Base.Index) -> T { get }
    func generate() -> MapSequenceGenerator<Base.Generator, T>
}

enum Optional<T> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)
    init()
    init(_ some: T)
    func map<U>(_ f: (T) -> U) -> U?
    func getMirror() -> MirrorType
    static func convertFromNilLiteral() -> T?
}

enum Optional<T> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)
    init()
    init(_ some: T)
    func map<U>(_ f: (T) -> U) -> U?
    func getMirror() -> MirrorType
    init(nilLiteral nilLiteral: ())
}

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 seq: C, indices indices: Indices)
}

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

init(elements seq: C, indices indices: Indices)

init(elements elements: C, indices indices: Indices)

struct RandomAccessReverseView<T : CollectionType where T.Index : RandomAccessIndexType> : CollectionType {
    typealias Index = ReverseRandomAccessIndex<T.Index>
    typealias Generator = IndexingGenerator<RandomAccessReverseView<T>>
    func generate() -> IndexingGenerator<RandomAccessReverseView<T>>
    var startIndex: Index { get }
    var endIndex: Index { get }
    subscript (i: Index) -> T.Generator.Element { get }
}

struct RandomAccessReverseView<T : CollectionType where T.Index : RandomAccessIndexType> : CollectionType {
    typealias Index = ReverseRandomAccessIndex<T.Index>
    typealias Generator = IndexingGenerator<RandomAccessReverseView<T>>
    func generate() -> IndexingGenerator<RandomAccessReverseView<T>>
    var startIndex: Index { get }
    var endIndex: Index { get }
    subscript (position: Index) -> T.Generator.Element { get }
}

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 Slice = Range<T>
    subscript (i: 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 }
}

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

mutating func replaceRange<C : CollectionType where `Self`.Generator.Element == Self.Generator.Element>(_ subRange: Range<Self.Index>, with newValues: C)

mutating func replaceRange<C : CollectionType where `Self`.Generator.Element == Self.Generator.Element>(_ subRange: Range<Self.Index>, with newElements: C)

mutating func splice<S : CollectionType where `Self`.Generator.Element == Self.Generator.Element>(_ newValues: S, atIndex i: Self.Index)

mutating func splice<S : CollectionType where `Self`.Generator.Element == Self.Generator.Element>(_ newElements: S, atIndex i: Self.Index)

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 (i: Int) -> T { get }
    var count: Int
    let repeatedValue: T
}

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 SequenceOf<T> : SequenceType {
    init<G : GeneratorType where T == T>(_ generate: () -> G)
    init<S : SequenceType where T == T>(_ self_: S)
    func generate() -> GeneratorOf<T>
}

struct SequenceOf<T> : SequenceType {
    init<G : GeneratorType where T == T>(_ makeUnderlyingGenerator: () -> G)
    init<S : SequenceType where T == T>(_ base: S)
    func generate() -> GeneratorOf<T>
}

init<G : GeneratorType where T == T>(_ generate: () -> G)

init<G : GeneratorType where T == T>(_ makeUnderlyingGenerator: () -> G)

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

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

struct SinkOf<T> : SinkType {
    init(_ put: (T) -> ())
    init<S : SinkType where T == T>(_ base: S)
    func put(_ x: T)
}

struct SinkOf<T> : SinkType {
    init(_ putElement: (T) -> ())
    init<S : SinkType where T == T>(_ base: S)
    func put(_ x: T)
}

init(_ put: (T) -> ())

init(_ putElement: (T) -> ())

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

mutating func extend<S : SequenceType where T == T>(_ newElements: S)

mutating func replaceRange<C : CollectionType where T == T>(_ subRange: Range<Int>, with newValues: C)

mutating func replaceRange<C : CollectionType where T == T>(_ subRange: Range<Int>, with newElements: C)

mutating func splice<S : CollectionType where T == T>(_ s: S, atIndex i: Int)

mutating func splice<S : CollectionType where T == T>(_ newElements: S, atIndex i: Int)

struct StaticString : StaticStringType {
    var start: UnsafePointer<UInt8> { get }
    var byteSize: UWord { get }
    var isASCII: Bool { get }
    var stringValue: String { get }
    init()
    init(start start: Builtin.RawPointer, byteSize byteSize: Builtin.Word, isASCII isASCII: Builtin.Int1)
    static func convertFromExtendedGraphemeClusterLiteral(_ value: StaticString) -> StaticString
    static func convertFromStringLiteral(_ value: StaticString) -> StaticString
}

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

var byteSize: UWord { get }

var byteSize: Word { get }

mutating func extend<S : SequenceType where Character == Character>(_ seq: S)

mutating func extend<S : SequenceType where Character == Character>(_ newElements: S)

mutating func extend(_ rhs: String)

mutating func extend(_ other: String)

mutating func replaceRange<C : CollectionType where Character == Character>(_ subRange: Range<String.Index>, with newValues: C)

mutating func replaceRange<C : CollectionType where Character == Character>(_ subRange: Range<String.Index>, with newElements: C)

mutating func splice<S : CollectionType where Character == Character>(_ newValues: S, atIndex i: String.Index)

mutating func splice<S : CollectionType where Character == Character>(_ newElements: S, atIndex i: String.Index)

mutating func write(_ string: String)

mutating func write(_ other: String)

struct UTF16View : Sliceable, Reflectable {
        var startIndex: Int { get }
        var endIndex: Int { get }
        typealias Generator
        func generate() -> Generator
        subscript (i: Int) -> UInt16 { get }
        subscript (subRange: Range<Int>) -> String.UTF16View { get }
        func getMirror() -> MirrorType
    }

struct UTF16View : Sliceable, Reflectable {
        var startIndex: Int { get }
        var endIndex: Int { get }
        typealias Generator
        func generate() -> Generator
        subscript (position: Int) -> UInt16 { get }
        subscript (subRange: Range<Int>) -> String.UTF16View { get }
        func getMirror() -> MirrorType
    }

struct UTF8View : CollectionType, Reflectable {
        struct Index : ForwardIndexType {
            func successor() -> String.UTF8View.Index
        }
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        subscript (i: String.UTF8View.Index) -> CodeUnit { get }
        func generate() -> IndexingGenerator<String.UTF8View>
        func getMirror() -> MirrorType
    }

struct UTF8View : CollectionType, Reflectable {
        struct Index : ForwardIndexType {
            func successor() -> String.UTF8View.Index
        }
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        subscript (position: String.UTF8View.Index) -> CodeUnit { get }
        func generate() -> IndexingGenerator<String.UTF8View>
        func getMirror() -> MirrorType
    }

struct UnicodeScalarView : Sliceable, SequenceType, Reflectable {
        struct Index : BidirectionalIndexType, Comparable {
            func successor() -> String.UnicodeScalarView.Index
            func predecessor() -> String.UnicodeScalarView.Index
        }
        var startIndex: String.UnicodeScalarView.Index { get }
        var endIndex: String.UnicodeScalarView.Index { get }
        subscript (i: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
        subscript (r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
        struct Generator : GeneratorType {
            mutating func next() -> UnicodeScalar?
        }
        func generate() -> String.UnicodeScalarView.Generator
        func compare(_ other: String.UnicodeScalarView) -> Int
        func getMirror() -> MirrorType
    }

struct UnicodeScalarView : Sliceable, SequenceType, Reflectable {
        struct Index : BidirectionalIndexType, Comparable {
            func successor() -> String.UnicodeScalarView.Index
            func predecessor() -> String.UnicodeScalarView.Index
        }
        var startIndex: String.UnicodeScalarView.Index { get }
        var endIndex: String.UnicodeScalarView.Index { get }
        subscript (position: String.UnicodeScalarView.Index) -> UnicodeScalar { get }
        subscript (r: Range<String.UnicodeScalarView.Index>) -> String.UnicodeScalarView { get }
        struct Generator : GeneratorType {
            mutating func next() -> UnicodeScalar?
        }
        func generate() -> String.UnicodeScalarView.Generator
        func getMirror() -> MirrorType
    }

struct UInt : UnsignedIntegerType {
    var value: Builtin.Word
    init()
    init(_ v: Builtin.Word)
    init(_ value: UInt)
    init(bigEndian value: UInt)
    init(littleEndian value: UInt)
    static func convertFromIntegerLiteral(_ value: UInt) -> UInt
    typealias ArrayBound = UInt
    var arrayBoundValue: UInt { get }
    var bigEndian: UInt { get }
    var littleEndian: UInt { get }
    var byteSwapped: UInt { get }
    static var max: UInt { get }
    static var min: UInt { get }
}

struct UInt : UnsignedIntegerType {
    var value: Builtin.Word
    typealias Distance = Int
    init()
    init(_ value: UInt)
    init(bigEndian value: UInt)
    init(littleEndian value: UInt)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt)
    var bigEndian: UInt { get }
    var littleEndian: UInt { get }
    var byteSwapped: UInt { get }
    static var max: UInt { get }
    static var min: UInt { get }
}

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

func advancedBy(_ amount: Int) -> UInt

func advancedBy(_ amount: Distance) -> UInt

func distanceTo(_ other: UInt) -> Int

func distanceTo(_ other: UInt) -> Distance

struct UInt16 : UnsignedIntegerType {
    var value: Builtin.Int16
    init()
    init(_ v: Builtin.Int16)
    init(_ value: UInt16)
    init(bigEndian value: UInt16)
    init(littleEndian value: UInt16)
    static func convertFromIntegerLiteral(_ value: UInt16) -> UInt16
    typealias ArrayBound = UInt16
    var arrayBoundValue: UInt16 { get }
    var bigEndian: UInt16 { get }
    var littleEndian: UInt16 { get }
    var byteSwapped: UInt16 { get }
    static var max: UInt16 { get }
    static var min: UInt16 { get }
}

struct UInt16 : UnsignedIntegerType {
    var value: Builtin.Int16
    typealias Distance = Int
    init()
    init(_ value: UInt16)
    init(bigEndian value: UInt16)
    init(littleEndian value: UInt16)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt16)
    var bigEndian: UInt16 { get }
    var littleEndian: UInt16 { get }
    var byteSwapped: UInt16 { get }
    static var max: UInt16 { get }
    static var min: UInt16 { get }
}

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

func advancedBy(_ amount: Int) -> UInt16

func advancedBy(_ amount: Distance) -> UInt16

func distanceTo(_ other: UInt16) -> Int

func distanceTo(_ other: UInt16) -> Distance

struct UInt32 : UnsignedIntegerType {
    var value: Builtin.Int32
    init()
    init(_ v: Builtin.Int32)
    init(_ value: UInt32)
    init(bigEndian value: UInt32)
    init(littleEndian value: UInt32)
    static func convertFromIntegerLiteral(_ value: UInt32) -> UInt32
    typealias ArrayBound = UInt32
    var arrayBoundValue: UInt32 { get }
    var bigEndian: UInt32 { get }
    var littleEndian: UInt32 { get }
    var byteSwapped: UInt32 { get }
    static var max: UInt32 { get }
    static var min: UInt32 { get }
}

struct UInt32 : UnsignedIntegerType {
    var value: Builtin.Int32
    typealias Distance = Int
    init()
    init(_ value: UInt32)
    init(bigEndian value: UInt32)
    init(littleEndian value: UInt32)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt32)
    var bigEndian: UInt32 { get }
    var littleEndian: UInt32 { get }
    var byteSwapped: UInt32 { get }
    static var max: UInt32 { get }
    static var min: UInt32 { get }
}

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

func advancedBy(_ amount: Int) -> UInt32

func advancedBy(_ amount: Distance) -> UInt32

func distanceTo(_ other: UInt32) -> Int

func distanceTo(_ other: UInt32) -> Distance

struct UInt64 : UnsignedIntegerType {
    var value: Builtin.Int64
    init()
    init(_ v: Builtin.Int64)
    init(_ value: UInt64)
    init(bigEndian value: UInt64)
    init(littleEndian value: UInt64)
    static func convertFromIntegerLiteral(_ value: UInt64) -> UInt64
    typealias ArrayBound = UInt64
    var arrayBoundValue: UInt64 { get }
    var bigEndian: UInt64 { get }
    var littleEndian: UInt64 { get }
    var byteSwapped: UInt64 { get }
    static var max: UInt64 { get }
    static var min: UInt64 { get }
}

struct UInt64 : UnsignedIntegerType {
    var value: Builtin.Int64
    typealias Distance = Int
    init()
    init(_ value: UInt64)
    init(bigEndian value: UInt64)
    init(littleEndian value: UInt64)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt64)
    var bigEndian: UInt64 { get }
    var littleEndian: UInt64 { get }
    var byteSwapped: UInt64 { get }
    static var max: UInt64 { get }
    static var min: UInt64 { get }
}

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

func advancedBy(_ amount: Int) -> UInt64

func advancedBy(_ amount: Distance) -> UInt64

func distanceTo(_ other: UInt64) -> Int

func distanceTo(_ other: UInt64) -> Distance

struct UInt8 : UnsignedIntegerType {
    var value: Builtin.Int8
    init()
    init(_ v: Builtin.Int8)
    init(_ value: UInt8)
    static func convertFromIntegerLiteral(_ value: UInt8) -> UInt8
    typealias ArrayBound = UInt8
    var arrayBoundValue: UInt8 { get }
    static var max: UInt8 { get }
    static var min: UInt8 { get }
}

struct UInt8 : UnsignedIntegerType {
    var value: Builtin.Int8
    typealias Distance = Int
    init()
    init(_ value: UInt8)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt8)
    static var max: UInt8 { get }
    static var min: UInt8 { get }
}

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

func advancedBy(_ amount: Int) -> UInt8

func advancedBy(_ amount: Distance) -> UInt8

func distanceTo(_ other: UInt8) -> Int

func distanceTo(_ other: UInt8) -> Distance

static func copy<T : StringElementType, U : StringElementType>(_ source: UnsafeMutablePointer<T>, destination destination: UnsafeMutablePointer<U>, count count: Int)

static func copy<T : _StringElementType, U : _StringElementType>(_ source: UnsafeMutablePointer<T>, destination destination: UnsafeMutablePointer<U>, count count: Int)

struct UnicodeScalar : ExtendedGraphemeClusterLiteralConvertible {
    var value: UInt32 { get }
    static func convertFromExtendedGraphemeClusterLiteral(_ value: String) -> UnicodeScalar
    init()
    init(_ value: Builtin.Int32)
    init(_ v: UInt32)
    init(_ v: UInt16)
    init(_ v: UInt8)
    init(_ v: UnicodeScalar)
    func escape(asASCII asASCII: Bool) -> String
    func isASCII() -> Bool
}

struct UnicodeScalar : UnicodeScalarLiteralConvertible {
    var value: UInt32 { get }
    init(_builtinUnicodeScalarLiteral value: Builtin.Int32)
    init(unicodeScalarLiteral value: UnicodeScalar)
    init()
    init(_ value: Builtin.Int32)
    init(_ v: UInt32)
    init(_ v: UInt16)
    init(_ v: UInt8)
    init(_ v: UnicodeScalar)
    func escape(asASCII asASCII: Bool) -> String
    func isASCII() -> Bool
}

struct UnsafeMutablePointer<T> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType {
    var value: Builtin.RawPointer
    init()
    init(_ value: Builtin.RawPointer)
    init(_ other: COpaquePointer)
    init(bitPattern bitPattern: Word)
    init(bitPattern bitPattern: UWord)
    init<U>(_ from: UnsafeMutablePointer<U>)
    init<U>(_ from: UnsafePointer<U>)
    static func convertFromNilLiteral() -> UnsafeMutablePointer<T>
    static func null() -> UnsafeMutablePointer<T>
    static func alloc(_ num: Int) -> UnsafeMutablePointer<T>
    func dealloc(_ num: Int)
    var memory: T { get nonmutating set }
    func initialize(_ newvalue: T)
    func move() -> T
    func moveInitializeBackwardFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func moveAssignFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func assignFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func assignBackwardFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func moveInitializeFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func initializeFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func initializeFrom<C : CollectionType where T == T>(_ source: C)
    func destroy()
    func destroy(_ count: Int)
    subscript (i: Int) -> T { get nonmutating set }
    var hashValue: Int { get }
    func successor() -> UnsafeMutablePointer<T>
    func predecessor() -> UnsafeMutablePointer<T>
    func distanceTo(_ x: UnsafeMutablePointer<T>) -> Int
    func advancedBy(_ n: Int) -> UnsafeMutablePointer<T>
}

struct UnsafeMutablePointer<T> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType {
    var value: Builtin.RawPointer
    init()
    init(_ value: Builtin.RawPointer)
    init(_ other: COpaquePointer)
    init(bitPattern bitPattern: Word)
    init(bitPattern bitPattern: UWord)
    init<U>(_ from: UnsafeMutablePointer<U>)
    init<U>(_ from: UnsafePointer<U>)
    init(nilLiteral nilLiteral: ())
    static func null() -> UnsafeMutablePointer<T>
    static func alloc(_ num: Int) -> UnsafeMutablePointer<T>
    func dealloc(_ num: Int)
    var memory: T { get nonmutating set }
    func initialize(_ newvalue: T)
    func move() -> T
    func moveInitializeBackwardFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func moveAssignFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func assignFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func assignBackwardFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func moveInitializeFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func initializeFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func initializeFrom<C : CollectionType where T == T>(_ source: C)
    func destroy()
    func destroy(_ count: Int)
    subscript (i: Int) -> T { get nonmutating set }
    var hashValue: Int { get }
    func successor() -> UnsafeMutablePointer<T>
    func predecessor() -> UnsafeMutablePointer<T>
    func distanceTo(_ x: UnsafeMutablePointer<T>) -> Int
    func advancedBy(_ n: Int) -> UnsafeMutablePointer<T>
}

struct UnsafePointer<T> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType {
    var value: Builtin.RawPointer
    init()
    init(_ value: Builtin.RawPointer)
    init(_ other: COpaquePointer)
    init(bitPattern bitPattern: Word)
    init(bitPattern bitPattern: UWord)
    init<U>(_ from: UnsafeMutablePointer<U>)
    init<U>(_ from: UnsafePointer<U>)
    static func convertFromNilLiteral() -> UnsafePointer<T>
    static func null() -> UnsafePointer<T>
    var memory: T { get }
    subscript (i: Int) -> T { get }
    var hashValue: Int { get }
    func successor() -> UnsafePointer<T>
    func predecessor() -> UnsafePointer<T>
    func distanceTo(_ x: UnsafePointer<T>) -> Int
    func advancedBy(_ n: Int) -> UnsafePointer<T>
}

struct UnsafePointer<T> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType {
    var value: Builtin.RawPointer
    init()
    init(_ value: Builtin.RawPointer)
    init(_ other: COpaquePointer)
    init(bitPattern bitPattern: Word)
    init(bitPattern bitPattern: UWord)
    init<U>(_ from: UnsafeMutablePointer<U>)
    init<U>(_ from: UnsafePointer<U>)
    init(nilLiteral nilLiteral: ())
    static func null() -> UnsafePointer<T>
    var memory: T { get }
    subscript (i: Int) -> T { get }
    var hashValue: Int { get }
    func successor() -> UnsafePointer<T>
    func predecessor() -> UnsafePointer<T>
    func distanceTo(_ x: UnsafePointer<T>) -> Int
    func advancedBy(_ n: Int) -> UnsafePointer<T>
}

var Process: _Process

let Process: _Process

func debugPrint<T>(_ object: T)

func debugPrint<T>(_ x: T)

func debugPrint<T, TargetStream : OutputStreamType>(_ object: T, inout _ target: TargetStream)

func debugPrint<T, TargetStream : OutputStreamType>(_ x: T, inout _ target: TargetStream)

func debugPrintln<T>(_ object: T)

func debugPrintln<T>(_ x: T)

func debugPrintln<T, TargetStream : OutputStreamType>(_ object: T, inout _ target: TargetStream)

func debugPrintln<T, TargetStream : OutputStreamType>(_ x: T, inout _ target: TargetStream)

func equal<S1 : SequenceType, S2 : SequenceType where S1.Generator.Element == S1.Generator.Element>(_ a1: S1, _ a2: S2, _ predicate: (S1.Generator.Element, S1.Generator.Element) -> Bool) -> Bool

func equal<S1 : SequenceType, S2 : SequenceType where S1.Generator.Element == S1.Generator.Element>(_ a1: S1, _ a2: S2, _ isEquivalent: (S1.Generator.Element, S1.Generator.Element) -> Bool) -> Bool

func extend<C : RangeReplaceableCollectionType, S : CollectionType where S.Generator.Element == S.Generator.Element>(inout _ x: C, _ newValues: S)

func extend<C : RangeReplaceableCollectionType, S : CollectionType where S.Generator.Element == S.Generator.Element>(inout _ x: C, _ newElements: S)

func maxElement<R : SequenceType where R.Generator.Element : Comparable>(_ range: R) -> R.Generator.Element

func maxElement<R : SequenceType where R.Generator.Element : Comparable>(_ elements: R) -> R.Generator.Element

func minElement<R : SequenceType where R.Generator.Element : Comparable>(_ range: R) -> R.Generator.Element

func minElement<R : SequenceType where R.Generator.Element : Comparable>(_ elements: R) -> R.Generator.Element

func numericCast<T : _UnsignedIntegerType, U : _UnsignedIntegerType>(_ x: T) -> U

func numericCast<T : _UnsignedIntegerType, U : _SignedIntegerType>(_ x: T) -> U

func splice<C : RangeReplaceableCollectionType, S : CollectionType where S.Generator.Element == S.Generator.Element>(inout _ x: C, _ newValues: S, atIndex i: C.Index)

func splice<C : RangeReplaceableCollectionType, S : CollectionType where S.Generator.Element == S.Generator.Element>(inout _ x: C, _ newElements: S, atIndex i: C.Index)

func startsWith<S0 : SequenceType, S1 : SequenceType where S0.Generator.Element == S0.Generator.Element>(_ s: S0, _ prefix: S1, _ predicate: (S0.Generator.Element, S0.Generator.Element) -> Bool) -> Bool

func startsWith<S0 : SequenceType, S1 : SequenceType where S0.Generator.Element == S0.Generator.Element>(_ s: S0, _ prefix: S1, _ isEquivalent: (S0.Generator.Element, S0.Generator.Element) -> Bool) -> Bool