struct Array<T> : MutableCollection, Sliceable {
    typealias Element = T
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (index: Int) -> T
    func generate() -> IndexingGenerator<[T]>
    typealias SliceType = Slice<T>
    subscript (subRange: Range<Int>) -> Slice<T>
}

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

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

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

func append(_ newElement: T)

mutating func append(_ newElement: T)

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

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

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

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

func join<S : Sequence where [T] == [T]>(_ elements: S) -> [T]

func join<S : SequenceType where [T] == [T]>(_ elements: S) -> [T]

func reduce<U>(_ initial: U, combine combine: (U, T) -> U) -> U

func reduce<U>(_ initial: U, combine combine: @noescape (U, T) -> U) -> U

func removeAll(keepCapacity keepCapacity: Bool = default)

mutating func removeAll(keepCapacity keepCapacity: Bool = default)

func removeAtIndex(_ index: Int) -> T

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

func removeLast() -> T

mutating func removeLast() -> T

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

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

func reserveCapacity(_ minimumCapacity: Int)

mutating func reserveCapacity(_ minimumCapacity: Int)

func sort(_ isOrderedBefore: (T, T) -> Bool)

mutating func sort(_ isOrderedBefore: (T, T) -> Bool)

struct BidirectionalReverseView<T : Collection where T.IndexType : BidirectionalIndex> : Collection {
    typealias IndexType = ReverseBidirectionalIndex<T.IndexType>
    typealias GeneratorType = IndexingGenerator<BidirectionalReverseView<T>>
    func generate() -> IndexingGenerator<BidirectionalReverseView<T>>
    var startIndex: IndexType { get }
    var endIndex: IndexType { get }
    subscript (i: IndexType) -> T.GeneratorType.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 }
}

var endIndex: IndexType { get }

var endIndex: Index { get }

var startIndex: IndexType { get }

var startIndex: Index { get }

enum Bit : Int, RandomAccessIndex, Reflectable {
    case zero
    case one
    func successor() -> Bit
    func predecessor() -> Bit
    func distanceTo(_ other: Bit) -> Int
    func advancedBy(_ distance: Int) -> Bit
    func getMirror() -> Mirror
}

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
}

struct Bool {
    init()
}

struct Bool {
    var value: Builtin.Int1
    init()
    init(_ v: Builtin.Int1)
}

