     return lhs.currect1 == rhs.currect1 && lhs.currect2 == rhs.currect2
 }
 
-extension SequenceType {
-    
-    @warn_unused_result
-    public func concat<S : SequenceType where Generator.Element == S.Generator.Element>(with: S) -> ConcatSequence<Self, S> {
+public extension SequenceType {
+    
+    @warn_unused_result
+    func concat<S : SequenceType where Generator.Element == S.Generator.Element>(with: S) -> ConcatSequence<Self, S> {
         return ConcatSequence(base1: self, base2: with)
     }
 }
 
-extension CollectionType {
-    
-    @warn_unused_result
-    public func concat<S : CollectionType where Generator.Element == S.Generator.Element>(with: S) -> ConcatCollection<Self, S> {
+public extension CollectionType {
+    
+    @warn_unused_result
+    func concat<S : CollectionType where Generator.Element == S.Generator.Element>(with: S) -> ConcatCollection<Self, S> {
         return ConcatCollection(base1: self, base2: with)
     }
 }
 
-extension CollectionType where Index : BidirectionalIndexType {
-    
-    @warn_unused_result
-    public func concat<S : CollectionType where Generator.Element == S.Generator.Element, S.Index : BidirectionalIndexType>(with: S) -> ConcatBidirectionalCollection<Self, S> {
+public extension CollectionType where Index : BidirectionalIndexType {
+    
+    @warn_unused_result
+    func concat<S : CollectionType where Generator.Element == S.Generator.Element, S.Index : BidirectionalIndexType>(with: S) -> ConcatBidirectionalCollection<Self, S> {
         return ConcatBidirectionalCollection(base1: self, base2: with)
     }
 }
 
-extension LazySequenceType {
-    
-    @warn_unused_result
-    public func concat<S : SequenceType where Elements.Generator.Element == S.Generator.Element>(with: S) -> LazySequence<ConcatSequence<Elements, S>> {
+public extension LazySequenceType {
+    
+    @warn_unused_result
+    func concat<S : SequenceType where Elements.Generator.Element == S.Generator.Element>(with: S) -> LazySequence<ConcatSequence<Elements, S>> {
         return ConcatSequence(base1: self.elements, base2: with).lazy
     }
 }
 
-extension LazyCollectionType {
-    
-    @warn_unused_result
-    public func concat<S : CollectionType where Elements.Generator.Element == S.Generator.Element>(with: S) -> LazyCollection<ConcatCollection<Elements, S>> {
+public extension LazyCollectionType {
+    
+    @warn_unused_result
+    func concat<S : CollectionType where Elements.Generator.Element == S.Generator.Element>(with: S) -> LazyCollection<ConcatCollection<Elements, S>> {
         return ConcatCollection(base1: self.elements, base2: with).lazy
     }
 }
 
-extension LazyCollectionType where Elements.Index : BidirectionalIndexType {
-    
-    @warn_unused_result
-    public func concat<S : CollectionType where Elements.Generator.Element == S.Generator.Element, S.Index : BidirectionalIndexType>(with: S) -> LazyCollection<ConcatBidirectionalCollection<Elements, S>> {
+public extension LazyCollectionType where Elements.Index : BidirectionalIndexType {
+    
+    @warn_unused_result
+    func concat<S : CollectionType where Elements.Generator.Element == S.Generator.Element, S.Index : BidirectionalIndexType>(with: S) -> LazyCollection<ConcatBidirectionalCollection<Elements, S>> {
         return ConcatBidirectionalCollection(base1: self.elements, base2: with).lazy
     }
 }
 
-extension LazySequenceType {
-    
-    @warn_unused_result
-    public func append(newElement: Elements.Generator.Element) -> LazySequence<ConcatSequence<Elements, CollectionOfOne<Elements.Generator.Element>>> {
+public extension LazySequenceType {
+    
+    @warn_unused_result
+    func append(newElement: Elements.Generator.Element) -> LazySequence<ConcatSequence<Elements, CollectionOfOne<Elements.Generator.Element>>> {
         return self.concat(CollectionOfOne(newElement))
     }
 }
 
-extension LazyCollectionType {
-    
-    @warn_unused_result
-    public func append(newElement: Elements.Generator.Element) -> LazyCollection<ConcatCollection<Elements, CollectionOfOne<Elements.Generator.Element>>> {
+public extension LazyCollectionType {
+    
+    @warn_unused_result
+    func append(newElement: Elements.Generator.Element) -> LazyCollection<ConcatCollection<Elements, CollectionOfOne<Elements.Generator.Element>>> {
         return self.concat(CollectionOfOne(newElement))
     }
 }
 
-extension LazyCollectionType where Elements.Index : BidirectionalIndexType {
-    
-    @warn_unused_result
-    public func append(newElement: Elements.Generator.Element) -> LazyCollection<ConcatBidirectionalCollection<Elements, CollectionOfOne<Elements.Generator.Element>>> {
+public extension LazyCollectionType where Elements.Index : BidirectionalIndexType {
+    
+    @warn_unused_result
+    func append(newElement: Elements.Generator.Element) -> LazyCollection<ConcatBidirectionalCollection<Elements, CollectionOfOne<Elements.Generator.Element>>> {
         return self.concat(CollectionOfOne(newElement))
     }
 }

    ///
    /// - Complexity: O(`self.count`)
    @warn_unused_result
    public func suffixUntil(@noescape predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Self.SubSequence {
        return self.suffixFrom(try self.reverse().indexOf(predicate)?.base ?? self.startIndex)
    }
}


    ///
    /// - Complexity: O(`self.count`)
    @warn_unused_result
    func prefixUntil(element: Self.Generator.Element) -> Self.SubSequence {
        return self.prefixUpTo(self.indexOf(element) ?? self.endIndex)
    }
}

public extension CollectionType {
    
    /// Returns a subsequence, until a element satisfying the predicate, containing the
    /// initial elements.
