diff --git a/stdlib.swift b/stdlib.swift
index fab4fcd..f289f82 100644
--- a/stdlib.swift
+++ b/stdlib.swift
@@ -1,6 +1,6 @@
-infix operator | {
-    associativity left
-    precedence 140
+infix operator >> {
+    associativity none
+    precedence 160
 }
 
 infix operator += {
@@ -25,17 +25,17 @@ infix operator &% {
     precedence 150
 }
 
+infix operator && {
+    associativity left
+    precedence 120
+}
+
 infix operator /= {
     associativity right
     precedence 90
     assignment
 }
 
-infix operator && {
-    associativity left
-    precedence 120
-}
-
 infix operator &* {
     associativity left
     precedence 150
@@ -77,19 +77,19 @@ infix operator ^= {
     assignment
 }
 
-infix operator ^ {
-    associativity left
-    precedence 140
-}
-
 infix operator ?? {
     associativity right
     precedence 110
 }
 
-infix operator < {
-    associativity none
-    precedence 130
+infix operator ^ {
+    associativity left
+    precedence 140
+}
+
+infix operator ~> {
+    associativity left
+    precedence 255
 }
 
 infix operator &= {
@@ -119,9 +119,9 @@ infix operator * {
     precedence 150
 }
 
-infix operator >> {
-    associativity none
-    precedence 160
+infix operator | {
+    associativity left
+    precedence 140
 }
 
 infix operator + {
@@ -129,9 +129,9 @@ infix operator + {
     precedence 140
 }
 
-infix operator ~> {
-    associativity left
-    precedence 255
+infix operator < {
+    associativity none
+    precedence 130
 }
 
 infix operator - {
@@ -150,59 +150,59 @@ infix operator <<= {
     assignment
 }
 
-infix operator !== {
+infix operator ~= {
     associativity none
     precedence 130
 }
 
-infix operator ~= {
+infix operator !== {
     associativity none
     precedence 130
 }
 
+infix operator << {
+    associativity none
+    precedence 160
+}
+
 infix operator || {
     associativity left
     precedence 110
 }
 
-infix operator << {
+infix operator <= {
     associativity none
-    precedence 160
+    precedence 130
 }
 
-infix operator >>= {
+infix operator |= {
     associativity right
     precedence 90
     assignment
 }
 
-infix operator <= {
+infix operator >= {
     associativity none
     precedence 130
 }
 
-infix operator >= {
+infix operator > {
     associativity none
     precedence 130
 }
 
-infix operator %= {
-    associativity right
-    precedence 90
-    assignment
-}
-
 infix operator != {
     associativity none
     precedence 130
 }
 
-infix operator > {
-    associativity none
-    precedence 130
+infix operator %= {
+    associativity right
+    precedence 90
+    assignment
 }
 
-infix operator |= {
+infix operator >>= {
     associativity right
     precedence 90
     assignment
@@ -238,12 +238,14 @@ prefix func !(a: Bool) -> Bool
 /// Return the result of inverting `a`\ 's logic value
 prefix func !<T : BooleanType>(a: T) -> Bool
 
-func !=(lhs: Int, rhs: Int) -> Bool
-
 func !=<T : Equatable>(lhs: T?, rhs: T?) -> Bool
 
 func !=<T>(lhs: T?, rhs: _OptionalNilComparisonType) -> Bool
 
+func !=<T>(lhs: _OptionalNilComparisonType, rhs: T?) -> Bool
+
+func !=(lhs: Int, rhs: Int) -> Bool
+
 func !=(lhs: UInt, rhs: UInt) -> Bool
 
 func !=(lhs: Int64, rhs: Int64) -> Bool
@@ -254,25 +256,21 @@ func !=(lhs: Int32, rhs: Int32) -> Bool
 
 func !=(lhs: UInt32, rhs: UInt32) -> Bool
 
-func !=(lhs: Int16, rhs: Int16) -> Bool
+
+/// Returns true if the arrays do not contain the same elements.
+func !=<T : Equatable>(lhs: Slice<T>, rhs: Slice<T>) -> Bool
 
 func !=(lhs: UInt16, rhs: UInt16) -> Bool
 
 func !=(lhs: Int8, rhs: Int8) -> Bool
 
-func !=(lhs: UInt8, rhs: UInt8) -> Bool
-
-func !=<T>(lhs: _OptionalNilComparisonType, rhs: T?) -> Bool
-
 func !=<T : Equatable>(lhs: T, rhs: T) -> Bool
 
-
-/// Returns true if the arrays do not contain the same elements.
-func !=<T : Equatable>(lhs: ContiguousArray<T>, rhs: ContiguousArray<T>) -> Bool
+func !=(lhs: Int16, rhs: Int16) -> Bool
 
 
 /// Returns true if the arrays do not contain the same elements.
-func !=<T : Equatable>(lhs: Slice<T>, rhs: Slice<T>) -> Bool
+func !=<T : Equatable>(lhs: ContiguousArray<T>, rhs: ContiguousArray<T>) -> Bool
 
 
 /// Returns true if the arrays do not contain the same elements.
@@ -280,17 +278,19 @@ func !=<T : Equatable>(lhs: [T], rhs: [T]) -> Bool
 
 func !=<Key : Equatable, Value : Equatable>(lhs: [Key : Value], rhs: [Key : Value]) -> Bool
 
-func !==(lhs: AnyObject?, rhs: AnyObject?) -> Bool
+func !=(lhs: UInt8, rhs: UInt8) -> Bool
 
-func %(lhs: UInt32, rhs: UInt32) -> UInt32
+func !==(lhs: AnyObject?, rhs: AnyObject?) -> Bool
 
-func %(lhs: Int16, rhs: Int16) -> Int16
+func %(lhs: Int64, rhs: Int64) -> Int64
 
-func %(lhs: UInt16, rhs: UInt16) -> UInt16
+func %(lhs: UInt8, rhs: UInt8) -> UInt8
 
 func %(lhs: Int8, rhs: Int8) -> Int8
 
-func %(lhs: UInt8, rhs: UInt8) -> UInt8
+func %(lhs: UInt32, rhs: UInt32) -> UInt32
+
+func %(lhs: UInt16, rhs: UInt16) -> UInt16
 
 
 /// Divide `lhs` and `rhs`, returning the remainder and trapping in case of
@@ -305,31 +305,33 @@ func %(lhs: Float, rhs: Float) -> Float
 
 func %(lhs: Int, rhs: Int) -> Int
 
+func %(lhs: Int16, rhs: Int16) -> Int16
+
 func %(lhs: Int32, rhs: Int32) -> Int32
 
 func %(lhs: UInt64, rhs: UInt64) -> UInt64
 
-func %(lhs: Int64, rhs: Int64) -> Int64
-
 func %(lhs: UInt, rhs: UInt) -> UInt
 
+func %=(inout lhs: Float80, rhs: Float80)
+
 func %=(inout lhs: Float, rhs: Float)
 
 func %=(inout lhs: Double, rhs: Double)
 
-func %=(inout lhs: Float80, rhs: Float80)
-
 
 /// remainder `lhs` and `rhs` and store the result in `lhs`, trapping in
 /// case of arithmetic overflow (except in -Ounchecked builds).
 func %=<T : _IntegerArithmeticType>(inout lhs: T, rhs: T)
 
-func &(lhs: UInt32, rhs: UInt32) -> UInt32
+func &(lhs: Int8, rhs: Int8) -> Int8
 
 func &(lhs: UInt16, rhs: UInt16) -> UInt16
 
 func &(lhs: Int16, rhs: Int16) -> Int16
 
+func &(lhs: UInt32, rhs: UInt32) -> UInt32
+
 func &(lhs: Int32, rhs: Int32) -> Int32
 
 func &(lhs: UInt64, rhs: UInt64) -> UInt64
@@ -346,8 +348,6 @@ func &<T : _RawOptionSetType>(a: T, b: T) -> T
 
 func &(lhs: UInt8, rhs: UInt8) -> UInt8
 
-func &(lhs: Int8, rhs: Int8) -> Int8
-
 
 /// remainder `lhs` and `rhs`, silently discarding any overflow.
 func &%<T : _IntegerArithmeticType>(lhs: T, rhs: T) -> T
@@ -375,6 +375,10 @@ func &-<T : _IntegerArithmeticType>(lhs: T, rhs: T) -> T
 /// divide `lhs` and `rhs`, silently discarding any overflow.
 func &/<T : _IntegerArithmeticType>(lhs: T, rhs: T) -> T
 
+func &=(inout lhs: Int, rhs: Int)
+
+func &=<T : BitwiseOperationsType>(inout lhs: T, rhs: T)
+
 func &=(inout lhs: Bool, rhs: Bool)
 
 func &=(inout lhs: UInt8, rhs: UInt8)
@@ -389,15 +393,24 @@ func &=(inout lhs: UInt32, rhs: UInt32)
 
 func &=(inout lhs: Int32, rhs: Int32)
 
+func &=(inout lhs: Int64, rhs: Int64)
+
+func &=(inout lhs: UInt, rhs: UInt)
+
 func &=(inout lhs: UInt64, rhs: UInt64)
 
-func &=<T : BitwiseOperationsType>(inout lhs: T, rhs: T)
+func *(lhs: Int8, rhs: Int8) -> Int8
 
-func &=(inout lhs: Int, rhs: Int)
+func *(lhs: UInt8, rhs: UInt8) -> UInt8
 
-func &=(inout lhs: UInt, rhs: UInt)
 
-func &=(inout lhs: Int64, rhs: Int64)
+/// Multiply `lhs` and `rhs`, returning a result and trapping in case of
+/// arithmetic overflow (except in -Ounchecked builds).
+func *<T : _IntegerArithmeticType>(lhs: T, rhs: T) -> T
+
+func *(lhs: UInt16, rhs: UInt16) -> UInt16
+
+func *(lhs: Int16, rhs: Int16) -> Int16
 
 func *(lhs: UInt32, rhs: UInt32) -> UInt32
 
@@ -417,19 +430,6 @@ func *(lhs: Double, rhs: Double) -> Double
 
 func *(lhs: Float80, rhs: Float80) -> Float80
 
-
-/// Multiply `lhs` and `rhs`, returning a result and trapping in case of
-/// arithmetic overflow (except in -Ounchecked builds).
-func *<T : _IntegerArithmeticType>(lhs: T, rhs: T) -> T
-
-func *(lhs: Int16, rhs: Int16) -> Int16
-
-func *(lhs: UInt16, rhs: UInt16) -> UInt16
-
-func *(lhs: Int8, rhs: Int8) -> Int8
-
-func *(lhs: UInt8, rhs: UInt8) -> UInt8
-
 func *=(inout lhs: UInt8, rhs: UInt8)
 
 func *=(inout lhs: Int8, rhs: Int8)
@@ -639,12 +639,12 @@ func +=<T, C : CollectionType where T == T>(inout lhs: [T], rhs: C)
 /// Append the elements of rhs to lhs
 func +=<T, C : CollectionType where T == T>(inout lhs: _ContiguousArrayBuffer<T>, rhs: C)
 
+func +=(inout lhs: UInt16, rhs: UInt16)
+
 
 /// Append rhs to lhs
 func +=<T>(inout lhs: _ContiguousArrayBuffer<T>, rhs: T)
 
-func +=(inout lhs: UInt16, rhs: UInt16)
-
 func +=(inout lhs: Int8, rhs: Int8)
 
 func +=(inout lhs: UInt8, rhs: UInt8)
@@ -700,11 +700,11 @@ func -(lhs: Float, rhs: Float) -> Float
 
 func -(lhs: Int, rhs: Int) -> Int
 
-postfix func --(inout lhs: Float80) -> Float80
+postfix func --(inout x: UInt) -> UInt
 
 prefix func --(inout rhs: Float) -> Float
 
-postfix func --(inout x: UInt) -> UInt
+postfix func --(inout lhs: Float80) -> Float80
 
 prefix func --(inout x: UInt) -> UInt
 
@@ -774,15 +774,15 @@ func -=<T>(inout lhs: UnsafeMutablePointer<T>, rhs: Int)
 
 func -=<T : Strideable>(inout lhs: T, rhs: T.Stride)
 
+func -=(inout lhs: UInt32, rhs: UInt32)
+
+func -=(inout lhs: Int16, rhs: Int16)
+
 
 /// subtract `lhs` and `rhs` and store the result in `lhs`, trapping in
 /// case of arithmetic overflow (except in -Ounchecked builds).
 func -=<T : _IntegerArithmeticType>(inout lhs: T, rhs: T)
 
-func -=(inout lhs: UInt32, rhs: UInt32)
-
-func -=(inout lhs: Int16, rhs: Int16)
-
 func -=(inout lhs: Float80, rhs: Float80)
 
 func -=(inout lhs: Double, rhs: Double)
@@ -862,30 +862,16 @@ func /=(inout lhs: Float80, rhs: Float80)
 /// case of arithmetic overflow (except in -Ounchecked builds).
 func /=<T : _IntegerArithmeticType>(inout lhs: T, rhs: T)
 
-func <(lhs: UnicodeScalar, rhs: UnicodeScalar) -> Bool
+func <(lhs: Int64, rhs: Int64) -> Bool
 
 func <(lhs: UInt, rhs: UInt) -> Bool
 
-func <<Key : Hashable, Value>(lhs: DictionaryIndex<Key, Value>, rhs: DictionaryIndex<Key, Value>) -> Bool
-
-func <(lhs: UInt8, rhs: UInt8) -> Bool
-
-func <(lhs: Int8, rhs: Int8) -> Bool
-
-func <(lhs: UInt16, rhs: UInt16) -> Bool
-
-func <(lhs: Int16, rhs: Int16) -> Bool
-
-func <(lhs: UInt32, rhs: UInt32) -> Bool
-
 func <(lhs: Int32, rhs: Int32) -> Bool
 
-func <(lhs: UInt64, rhs: UInt64) -> Bool
-
-func <(lhs: Int64, rhs: Int64) -> Bool
-
 func <(lhs: Int, rhs: Int) -> Bool
 
+func <(lhs: UInt32, rhs: UInt32) -> Bool
+
 func <(lhs: Float, rhs: Float) -> Bool
 
 func <(lhs: Double, rhs: Double) -> Bool
@@ -900,61 +886,73 @@ func <<T : _Strideable>(x: T, y: T) -> Bool
 
 func <(lhs: String, rhs: String) -> Bool
 
+func <(lhs: Int16, rhs: Int16) -> Bool
+
 func <(lhs: String.Index, rhs: String.Index) -> Bool
 
 func <(lhs: String.UnicodeScalarView.Index, rhs: String.UnicodeScalarView.Index) -> Bool
 
-func <(lhs: Bit, rhs: Bit) -> Bool
+func <(lhs: UnicodeScalar, rhs: UnicodeScalar) -> Bool
 
-func <<T>(lhs: UnsafePointer<T>, rhs: UnsafePointer<T>) -> Bool
+func <(lhs: UInt16, rhs: UInt16) -> Bool
+
+func <(lhs: Int8, rhs: Int8) -> Bool
 
 func <<T>(lhs: UnsafeMutablePointer<T>, rhs: UnsafeMutablePointer<T>) -> Bool
 
-func <(lhs: Character, rhs: Character) -> Bool
+func <(lhs: UInt8, rhs: UInt8) -> Bool
 
-func <<(lhs: UInt8, rhs: UInt8) -> UInt8
+func <<T>(lhs: UnsafePointer<T>, rhs: UnsafePointer<T>) -> Bool
 
-func <<(lhs: Int8, rhs: Int8) -> Int8
+func <(lhs: Character, rhs: Character) -> Bool
 
-func <<(lhs: UInt16, rhs: UInt16) -> UInt16
+func <(lhs: UInt64, rhs: UInt64) -> Bool
 
-func <<(lhs: Int16, rhs: Int16) -> Int16
+func <<Key : Hashable, Value>(lhs: DictionaryIndex<Key, Value>, rhs: DictionaryIndex<Key, Value>) -> Bool
 
-func <<(lhs: UInt32, rhs: UInt32) -> UInt32
+func <(lhs: Bit, rhs: Bit) -> Bool
 
-func <<(lhs: Int32, rhs: Int32) -> Int32
+func <<(lhs: Int64, rhs: Int64) -> Int64
 
 func <<(lhs: UInt64, rhs: UInt64) -> UInt64
 
-func <<(lhs: Int, rhs: Int) -> Int
+func <<(lhs: UInt8, rhs: UInt8) -> UInt8
+
+func <<(lhs: Int32, rhs: Int32) -> Int32
 
 func <<(lhs: UInt, rhs: UInt) -> UInt
 
-func <<(lhs: Int64, rhs: Int64) -> Int64
+func <<(lhs: UInt32, rhs: UInt32) -> UInt32
 
-func <<=(inout lhs: UInt16, rhs: UInt16)
+func <<(lhs: Int, rhs: Int) -> Int
 
-func <<=(inout lhs: Int, rhs: Int)
+func <<(lhs: Int16, rhs: Int16) -> Int16
 
-func <<=(inout lhs: UInt, rhs: UInt)
+func <<(lhs: Int8, rhs: Int8) -> Int8
 
-func <<=(inout lhs: Int64, rhs: Int64)
+func <<(lhs: UInt16, rhs: UInt16) -> UInt16
+
+func <<=(inout lhs: UInt, rhs: UInt)
 
 func <<=(inout lhs: UInt8, rhs: UInt8)
 
 func <<=(inout lhs: Int8, rhs: Int8)
 
-func <<=(inout lhs: UInt64, rhs: UInt64)
+func <<=(inout lhs: UInt16, rhs: UInt16)
+
+func <<=(inout lhs: Int, rhs: Int)
 
 func <<=(inout lhs: Int16, rhs: Int16)
 
 func <<=(inout lhs: UInt32, rhs: UInt32)
 
-func <<=(inout lhs: Int32, rhs: Int32)
+func <<=(inout lhs: Int64, rhs: Int64)
 
-func <=(lhs: UInt16, rhs: UInt16) -> Bool
+func <<=(inout lhs: UInt64, rhs: UInt64)
 
-func <=(lhs: UInt8, rhs: UInt8) -> Bool
+func <<=(inout lhs: Int32, rhs: Int32)
+
+func <=(lhs: Int16, rhs: Int16) -> Bool
 
 func <=<T : _Comparable>(lhs: T, rhs: T) -> Bool
 
@@ -966,17 +964,17 @@ func <=(lhs: UInt, rhs: UInt) -> Bool
 
 func <=(lhs: Int64, rhs: Int64) -> Bool
 
-func <=(lhs: Int8, rhs: Int8) -> Bool
+func <=(lhs: UInt64, rhs: UInt64) -> Bool
 
 func <=(lhs: Int32, rhs: Int32) -> Bool
 
 func <=(lhs: UInt32, rhs: UInt32) -> Bool
 
-func <=(lhs: Int16, rhs: Int16) -> Bool
+func <=(lhs: UInt16, rhs: UInt16) -> Bool
 
-func <=(lhs: UInt64, rhs: UInt64) -> Bool
+func <=(lhs: Int8, rhs: Int8) -> Bool
 
-func ==(lhs: UInt64, rhs: UInt64) -> Bool
+func <=(lhs: UInt8, rhs: UInt8) -> Bool
 
 func ==<T>(lhs: UnsafePointer<T>, rhs: UnsafePointer<T>) -> Bool
 
@@ -984,45 +982,42 @@ func ==<T>(lhs: UnsafeMutablePointer<T>, rhs: UnsafeMutablePointer<T>) -> Bool
 
 func ==(lhs: Bit, rhs: Bit) -> Bool
 
-func ==(lhs: Int64, rhs: Int64) -> Bool
+func ==(lhs: UnicodeScalar, rhs: UnicodeScalar) -> Bool
 
-func ==(lhs: UInt, rhs: UInt) -> Bool
+func ==(lhs: Int32, rhs: Int32) -> Bool
 
 func ==<Base : CollectionType>(lhs: FilterCollectionViewIndex<Base>, rhs: FilterCollectionViewIndex<Base>) -> Bool
 
-func ==(lhs: Int, rhs: Int) -> Bool
+func ==(lhs: UInt32, rhs: UInt32) -> Bool
 
 func ==<Key : Equatable, Value : Equatable>(lhs: [Key : Value], rhs: [Key : Value]) -> Bool
 
 func ==<Key : Hashable, Value>(lhs: DictionaryIndex<Key, Value>, rhs: DictionaryIndex<Key, Value>) -> Bool
 
-func ==(lhs: Float, rhs: Float) -> Bool
+func ==<T>(lhs: Range<T>, rhs: Range<T>) -> Bool
 
 func ==<T : _RawOptionSetType>(a: T, b: T) -> Bool
 
 func ==(lhs: Character, rhs: Character) -> Bool
 
-func ==(lhs: Double, rhs: Double) -> Bool
+func ==<I>(lhs: ReverseBidirectionalIndex<I>, rhs: ReverseBidirectionalIndex<I>) -> Bool
 
-func ==(lhs: Float80, rhs: Float80) -> Bool
+func ==<T>(lhs: T?, rhs: _OptionalNilComparisonType) -> Bool
 
-func ==(lhs: FloatingPointClassification, rhs: FloatingPointClassification) -> Bool
+func ==<T : Equatable>(lhs: T?, rhs: T?) -> Bool
 
-func ==<T>(lhs: CFunctionPointer<T>, rhs: CFunctionPointer<T>) -> Bool
+func ==(lhs: Int16, rhs: Int16) -> Bool
 
-func ==<Value, Element>(lhs: HeapBuffer<Value, Element>, rhs: HeapBuffer<Value, Element>) -> Bool
+func ==<T>(lhs: CFunctionPointer<T>, rhs: CFunctionPointer<T>) -> Bool
 
 
-/// Two `HalfOpenInterval`\ s are equal if their `start` and `end` are
+/// Two `ClosedInterval`\ s are equal if their `start` and `end` are
 /// equal
-func ==<T : Comparable>(lhs: HalfOpenInterval<T>, rhs: HalfOpenInterval<T>) -> Bool
+func ==<T : Comparable>(lhs: ClosedInterval<T>, rhs: ClosedInterval<T>) -> Bool
 
 func ==(lhs: COpaquePointer, rhs: COpaquePointer) -> Bool
 
-
-/// Two `ClosedInterval`\ s are equal if their `start` and `end` are
-/// equal
-func ==<T : Comparable>(lhs: ClosedInterval<T>, rhs: ClosedInterval<T>) -> Bool
+func ==(lhs: String.UnicodeScalarView.Index, rhs: String.UnicodeScalarView.Index) -> Bool
 
 func ==<T>(lhs: AutoreleasingUnsafeMutablePointer<T>, rhs: AutoreleasingUnsafeMutablePointer<T>) -> Bool
 
@@ -1040,47 +1035,50 @@ func ==<T : Equatable>(lhs: Slice<T>, rhs: Slice<T>) -> Bool
 /// Returns true if these arrays contain the same elements.
 func ==<T : Equatable>(lhs: ContiguousArray<T>, rhs: ContiguousArray<T>) -> Bool
 
-func ==<T : Equatable>(lhs: T?, rhs: T?) -> Bool
-
-func ==<T>(lhs: T?, rhs: _OptionalNilComparisonType) -> Bool
 
-func ==<T>(lhs: _OptionalNilComparisonType, rhs: T?) -> Bool
-
-func ==<T>(lhs: Range<T>, rhs: Range<T>) -> Bool
+/// Two `HalfOpenInterval`\ s are equal if their `start` and `end` are
+/// equal
+func ==<T : Comparable>(lhs: HalfOpenInterval<T>, rhs: HalfOpenInterval<T>) -> Bool
 
-func ==(lhs: Int32, rhs: Int32) -> Bool
+func ==(lhs: UInt16, rhs: UInt16) -> Bool
 
-func ==(lhs: UInt32, rhs: UInt32) -> Bool
+func ==<Value, Element>(lhs: HeapBuffer<Value, Element>, rhs: HeapBuffer<Value, Element>) -> Bool
 
-func ==(lhs: Int16, rhs: Int16) -> Bool
+func ==(lhs: String.UTF8View.Index, rhs: String.UTF8View.Index) -> Bool
 
-func ==(lhs: UInt16, rhs: UInt16) -> Bool
+func ==(lhs: String.Index, rhs: String.Index) -> Bool
 
 func ==(lhs: Int8, rhs: Int8) -> Bool
 
 func ==(lhs: UInt8, rhs: UInt8) -> Bool
 
-func ==(x: ObjectIdentifier, y: ObjectIdentifier) -> Bool
+func ==(lhs: String, rhs: String) -> Bool
 
-func ==<I>(lhs: ReverseBidirectionalIndex<I>, rhs: ReverseBidirectionalIndex<I>) -> Bool
+func ==<T : _Strideable>(x: T, y: T) -> Bool
 
 func ==<I>(lhs: ReverseRandomAccessIndex<I>, rhs: ReverseRandomAccessIndex<I>) -> Bool
 
-func ==<T : _Strideable>(x: T, y: T) -> Bool
+func ==(lhs: FloatingPointClassification, rhs: FloatingPointClassification) -> Bool
 
-func ==(lhs: String, rhs: String) -> Bool
+func ==(x: ObjectIdentifier, y: ObjectIdentifier) -> Bool
 
-func ==(lhs: String.Index, rhs: String.Index) -> Bool
+func ==(lhs: Float80, rhs: Float80) -> Bool
 
-func ==(lhs: String.UTF8View.Index, rhs: String.UTF8View.Index) -> Bool
+func ==<T>(lhs: _OptionalNilComparisonType, rhs: T?) -> Bool
 
-func ==(lhs: String.UnicodeScalarView.Index, rhs: String.UnicodeScalarView.Index) -> Bool
+func ==(lhs: UInt64, rhs: UInt64) -> Bool
 
-func ==(lhs: UnicodeScalar, rhs: UnicodeScalar) -> Bool
+func ==(lhs: Double, rhs: Double) -> Bool
 
-func ===(lhs: AnyObject?, rhs: AnyObject?) -> Bool
+func ==(lhs: Float, rhs: Float) -> Bool
 
-func >(lhs: Int32, rhs: Int32) -> Bool
+func ==(lhs: Int, rhs: Int) -> Bool
+
+func ==(lhs: UInt, rhs: UInt) -> Bool
+
+func ==(lhs: Int64, rhs: Int64) -> Bool
+
+func ===(lhs: AnyObject?, rhs: AnyObject?) -> Bool
 
 func >(lhs: Int, rhs: Int) -> Bool
 
@@ -1088,14 +1086,16 @@ func >(lhs: UInt, rhs: UInt) -> Bool
 
 func >(lhs: Int64, rhs: Int64) -> Bool
 
-func >(lhs: UInt64, rhs: UInt64) -> Bool
-
 func ><T : _Comparable>(lhs: T?, rhs: T?) -> Bool
 
-func >(lhs: UInt32, rhs: UInt32) -> Bool
+func >(lhs: UInt64, rhs: UInt64) -> Bool
 
 func ><T : _Comparable>(lhs: T, rhs: T) -> Bool
 
+func >(lhs: Int32, rhs: Int32) -> Bool
+
+func >(lhs: UInt32, rhs: UInt32) -> Bool
+
 func >(lhs: Int16, rhs: Int16) -> Bool
 
 func >(lhs: UInt16, rhs: UInt16) -> Bool
@@ -1104,21 +1104,17 @@ func >(lhs: Int8, rhs: Int8) -> Bool
 
 func >(lhs: UInt8, rhs: UInt8) -> Bool
 
+func >=(lhs: UInt16, rhs: UInt16) -> Bool
+
 func >=<T : _Comparable>(lhs: T, rhs: T) -> Bool
 
 func >=<T : _Comparable>(lhs: T?, rhs: T?) -> Bool
 
-func >=(lhs: Int, rhs: Int) -> Bool
-
-func >=(lhs: UInt, rhs: UInt) -> Bool
-
-func >=(lhs: Int64, rhs: Int64) -> Bool
-
 func >=(lhs: UInt8, rhs: UInt8) -> Bool
 
 func >=(lhs: Int8, rhs: Int8) -> Bool
 
-func >=(lhs: UInt16, rhs: UInt16) -> Bool
+func >=(lhs: Int, rhs: Int) -> Bool
 
 func >=(lhs: Int16, rhs: Int16) -> Bool
 
@@ -1128,45 +1124,49 @@ func >=(lhs: Int32, rhs: Int32) -> Bool
 
 func >=(lhs: UInt64, rhs: UInt64) -> Bool
 
-func >>(lhs: Int8, rhs: Int8) -> Int8
+func >=(lhs: Int64, rhs: Int64) -> Bool
 
-func >>(lhs: UInt32, rhs: UInt32) -> UInt32
+func >=(lhs: UInt, rhs: UInt) -> Bool
 
 func >>(lhs: Int, rhs: Int) -> Int
 
-func >>(lhs: UInt, rhs: UInt) -> UInt
+func >>(lhs: UInt64, rhs: UInt64) -> UInt64
+
+func >>(lhs: Int32, rhs: Int32) -> Int32
 
 func >>(lhs: Int64, rhs: Int64) -> Int64
 
-func >>(lhs: UInt64, rhs: UInt64) -> UInt64
+func >>(lhs: UInt32, rhs: UInt32) -> UInt32
 
-func >>(lhs: Int32, rhs: Int32) -> Int32
+func >>(lhs: UInt, rhs: UInt) -> UInt
+
+func >>(lhs: UInt8, rhs: UInt8) -> UInt8
 
 func >>(lhs: Int16, rhs: Int16) -> Int16
 
-func >>(lhs: UInt16, rhs: UInt16) -> UInt16
+func >>(lhs: Int8, rhs: Int8) -> Int8
 
-func >>(lhs: UInt8, rhs: UInt8) -> UInt8
+func >>(lhs: UInt16, rhs: UInt16) -> UInt16
 
 func >>=(inout lhs: Int64, rhs: Int64)
 
-func >>=(inout lhs: UInt, rhs: UInt)
-
-func >>=(inout lhs: Int, rhs: Int)
+func >>=(inout lhs: UInt64, rhs: UInt64)
 
 func >>=(inout lhs: UInt8, rhs: UInt8)
 
-func >>=(inout lhs: UInt16, rhs: UInt16)
+func >>=(inout lhs: UInt, rhs: UInt)
 
-func >>=(inout lhs: Int8, rhs: Int8)
+func >>=(inout lhs: Int, rhs: Int)
 
-func >>=(inout lhs: Int16, rhs: Int16)
+func >>=(inout lhs: Int8, rhs: Int8)
 
-func >>=(inout lhs: UInt64, rhs: UInt64)
+func >>=(inout lhs: Int32, rhs: Int32)
 
 func >>=(inout lhs: UInt32, rhs: UInt32)
 
-func >>=(inout lhs: Int32, rhs: Int32)
+func >>=(inout lhs: Int16, rhs: Int16)
+
+func >>=(inout lhs: UInt16, rhs: UInt16)
 
 func ??<T>(optional: T?, defaultValue: @autoclosure () -> T) -> T
 
@@ -8402,18 +8402,10 @@ struct ZipGenerator2<E0 : GeneratorType, E1 : GeneratorType> : GeneratorType {
     mutating func next() -> Element?
 }
 
-func ^<T : _RawOptionSetType>(a: T, b: T) -> T
-
-func ^(lhs: Bool, rhs: Bool) -> Bool
+func ^(lhs: Int32, rhs: Int32) -> Int32
 
 func ^(lhs: UInt8, rhs: UInt8) -> UInt8
 
-func ^(lhs: Int8, rhs: Int8) -> Int8
-
-func ^(lhs: UInt16, rhs: UInt16) -> UInt16
-
-func ^(lhs: Int16, rhs: Int16) -> Int16
-
 func ^(lhs: Int, rhs: Int) -> Int
 
 func ^(lhs: UInt, rhs: UInt) -> UInt
@@ -8422,34 +8414,42 @@ func ^(lhs: Int64, rhs: Int64) -> Int64
 
 func ^(lhs: UInt64, rhs: UInt64) -> UInt64
 
-func ^(lhs: Int32, rhs: Int32) -> Int32
-
 func ^(lhs: UInt32, rhs: UInt32) -> UInt32
 
-func ^=(inout lhs: Int, rhs: Int)
-
-func ^=(inout lhs: Int32, rhs: Int32)
-
-func ^=(inout lhs: UInt32, rhs: UInt32)
+func ^(lhs: Int16, rhs: Int16) -> Int16
 
-func ^=(inout lhs: Int16, rhs: Int16)
+func ^(lhs: UInt16, rhs: UInt16) -> UInt16
 
-func ^=(inout lhs: Int8, rhs: Int8)
+func ^(lhs: Int8, rhs: Int8) -> Int8
 
-func ^=(inout lhs: UInt8, rhs: UInt8)
+func ^<T : _RawOptionSetType>(a: T, b: T) -> T
 
-func ^=(inout lhs: UInt16, rhs: UInt16)
+func ^(lhs: Bool, rhs: Bool) -> Bool
 
 func ^=(inout lhs: Bool, rhs: Bool)
 
+func ^=<T : BitwiseOperationsType>(inout lhs: T, rhs: T)
+
 func ^=(inout lhs: UInt64, rhs: UInt64)
 
-func ^=<T : BitwiseOperationsType>(inout lhs: T, rhs: T)
+func ^=(inout lhs: UInt8, rhs: UInt8)
 
-func ^=(inout lhs: Int64, rhs: Int64)
+func ^=(inout lhs: Int32, rhs: Int32)
+
+func ^=(inout lhs: Int8, rhs: Int8)
+
+func ^=(inout lhs: UInt32, rhs: UInt32)
+
+func ^=(inout lhs: Int, rhs: Int)
 
 func ^=(inout lhs: UInt, rhs: UInt)
 
+func ^=(inout lhs: Int16, rhs: Int16)
+
+func ^=(inout lhs: UInt16, rhs: UInt16)
+
+func ^=(inout lhs: Int64, rhs: Int64)
+
 
 /// The underlying buffer for an ArrayType conforms to _ArrayBufferType
 protocol _ArrayBufferType : MutableCollectionType {