struct CFunctionPointer<T> : Equatable, Hashable, LogicValue, NilLiteralConvertible {
    var value: COpaquePointer
    init()
    init(_ value: COpaquePointer)
    static func null() -> CFunctionPointer<T>
    func getLogicValue() -> Bool
    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, LogicValue, NilLiteralConvertible {
    init()
    static func null() -> COpaquePointer
    func getLogicValue() -> Bool
    var hashValue: Int { get }
    static func convertFromNilLiteral() -> COpaquePointer
}

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

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

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

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

init<T>(_ source: UnsafePointer<T>)

struct CVaListPointer {
    var value: UnsafePointer<Void>
    init(fromUnsafePointer from: UnsafePointer<Void>)
}

struct CVaListPointer {
    var value: UnsafeMutablePointer<Void>
    init(_fromUnsafeMutablePointer from: UnsafeMutablePointer<Void>)
}

var value: UnsafePointer<Void>

var value: UnsafeMutablePointer<Void>

struct CollectionOfOne<T> : Collection {
    typealias IndexType = Bit
    init(_ element: T)
    var startIndex: IndexType { get }
    var endIndex: IndexType { get }
    func generate() -> GeneratorOfOne<T>
    subscript (i: IndexType) -> 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
}

var endIndex: IndexType { get }

var endIndex: Index { get }

var startIndex: IndexType { get }

var startIndex: Index { get }

struct ContiguousArray<T> : MutableCollection, Sliceable {
    typealias Element = T
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (index: Int) -> T
    func generate() -> IndexingGenerator<ContiguousArray<T>>
    typealias SliceType = Slice<T>
    subscript (subRange: Range<Int>) -> Slice<T>
}

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

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

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

func append(_ newElement: T)

mutating func append(_ newElement: T)

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

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

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

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

func join<S : Sequence where ContiguousArray<T> == ContiguousArray<T>>(_ elements: S) -> ContiguousArray<T>

func join<S : SequenceType where ContiguousArray<T> == ContiguousArray<T>>(_ elements: S) -> ContiguousArray<T>

func reduce<U>(_ initial: U, combine combine: (U, T) -> U) -> U

func reduce<U>(_ initial: U, combine combine: @noescape (U, T) -> U) -> U

func removeAll(keepCapacity keepCapacity: Bool = default)

mutating func removeAll(keepCapacity keepCapacity: Bool = default)

func removeAtIndex(_ index: Int) -> T

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

func removeLast() -> T

mutating func removeLast() -> T

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

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

func reserveCapacity(_ minimumCapacity: Int)

mutating func reserveCapacity(_ minimumCapacity: Int)

func sort(_ isOrderedBefore: (T, T) -> Bool)

mutating func sort(_ isOrderedBefore: (T, T) -> Bool)

struct Dictionary<KeyType : Hashable, ValueType> : Collection, DictionaryLiteralConvertible {
    typealias Element = (KeyType, ValueType)
    typealias Index = DictionaryIndex<KeyType, ValueType>
    init(minimumCapacity minimumCapacity: Int = default)
    var startIndex: DictionaryIndex<KeyType, ValueType> { get }
    var endIndex: DictionaryIndex<KeyType, ValueType> { get }
    func indexForKey(_ key: KeyType) -> DictionaryIndex<KeyType, ValueType>?
    subscript (i: DictionaryIndex<KeyType, ValueType>) -> (KeyType, ValueType) { get }
    subscript (key: KeyType) -> ValueType?
    func updateValue(_ value: ValueType, forKey key: KeyType) -> ValueType?
    func removeAtIndex(_ index: DictionaryIndex<KeyType, ValueType>)
    func removeValueForKey(_ key: KeyType) -> ValueType?
    func removeAll(keepCapacity keepCapacity: Bool = default)
    var count: Int { get }
    func generate() -> DictionaryGenerator<KeyType, ValueType>
    static func convertFromDictionaryLiteral(_ elements: (KeyType, ValueType)...) -> [KeyType : ValueType]
    var isEmpty: Bool { get }
    var keys: LazyBidirectionalCollection<MapCollectionView<[KeyType : ValueType], KeyType>> { get }
    var values: LazyBidirectionalCollection<MapCollectionView<[KeyType : ValueType], ValueType>> { 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: LazyForwardCollection<MapCollectionView<[Key : Value], Key>> { get }
    var values: LazyForwardCollection<MapCollectionView<[Key : Value], Value>> { get }
}

var endIndex: DictionaryIndex<KeyType, ValueType> { get }

var endIndex: DictionaryIndex<Key, Value> { get }

var keys: LazyBidirectionalCollection<MapCollectionView<[KeyType : ValueType], KeyType>> { get }

var keys: LazyForwardCollection<MapCollectionView<[Key : Value], Key>> { get }

init(minimumCapacity minimumCapacity: Int = default)

init(minimumCapacity minimumCapacity: Int)

func removeAll(keepCapacity keepCapacity: Bool = default)

mutating func removeAll(keepCapacity keepCapacity: Bool = default)

func removeValueForKey(_ key: KeyType) -> ValueType?

mutating func removeValueForKey(_ key: Key) -> Value?

var startIndex: DictionaryIndex<KeyType, ValueType> { get }

var startIndex: DictionaryIndex<Key, Value> { get }

func updateValue(_ value: ValueType, forKey key: KeyType) -> ValueType?

mutating func updateValue(_ value: Value, forKey key: Key) -> Value?

var values: LazyBidirectionalCollection<MapCollectionView<[KeyType : ValueType], ValueType>> { get }

var values: LazyForwardCollection<MapCollectionView<[Key : Value], Value>> { get }

struct DictionaryGenerator<KeyType : Hashable, ValueType> : Generator {
    func next() -> (KeyType, ValueType)?
}

struct DictionaryGenerator<Key : Hashable, Value> : GeneratorType {
    mutating func next() -> (Key, Value)?
}

func next() -> (KeyType, ValueType)?

mutating func next() -> (Key, Value)?

struct DictionaryIndex<KeyType : Hashable, ValueType> : BidirectionalIndex {
    typealias Index = DictionaryIndex<KeyType, ValueType>
    func predecessor() -> DictionaryIndex<KeyType, ValueType>
    func successor() -> DictionaryIndex<KeyType, ValueType>
}

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

func successor() -> DictionaryIndex<KeyType, ValueType>

func successor() -> DictionaryIndex<Key, Value>

struct Double {
    init()
    init(_ value: Double)
}

struct Double {
    var value: Builtin.FPIEEE64
    init()
    init(_bits v: Builtin.FPIEEE64)
    init(_ value: Double)
}

init(_ v: Float)

init(_ other: Float)

init(_ v: Float80)

init(_ other: Float80)

struct EmptyCollection<T> : Collection {
    typealias IndexType = Int
    init()
    var startIndex: IndexType { get }
    var endIndex: IndexType { get }
    func generate() -> EmptyGenerator<T>
    subscript (i: IndexType) -> 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 }
}

var endIndex: IndexType { get }

var endIndex: Index { get }

var startIndex: IndexType { get }

var startIndex: Index { get }

struct EmptyGenerator<T> : Generator, Sequence {
    func generate() -> EmptyGenerator<T>
    func next() -> T?
}

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

func next() -> T?

mutating func next() -> T?

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

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

func next() -> Element?

mutating func next() -> Element?

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

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

struct FilterCollectionViewIndex<Base : Collection> : ForwardIndex {
    func successor() -> FilterCollectionViewIndex<Base>
}

struct FilterCollectionViewIndex<Base : CollectionType> : ForwardIndexType {
    func successor() -> FilterCollectionViewIndex<Base>
}

struct FilterGenerator<Base : Generator> : Generator, Sequence {
    func next() -> Base.Element?
    func generate() -> FilterGenerator<Base>
}

struct FilterGenerator<Base : GeneratorType> : GeneratorType, SequenceType {
    mutating func next() -> Base.Element?
    func generate() -> FilterGenerator<Base>
}

func next() -> Base.Element?

mutating func next() -> Base.Element?

struct FilterSequenceView<Base : Sequence> : Sequence {
    func generate() -> FilterGenerator<Base.GeneratorType>
}

struct FilterSequenceView<Base : SequenceType> : SequenceType {
    func generate() -> FilterGenerator<Base.Generator>
}

struct Float {
    init()
    init(_ value: Float)
}

struct Float {
    var value: Builtin.FPIEEE32
    init()
    init(_bits v: Builtin.FPIEEE32)
    init(_ value: Float)
}

init(_ v: Double)

init(_ other: Double)

init(_ v: Float80)

init(_ other: Float80)

struct Float80 {
    init()
    init(_ value: Float80)
}

struct Float80 {
    var value: Builtin.FPIEEE80
    init()
    init(_bits v: Builtin.FPIEEE80)
    init(_ value: Float80)
}

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

struct GeneratorOf<T> : Generator, Sequence {
    init(_ next: () -> T?)
    init<G : Generator where T == T>(_ self_: G)
    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 : Generator where T == T>(_ self_: G)

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

func next() -> T?

mutating func next() -> T?

struct GeneratorOfOne<T> : Generator, Sequence {
    init(_ elements: T?)
    func generate() -> GeneratorOfOne<T>
    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?)

func next() -> T?

mutating func next() -> T?

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

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

func next() -> G.Element?

mutating func next() -> G.Element?

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

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
}

func map<U>(_ f: (T) -> U) -> U!

func map<U>(_ f: @noescape (T) -> U) -> U!

struct IndexingGenerator<C> : Generator, Sequence {
    init(_ seq: C)
    func generate() -> IndexingGenerator<C>
    func next() -> C._Element?
}

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

func next() -> C._Element?

mutating func next() -> C._Element?

struct Int : SignedInteger {
    init()
    init(_ value: Int)
    init(bigEndian value: Int)
    init(littleEndian value: Int)
    static func convertFromIntegerLiteral(_ value: Int) -> Int
    typealias ArrayBoundType = Int
    func getArrayBoundValue() -> Int
    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.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 }
}

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

