Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 2 of 2.

16 files changed, 513 insertions, 513 deletions

diff --git a/contrib/tools/cython/Cython/Includes/libcpp/__init__.pxd b/contrib/tools/cython/Cython/Includes/libcpp/__init__.pxd
index 8ccd1ae6d9..111ea25c2f 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/__init__.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/__init__.pxd
@@ -1,4 +1,4 @@
-cdef extern from *: 
-    ctypedef bint bool 
+cdef extern from *:
+    ctypedef bint bool
     ctypedef void* nullptr_t
     nullptr_t nullptr
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/algorithm.pxd b/contrib/tools/cython/Cython/Includes/libcpp/algorithm.pxd
index e7649cf9be..ec7c3835b4 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/algorithm.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/algorithm.pxd
@@ -1,7 +1,7 @@
 from libcpp cimport bool
 
 
-cdef extern from "<algorithm>" namespace "std" nogil: 
+cdef extern from "<algorithm>" namespace "std" nogil:
     # Sorting and searching
     bool binary_search[Iter, T](Iter first, Iter last, const T& value)
     bool binary_search[Iter, T, Compare](Iter first, Iter last, const T& value,
@@ -27,17 +27,17 @@ cdef extern from "<algorithm>" namespace "std" nogil:
     Iter unique[Iter, BinaryPredicate](Iter first, Iter last, BinaryPredicate p)
 
     # Binary heaps (priority queues)
-    void make_heap[Iter](Iter first, Iter last) 
-    void make_heap[Iter, Compare](Iter first, Iter last, Compare comp) 
- 
-    void pop_heap[Iter](Iter first, Iter last) 
-    void pop_heap[Iter, Compare](Iter first, Iter last, Compare comp) 
- 
-    void push_heap[Iter](Iter first, Iter last) 
-    void push_heap[Iter, Compare](Iter first, Iter last, Compare comp) 
- 
-    void sort_heap[Iter](Iter first, Iter last) 
-    void sort_heap[Iter, Compare](Iter first, Iter last, Compare comp) 
+    void make_heap[Iter](Iter first, Iter last)
+    void make_heap[Iter, Compare](Iter first, Iter last, Compare comp)
+
+    void pop_heap[Iter](Iter first, Iter last)
+    void pop_heap[Iter, Compare](Iter first, Iter last, Compare comp)
+
+    void push_heap[Iter](Iter first, Iter last)
+    void push_heap[Iter, Compare](Iter first, Iter last, Compare comp)
+
+    void sort_heap[Iter](Iter first, Iter last)
+    void sort_heap[Iter, Compare](Iter first, Iter last, Compare comp)
 
     # Copy
     OutputIter copy[InputIter,OutputIter](InputIter,InputIter,OutputIter)
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/cast.pxd b/contrib/tools/cython/Cython/Includes/libcpp/cast.pxd
index b0ce3b9b3d..c3a4d8978f 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/cast.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/cast.pxd
@@ -1,12 +1,12 @@
-# Defines the standard C++ cast operators. 
-# 
-# Due to type restrictions, these are only defined for pointer parameters, 
-# however that is the only case where they are significantly more interesting 
-# than the standard C cast operator which can be written "<T>(expression)" in 
-# Cython. 
- 
+# Defines the standard C++ cast operators.
+#
+# Due to type restrictions, these are only defined for pointer parameters,
+# however that is the only case where they are significantly more interesting
+# than the standard C cast operator which can be written "<T>(expression)" in
+# Cython.
+
 cdef extern from * nogil:
-    cdef T dynamic_cast[T](void *) except +   # nullptr may also indicate failure 
-    cdef T static_cast[T](void *) 
-    cdef T reinterpret_cast[T](void *) 
-    cdef T const_cast[T](void *) 
+    cdef T dynamic_cast[T](void *) except +   # nullptr may also indicate failure
+    cdef T static_cast[T](void *)
+    cdef T reinterpret_cast[T](void *)
+    cdef T const_cast[T](void *)
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/complex.pxd b/contrib/tools/cython/Cython/Includes/libcpp/complex.pxd
index 7ae6fd0908..c875d5e5bd 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/complex.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/complex.pxd
@@ -1,101 +1,101 @@
-# Note: add integer versions of the functions? 
- 
-cdef extern from "<complex>" namespace "std" nogil: 
-    cdef cppclass complex[T]: 
-        complex() except + 
-        complex(T, T) except + 
-        complex(complex[T]&) except + 
-        # How to make the converting constructor, i.e. convert complex[double] 
-        # to complex[float]? 
- 
-        complex[T] operator+(complex[T]&) 
-        complex[T] operator-(complex[T]&) 
-        complex[T] operator+(complex[T]&, complex[T]&) 
-        complex[T] operator+(complex[T]&, T&) 
-        complex[T] operator+(T&, complex[T]&) 
-        complex[T] operator-(complex[T]&, complex[T]&) 
-        complex[T] operator-(complex[T]&, T&) 
-        complex[T] operator-(T&, complex[T]&) 
-        complex[T] operator*(complex[T]&, complex[T]&) 
-        complex[T] operator*(complex[T]&, T&) 
-        complex[T] operator*(T&, complex[T]&) 
-        complex[T] operator/(complex[T]&, complex[T]&) 
-        complex[T] operator/(complex[T]&, T&) 
-        complex[T] operator/(T&, complex[T]&) 
- 
-        bint operator==(complex[T]&, complex[T]&) 
-        bint operator==(complex[T]&, T&) 
-        bint operator==(T&, complex[T]&) 
-        bint operator!=(complex[T]&, complex[T]&) 
-        bint operator!=(complex[T]&, T&) 
-        bint operator!=(T&, complex[T]&) 
- 
-        # Access real part 
-        T real() 
-        void real(T) 
- 
-        # Access imaginary part 
-        T imag() 
-        void imag(T) 
- 
-    # Return real part 
+# Note: add integer versions of the functions?
+
+cdef extern from "<complex>" namespace "std" nogil:
+    cdef cppclass complex[T]:
+        complex() except +
+        complex(T, T) except +
+        complex(complex[T]&) except +
+        # How to make the converting constructor, i.e. convert complex[double]
+        # to complex[float]?
+
+        complex[T] operator+(complex[T]&)
+        complex[T] operator-(complex[T]&)
+        complex[T] operator+(complex[T]&, complex[T]&)
+        complex[T] operator+(complex[T]&, T&)
+        complex[T] operator+(T&, complex[T]&)
+        complex[T] operator-(complex[T]&, complex[T]&)
+        complex[T] operator-(complex[T]&, T&)
+        complex[T] operator-(T&, complex[T]&)
+        complex[T] operator*(complex[T]&, complex[T]&)
+        complex[T] operator*(complex[T]&, T&)
+        complex[T] operator*(T&, complex[T]&)
+        complex[T] operator/(complex[T]&, complex[T]&)
+        complex[T] operator/(complex[T]&, T&)
+        complex[T] operator/(T&, complex[T]&)
+
+        bint operator==(complex[T]&, complex[T]&)
+        bint operator==(complex[T]&, T&)
+        bint operator==(T&, complex[T]&)
+        bint operator!=(complex[T]&, complex[T]&)
+        bint operator!=(complex[T]&, T&)
+        bint operator!=(T&, complex[T]&)
+
+        # Access real part
+        T real()
+        void real(T)
+
+        # Access imaginary part
+        T imag()
+        void imag(T)
+
+    # Return real part
     T real[T](complex[T]&)
-    long double real(long double) 
-    double real(double) 
-    float real(float) 
- 
-    # Return imaginary part 
+    long double real(long double)
+    double real(double)
+    float real(float)
+
+    # Return imaginary part
     T imag[T](complex[T]&)
-    long double imag(long double) 
-    double imag(double) 
-    float imag(float) 
- 
+    long double imag(long double)
+    double imag(double)
+    float imag(float)
+
     T abs[T](complex[T]&)
     T arg[T](complex[T]&)
-    long double arg(long double) 
-    double arg(double) 
-    float arg(float) 
- 
+    long double arg(long double)
+    double arg(double)
+    float arg(float)
+
     T norm[T](complex[T])
-    long double norm(long double) 
-    double norm(double) 
-    float norm(float) 
- 
+    long double norm(long double)
+    double norm(double)
+    float norm(float)
+
     complex[T] conj[T](complex[T]&)
-    complex[long double] conj(long double) 
-    complex[double] conj(double) 
-    complex[float] conj(float) 
- 
+    complex[long double] conj(long double)
+    complex[double] conj(double)
+    complex[float] conj(float)
+
     complex[T] proj[T](complex[T])
-    complex[long double] proj(long double) 
-    complex[double] proj(double) 
-    complex[float] proj(float) 
- 
+    complex[long double] proj(long double)
+    complex[double] proj(double)
+    complex[float] proj(float)
+
     complex[T] polar[T](T&, T&)
     complex[T] ploar[T](T&)
- 
+
     complex[T] exp[T](complex[T]&)
     complex[T] log[T](complex[T]&)
     complex[T] log10[T](complex[T]&)
- 
+
     complex[T] pow[T](complex[T]&, complex[T]&)
     complex[T] pow[T](complex[T]&, T&)
     complex[T] pow[T](T&, complex[T]&)
-    # There are some promotion versions too 
- 
+    # There are some promotion versions too
+
     complex[T] sqrt[T](complex[T]&)
- 
+
     complex[T] sin[T](complex[T]&)
     complex[T] cos[T](complex[T]&)
     complex[T] tan[T](complex[T]&)
     complex[T] asin[T](complex[T]&)
     complex[T] acos[T](complex[T]&)
     complex[T] atan[T](complex[T]&)
- 
+
     complex[T] sinh[T](complex[T]&)
     complex[T] cosh[T](complex[T]&)
     complex[T] tanh[T](complex[T]&)
- 
+
     complex[T] asinh[T](complex[T]&)
     complex[T] acosh[T](complex[T]&)
     complex[T] atanh[T](complex[T]&)
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/deque.pxd b/contrib/tools/cython/Cython/Includes/libcpp/deque.pxd
index c1374cd2f4..9e2b2291d0 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/deque.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/deque.pxd
@@ -1,4 +1,4 @@
-cdef extern from "<deque>" namespace "std" nogil: 
+cdef extern from "<deque>" namespace "std" nogil:
     cdef cppclass deque[T,ALLOCATOR=*]:
         ctypedef T value_type
         ctypedef ALLOCATOR allocator_type
@@ -9,28 +9,28 @@ cdef extern from "<deque>" namespace "std" nogil:
         ctypedef size_t size_type
         ctypedef ptrdiff_t difference_type
 
-        cppclass iterator: 
-            T& operator*() 
-            iterator operator++() 
-            iterator operator--() 
+        cppclass iterator:
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
             iterator operator+(size_type)
             iterator operator-(size_type)
             difference_type operator-(iterator)
-            bint operator==(iterator) 
-            bint operator!=(iterator) 
+            bint operator==(iterator)
+            bint operator!=(iterator)
             bint operator<(iterator)
             bint operator>(iterator)
             bint operator<=(iterator)
             bint operator>=(iterator)
-        cppclass reverse_iterator: 
-            T& operator*() 
+        cppclass reverse_iterator:
+            T& operator*()
             reverse_iterator operator++()
             reverse_iterator operator--()
             reverse_iterator operator+(size_type)
             reverse_iterator operator-(size_type)
             difference_type operator-(reverse_iterator)
-            bint operator==(reverse_iterator) 
-            bint operator!=(reverse_iterator) 
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
             bint operator<(reverse_iterator)
             bint operator>(reverse_iterator)
             bint operator<=(reverse_iterator)
@@ -39,48 +39,48 @@ cdef extern from "<deque>" namespace "std" nogil:
             pass
         cppclass const_reverse_iterator(reverse_iterator):
             pass
-        deque() except + 
-        deque(deque&) except + 
-        deque(size_t) except + 
-        deque(size_t, T&) except + 
-        #deque[input_iterator](input_iterator, input_iterator) 
-        T& operator[](size_t) 
-        #deque& operator=(deque&) 
-        bint operator==(deque&, deque&) 
-        bint operator!=(deque&, deque&) 
-        bint operator<(deque&, deque&) 
-        bint operator>(deque&, deque&) 
-        bint operator<=(deque&, deque&) 
-        bint operator>=(deque&, deque&) 
-        void assign(size_t, T&) 
-        void assign(input_iterator, input_iterator) 
-        T& at(size_t) 
-        T& back() 
-        iterator begin() 
+        deque() except +
+        deque(deque&) except +
+        deque(size_t) except +
+        deque(size_t, T&) except +
+        #deque[input_iterator](input_iterator, input_iterator)
+        T& operator[](size_t)
+        #deque& operator=(deque&)
+        bint operator==(deque&, deque&)
+        bint operator!=(deque&, deque&)
+        bint operator<(deque&, deque&)
+        bint operator>(deque&, deque&)
+        bint operator<=(deque&, deque&)
+        bint operator>=(deque&, deque&)
+        void assign(size_t, T&)
+        void assign(input_iterator, input_iterator)
+        T& at(size_t)
+        T& back()
+        iterator begin()
         const_iterator const_begin "begin"()
-        void clear() 
-        bint empty() 
-        iterator end() 
+        void clear()
+        bint empty()
+        iterator end()
         const_iterator const_end "end"()
-        iterator erase(iterator) 
-        iterator erase(iterator, iterator) 
-        T& front() 
-        iterator insert(iterator, T&) 
-        void insert(iterator, size_t, T&) 
-        void insert(iterator, input_iterator, input_iterator) 
-        size_t max_size() 
-        void pop_back() 
-        void pop_front() 
-        void push_back(T&) 
-        void push_front(T&) 
-        reverse_iterator rbegin() 
-        #const_reverse_iterator rbegin() 
-        reverse_iterator rend() 
-        #const_reverse_iterator rend() 
-        void resize(size_t) 
-        void resize(size_t, T&) 
-        size_t size() 
-        void swap(deque&) 
+        iterator erase(iterator)
+        iterator erase(iterator, iterator)
+        T& front()
+        iterator insert(iterator, T&)
+        void insert(iterator, size_t, T&)
+        void insert(iterator, input_iterator, input_iterator)
+        size_t max_size()
+        void pop_back()
+        void pop_front()
+        void push_back(T&)
+        void push_front(T&)
+        reverse_iterator rbegin()
+        #const_reverse_iterator rbegin()
+        reverse_iterator rend()
+        #const_reverse_iterator rend()
+        void resize(size_t)
+        void resize(size_t, T&)
+        size_t size()
+        void swap(deque&)
 
         # C++11 methods
         void shrink_to_fit()
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/list.pxd b/contrib/tools/cython/Cython/Includes/libcpp/list.pxd
index ebbe39d487..b5b0410ad8 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/list.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/list.pxd
@@ -1,4 +1,4 @@
-cdef extern from "<list>" namespace "std" nogil: 
+cdef extern from "<list>" namespace "std" nogil:
     cdef cppclass list[T,ALLOCATOR=*]:
         ctypedef T value_type
         ctypedef ALLOCATOR allocator_type
@@ -9,70 +9,70 @@ cdef extern from "<list>" namespace "std" nogil:
         ctypedef size_t size_type
         ctypedef ptrdiff_t difference_type
 
-        cppclass iterator: 
-            iterator() 
-            iterator(iterator &) 
-            T& operator*() 
-            iterator operator++() 
-            iterator operator--() 
-            bint operator==(iterator) 
-            bint operator!=(iterator) 
-        cppclass reverse_iterator: 
-            reverse_iterator() 
-            reverse_iterator(iterator &) 
-            T& operator*() 
-            reverse_iterator operator++() 
-            reverse_iterator operator--() 
-            bint operator==(reverse_iterator) 
-            bint operator!=(reverse_iterator) 
+        cppclass iterator:
+            iterator()
+            iterator(iterator &)
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
+        cppclass reverse_iterator:
+            reverse_iterator()
+            reverse_iterator(iterator &)
+            T& operator*()
+            reverse_iterator operator++()
+            reverse_iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         cppclass const_iterator(iterator):
             pass
         cppclass const_reverse_iterator(reverse_iterator):
             pass
-        list() except + 
-        list(list&) except + 
-        list(size_t, T&) except + 
-        #list operator=(list&) 
-        bint operator==(list&, list&) 
-        bint operator!=(list&, list&) 
-        bint operator<(list&, list&) 
-        bint operator>(list&, list&) 
-        bint operator<=(list&, list&) 
-        bint operator>=(list&, list&) 
-        void assign(size_t, T&) 
-        T& back() 
-        iterator begin() 
+        list() except +
+        list(list&) except +
+        list(size_t, T&) except +
+        #list operator=(list&)
+        bint operator==(list&, list&)
+        bint operator!=(list&, list&)
+        bint operator<(list&, list&)
+        bint operator>(list&, list&)
+        bint operator<=(list&, list&)
+        bint operator>=(list&, list&)
+        void assign(size_t, T&)
+        T& back()
+        iterator begin()
         const_iterator const_begin "begin"()
-        void clear() 
-        bint empty() 
-        iterator end() 
+        void clear()
+        bint empty()
+        iterator end()
         const_iterator const_end "end"()
-        iterator erase(iterator) 
-        iterator erase(iterator, iterator) 
-        T& front() 
-        iterator insert(iterator, T&) 
-        void insert(iterator, size_t, T&) 
-        size_t max_size() 
-        void merge(list&) 
-        #void merge(list&, BinPred) 
-        void pop_back() 
-        void pop_front() 
-        void push_back(T&) 
-        void push_front(T&) 
-        reverse_iterator rbegin() 
+        iterator erase(iterator)
+        iterator erase(iterator, iterator)
+        T& front()
+        iterator insert(iterator, T&)
+        void insert(iterator, size_t, T&)
+        size_t max_size()
+        void merge(list&)
+        #void merge(list&, BinPred)
+        void pop_back()
+        void pop_front()
+        void push_back(T&)
+        void push_front(T&)
+        reverse_iterator rbegin()
         const_reverse_iterator const_rbegin "rbegin"()
-        void remove(T&) 
-        #void remove_if(UnPred) 
-        reverse_iterator rend() 
+        void remove(T&)
+        #void remove_if(UnPred)
+        reverse_iterator rend()
         const_reverse_iterator const_rend "rend"()
-        void resize(size_t, T&) 
-        void reverse() 
-        size_t size() 
-        void sort() 
-        #void sort(BinPred) 
-        void splice(iterator, list&) 
-        void splice(iterator, list&, iterator) 
-        void splice(iterator, list&, iterator, iterator) 
-        void swap(list&) 
-        void unique() 
-        #void unique(BinPred) 
+        void resize(size_t, T&)
+        void reverse()
+        size_t size()
+        void sort()
+        #void sort(BinPred)
+        void splice(iterator, list&)
+        void splice(iterator, list&, iterator)
+        void splice(iterator, list&, iterator, iterator)
+        void swap(list&)
+        void unique()
+        #void unique(BinPred)
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/map.pxd b/contrib/tools/cython/Cython/Includes/libcpp/map.pxd
index 167d467848..624a7ac026 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/map.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/map.pxd
@@ -1,68 +1,68 @@
-from .utility cimport pair 
- 
-cdef extern from "<map>" namespace "std" nogil: 
+from .utility cimport pair
+
+cdef extern from "<map>" namespace "std" nogil:
     cdef cppclass map[T, U, COMPARE=*, ALLOCATOR=*]:
         ctypedef T key_type
         ctypedef U mapped_type
         ctypedef pair[const T, U] value_type
         ctypedef COMPARE key_compare
         ctypedef ALLOCATOR allocator_type
-        cppclass iterator: 
-            pair[T, U]& operator*() 
-            iterator operator++() 
-            iterator operator--() 
-            bint operator==(iterator) 
-            bint operator!=(iterator) 
-        cppclass reverse_iterator: 
-            pair[T, U]& operator*() 
-            iterator operator++() 
-            iterator operator--() 
-            bint operator==(reverse_iterator) 
-            bint operator!=(reverse_iterator) 
+        cppclass iterator:
+            pair[T, U]& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
+        cppclass reverse_iterator:
+            pair[T, U]& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         cppclass const_iterator(iterator):
             pass
         cppclass const_reverse_iterator(reverse_iterator):
             pass
-        map() except + 
-        map(map&) except + 
-        #map(key_compare&) 
-        U& operator[](T&) 
-        #map& operator=(map&) 
-        bint operator==(map&, map&) 
-        bint operator!=(map&, map&) 
-        bint operator<(map&, map&) 
-        bint operator>(map&, map&) 
-        bint operator<=(map&, map&) 
-        bint operator>=(map&, map&) 
+        map() except +
+        map(map&) except +
+        #map(key_compare&)
+        U& operator[](T&)
+        #map& operator=(map&)
+        bint operator==(map&, map&)
+        bint operator!=(map&, map&)
+        bint operator<(map&, map&)
+        bint operator>(map&, map&)
+        bint operator<=(map&, map&)
+        bint operator>=(map&, map&)
         U& at(const T&) except +
         const U& const_at "at"(const T&) except +
-        iterator begin() 
-        const_iterator const_begin "begin" () 
-        void clear() 
+        iterator begin()
+        const_iterator const_begin "begin" ()
+        void clear()
         size_t count(const T&)
-        bint empty() 
-        iterator end() 
-        const_iterator const_end "end" () 
+        bint empty()
+        iterator end()
+        const_iterator const_end "end" ()
         pair[iterator, iterator] equal_range(const T&)
-        #pair[const_iterator, const_iterator] equal_range(key_type&) 
-        void erase(iterator) 
-        void erase(iterator, iterator) 
+        #pair[const_iterator, const_iterator] equal_range(key_type&)
+        void erase(iterator)
+        void erase(iterator, iterator)
         size_t erase(const T&)
         iterator find(const T&)
         const_iterator const_find "find" (const T&)
         pair[iterator, bint] insert(pair[T, U]) except + # XXX pair[T,U]&
         iterator insert(iterator, pair[T, U]) except + # XXX pair[T,U]&
-        #void insert(input_iterator, input_iterator) 
-        #key_compare key_comp() 
+        #void insert(input_iterator, input_iterator)
+        #key_compare key_comp()
         iterator lower_bound(const T&)
         const_iterator const_lower_bound "lower_bound"(const T&)
-        size_t max_size() 
-        reverse_iterator rbegin() 
+        size_t max_size()
+        reverse_iterator rbegin()
         const_reverse_iterator const_rbegin "rbegin"()
-        reverse_iterator rend() 
+        reverse_iterator rend()
         const_reverse_iterator const_rend "rend"()
-        size_t size() 
-        void swap(map&) 
+        size_t size()
+        void swap(map&)
         iterator upper_bound(const T&)
         const_iterator const_upper_bound "upper_bound"(const T&)
-        #value_compare value_comp() 
+        #value_compare value_comp()
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/pair.pxd b/contrib/tools/cython/Cython/Includes/libcpp/pair.pxd
index 76a21aba91..869fe6674d 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/pair.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/pair.pxd
@@ -1 +1 @@
-from .utility cimport pair 
+from .utility cimport pair
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/queue.pxd b/contrib/tools/cython/Cython/Includes/libcpp/queue.pxd
index 1b4adbbed6..578cbd9159 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/queue.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/queue.pxd
@@ -1,25 +1,25 @@
-cdef extern from "<queue>" namespace "std" nogil: 
-    cdef cppclass queue[T]: 
-        queue() except + 
-        queue(queue&) except + 
-        #queue(Container&) 
-        T& back() 
-        bint empty() 
-        T& front() 
-        void pop() 
-        void push(T&) 
-        size_t size() 
+cdef extern from "<queue>" namespace "std" nogil:
+    cdef cppclass queue[T]:
+        queue() except +
+        queue(queue&) except +
+        #queue(Container&)
+        T& back()
+        bint empty()
+        T& front()
+        void pop()
+        void push(T&)
+        size_t size()
         # C++11 methods
         void swap(queue&)
 
-    cdef cppclass priority_queue[T]: 
-        priority_queue() except + 
-        priority_queue(priority_queue&) except + 
-        #priority_queue(Container&) 
-        bint empty() 
-        void pop() 
-        void push(T&) 
-        size_t size() 
-        T& top() 
+    cdef cppclass priority_queue[T]:
+        priority_queue() except +
+        priority_queue(priority_queue&) except +
+        #priority_queue(Container&)
+        bint empty()
+        void pop()
+        void push(T&)
+        size_t size()
+        T& top()
         # C++11 methods
         void swap(priority_queue&)
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/set.pxd b/contrib/tools/cython/Cython/Includes/libcpp/set.pxd
index 9d9e0ca66d..1069be7466 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/set.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/set.pxd
@@ -1,61 +1,61 @@
-from .utility cimport pair 
- 
-cdef extern from "<set>" namespace "std" nogil: 
-    cdef cppclass set[T]: 
+from .utility cimport pair
+
+cdef extern from "<set>" namespace "std" nogil:
+    cdef cppclass set[T]:
         ctypedef T value_type
-        cppclass iterator: 
-            T& operator*() 
-            iterator operator++() 
-            iterator operator--() 
-            bint operator==(iterator) 
-            bint operator!=(iterator) 
-        cppclass reverse_iterator: 
-            T& operator*() 
-            iterator operator++() 
-            iterator operator--() 
-            bint operator==(reverse_iterator) 
-            bint operator!=(reverse_iterator) 
+        cppclass iterator:
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
+        cppclass reverse_iterator:
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         cppclass const_iterator(iterator):
             pass
         cppclass const_reverse_iterator(reverse_iterator):
             pass
-        set() except + 
-        set(set&) except + 
-        #set(key_compare&) 
-        #set& operator=(set&) 
-        bint operator==(set&, set&) 
-        bint operator!=(set&, set&) 
-        bint operator<(set&, set&) 
-        bint operator>(set&, set&) 
-        bint operator<=(set&, set&) 
-        bint operator>=(set&, set&) 
-        iterator begin() 
+        set() except +
+        set(set&) except +
+        #set(key_compare&)
+        #set& operator=(set&)
+        bint operator==(set&, set&)
+        bint operator!=(set&, set&)
+        bint operator<(set&, set&)
+        bint operator>(set&, set&)
+        bint operator<=(set&, set&)
+        bint operator>=(set&, set&)
+        iterator begin()
         const_iterator const_begin "begin"()
-        void clear() 
+        void clear()
         size_t count(const T&)
-        bint empty() 
-        iterator end() 
+        bint empty()
+        iterator end()
         const_iterator const_end "end"()
         pair[iterator, iterator] equal_range(const T&)
-        #pair[const_iterator, const_iterator] equal_range(T&) 
+        #pair[const_iterator, const_iterator] equal_range(T&)
         iterator erase(iterator)
         iterator erase(iterator, iterator)
-        size_t erase(T&) 
-        iterator find(T&) 
+        size_t erase(T&)
+        iterator find(T&)
         const_iterator const_find "find"(T&)
         pair[iterator, bint] insert(const T&) except +
         iterator insert(iterator, const T&) except +
         void insert(iterator, iterator) except +
-        #key_compare key_comp() 
-        iterator lower_bound(T&) 
+        #key_compare key_comp()
+        iterator lower_bound(T&)
         const_iterator const_lower_bound "lower_bound"(T&)
-        size_t max_size() 
-        reverse_iterator rbegin() 
+        size_t max_size()
+        reverse_iterator rbegin()
         const_reverse_iterator const_rbegin "rbegin"()
-        reverse_iterator rend() 
+        reverse_iterator rend()
         const_reverse_iterator const_rend "rend"()
-        size_t size() 
-        void swap(set&) 
+        size_t size()
+        void swap(set&)
         iterator upper_bound(const T&)
         const_iterator const_upper_bound "upper_bound"(const T&)
-        #value_compare value_comp() 
+        #value_compare value_comp()
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/stack.pxd b/contrib/tools/cython/Cython/Includes/libcpp/stack.pxd
index 923823e3ec..2dc80992b7 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/stack.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/stack.pxd
@@ -1,11 +1,11 @@
-cdef extern from "<stack>" namespace "std" nogil: 
-    cdef cppclass stack[T]: 
+cdef extern from "<stack>" namespace "std" nogil:
+    cdef cppclass stack[T]:
         ctypedef T value_type
-        stack() except + 
-        stack(stack&) except + 
-        #stack(Container&) 
-        bint empty() 
-        void pop() 
-        void push(T&) 
-        size_t size() 
-        T& top() 
+        stack() except +
+        stack(stack&) except +
+        #stack(Container&)
+        bint empty()
+        void pop()
+        void push(T&)
+        size_t size()
+        T& top()
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/string.pxd b/contrib/tools/cython/Cython/Includes/libcpp/string.pxd
index 5f965e8d97..a894144f1f 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/string.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/string.pxd
@@ -1,13 +1,13 @@
- 
-# deprecated cimport for backwards compatibility: 
-from libc.string cimport const_char 
- 
+
+# deprecated cimport for backwards compatibility:
+from libc.string cimport const_char
+
 cdef extern from "<string>" namespace "std::string" nogil:
     const size_t npos
- 
-cdef extern from "<string>" namespace "std" nogil: 
-    cdef cppclass string: 
- 
+
+cdef extern from "<string>" namespace "std" nogil:
+    cdef cppclass string:
+
         cppclass iterator:
             iterator()
             char& operator*()
@@ -54,19 +54,19 @@ cdef extern from "<string>" namespace "std" nogil:
         reverse_iterator rend()
         const_reverse_iterator const_rend "rend"()
 
-        const char* c_str() 
-        const char* data() 
-        size_t size() 
-        size_t max_size() 
-        size_t length() 
+        const char* c_str()
+        const char* data()
+        size_t size()
+        size_t max_size()
+        size_t length()
         void resize(size_t) except +
         void resize(size_t, char) except +
         void shrink_to_fit() except +
-        size_t capacity() 
+        size_t capacity()
         void reserve(size_t) except +
-        void clear() 
-        bint empty() 
- 
+        void clear()
+        bint empty()
+
         iterator erase(iterator first, iterator last)
         iterator erase(iterator p)
         iterator erase(const_iterator first, const_iterator last)
@@ -74,7 +74,7 @@ cdef extern from "<string>" namespace "std" nogil:
         string& erase(size_t pos, size_t len) except +
         string& erase(size_t pos) except +
         string& erase() except +
- 
+
         char& at(size_t pos) except +
         char& operator[](size_t pos)
         char& front()
@@ -85,22 +85,22 @@ cdef extern from "<string>" namespace "std" nogil:
         int compare(const char* s) except +
         int compare(size_t pos, size_t len, const char* s) except +
         int compare(size_t pos, size_t len, const char* s , size_t n) except +
- 
+
         string& append(const string& s) except +
         string& append(const string& s, size_t subpos, size_t sublen) except +
         string& append(const char* s) except +
         string& append(const char* s, size_t n) except +
         string& append(size_t n, char c) except +
- 
+
         void push_back(char c) except +
         void pop_back()
- 
+
         string& assign(const string& s) except +
         string& assign(const string& s, size_t subpos, size_t sublen) except +
         string& assign(const char* s, size_t n) except +
         string& assign(const char* s) except +
         string& assign(size_t n, char c) except +
- 
+
         string& insert(size_t pos, const string& s, size_t subpos, size_t sublen) except +
         string& insert(size_t pos, const string& s) except +
         string& insert(size_t pos, const char* s, size_t n) except +
@@ -108,10 +108,10 @@ cdef extern from "<string>" namespace "std" nogil:
         string& insert(size_t pos, size_t n, char c) except +
         void insert(iterator p, size_t n, char c) except +
         iterator insert(iterator p, char c) except +
- 
+
         size_t copy(char* s, size_t len, size_t pos) except +
         size_t copy(char* s, size_t len) except +
- 
+
         size_t find(const string& s, size_t pos)
         size_t find(const string& s)
         size_t find(const char* s, size_t pos, size_t n)
@@ -119,39 +119,39 @@ cdef extern from "<string>" namespace "std" nogil:
         size_t find(const char* s)
         size_t find(char c, size_t pos)
         size_t find(char c)
- 
+
         size_t rfind(const string&, size_t pos)
         size_t rfind(const string&)
         size_t rfind(const char* s, size_t pos, size_t n)
         size_t rfind(const char* s, size_t pos)
         size_t rfind(const char* s)
         size_t rfind(char c, size_t pos)
-        size_t rfind(char c) 
- 
+        size_t rfind(char c)
+
         size_t find_first_of(const string&, size_t pos)
         size_t find_first_of(const string&)
         size_t find_first_of(const char* s, size_t pos, size_t n)
         size_t find_first_of(const char* s, size_t pos)
         size_t find_first_of(const char* s)
         size_t find_first_of(char c, size_t pos)
-        size_t find_first_of(char c) 
- 
+        size_t find_first_of(char c)
+
         size_t find_first_not_of(const string& s, size_t pos)
         size_t find_first_not_of(const string& s)
         size_t find_first_not_of(const char* s, size_t pos, size_t n)
         size_t find_first_not_of(const char* s, size_t pos)
         size_t find_first_not_of(const char*)
         size_t find_first_not_of(char c, size_t pos)
-        size_t find_first_not_of(char c) 
- 
+        size_t find_first_not_of(char c)
+
         size_t find_last_of(const string& s, size_t pos)
         size_t find_last_of(const string& s)
         size_t find_last_of(const char* s, size_t pos, size_t n)
         size_t find_last_of(const char* s, size_t pos)
         size_t find_last_of(const char* s)
         size_t find_last_of(char c, size_t pos)
-        size_t find_last_of(char c) 
- 
+        size_t find_last_of(char c)
+
         size_t find_last_not_of(const string& s, size_t pos)
         size_t find_last_not_of(const string& s)
         size_t find_last_not_of(const char* s, size_t pos, size_t n)
@@ -159,33 +159,33 @@ cdef extern from "<string>" namespace "std" nogil:
         size_t find_last_not_of(const char* s)
         size_t find_last_not_of(char c, size_t pos)
         size_t find_last_not_of(char c)
- 
+
         string substr(size_t pos, size_t len) except +
         string substr(size_t pos) except +
-        string substr() 
- 
+        string substr()
+
         #string& operator= (const string&)
         #string& operator= (const char*)
-        #string& operator= (char) 
- 
+        #string& operator= (char)
+
         string operator+ (const string&) except +
         string operator+ (const char*) except +
- 
+
         bint operator==(const string&)
         bint operator==(const char*)
- 
+
         bint operator!= (const string&)
         bint operator!= (const char*)
- 
+
         bint operator< (const string&)
         bint operator< (const char*)
- 
+
         bint operator> (const string&)
         bint operator> (const char*)
- 
+
         bint operator<= (const string&)
         bint operator<= (const char*)
- 
+
         bint operator>= (const string&)
         bint operator>= (const char*)
 
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/unordered_map.pxd b/contrib/tools/cython/Cython/Includes/libcpp/unordered_map.pxd
index 370710abe0..a00fbbed28 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/unordered_map.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/unordered_map.pxd
@@ -1,69 +1,69 @@
-from .utility cimport pair 
- 
-cdef extern from "<unordered_map>" namespace "std" nogil: 
+from .utility cimport pair
+
+cdef extern from "<unordered_map>" namespace "std" nogil:
     cdef cppclass unordered_map[T, U, HASH=*, PRED=*, ALLOCATOR=*]:
         ctypedef T key_type
         ctypedef U mapped_type
         ctypedef pair[const T, U] value_type
-        cppclass iterator: 
-            pair[T, U]& operator*() 
-            iterator operator++() 
-            iterator operator--() 
-            bint operator==(iterator) 
-            bint operator!=(iterator) 
-        cppclass reverse_iterator: 
-            pair[T, U]& operator*() 
-            iterator operator++() 
-            iterator operator--() 
-            bint operator==(reverse_iterator) 
-            bint operator!=(reverse_iterator) 
+        cppclass iterator:
+            pair[T, U]& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
+        cppclass reverse_iterator:
+            pair[T, U]& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         cppclass const_iterator(iterator):
             pass
         cppclass const_reverse_iterator(reverse_iterator):
             pass
-        unordered_map() except + 
-        unordered_map(unordered_map&) except + 
-        #unordered_map(key_compare&) 
-        U& operator[](T&) 
-        #unordered_map& operator=(unordered_map&) 
-        bint operator==(unordered_map&, unordered_map&) 
-        bint operator!=(unordered_map&, unordered_map&) 
-        bint operator<(unordered_map&, unordered_map&) 
-        bint operator>(unordered_map&, unordered_map&) 
-        bint operator<=(unordered_map&, unordered_map&) 
-        bint operator>=(unordered_map&, unordered_map&) 
+        unordered_map() except +
+        unordered_map(unordered_map&) except +
+        #unordered_map(key_compare&)
+        U& operator[](T&)
+        #unordered_map& operator=(unordered_map&)
+        bint operator==(unordered_map&, unordered_map&)
+        bint operator!=(unordered_map&, unordered_map&)
+        bint operator<(unordered_map&, unordered_map&)
+        bint operator>(unordered_map&, unordered_map&)
+        bint operator<=(unordered_map&, unordered_map&)
+        bint operator>=(unordered_map&, unordered_map&)
         U& at(const T&)
         const U& const_at "at"(const T&)
-        iterator begin() 
+        iterator begin()
         const_iterator const_begin "begin"()
-        void clear() 
-        size_t count(T&) 
-        bint empty() 
-        iterator end() 
+        void clear()
+        size_t count(T&)
+        bint empty()
+        iterator end()
         const_iterator const_end "end"()
-        pair[iterator, iterator] equal_range(T&) 
+        pair[iterator, iterator] equal_range(T&)
         pair[const_iterator, const_iterator] const_equal_range "equal_range"(const T&)
         iterator erase(iterator)
         iterator erase(iterator, iterator)
-        size_t erase(T&) 
-        iterator find(T&) 
+        size_t erase(T&)
+        iterator find(T&)
         const_iterator const_find "find"(T&)
-        pair[iterator, bint] insert(pair[T, U]) # XXX pair[T,U]& 
-        iterator insert(iterator, pair[T, U]) # XXX pair[T,U]& 
+        pair[iterator, bint] insert(pair[T, U]) # XXX pair[T,U]&
+        iterator insert(iterator, pair[T, U]) # XXX pair[T,U]&
         iterator insert(iterator, iterator)
-        #key_compare key_comp() 
-        iterator lower_bound(T&) 
+        #key_compare key_comp()
+        iterator lower_bound(T&)
         const_iterator const_lower_bound "lower_bound"(T&)
-        size_t max_size() 
-        reverse_iterator rbegin() 
+        size_t max_size()
+        reverse_iterator rbegin()
         const_reverse_iterator const_rbegin "rbegin"()
-        reverse_iterator rend() 
+        reverse_iterator rend()
         const_reverse_iterator const_rend "rend"()
-        size_t size() 
-        void swap(unordered_map&) 
-        iterator upper_bound(T&) 
+        size_t size()
+        void swap(unordered_map&)
+        iterator upper_bound(T&)
         const_iterator const_upper_bound "upper_bound"(T&)
-        #value_compare value_comp() 
+        #value_compare value_comp()
         void max_load_factor(float)
         float max_load_factor()
         void rehash(size_t)
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/unordered_set.pxd b/contrib/tools/cython/Cython/Includes/libcpp/unordered_set.pxd
index 9379003a45..5aa2417528 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/unordered_set.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/unordered_set.pxd
@@ -1,64 +1,64 @@
-from .utility cimport pair 
- 
-cdef extern from "<unordered_set>" namespace "std" nogil: 
+from .utility cimport pair
+
+cdef extern from "<unordered_set>" namespace "std" nogil:
     cdef cppclass unordered_set[T,HASH=*,PRED=*,ALLOCATOR=*]:
         ctypedef T value_type
-        cppclass iterator: 
-            T& operator*() 
-            iterator operator++() 
-            iterator operator--() 
-            bint operator==(iterator) 
-            bint operator!=(iterator) 
-        cppclass reverse_iterator: 
-            T& operator*() 
-            iterator operator++() 
-            iterator operator--() 
-            bint operator==(reverse_iterator) 
-            bint operator!=(reverse_iterator) 
+        cppclass iterator:
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
+        cppclass reverse_iterator:
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         cppclass const_iterator(iterator):
             pass
         cppclass const_reverse_iterator(reverse_iterator):
             pass
-        unordered_set() except + 
-        unordered_set(unordered_set&) except + 
-        #unordered_set(key_compare&) 
-        #unordered_set& operator=(unordered_set&) 
-        bint operator==(unordered_set&, unordered_set&) 
-        bint operator!=(unordered_set&, unordered_set&) 
-        bint operator<(unordered_set&, unordered_set&) 
-        bint operator>(unordered_set&, unordered_set&) 
-        bint operator<=(unordered_set&, unordered_set&) 
-        bint operator>=(unordered_set&, unordered_set&) 
-        iterator begin() 
+        unordered_set() except +
+        unordered_set(unordered_set&) except +
+        #unordered_set(key_compare&)
+        #unordered_set& operator=(unordered_set&)
+        bint operator==(unordered_set&, unordered_set&)
+        bint operator!=(unordered_set&, unordered_set&)
+        bint operator<(unordered_set&, unordered_set&)
+        bint operator>(unordered_set&, unordered_set&)
+        bint operator<=(unordered_set&, unordered_set&)
+        bint operator>=(unordered_set&, unordered_set&)
+        iterator begin()
         const_iterator const_begin "begin"()
-        void clear() 
-        size_t count(T&) 
-        bint empty() 
-        iterator end() 
+        void clear()
+        size_t count(T&)
+        bint empty()
+        iterator end()
         const_iterator const_end "end"()
-        pair[iterator, iterator] equal_range(T&) 
+        pair[iterator, iterator] equal_range(T&)
         pair[const_iterator, const_iterator] const_equal_range "equal_range"(T&)
         iterator erase(iterator)
         iterator erase(iterator, iterator)
-        size_t erase(T&) 
-        iterator find(T&) 
+        size_t erase(T&)
+        iterator find(T&)
         const_iterator const_find "find"(T&)
-        pair[iterator, bint] insert(T&) 
-        iterator insert(iterator, T&) 
-        #key_compare key_comp() 
+        pair[iterator, bint] insert(T&)
+        iterator insert(iterator, T&)
+        #key_compare key_comp()
         iterator insert(iterator, iterator)
-        iterator lower_bound(T&) 
+        iterator lower_bound(T&)
         const_iterator const_lower_bound "lower_bound"(T&)
-        size_t max_size() 
-        reverse_iterator rbegin() 
+        size_t max_size()
+        reverse_iterator rbegin()
         const_reverse_iterator const_rbegin "rbegin"()
-        reverse_iterator rend() 
+        reverse_iterator rend()
         const_reverse_iterator const_rend "rend"()
-        size_t size() 
-        void swap(unordered_set&) 
-        iterator upper_bound(T&) 
+        size_t size()
+        void swap(unordered_set&)
+        iterator upper_bound(T&)
         const_iterator const_upper_bound "upper_bound"(T&)
-        #value_compare value_comp() 
+        #value_compare value_comp()
         void max_load_factor(float)
         float max_load_factor()
         void rehash(size_t)
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/utility.pxd b/contrib/tools/cython/Cython/Includes/libcpp/utility.pxd
index 82bd11e42f..e0df69b166 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/utility.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/utility.pxd
@@ -1,18 +1,18 @@
-cdef extern from "<utility>" namespace "std" nogil: 
-    cdef cppclass pair[T, U]: 
+cdef extern from "<utility>" namespace "std" nogil:
+    cdef cppclass pair[T, U]:
         ctypedef T first_type
         ctypedef U second_type
-        T first 
-        U second 
-        pair() except + 
-        pair(pair&) except + 
-        pair(T&, U&) except + 
-        bint operator==(pair&, pair&) 
-        bint operator!=(pair&, pair&) 
-        bint operator<(pair&, pair&) 
-        bint operator>(pair&, pair&) 
-        bint operator<=(pair&, pair&) 
-        bint operator>=(pair&, pair&) 
+        T first
+        U second
+        pair() except +
+        pair(pair&) except +
+        pair(T&, U&) except +
+        bint operator==(pair&, pair&)
+        bint operator!=(pair&, pair&)
+        bint operator<(pair&, pair&)
+        bint operator>(pair&, pair&)
+        bint operator<=(pair&, pair&)
+        bint operator>=(pair&, pair&)
 
 cdef extern from * namespace "cython_std" nogil:
     """
diff --git a/contrib/tools/cython/Cython/Includes/libcpp/vector.pxd b/contrib/tools/cython/Cython/Includes/libcpp/vector.pxd
index 1ec22706b2..9b007dd0c7 100644
--- a/contrib/tools/cython/Cython/Includes/libcpp/vector.pxd
+++ b/contrib/tools/cython/Cython/Includes/libcpp/vector.pxd
@@ -1,4 +1,4 @@
-cdef extern from "<vector>" namespace "std" nogil: 
+cdef extern from "<vector>" namespace "std" nogil:
     cdef cppclass vector[T,ALLOCATOR=*]:
         ctypedef T value_type
         ctypedef ALLOCATOR allocator_type
@@ -9,80 +9,80 @@ cdef extern from "<vector>" namespace "std" nogil:
         ctypedef size_t size_type
         ctypedef ptrdiff_t difference_type
 
-        cppclass iterator: 
-            T& operator*() 
-            iterator operator++() 
-            iterator operator--() 
+        cppclass iterator:
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
             iterator operator+(size_type)
             iterator operator-(size_type)
             difference_type operator-(iterator)
-            bint operator==(iterator) 
-            bint operator!=(iterator) 
-            bint operator<(iterator) 
-            bint operator>(iterator) 
-            bint operator<=(iterator) 
-            bint operator>=(iterator) 
-        cppclass reverse_iterator: 
-            T& operator*() 
+            bint operator==(iterator)
+            bint operator!=(iterator)
+            bint operator<(iterator)
+            bint operator>(iterator)
+            bint operator<=(iterator)
+            bint operator>=(iterator)
+        cppclass reverse_iterator:
+            T& operator*()
             reverse_iterator operator++()
             reverse_iterator operator--()
             reverse_iterator operator+(size_type)
             reverse_iterator operator-(size_type)
             difference_type operator-(reverse_iterator)
-            bint operator==(reverse_iterator) 
-            bint operator!=(reverse_iterator) 
-            bint operator<(reverse_iterator) 
-            bint operator>(reverse_iterator) 
-            bint operator<=(reverse_iterator) 
-            bint operator>=(reverse_iterator) 
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator>=(reverse_iterator)
         cppclass const_iterator(iterator):
             pass
         cppclass const_reverse_iterator(reverse_iterator):
             pass
-        vector() except + 
-        vector(vector&) except + 
+        vector() except +
+        vector(vector&) except +
         vector(size_type) except +
         vector(size_type, T&) except +
-        #vector[input_iterator](input_iterator, input_iterator) 
+        #vector[input_iterator](input_iterator, input_iterator)
         T& operator[](size_type)
-        #vector& operator=(vector&) 
-        bint operator==(vector&, vector&) 
-        bint operator!=(vector&, vector&) 
-        bint operator<(vector&, vector&) 
-        bint operator>(vector&, vector&) 
-        bint operator<=(vector&, vector&) 
-        bint operator>=(vector&, vector&) 
+        #vector& operator=(vector&)
+        bint operator==(vector&, vector&)
+        bint operator!=(vector&, vector&)
+        bint operator<(vector&, vector&)
+        bint operator>(vector&, vector&)
+        bint operator<=(vector&, vector&)
+        bint operator>=(vector&, vector&)
         void assign(size_type, const T&)
         void assign[input_iterator](input_iterator, input_iterator) except +
         T& at(size_type) except +
-        T& back() 
-        iterator begin() 
+        T& back()
+        iterator begin()
         const_iterator const_begin "begin"()
         size_type capacity()
-        void clear() 
-        bint empty() 
-        iterator end() 
+        void clear()
+        bint empty()
+        iterator end()
         const_iterator const_end "end"()
-        iterator erase(iterator) 
-        iterator erase(iterator, iterator) 
-        T& front() 
+        iterator erase(iterator)
+        iterator erase(iterator, iterator)
+        T& front()
         iterator insert(iterator, const T&) except +
         iterator insert(iterator, size_type, const T&) except +
         iterator insert[Iter](iterator, Iter, Iter) except +
         size_type max_size()
-        void pop_back() 
+        void pop_back()
         void push_back(T&) except +
-        reverse_iterator rbegin() 
+        reverse_iterator rbegin()
         const_reverse_iterator const_rbegin "crbegin"()
-        reverse_iterator rend() 
+        reverse_iterator rend()
         const_reverse_iterator const_rend "crend"()
         void reserve(size_type)
         void resize(size_type) except +
         void resize(size_type, T&) except +
         size_type size()
-        void swap(vector&) 
+        void swap(vector&)
 
         # C++11 methods
-        T* data() 
+        T* data()
         const T* const_data "data"()
-        void shrink_to_fit() 
+        void shrink_to_fit()