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

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

struct Array<T> : MutableCollectionType, Sliceable {
    typealias Element = T
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (index: Int) -> T
    func generate() -> IndexingGenerator<[T]>
    typealias SubSlice = Slice<T>
    subscript (subRange: Range<Int>) -> Slice<T>
    init(_ buffer: _ArrayBuffer<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>)
}

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

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

func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<T>) -> R) -> R

func withUnsafeBufferPointer<R>(_ body: @noescape (UnsafeBufferPointer<T>) -> R) -> R

mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<T>) -> R) -> R

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

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 AutoreleasingUnsafeMutablePointer<T> : Equatable, NilLiteralConvertible, _PointerType {
    var memory: T { get nonmutating set }
    subscript (i: Int) -> T { get }
    init(nilLiteral nilLiteral: ())
    static func null() -> AutoreleasingUnsafeMutablePointer<T>
    init()
    init<U>(_ ptr: UnsafeMutablePointer<U>)
    init<U>(_ ptr: UnsafePointer<U>)
}

class var allZeros: Self { get }

static var allZeros: Self { get }

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

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>(_ value: UnsafeMutablePointer<T>)

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

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

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

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

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

struct ContiguousArray<T> : MutableCollectionType, Sliceable {
    typealias Element = T
    var startIndex: Int { get }
    var endIndex: Int { get }
    subscript (index: Int) -> T
    func generate() -> IndexingGenerator<ContiguousArray<T>>
    typealias SubSlice = Slice<T>
    subscript (subRange: Range<Int>) -> Slice<T>
    init(_ buffer: _ContiguousArrayBuffer<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>)
}

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

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

func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<T>) -> R) -> R

func withUnsafeBufferPointer<R>(_ body: @noescape (UnsafeBufferPointer<T>) -> R) -> R

mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<T>) -> R) -> R

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class var NaN: Self { get }

static var NaN: Self { get }

class var infinity: Self { get }

static var infinity: Self { get }

class var quietNaN: Self { get }

static var quietNaN: Self { get }

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

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

var value: Builtin.Word

var value: Builtin.Int32

struct ObjectIdentifier : Hashable {
    let value: Builtin.RawPointer
    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> : Reflectable, NilLiteralConvertible {
    case None
    case Some(T)
    init()
    init(_ some: T)
    func map<U>(_ f: (T) -> U) -> U?
    func getMirror() -> MirrorType
    init(nilLiteral nilLiteral: ())
}

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?

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

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

mutating func replaceRange<C : CollectionType where `Self`.Generator.Element == Self.Generator.Element>(_ subRange: Range<Self.Index>, with newElements: 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>(_ newElements: S, atIndex i: Self.Index)

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

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

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 withUTF8Buffer<R>(_ body: (UnsafeBufferPointer<UInt8>) -> R) -> R

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

init(_ view: String.UnicodeScalarView)

init(_ unicodeScalars: String.UnicodeScalarView)

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

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

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

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

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

var startIndex: Int { get }

var startIndex: String.UTF16View.Index { get }

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 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 : ForwardIndexType {
            func successor() -> String.UTF8View.Index
        }

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

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

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

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

var value: Builtin.Word

var value: Builtin.Int32

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

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
}

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

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

class func encode<S : SinkType where `Self`.CodeUnit == CodeUnit>(_ input: UnicodeScalar, inout output output: S)

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

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 UnsafeMutablePointer<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() -> 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 assignFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func assignBackwardFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func moveInitializeFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func moveInitializeBackwardFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func initializeFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    func initializeFrom<C : CollectionType where T == T>(_ source: C)
    func moveAssignFrom(_ source: UnsafeMutablePointer<T>, count count: Int)
    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>)
    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>
}

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

typealias SubSlice = Slice<T>

typealias SubSlice = ArraySlice<T>

typealias SubSlice = Slice<T>

typealias SubSlice = ArraySlice<T>

func assert(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = default, file file: StaticString = default, line line: UWord = default)

func assert(_ condition: @autoclosure_ condition: @autoclosure () -> Bool, _ message: @autoclosure_ message: @autoclosure () -> String = default, file file: StaticString = default, line line: UWord = default)

@noreturn func assertionFailure(_ message: @autoclosure () -> String = default, file file: StaticString = default, line line: UWord = default)

@inline(__always) func assertionFailure(_ message: @autoclosure_ message: @autoclosure () -> String = default, file file: StaticString = default, line line: UWord = default)

func contains<S : SequenceType, L : BooleanType>(_ seq: S, _ predicate: (S.Generator.Element) -> L) -> Bool

func contains<S : SequenceType, L : BooleanType>(_ seq: S, _ predicate: @noescape (S.Generator.Element) -> L) -> Bool

func debugPrint<T>(_ x: T)

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

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

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

func debugPrintln<T>(_ x: T)

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

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

@inline(never) 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, _ isEquivalent: (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: @noescape (S1.Generator.Element, S1.Generator.Element) -> Bool) -> Bool

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

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

@noreturn func fatalError(_ message: @autoclosure () -> String = default, file file: StaticString = default, line line: UWord = default)

@noreturn func fatalError(_ message: @autoclosure_ message: @autoclosure () -> String = default, file file: StaticString = default, line line: UWord = default)

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

func lexicographicalCompare<S1 : SequenceType, S2 : SequenceType where S1.Generator.Element == S1.Generator.Element>(_ a1: S1, _ a2: S2, isOrderedBefore less: @noescape (S1.Generator.Element, S1.Generator.Element) -> Bool) -> 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 : _SignedIntegerType, U : _SignedIntegerType>(_ x: T) -> U

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

func precondition(_ condition: @autoclosure () -> Bool, _ message: @autoclosure () -> String = default, file file: StaticString = default, line line: UWord = default)

func precondition(_ condition: @autoclosure_ condition: @autoclosure () -> Bool, _ message: @autoclosure_ message: @autoclosure () -> String = default, file file: StaticString = default, line line: UWord = default)

@noreturn func preconditionFailure(_ message: @autoclosure () -> String = default, file file: StaticString = default, line line: UWord = default)

@noreturn func preconditionFailure(_ message: @autoclosure_ message: @autoclosure () -> String = default, file file: StaticString = default, line line: UWord = default)

func print<T>(_ object: T)

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

func print<T, TargetStream : OutputStreamType>(_ 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 : OutputStreamType>(_ object: T, inout _ target: TargetStream)

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

func reduce<S : SequenceType, U>(_ sequence: S, _ initial: U, _ combine: (U, S.Generator.Element) -> U) -> U

func reduce<S : SequenceType, U>(_ sequence: S, _ initial: U, _ combine: @noescape (U, S.Generator.Element) -> U) -> U

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

func splice<C : RangeReplaceableCollectionType, S : CollectionType where C.Generator.Element == C.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, _ isEquivalent: (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: @noescape (S0.Generator.Element, S0.Generator.Element) -> Bool) -> Bool

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

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

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 withUnsafeMutablePointer<T, Result>(inout _ arg: T, _ body: (UnsafeMutablePointer<T>) -> Result) -> Result

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

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

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

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

func withUnsafeMutablePointers<A0, A1, A2, Result>(inout _ arg0: A0, inout _ arg1: A1, inout _ arg2: A2, _ body: @noescape (UnsafeMutablePointer<A0>, UnsafeMutablePointer<A1>, UnsafeMutablePointer<A2>) -> 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

func withVaList<R>(_ args: [CVarArgType], _ f: (CVaListPointer) -> R) -> R

func withVaList<R>(_ args: [CVarArgType], _ f: @noescape CVaListPointer -> R) -> R