init(_ v: Float80)

init(_ other: Float80)

func advancedBy(_ amount: Int) -> Int

func advancedBy(_ amount: Distance) -> Int

func distanceTo(_ other: Int) -> Int

func distanceTo(_ other: Int) -> Distance

struct Int16 : SignedInteger {
    init()
    init(_ value: Int16)
    init(bigEndian value: Int16)
    init(littleEndian value: Int16)
    static func convertFromIntegerLiteral(_ value: Int16) -> Int16
    typealias ArrayBoundType = Int16
    func getArrayBoundValue() -> Int16
    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)

init(_ v: Float80)

init(_ other: Float80)

func advancedBy(_ amount: Int) -> Int16

func advancedBy(_ amount: Distance) -> Int16

func distanceTo(_ other: Int16) -> Int

func distanceTo(_ other: Int16) -> Distance

struct Int32 : SignedInteger {
    init()
    init(_ value: Int32)
    init(bigEndian value: Int32)
    init(littleEndian value: Int32)
    static func convertFromIntegerLiteral(_ value: Int32) -> Int32
    typealias ArrayBoundType = Int32
    func getArrayBoundValue() -> Int32
    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)

init(_ v: Float80)

init(_ other: Float80)

func advancedBy(_ amount: Int) -> Int32

func advancedBy(_ amount: Distance) -> Int32

func distanceTo(_ other: Int32) -> Int

func distanceTo(_ other: Int32) -> Distance

struct Int64 : SignedInteger {
    init()
    init(_ value: Int64)
    init(bigEndian value: Int64)
    init(littleEndian value: Int64)
    static func convertFromIntegerLiteral(_ value: Int64) -> Int64
    typealias ArrayBoundType = Int64
    func getArrayBoundValue() -> Int64
    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)

init(_ v: Float80)

init(_ other: Float80)

func advancedBy(_ amount: Int) -> Int64

func advancedBy(_ amount: Distance) -> Int64

func distanceTo(_ other: Int64) -> Int

func distanceTo(_ other: Int64) -> Distance

struct Int8 : SignedInteger {
    init()
    init(_ value: Int8)
    static func convertFromIntegerLiteral(_ value: Int8) -> Int8
    typealias ArrayBoundType = Int8
    func getArrayBoundValue() -> Int8
    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)

init(_ v: Float80)

init(_ other: Float80)

func advancedBy(_ amount: Int) -> Int8

func advancedBy(_ amount: Distance) -> Int8

func distanceTo(_ other: Int8) -> Int

func distanceTo(_ other: Int8) -> Distance

struct LazyBidirectionalCollection<S : Collection where S.IndexType : BidirectionalIndex> : Collection {
    init(_ base: S)
    func generate() -> S.GeneratorType
    var startIndex: S.IndexType { get }
    var endIndex: S.IndexType { get }
    subscript (i: S.IndexType) -> S.GeneratorType.Element { get }
    var array: [S.GeneratorType.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 }
}

var array: [S.GeneratorType.Element] { get }

var array: [S.Generator.Element] { get }

var endIndex: S.IndexType { get }

var endIndex: S.Index { get }

var startIndex: S.IndexType { get }

var startIndex: S.Index { get }

struct LazyForwardCollection<S : Collection where S.IndexType : ForwardIndex> : Collection {
    init(_ base: S)
    func generate() -> S.GeneratorType
    var startIndex: S.IndexType { get }
    var endIndex: S.IndexType { get }
    subscript (i: S.IndexType) -> S.GeneratorType.Element { get }
    var array: [S.GeneratorType.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 }
}

var array: [S.GeneratorType.Element] { get }

var array: [S.Generator.Element] { get }

var endIndex: S.IndexType { get }

var endIndex: S.Index { get }

var startIndex: S.IndexType { get }

var startIndex: S.Index { get }

struct LazyRandomAccessCollection<S : Collection where S.IndexType : RandomAccessIndex> : Collection {
    init(_ base: S)
    func generate() -> S.GeneratorType
    var startIndex: S.IndexType { get }
    var endIndex: S.IndexType { get }
    subscript (i: S.IndexType) -> S.GeneratorType.Element { get }
    var array: [S.GeneratorType.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 }
}

var array: [S.GeneratorType.Element] { get }

var array: [S.Generator.Element] { get }

var endIndex: S.IndexType { get }

var endIndex: S.Index { get }

var startIndex: S.IndexType { get }

var startIndex: S.Index { get }

struct LazySequence<S : Sequence> : Sequence {
    init(_ base: S)
    func generate() -> S.GeneratorType
    var array: [S.GeneratorType.Element] { get }
}

struct LazySequence<S : SequenceType> : SequenceType {
    init(_ base: S)
    func generate() -> S.Generator
    var array: [S.Generator.Element] { get }
}

var array: [S.GeneratorType.Element] { get }

var array: [S.Generator.Element] { get }

struct MapCollectionView<Base : Collection, T> : Collection {
    var startIndex: Base.IndexType { get }
    var endIndex: Base.IndexType { get }
    subscript (index: Base.IndexType) -> T { get }
    func generate() -> MapSequenceGenerator<Base.GeneratorType, 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>
}

var endIndex: Base.IndexType { get }

var endIndex: Base.Index { get }

var startIndex: Base.IndexType { get }

var startIndex: Base.Index { get }

struct MapSequenceGenerator<Base : Generator, T> : Generator, Sequence {
    func next() -> T?
    func generate() -> MapSequenceGenerator<Base, T>
}

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

func next() -> T?

mutating func next() -> T?

struct MapSequenceView<Base : Sequence, T> : Sequence {
    func generate() -> MapSequenceGenerator<Base.GeneratorType, T>
}

struct MapSequenceView<Base : SequenceType, T> : SequenceType {
    func generate() -> MapSequenceGenerator<Base.Generator, T>
}

struct ObjectIdentifier : Hashable {
    func uintValue() -> UInt
    var hashValue: Int { get }
    init(_ x: AnyObject)
}

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

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

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

func map<U>(_ f: (T) -> U) -> U?

func map<U>(_ f: @noescape (T) -> U) -> U?

struct PermutationGenerator<C : Collection, Indices : Sequence where C.IndexType == C.IndexType> : Generator, Sequence {
    var seq: C
    var indices: Indices.GeneratorType
    typealias Element = C.GeneratorType.Element
    func next() -> Element?
    typealias GeneratorType = 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)

var indices: Indices.GeneratorType

var indices: Indices.Generator

func next() -> Element?

mutating func next() -> Element?

enum QuickLookObject {
    case Text(String)
    case Int(Int64)
    case UInt(UInt64)
    case Float(Double)
    case Image(Any)
    case Sound(Any)
    case Color(Any)
    case BezierPath(Any)
    case AttributedString(Any)
    case Rectangle(Double, Double, Double, Double)
    case Point(Double, Double)
    case Size(Double, Double)
    case Logical(Bool)
    case Range(UInt64, UInt64)
    case View(Any)
    case Sprite(Any)
    case URL(String)
}

enum QuickLookObject {
    case Text(String)
    case Int(Int64)
    case UInt(UInt64)
    case Float(Float32)
    case Double(Float64)
    case Image(Any)
    case Sound(Any)
    case Color(Any)
    case BezierPath(Any)
    case AttributedString(Any)
    case Rectangle(Float64, Float64, Float64, Float64)
    case Point(Float64, Float64)
    case Size(Float64, Float64)
    case Logical(Bool)
    case Range(UInt64, UInt64)
    case View(Any)
    case Sprite(Any)
    case URL(String)
}

case Float(Double)

case Float(Float32)

case Point(Double, Double)

case Point(Float64, Float64)

case Rectangle(Double, Double, Double, Double)

case Rectangle(Float64, Float64, Float64, Float64)

case Size(Double, Double)

case Size(Float64, Float64)

struct RandomAccessReverseView<T : Collection where T.IndexType : RandomAccessIndex> : Collection {
    typealias IndexType = ReverseRandomAccessIndex<T.IndexType>
    typealias GeneratorType = IndexingGenerator<RandomAccessReverseView<T>>
    func generate() -> IndexingGenerator<RandomAccessReverseView<T>>
    var startIndex: IndexType { get }
    var endIndex: IndexType { get }
    subscript (i: IndexType) -> T.GeneratorType.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 }
}

var endIndex: IndexType { get }

var endIndex: Index { get }

var startIndex: IndexType { get }

var startIndex: Index { get }

struct Range<T : ForwardIndex> : LogicValue, Equatable, Collection {
    init(start start: T, end end: T)
    var isEmpty: Bool { get }
    func getLogicValue() -> Bool
    typealias IndexType = T
    typealias SliceType = Range<T>
    subscript (i: T) -> T { get }
    subscript (_: T._DisabledRangeIndex) -> T { get }
    typealias GeneratorType = RangeGenerator<T>
    func generate() -> RangeGenerator<T>
    var startIndex: T
    var endIndex: T
}

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

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

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
}

func next() -> T?

mutating func next() -> T?

struct Repeat<T> : Collection {
    typealias IndexType = Int
    init(count count: Int, repeatedValue repeatedValue: T)
    var startIndex: IndexType { get }
    var endIndex: IndexType { 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
}

var endIndex: IndexType { get }

var endIndex: Index { get }

var startIndex: IndexType { get }

var startIndex: Index { get }

struct ReverseBidirectionalIndex<I : BidirectionalIndex> : BidirectionalIndex {
    func successor() -> ReverseBidirectionalIndex<I>
    func predecessor() -> ReverseBidirectionalIndex<I>
    typealias DistanceType = I.DistanceType
}

struct ReverseBidirectionalIndex<I : BidirectionalIndexType> : BidirectionalIndexType {
    func successor() -> ReverseBidirectionalIndex<I>
    func predecessor() -> ReverseBidirectionalIndex<I>
    typealias Distance = I.Distance
}

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

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 SequenceOf<T> : Sequence {
    init<G : Generator where T == T>(_ generate: () -> G)
    init<S : Sequence 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 : Generator where T == T>(_ generate: () -> G)

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

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

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

struct SinkOf<T> : Sink {
    init(_ put: (T) -> ())
    init<S : Sink 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) -> ())

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

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

struct StaticString : ExtendedGraphemeClusterLiteralConvertible, StringLiteralConvertible {
    init()
    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: @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 }
}

func writeTo<Target : OutputStream>(inout _ target: Target)

func writeTo<Target : OutputStreamType>(inout _ target: Target)

struct StrideThrough<T : Strideable> : Sequence {
    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
}

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
}

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

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

func next() -> T?

mutating func next() -> T?

struct StrideTo<T : Strideable> : Sequence {
    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
}

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
}

struct StrideToGenerator<T : Strideable> : Generator {
    var current: T
    let end: T
    let stride: T.Stride
    func next() -> T?
}

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

func next() -> T?

mutating func next() -> T?

init(_ view: String.UnicodeScalarView)

init(_ unicodeScalars: String.UnicodeScalarView)

init(count sz: Int, repeatedValue c: Character)

init(count count: Int, repeatedValue c: Character)

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

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

func join<S : Sequence where String == String>(_ elements: S) -> String

func join<S : SequenceType where String == String>(_ elements: S) -> String

func reserveCapacity(_ n: Int)

mutating func reserveCapacity(_ n: Int)

var unicodeScalars: String.UnicodeScalarView { get }

var unicodeScalars: String.UnicodeScalarView

func withCString<Result>(_ f: (UnsafePointer<CChar>) -> Result) -> Result

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

func write(_ string: String)

mutating func write(_ other: String)

func writeTo<Target : OutputStream>(inout _ target: Target)

func writeTo<Target : OutputStreamType>(inout _ target: Target)

struct Index : BidirectionalIndex, Reflectable {
        func successor() -> String.Index
        func predecessor() -> String.Index
        func getMirror() -> Mirror
    }

struct Index : BidirectionalIndexType, Comparable, Reflectable {
        func successor() -> String.Index
        func predecessor() -> String.Index
        func getMirror() -> MirrorType
    }

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

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

var endIndex: Int { get }

var endIndex: String.UTF16View.Index { get }

func generate() -> GeneratorType

func generate() -> Generator

var startIndex: Int { get }

var startIndex: String.UTF16View.Index { get }

struct UTF8View : Collection, Reflectable {
        struct Index : ForwardIndex {
            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() -> Mirror
    }

struct UTF8View : CollectionType, Reflectable, Printable, DebugPrintable {
        struct Index : ForwardIndexType {
            typealias Buffer = UTF8Chunk
            func successor() -> String.UTF8View.Index
        }
        var startIndex: String.UTF8View.Index { get }
        var endIndex: String.UTF8View.Index { get }
        subscript (position: String.UTF8View.Index) -> CodeUnit { get }
        subscript (subRange: Range<String.UTF8View.Index>) -> String.UTF8View { get }
        func generate() -> IndexingGenerator<String.UTF8View>
        func getMirror() -> MirrorType
        var description: String { get }
        var debugDescription: String { get }
    }

struct Index : ForwardIndex {
            func successor() -> String.UTF8View.Index
        }

struct Index : ForwardIndexType {
            typealias Buffer = UTF8Chunk
            func successor() -> String.UTF8View.Index
        }

struct UnicodeScalarView : Sliceable, Sequence {
        struct IndexType : BidirectionalIndex {
            func successor() -> String.UnicodeScalarView.IndexType
            func predecessor() -> String.UnicodeScalarView.IndexType
        }
        var startIndex: String.UnicodeScalarView.IndexType { get }
        var endIndex: String.UnicodeScalarView.IndexType { get }
        subscript (i: String.UnicodeScalarView.IndexType) -> UnicodeScalar { get }
        subscript (r: Range<String.UnicodeScalarView.IndexType>) -> String.UnicodeScalarView { get }
        struct GeneratorType : Generator {
            func next() -> UnicodeScalar?
        }
        func generate() -> String.UnicodeScalarView.GeneratorType
        func compare(_ other: String.UnicodeScalarView) -> Int
    }

struct UnicodeScalarView : Sliceable, SequenceType, Reflectable, Printable, DebugPrintable {
        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
        var description: String { get }
        var debugDescription: String { get }
    }

var endIndex: String.UnicodeScalarView.IndexType { get }

var endIndex: String.UnicodeScalarView.Index { get }

var startIndex: String.UnicodeScalarView.IndexType { get }

var startIndex: String.UnicodeScalarView.Index { get }

struct UInt : UnsignedInteger {
    init()
    init(_ value: UInt)
    init(bigEndian value: UInt)
    init(littleEndian value: UInt)
    static func convertFromIntegerLiteral(_ value: UInt) -> UInt
    typealias ArrayBoundType = UInt
    func getArrayBoundValue() -> UInt
    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.Int64
    typealias Distance = Int
    init()
    init(_ v: Builtin.Word)
    init(_ value: UInt)
    init(bigEndian value: UInt)
    init(littleEndian value: UInt)
    init(_builtinIntegerLiteral value: Builtin.Int2048)
    init(integerLiteral value: UInt)
    var bigEndian: UInt { get }
    var littleEndian: UInt { get }
    var byteSwapped: UInt { get }
    static var max: UInt { get }
    static var min: UInt { get }
}

init(_ v: Double)

init(_ other: Double)

init(_ v: Float)

init(_ other: Float)

init(_ v: Float80)

init(_ other: Float80)

func advancedBy(_ amount: Int) -> UInt

func advancedBy(_ amount: Distance) -> UInt

func distanceTo(_ other: UInt) -> Int

func distanceTo(_ other: UInt) -> Distance

struct UInt16 : UnsignedInteger {
    init()
    init(_ value: UInt16)
    init(bigEndian value: UInt16)
    init(littleEndian value: UInt16)
    static func convertFromIntegerLiteral(_ value: UInt16) -> UInt16
    typealias ArrayBoundType = UInt16
    func getArrayBoundValue() -> UInt16
    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)

init(_ v: Float80)

init(_ other: Float80)

func advancedBy(_ amount: Int) -> UInt16

func advancedBy(_ amount: Distance) -> UInt16

func distanceTo(_ other: UInt16) -> Int

func distanceTo(_ other: UInt16) -> Distance

struct UInt32 : UnsignedInteger {
    init()
    init(_ value: UInt32)
    init(bigEndian value: UInt32)
    init(littleEndian value: UInt32)
    static func convertFromIntegerLiteral(_ value: UInt32) -> UInt32
    typealias ArrayBoundType = UInt32
    func getArrayBoundValue() -> UInt32
    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)

init(_ v: Float80)

init(_ other: Float80)

func advancedBy(_ amount: Int) -> UInt32

func advancedBy(_ amount: Distance) -> UInt32

func distanceTo(_ other: UInt32) -> Int

func distanceTo(_ other: UInt32) -> Distance

struct UInt64 : UnsignedInteger {
    init()
    init(_ value: UInt64)
    init(bigEndian value: UInt64)
    init(littleEndian value: UInt64)
    static func convertFromIntegerLiteral(_ value: UInt64) -> UInt64
    typealias ArrayBoundType = UInt64
    func getArrayBoundValue() -> UInt64
    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)

init(_ v: Float80)

init(_ other: Float80)

func advancedBy(_ amount: Int) -> UInt64

func advancedBy(_ amount: Distance) -> UInt64

func distanceTo(_ other: UInt64) -> Int

func distanceTo(_ other: UInt64) -> Distance

struct UInt8 : UnsignedInteger {
    init()
    init(_ value: UInt8)
    static func convertFromIntegerLiteral(_ value: UInt8) -> UInt8
    typealias ArrayBoundType = UInt8
    func getArrayBoundValue() -> UInt8
    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)

init(_ v: Float80)

init(_ other: Float80)

func advancedBy(_ amount: Int) -> UInt8

func advancedBy(_ amount: Distance) -> UInt8

func distanceTo(_ other: UInt8) -> Int

func distanceTo(_ other: UInt8) -> Distance

struct UTF16 : UnicodeCodec {
    typealias CodeUnit = UInt16
    init()
    func decode<G : Generator where CodeUnit == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult
    static func encode<S : Sink where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)
}

struct UTF16 : UnicodeCodecType {
    typealias CodeUnit = UInt16
    init()
    mutating func decode<G : GeneratorType where CodeUnit == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult
    static func encode<S : SinkType where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)
}

func decode<G : Generator where CodeUnit == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult

mutating func decode<G : GeneratorType where CodeUnit == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult

static func encode<S : Sink where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)

static func encode<S : SinkType where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)

static func measure<Encoding : UnicodeCodec, Input : Generator where Encoding.CodeUnit == Encoding.CodeUnit>(_ _: Encoding.Type, input input: Input, repairIllFormedSequences repairIllFormedSequences: Bool) -> (Int, Bool)?

static func measure<Encoding : UnicodeCodecType, Input : GeneratorType where Encoding.CodeUnit == Encoding.CodeUnit>(_ _: Encoding.Type, input input: Input, repairIllFormedSequences repairIllFormedSequences: Bool) -> (Int, Bool)?

struct UTF32 : UnicodeCodec {
    typealias CodeUnit = UInt32
    init()
    func decode<G : Generator where CodeUnit == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult
    static func encode<S : Sink where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)
}

struct UTF32 : UnicodeCodecType {
    typealias CodeUnit = UInt32
    init()
    mutating func decode<G : GeneratorType where CodeUnit == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult
    static func encode<S : SinkType where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)
}

func decode<G : Generator where CodeUnit == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult

mutating func decode<G : GeneratorType where CodeUnit == CodeUnit>(inout _ input: G) -> UnicodeDecodingResult

static func encode<S : Sink where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)

static func encode<S : SinkType where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)

struct UTF8 : UnicodeCodec {
    typealias CodeUnit = UInt8
    init()
    func decode<G : Generator where CodeUnit == CodeUnit>(inout _ next: G) -> UnicodeDecodingResult
    static func encode<S : Sink where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)
}

struct UTF8 : UnicodeCodecType {
    typealias CodeUnit = UInt8
    init()
    mutating func decode<G : GeneratorType where CodeUnit == CodeUnit>(inout _ next: G) -> UnicodeDecodingResult
    static func encode<S : SinkType where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)
    static func isContinuation(_ byte: CodeUnit) -> Bool
}

func decode<G : Generator where CodeUnit == CodeUnit>(inout _ next: G) -> UnicodeDecodingResult

mutating func decode<G : GeneratorType where CodeUnit == CodeUnit>(inout _ next: G) -> UnicodeDecodingResult

static func encode<S : Sink where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)

static func encode<S : SinkType where CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)

struct UnicodeScalar : ExtendedGraphemeClusterLiteralConvertible {
    var value: UInt32 { get }
    static func convertFromExtendedGraphemeClusterLiteral(_ value: String) -> UnicodeScalar
    init()
    init(_ v: UInt32)
    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
}

func writeTo<Target : OutputStream>(inout _ target: Target)

func writeTo<Target : OutputStreamType>(inout _ target: Target)

struct UnsafePointer<T> : BidirectionalIndex, Comparable, Hashable, LogicValue, NilLiteralConvertible {
    init()
    init(_ other: COpaquePointer)
    init(_ value: Int)
    init<U>(_ from: UnsafePointer<U>)
    init<U>(_ from: ConstUnsafePointer<U>)
    static func convertFromNilLiteral() -> UnsafePointer<T>
    static func null() -> UnsafePointer<T>
    static func alloc(_ num: Int) -> UnsafePointer<T>
    func dealloc(_ num: Int)
    var memory: T
    func initialize(_ newvalue: T)
    func move() -> T
    func moveInitializeBackwardFrom(_ source: UnsafePointer<T>, count count: Int)
    func moveAssignFrom(_ source: UnsafePointer<T>, count count: Int)
    func moveInitializeFrom(_ source: UnsafePointer<T>, count count: Int)
    func initializeFrom(_ source: UnsafePointer<T>, count count: Int)
    func initializeFrom<C : Collection where T == T>(_ source: C)
    func destroy()
    func destroy(_ count: Int)
    func getLogicValue() -> Bool
    subscript (i: Int) -> T
    var hashValue: Int { get }
    func successor() -> UnsafePointer<T>
    func predecessor() -> UnsafePointer<T>
}

struct UnsafePointer<T> : RandomAccessIndexType, Hashable, NilLiteralConvertible, _PointerType {
    init()
    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 memory: T

var memory: T { get }

final final final var header: VaListBuilder.Header

final var header: VaListBuilder.Header

struct Header {
        var gp_offset: UInt32
        var fp_offset: UInt32
        var overflow_arg_area: UnsafePointer<Word>
        var reg_save_area: UnsafePointer<Word>
    }

struct Header {
        var gp_offset: UInt32
        var fp_offset: UInt32
        var overflow_arg_area: UnsafeMutablePointer<Word>
        var reg_save_area: UnsafeMutablePointer<Word>
    }

var overflow_arg_area: UnsafePointer<Word>

var overflow_arg_area: UnsafeMutablePointer<Word>

var reg_save_area: UnsafePointer<Word>

var reg_save_area: UnsafeMutablePointer<Word>

struct Zip2<S0 : Sequence, S1 : Sequence> : Sequence {
    typealias Stream1 = S0.GeneratorType
    typealias Stream2 = S1.GeneratorType
    typealias GeneratorType = ZipGenerator2<S0.GeneratorType, S1.GeneratorType>
    init(_ s0: S0, _ s1: S1)
    func generate() -> GeneratorType
    var sequences: (S0, S1)
}

struct Zip2<S0 : SequenceType, S1 : SequenceType> : SequenceType {
    typealias Stream1 = S0.Generator
    typealias Stream2 = S1.Generator
    typealias Generator = ZipGenerator2<S0.Generator, S1.Generator>
    init(_ s0: S0, _ s1: S1)
    func generate() -> Generator
    var sequences: (S0, S1)
}

struct ZipGenerator2<E0 : Generator, E1 : Generator> : Generator {
    typealias Element = (E0.Element, E1.Element)
    init(_ e0: E0, _ e1: E1)
    func next() -> Element?
    var baseStreams: (E0, E1)
}

struct ZipGenerator2<E0 : GeneratorType, E1 : GeneratorType> : GeneratorType {
    typealias Element = (E0.Element, E1.Element)
    init(_ e0: E0, _ e1: E1)
    mutating func next() -> Element?
    var baseStreams: (E0, E1)
}

func next() -> Element?

mutating func next() -> Element?

typealias Element = (KeyType, ValueType)

typealias Element = (Key, Value)

typealias Index = DictionaryIndex<KeyType, ValueType>

typealias Index = DictionaryIndex<Key, Value>

typealias Index = DictionaryIndex<KeyType, ValueType>

typealias Index = DictionaryIndex<Key, Value>

typealias Element = C.GeneratorType.Element

typealias Element = C.Generator.Element

typealias Stream1 = S0.GeneratorType

typealias Stream1 = S0.Generator

typealias Stream2 = S1.GeneratorType

typealias Stream2 = S1.Generator

func abs<T : SignedNumber>(_ x: T) -> T

func abs<T : SignedNumberType>(_ x: T) -> T

func debugPrint<T>(_ object: T)

@inline(never) func debugPrint<T>(_ x: T)

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

@inline(never) func debugPrint<T, TargetStream : OutputStreamType>(_ value: T, inout _ target: TargetStream)

func debugPrintln<T>(_ object: T)

@inline(never) func debugPrintln<T>(_ x: T)

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

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

func equal<S1 : Sequence, S2 : Sequence where S1.GeneratorType.Element == S1.GeneratorType.Element, S1.GeneratorType.Element : Equatable>(_ a1: S1, _ a2: S2) -> Bool

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

func join<C : ExtensibleCollection, S : Sequence where C == C>(_ separator: C, _ elements: S) -> C

func join<C : ExtensibleCollectionType, S : SequenceType where C == C>(_ separator: C, _ elements: S) -> C

func lazy<S : Collection where S.IndexType : BidirectionalIndex>(_ s: S) -> LazyBidirectionalCollection<S>

func lazy<S : CollectionType where S.Index : BidirectionalIndexType>(_ s: S) -> LazyBidirectionalCollection<S>

func lazy<S : Collection where S.IndexType : ForwardIndex>(_ s: S) -> LazyForwardCollection<S>

func lazy<S : CollectionType where S.Index : ForwardIndexType>(_ s: S) -> LazyForwardCollection<S>

func lazy<S : Collection where S.IndexType : RandomAccessIndex>(_ s: S) -> LazyRandomAccessCollection<S>

func lazy<S : CollectionType where S.Index : RandomAccessIndexType>(_ s: S) -> LazyRandomAccessCollection<S>

func lazy<S : Sequence>(_ s: S) -> LazySequence<S>

func lazy<S : SequenceType>(_ s: S) -> LazySequence<S>

func lexicographicalCompare<S1 : Sequence, S2 : Sequence where S1.GeneratorType.Element == S1.GeneratorType.Element, S1.GeneratorType.Element : Comparable>(_ a1: S1, _ a2: S2) -> Bool

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

func map<T, U>(_ x: T?, _ f: (T) -> U) -> U?

func map<T, U>(_ x: T?, _ f: @noescape (T) -> U) -> U?

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

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

func print<T>(_ object: T)

@inline(never) func print<T>(_ value: T)

func print<T, TargetStream : OutputStream>(_ object: T, inout _ target: TargetStream)

@inline(never) func print<T, TargetStream : OutputStreamType>(_ value: T, inout _ target: TargetStream)

func println()

@inline(never) func println()

func println<T>(_ object: T)

@inline(never) func println<T>(_ value: T)

func println<T, TargetStream : OutputStream>(_ object: T, inout _ target: TargetStream)

@inline(never) func println<T, TargetStream : OutputStreamType>(_ value: T, inout _ target: TargetStream)

func sort<C : MutableCollection where C.IndexType : RandomAccessIndex, C.GeneratorType.Element : Comparable>(inout _ collection: C)

func sort<C : MutableCollectionType where C.Index : RandomAccessIndexType, C.Generator.Element : Comparable>(inout _ collection: C)

func sort<T>(inout _ array: [T], _ predicate: (T, T) -> Bool)

func sort<T>(inout _ array: [T], _ isOrderedBefore: (T, T) -> Bool)

func startsWith<S0 : Sequence, S1 : Sequence where S0.GeneratorType.Element == S0.GeneratorType.Element, S0.GeneratorType.Element : Equatable>(_ s: S0, _ prefix: S1) -> Bool

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

func toString<T>(_ object: T) -> String

@inline(never) func toString<T>(_ x: T) -> String

func underestimateCount<T : Sequence>(_ x: T) -> Int

func underestimateCount<T : SequenceType>(_ x: T) -> Int

func withExtendedLifetime<T, Result>(_ x: T, _ f: () -> Result) -> Result

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

func withExtendedLifetime<T, Result>(_ x: T, _ f: (T) -> Result) -> Result

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

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

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

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

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

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

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

func withVaList<R>(_ builder: VaListBuilder, _ f: (CVaListPointer) -> R) -> R

func withVaList<R>(_ builder: VaListBuilder, _ f: @noescape CVaListPointer -> R) -> R